aboutsummaryrefslogtreecommitdiffstats
path: root/fs/xfs/xfs_dquot.c
diff options
context:
space:
mode:
authorChristoph Hellwig <hch@infradead.org>2011-08-12 17:21:35 -0400
committerAlex Elder <aelder@sgi.com>2011-08-12 17:21:35 -0400
commitc59d87c460767bc35dafd490139d3cfe78fb8da4 (patch)
tree2aad8261f86488e501d9645bd35d1398906da46d /fs/xfs/xfs_dquot.c
parent06f8e2d6754dc631732415b741b5aa58a0f7133f (diff)
xfs: remove subdirectories
Use the move from Linux 2.6 to Linux 3.x as an excuse to kill the annoying subdirectories in the XFS source code. Besides the large amount of file rename the only changes are to the Makefile, a few files including headers with the subdirectory prefix, and the binary sysctl compat code that includes a header under fs/xfs/ from kernel/. Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Alex Elder <aelder@sgi.com>
Diffstat (limited to 'fs/xfs/xfs_dquot.c')
-rw-r--r--fs/xfs/xfs_dquot.c1454
1 files changed, 1454 insertions, 0 deletions
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
new file mode 100644
index 000000000000..db62959bed13
--- /dev/null
+++ b/fs/xfs/xfs_dquot.c
@@ -0,0 +1,1454 @@
1/*
2 * Copyright (c) 2000-2003 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18#include "xfs.h"
19#include "xfs_fs.h"
20#include "xfs_bit.h"
21#include "xfs_log.h"
22#include "xfs_inum.h"
23#include "xfs_trans.h"
24#include "xfs_sb.h"
25#include "xfs_ag.h"
26#include "xfs_alloc.h"
27#include "xfs_quota.h"
28#include "xfs_mount.h"
29#include "xfs_bmap_btree.h"
30#include "xfs_inode.h"
31#include "xfs_bmap.h"
32#include "xfs_rtalloc.h"
33#include "xfs_error.h"
34#include "xfs_itable.h"
35#include "xfs_attr.h"
36#include "xfs_buf_item.h"
37#include "xfs_trans_space.h"
38#include "xfs_trans_priv.h"
39#include "xfs_qm.h"
40#include "xfs_trace.h"
41
42
43/*
44 LOCK ORDER
45
46 inode lock (ilock)
47 dquot hash-chain lock (hashlock)
48 xqm dquot freelist lock (freelistlock
49 mount's dquot list lock (mplistlock)
50 user dquot lock - lock ordering among dquots is based on the uid or gid
51 group dquot lock - similar to udquots. Between the two dquots, the udquot
52 has to be locked first.
53 pin lock - the dquot lock must be held to take this lock.
54 flush lock - ditto.
55*/
56
57#ifdef DEBUG
58xfs_buftarg_t *xfs_dqerror_target;
59int xfs_do_dqerror;
60int xfs_dqreq_num;
61int xfs_dqerror_mod = 33;
62#endif
63
64static struct lock_class_key xfs_dquot_other_class;
65
66/*
67 * Allocate and initialize a dquot. We don't always allocate fresh memory;
68 * we try to reclaim a free dquot if the number of incore dquots are above
69 * a threshold.
70 * The only field inside the core that gets initialized at this point
71 * is the d_id field. The idea is to fill in the entire q_core
72 * when we read in the on disk dquot.
73 */
74STATIC xfs_dquot_t *
75xfs_qm_dqinit(
76 xfs_mount_t *mp,
77 xfs_dqid_t id,
78 uint type)
79{
80 xfs_dquot_t *dqp;
81 boolean_t brandnewdquot;
82
83 brandnewdquot = xfs_qm_dqalloc_incore(&dqp);
84 dqp->dq_flags = type;
85 dqp->q_core.d_id = cpu_to_be32(id);
86 dqp->q_mount = mp;
87
88 /*
89 * No need to re-initialize these if this is a reclaimed dquot.
90 */
91 if (brandnewdquot) {
92 INIT_LIST_HEAD(&dqp->q_freelist);
93 mutex_init(&dqp->q_qlock);
94 init_waitqueue_head(&dqp->q_pinwait);
95
96 /*
97 * Because we want to use a counting completion, complete
98 * the flush completion once to allow a single access to
99 * the flush completion without blocking.
100 */
101 init_completion(&dqp->q_flush);
102 complete(&dqp->q_flush);
103
104 trace_xfs_dqinit(dqp);
105 } else {
106 /*
107 * Only the q_core portion was zeroed in dqreclaim_one().
108 * So, we need to reset others.
109 */
110 dqp->q_nrefs = 0;
111 dqp->q_blkno = 0;
112 INIT_LIST_HEAD(&dqp->q_mplist);
113 INIT_LIST_HEAD(&dqp->q_hashlist);
114 dqp->q_bufoffset = 0;
115 dqp->q_fileoffset = 0;
116 dqp->q_transp = NULL;
117 dqp->q_gdquot = NULL;
118 dqp->q_res_bcount = 0;
119 dqp->q_res_icount = 0;
120 dqp->q_res_rtbcount = 0;
121 atomic_set(&dqp->q_pincount, 0);
122 dqp->q_hash = NULL;
123 ASSERT(list_empty(&dqp->q_freelist));
124
125 trace_xfs_dqreuse(dqp);
126 }
127
128 /*
129 * In either case we need to make sure group quotas have a different
130 * lock class than user quotas, to make sure lockdep knows we can
131 * locks of one of each at the same time.
132 */
133 if (!(type & XFS_DQ_USER))
134 lockdep_set_class(&dqp->q_qlock, &xfs_dquot_other_class);
135
136 /*
137 * log item gets initialized later
138 */
139 return (dqp);
140}
141
142/*
143 * This is called to free all the memory associated with a dquot
144 */
145void
146xfs_qm_dqdestroy(
147 xfs_dquot_t *dqp)
148{
149 ASSERT(list_empty(&dqp->q_freelist));
150
151 mutex_destroy(&dqp->q_qlock);
152 kmem_zone_free(xfs_Gqm->qm_dqzone, dqp);
153
154 atomic_dec(&xfs_Gqm->qm_totaldquots);
155}
156
157/*
158 * This is what a 'fresh' dquot inside a dquot chunk looks like on disk.
159 */
160STATIC void
161xfs_qm_dqinit_core(
162 xfs_dqid_t id,
163 uint type,
164 xfs_dqblk_t *d)
165{
166 /*
167 * Caller has zero'd the entire dquot 'chunk' already.
168 */
169 d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
170 d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
171 d->dd_diskdq.d_id = cpu_to_be32(id);
172 d->dd_diskdq.d_flags = type;
173}
174
175/*
176 * If default limits are in force, push them into the dquot now.
177 * We overwrite the dquot limits only if they are zero and this
178 * is not the root dquot.
179 */
180void
181xfs_qm_adjust_dqlimits(
182 xfs_mount_t *mp,
183 xfs_disk_dquot_t *d)
184{
185 xfs_quotainfo_t *q = mp->m_quotainfo;
186
187 ASSERT(d->d_id);
188
189 if (q->qi_bsoftlimit && !d->d_blk_softlimit)
190 d->d_blk_softlimit = cpu_to_be64(q->qi_bsoftlimit);
191 if (q->qi_bhardlimit && !d->d_blk_hardlimit)
192 d->d_blk_hardlimit = cpu_to_be64(q->qi_bhardlimit);
193 if (q->qi_isoftlimit && !d->d_ino_softlimit)
194 d->d_ino_softlimit = cpu_to_be64(q->qi_isoftlimit);
195 if (q->qi_ihardlimit && !d->d_ino_hardlimit)
196 d->d_ino_hardlimit = cpu_to_be64(q->qi_ihardlimit);
197 if (q->qi_rtbsoftlimit && !d->d_rtb_softlimit)
198 d->d_rtb_softlimit = cpu_to_be64(q->qi_rtbsoftlimit);
199 if (q->qi_rtbhardlimit && !d->d_rtb_hardlimit)
200 d->d_rtb_hardlimit = cpu_to_be64(q->qi_rtbhardlimit);
201}
202
203/*
204 * Check the limits and timers of a dquot and start or reset timers
205 * if necessary.
206 * This gets called even when quota enforcement is OFF, which makes our
207 * life a little less complicated. (We just don't reject any quota
208 * reservations in that case, when enforcement is off).
209 * We also return 0 as the values of the timers in Q_GETQUOTA calls, when
210 * enforcement's off.
211 * In contrast, warnings are a little different in that they don't
212 * 'automatically' get started when limits get exceeded. They do
213 * get reset to zero, however, when we find the count to be under
214 * the soft limit (they are only ever set non-zero via userspace).
215 */
216void
217xfs_qm_adjust_dqtimers(
218 xfs_mount_t *mp,
219 xfs_disk_dquot_t *d)
220{
221 ASSERT(d->d_id);
222
223#ifdef DEBUG
224 if (d->d_blk_hardlimit)
225 ASSERT(be64_to_cpu(d->d_blk_softlimit) <=
226 be64_to_cpu(d->d_blk_hardlimit));
227 if (d->d_ino_hardlimit)
228 ASSERT(be64_to_cpu(d->d_ino_softlimit) <=
229 be64_to_cpu(d->d_ino_hardlimit));
230 if (d->d_rtb_hardlimit)
231 ASSERT(be64_to_cpu(d->d_rtb_softlimit) <=
232 be64_to_cpu(d->d_rtb_hardlimit));
233#endif
234
235 if (!d->d_btimer) {
236 if ((d->d_blk_softlimit &&
237 (be64_to_cpu(d->d_bcount) >=
238 be64_to_cpu(d->d_blk_softlimit))) ||
239 (d->d_blk_hardlimit &&
240 (be64_to_cpu(d->d_bcount) >=
241 be64_to_cpu(d->d_blk_hardlimit)))) {
242 d->d_btimer = cpu_to_be32(get_seconds() +
243 mp->m_quotainfo->qi_btimelimit);
244 } else {
245 d->d_bwarns = 0;
246 }
247 } else {
248 if ((!d->d_blk_softlimit ||
249 (be64_to_cpu(d->d_bcount) <
250 be64_to_cpu(d->d_blk_softlimit))) &&
251 (!d->d_blk_hardlimit ||
252 (be64_to_cpu(d->d_bcount) <
253 be64_to_cpu(d->d_blk_hardlimit)))) {
254 d->d_btimer = 0;
255 }
256 }
257
258 if (!d->d_itimer) {
259 if ((d->d_ino_softlimit &&
260 (be64_to_cpu(d->d_icount) >=
261 be64_to_cpu(d->d_ino_softlimit))) ||
262 (d->d_ino_hardlimit &&
263 (be64_to_cpu(d->d_icount) >=
264 be64_to_cpu(d->d_ino_hardlimit)))) {
265 d->d_itimer = cpu_to_be32(get_seconds() +
266 mp->m_quotainfo->qi_itimelimit);
267 } else {
268 d->d_iwarns = 0;
269 }
270 } else {
271 if ((!d->d_ino_softlimit ||
272 (be64_to_cpu(d->d_icount) <
273 be64_to_cpu(d->d_ino_softlimit))) &&
274 (!d->d_ino_hardlimit ||
275 (be64_to_cpu(d->d_icount) <
276 be64_to_cpu(d->d_ino_hardlimit)))) {
277 d->d_itimer = 0;
278 }
279 }
280
281 if (!d->d_rtbtimer) {
282 if ((d->d_rtb_softlimit &&
283 (be64_to_cpu(d->d_rtbcount) >=
284 be64_to_cpu(d->d_rtb_softlimit))) ||
285 (d->d_rtb_hardlimit &&
286 (be64_to_cpu(d->d_rtbcount) >=
287 be64_to_cpu(d->d_rtb_hardlimit)))) {
288 d->d_rtbtimer = cpu_to_be32(get_seconds() +
289 mp->m_quotainfo->qi_rtbtimelimit);
290 } else {
291 d->d_rtbwarns = 0;
292 }
293 } else {
294 if ((!d->d_rtb_softlimit ||
295 (be64_to_cpu(d->d_rtbcount) <
296 be64_to_cpu(d->d_rtb_softlimit))) &&
297 (!d->d_rtb_hardlimit ||
298 (be64_to_cpu(d->d_rtbcount) <
299 be64_to_cpu(d->d_rtb_hardlimit)))) {
300 d->d_rtbtimer = 0;
301 }
302 }
303}
304
305/*
306 * initialize a buffer full of dquots and log the whole thing
307 */
308STATIC void
309xfs_qm_init_dquot_blk(
310 xfs_trans_t *tp,
311 xfs_mount_t *mp,
312 xfs_dqid_t id,
313 uint type,
314 xfs_buf_t *bp)
315{
316 struct xfs_quotainfo *q = mp->m_quotainfo;
317 xfs_dqblk_t *d;
318 int curid, i;
319
320 ASSERT(tp);
321 ASSERT(xfs_buf_islocked(bp));
322
323 d = bp->b_addr;
324
325 /*
326 * ID of the first dquot in the block - id's are zero based.
327 */
328 curid = id - (id % q->qi_dqperchunk);
329 ASSERT(curid >= 0);
330 memset(d, 0, BBTOB(q->qi_dqchunklen));
331 for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++)
332 xfs_qm_dqinit_core(curid, type, d);
333 xfs_trans_dquot_buf(tp, bp,
334 (type & XFS_DQ_USER ? XFS_BLF_UDQUOT_BUF :
335 ((type & XFS_DQ_PROJ) ? XFS_BLF_PDQUOT_BUF :
336 XFS_BLF_GDQUOT_BUF)));
337 xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1);
338}
339
340
341
342/*
343 * Allocate a block and fill it with dquots.
344 * This is called when the bmapi finds a hole.
345 */
346STATIC int
347xfs_qm_dqalloc(
348 xfs_trans_t **tpp,
349 xfs_mount_t *mp,
350 xfs_dquot_t *dqp,
351 xfs_inode_t *quotip,
352 xfs_fileoff_t offset_fsb,
353 xfs_buf_t **O_bpp)
354{
355 xfs_fsblock_t firstblock;
356 xfs_bmap_free_t flist;
357 xfs_bmbt_irec_t map;
358 int nmaps, error, committed;
359 xfs_buf_t *bp;
360 xfs_trans_t *tp = *tpp;
361
362 ASSERT(tp != NULL);
363
364 trace_xfs_dqalloc(dqp);
365
366 /*
367 * Initialize the bmap freelist prior to calling bmapi code.
368 */
369 xfs_bmap_init(&flist, &firstblock);
370 xfs_ilock(quotip, XFS_ILOCK_EXCL);
371 /*
372 * Return if this type of quotas is turned off while we didn't
373 * have an inode lock
374 */
375 if (XFS_IS_THIS_QUOTA_OFF(dqp)) {
376 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
377 return (ESRCH);
378 }
379
380 xfs_trans_ijoin_ref(tp, quotip, XFS_ILOCK_EXCL);
381 nmaps = 1;
382 if ((error = xfs_bmapi(tp, quotip,
383 offset_fsb, XFS_DQUOT_CLUSTER_SIZE_FSB,
384 XFS_BMAPI_METADATA | XFS_BMAPI_WRITE,
385 &firstblock,
386 XFS_QM_DQALLOC_SPACE_RES(mp),
387 &map, &nmaps, &flist))) {
388 goto error0;
389 }
390 ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB);
391 ASSERT(nmaps == 1);
392 ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
393 (map.br_startblock != HOLESTARTBLOCK));
394
395 /*
396 * Keep track of the blkno to save a lookup later
397 */
398 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
399
400 /* now we can just get the buffer (there's nothing to read yet) */
401 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
402 dqp->q_blkno,
403 mp->m_quotainfo->qi_dqchunklen,
404 0);
405 if (!bp || (error = xfs_buf_geterror(bp)))
406 goto error1;
407 /*
408 * Make a chunk of dquots out of this buffer and log
409 * the entire thing.
410 */
411 xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id),
412 dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
413
414 /*
415 * xfs_bmap_finish() may commit the current transaction and
416 * start a second transaction if the freelist is not empty.
417 *
418 * Since we still want to modify this buffer, we need to
419 * ensure that the buffer is not released on commit of
420 * the first transaction and ensure the buffer is added to the
421 * second transaction.
422 *
423 * If there is only one transaction then don't stop the buffer
424 * from being released when it commits later on.
425 */
426
427 xfs_trans_bhold(tp, bp);
428
429 if ((error = xfs_bmap_finish(tpp, &flist, &committed))) {
430 goto error1;
431 }
432
433 if (committed) {
434 tp = *tpp;
435 xfs_trans_bjoin(tp, bp);
436 } else {
437 xfs_trans_bhold_release(tp, bp);
438 }
439
440 *O_bpp = bp;
441 return 0;
442
443 error1:
444 xfs_bmap_cancel(&flist);
445 error0:
446 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
447
448 return (error);
449}
450
451/*
452 * Maps a dquot to the buffer containing its on-disk version.
453 * This returns a ptr to the buffer containing the on-disk dquot
454 * in the bpp param, and a ptr to the on-disk dquot within that buffer
455 */
456STATIC int
457xfs_qm_dqtobp(
458 xfs_trans_t **tpp,
459 xfs_dquot_t *dqp,
460 xfs_disk_dquot_t **O_ddpp,
461 xfs_buf_t **O_bpp,
462 uint flags)
463{
464 xfs_bmbt_irec_t map;
465 int nmaps = 1, error;
466 xfs_buf_t *bp;
467 xfs_inode_t *quotip = XFS_DQ_TO_QIP(dqp);
468 xfs_mount_t *mp = dqp->q_mount;
469 xfs_disk_dquot_t *ddq;
470 xfs_dqid_t id = be32_to_cpu(dqp->q_core.d_id);
471 xfs_trans_t *tp = (tpp ? *tpp : NULL);
472
473 dqp->q_fileoffset = (xfs_fileoff_t)id / mp->m_quotainfo->qi_dqperchunk;
474
475 xfs_ilock(quotip, XFS_ILOCK_SHARED);
476 if (XFS_IS_THIS_QUOTA_OFF(dqp)) {
477 /*
478 * Return if this type of quotas is turned off while we
479 * didn't have the quota inode lock.
480 */
481 xfs_iunlock(quotip, XFS_ILOCK_SHARED);
482 return ESRCH;
483 }
484
485 /*
486 * Find the block map; no allocations yet
487 */
488 error = xfs_bmapi(NULL, quotip, dqp->q_fileoffset,
489 XFS_DQUOT_CLUSTER_SIZE_FSB, XFS_BMAPI_METADATA,
490 NULL, 0, &map, &nmaps, NULL);
491
492 xfs_iunlock(quotip, XFS_ILOCK_SHARED);
493 if (error)
494 return error;
495
496 ASSERT(nmaps == 1);
497 ASSERT(map.br_blockcount == 1);
498
499 /*
500 * Offset of dquot in the (fixed sized) dquot chunk.
501 */
502 dqp->q_bufoffset = (id % mp->m_quotainfo->qi_dqperchunk) *
503 sizeof(xfs_dqblk_t);
504
505 ASSERT(map.br_startblock != DELAYSTARTBLOCK);
506 if (map.br_startblock == HOLESTARTBLOCK) {
507 /*
508 * We don't allocate unless we're asked to
509 */
510 if (!(flags & XFS_QMOPT_DQALLOC))
511 return ENOENT;
512
513 ASSERT(tp);
514 error = xfs_qm_dqalloc(tpp, mp, dqp, quotip,
515 dqp->q_fileoffset, &bp);
516 if (error)
517 return error;
518 tp = *tpp;
519 } else {
520 trace_xfs_dqtobp_read(dqp);
521
522 /*
523 * store the blkno etc so that we don't have to do the
524 * mapping all the time
525 */
526 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
527
528 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
529 dqp->q_blkno,
530 mp->m_quotainfo->qi_dqchunklen,
531 0, &bp);
532 if (error || !bp)
533 return XFS_ERROR(error);
534 }
535
536 ASSERT(xfs_buf_islocked(bp));
537
538 /*
539 * calculate the location of the dquot inside the buffer.
540 */
541 ddq = bp->b_addr + dqp->q_bufoffset;
542
543 /*
544 * A simple sanity check in case we got a corrupted dquot...
545 */
546 error = xfs_qm_dqcheck(mp, ddq, id, dqp->dq_flags & XFS_DQ_ALLTYPES,
547 flags & (XFS_QMOPT_DQREPAIR|XFS_QMOPT_DOWARN),
548 "dqtobp");
549 if (error) {
550 if (!(flags & XFS_QMOPT_DQREPAIR)) {
551 xfs_trans_brelse(tp, bp);
552 return XFS_ERROR(EIO);
553 }
554 }
555
556 *O_bpp = bp;
557 *O_ddpp = ddq;
558
559 return (0);
560}
561
562
563/*
564 * Read in the ondisk dquot using dqtobp() then copy it to an incore version,
565 * and release the buffer immediately.
566 *
567 */
568/* ARGSUSED */
569STATIC int
570xfs_qm_dqread(
571 xfs_trans_t **tpp,
572 xfs_dqid_t id,
573 xfs_dquot_t *dqp, /* dquot to get filled in */
574 uint flags)
575{
576 xfs_disk_dquot_t *ddqp;
577 xfs_buf_t *bp;
578 int error;
579 xfs_trans_t *tp;
580
581 ASSERT(tpp);
582
583 trace_xfs_dqread(dqp);
584
585 /*
586 * get a pointer to the on-disk dquot and the buffer containing it
587 * dqp already knows its own type (GROUP/USER).
588 */
589 if ((error = xfs_qm_dqtobp(tpp, dqp, &ddqp, &bp, flags))) {
590 return (error);
591 }
592 tp = *tpp;
593
594 /* copy everything from disk dquot to the incore dquot */
595 memcpy(&dqp->q_core, ddqp, sizeof(xfs_disk_dquot_t));
596 ASSERT(be32_to_cpu(dqp->q_core.d_id) == id);
597 xfs_qm_dquot_logitem_init(dqp);
598
599 /*
600 * Reservation counters are defined as reservation plus current usage
601 * to avoid having to add every time.
602 */
603 dqp->q_res_bcount = be64_to_cpu(ddqp->d_bcount);
604 dqp->q_res_icount = be64_to_cpu(ddqp->d_icount);
605 dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount);
606
607 /* Mark the buf so that this will stay incore a little longer */
608 XFS_BUF_SET_VTYPE_REF(bp, B_FS_DQUOT, XFS_DQUOT_REF);
609
610 /*
611 * We got the buffer with a xfs_trans_read_buf() (in dqtobp())
612 * So we need to release with xfs_trans_brelse().
613 * The strategy here is identical to that of inodes; we lock
614 * the dquot in xfs_qm_dqget() before making it accessible to
615 * others. This is because dquots, like inodes, need a good level of
616 * concurrency, and we don't want to take locks on the entire buffers
617 * for dquot accesses.
618 * Note also that the dquot buffer may even be dirty at this point, if
619 * this particular dquot was repaired. We still aren't afraid to
620 * brelse it because we have the changes incore.
621 */
622 ASSERT(xfs_buf_islocked(bp));
623 xfs_trans_brelse(tp, bp);
624
625 return (error);
626}
627
628
629/*
630 * allocate an incore dquot from the kernel heap,
631 * and fill its core with quota information kept on disk.
632 * If XFS_QMOPT_DQALLOC is set, it'll allocate a dquot on disk
633 * if it wasn't already allocated.
634 */
635STATIC int
636xfs_qm_idtodq(
637 xfs_mount_t *mp,
638 xfs_dqid_t id, /* gid or uid, depending on type */
639 uint type, /* UDQUOT or GDQUOT */
640 uint flags, /* DQALLOC, DQREPAIR */
641 xfs_dquot_t **O_dqpp)/* OUT : incore dquot, not locked */
642{
643 xfs_dquot_t *dqp;
644 int error;
645 xfs_trans_t *tp;
646 int cancelflags=0;
647
648 dqp = xfs_qm_dqinit(mp, id, type);
649 tp = NULL;
650 if (flags & XFS_QMOPT_DQALLOC) {
651 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_DQALLOC);
652 error = xfs_trans_reserve(tp, XFS_QM_DQALLOC_SPACE_RES(mp),
653 XFS_WRITE_LOG_RES(mp) +
654 BBTOB(mp->m_quotainfo->qi_dqchunklen) - 1 +
655 128,
656 0,
657 XFS_TRANS_PERM_LOG_RES,
658 XFS_WRITE_LOG_COUNT);
659 if (error) {
660 cancelflags = 0;
661 goto error0;
662 }
663 cancelflags = XFS_TRANS_RELEASE_LOG_RES;
664 }
665
666 /*
667 * Read it from disk; xfs_dqread() takes care of
668 * all the necessary initialization of dquot's fields (locks, etc)
669 */
670 if ((error = xfs_qm_dqread(&tp, id, dqp, flags))) {
671 /*
672 * This can happen if quotas got turned off (ESRCH),
673 * or if the dquot didn't exist on disk and we ask to
674 * allocate (ENOENT).
675 */
676 trace_xfs_dqread_fail(dqp);
677 cancelflags |= XFS_TRANS_ABORT;
678 goto error0;
679 }
680 if (tp) {
681 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES)))
682 goto error1;
683 }
684
685 *O_dqpp = dqp;
686 return (0);
687
688 error0:
689 ASSERT(error);
690 if (tp)
691 xfs_trans_cancel(tp, cancelflags);
692 error1:
693 xfs_qm_dqdestroy(dqp);
694 *O_dqpp = NULL;
695 return (error);
696}
697
698/*
699 * Lookup a dquot in the incore dquot hashtable. We keep two separate
700 * hashtables for user and group dquots; and, these are global tables
701 * inside the XQM, not per-filesystem tables.
702 * The hash chain must be locked by caller, and it is left locked
703 * on return. Returning dquot is locked.
704 */
705STATIC int
706xfs_qm_dqlookup(
707 xfs_mount_t *mp,
708 xfs_dqid_t id,
709 xfs_dqhash_t *qh,
710 xfs_dquot_t **O_dqpp)
711{
712 xfs_dquot_t *dqp;
713 uint flist_locked;
714
715 ASSERT(mutex_is_locked(&qh->qh_lock));
716
717 flist_locked = B_FALSE;
718
719 /*
720 * Traverse the hashchain looking for a match
721 */
722 list_for_each_entry(dqp, &qh->qh_list, q_hashlist) {
723 /*
724 * We already have the hashlock. We don't need the
725 * dqlock to look at the id field of the dquot, since the
726 * id can't be modified without the hashlock anyway.
727 */
728 if (be32_to_cpu(dqp->q_core.d_id) == id && dqp->q_mount == mp) {
729 trace_xfs_dqlookup_found(dqp);
730
731 /*
732 * All in core dquots must be on the dqlist of mp
733 */
734 ASSERT(!list_empty(&dqp->q_mplist));
735
736 xfs_dqlock(dqp);
737 if (dqp->q_nrefs == 0) {
738 ASSERT(!list_empty(&dqp->q_freelist));
739 if (!mutex_trylock(&xfs_Gqm->qm_dqfrlist_lock)) {
740 trace_xfs_dqlookup_want(dqp);
741
742 /*
743 * We may have raced with dqreclaim_one()
744 * (and lost). So, flag that we don't
745 * want the dquot to be reclaimed.
746 */
747 dqp->dq_flags |= XFS_DQ_WANT;
748 xfs_dqunlock(dqp);
749 mutex_lock(&xfs_Gqm->qm_dqfrlist_lock);
750 xfs_dqlock(dqp);
751 dqp->dq_flags &= ~(XFS_DQ_WANT);
752 }
753 flist_locked = B_TRUE;
754 }
755
756 /*
757 * id couldn't have changed; we had the hashlock all
758 * along
759 */
760 ASSERT(be32_to_cpu(dqp->q_core.d_id) == id);
761
762 if (flist_locked) {
763 if (dqp->q_nrefs != 0) {
764 mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
765 flist_locked = B_FALSE;
766 } else {
767 /* take it off the freelist */
768 trace_xfs_dqlookup_freelist(dqp);
769 list_del_init(&dqp->q_freelist);
770 xfs_Gqm->qm_dqfrlist_cnt--;
771 }
772 }
773
774 XFS_DQHOLD(dqp);
775
776 if (flist_locked)
777 mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
778 /*
779 * move the dquot to the front of the hashchain
780 */
781 ASSERT(mutex_is_locked(&qh->qh_lock));
782 list_move(&dqp->q_hashlist, &qh->qh_list);
783 trace_xfs_dqlookup_done(dqp);
784 *O_dqpp = dqp;
785 return 0;
786 }
787 }
788
789 *O_dqpp = NULL;
790 ASSERT(mutex_is_locked(&qh->qh_lock));
791 return (1);
792}
793
794/*
795 * Given the file system, inode OR id, and type (UDQUOT/GDQUOT), return a
796 * a locked dquot, doing an allocation (if requested) as needed.
797 * When both an inode and an id are given, the inode's id takes precedence.
798 * That is, if the id changes while we don't hold the ilock inside this
799 * function, the new dquot is returned, not necessarily the one requested
800 * in the id argument.
801 */
802int
803xfs_qm_dqget(
804 xfs_mount_t *mp,
805 xfs_inode_t *ip, /* locked inode (optional) */
806 xfs_dqid_t id, /* uid/projid/gid depending on type */
807 uint type, /* XFS_DQ_USER/XFS_DQ_PROJ/XFS_DQ_GROUP */
808 uint flags, /* DQALLOC, DQSUSER, DQREPAIR, DOWARN */
809 xfs_dquot_t **O_dqpp) /* OUT : locked incore dquot */
810{
811 xfs_dquot_t *dqp;
812 xfs_dqhash_t *h;
813 uint version;
814 int error;
815
816 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
817 if ((! XFS_IS_UQUOTA_ON(mp) && type == XFS_DQ_USER) ||
818 (! XFS_IS_PQUOTA_ON(mp) && type == XFS_DQ_PROJ) ||
819 (! XFS_IS_GQUOTA_ON(mp) && type == XFS_DQ_GROUP)) {
820 return (ESRCH);
821 }
822 h = XFS_DQ_HASH(mp, id, type);
823
824#ifdef DEBUG
825 if (xfs_do_dqerror) {
826 if ((xfs_dqerror_target == mp->m_ddev_targp) &&
827 (xfs_dqreq_num++ % xfs_dqerror_mod) == 0) {
828 xfs_debug(mp, "Returning error in dqget");
829 return (EIO);
830 }
831 }
832#endif
833
834 again:
835
836#ifdef DEBUG
837 ASSERT(type == XFS_DQ_USER ||
838 type == XFS_DQ_PROJ ||
839 type == XFS_DQ_GROUP);
840 if (ip) {
841 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
842 if (type == XFS_DQ_USER)
843 ASSERT(ip->i_udquot == NULL);
844 else
845 ASSERT(ip->i_gdquot == NULL);
846 }
847#endif
848 mutex_lock(&h->qh_lock);
849
850 /*
851 * Look in the cache (hashtable).
852 * The chain is kept locked during lookup.
853 */
854 if (xfs_qm_dqlookup(mp, id, h, O_dqpp) == 0) {
855 XQM_STATS_INC(xqmstats.xs_qm_dqcachehits);
856 /*
857 * The dquot was found, moved to the front of the chain,
858 * taken off the freelist if it was on it, and locked
859 * at this point. Just unlock the hashchain and return.
860 */
861 ASSERT(*O_dqpp);
862 ASSERT(XFS_DQ_IS_LOCKED(*O_dqpp));
863 mutex_unlock(&h->qh_lock);
864 trace_xfs_dqget_hit(*O_dqpp);
865 return (0); /* success */
866 }
867 XQM_STATS_INC(xqmstats.xs_qm_dqcachemisses);
868
869 /*
870 * Dquot cache miss. We don't want to keep the inode lock across
871 * a (potential) disk read. Also we don't want to deal with the lock
872 * ordering between quotainode and this inode. OTOH, dropping the inode
873 * lock here means dealing with a chown that can happen before
874 * we re-acquire the lock.
875 */
876 if (ip)
877 xfs_iunlock(ip, XFS_ILOCK_EXCL);
878 /*
879 * Save the hashchain version stamp, and unlock the chain, so that
880 * we don't keep the lock across a disk read
881 */
882 version = h->qh_version;
883 mutex_unlock(&h->qh_lock);
884
885 /*
886 * Allocate the dquot on the kernel heap, and read the ondisk
887 * portion off the disk. Also, do all the necessary initialization
888 * This can return ENOENT if dquot didn't exist on disk and we didn't
889 * ask it to allocate; ESRCH if quotas got turned off suddenly.
890 */
891 if ((error = xfs_qm_idtodq(mp, id, type,
892 flags & (XFS_QMOPT_DQALLOC|XFS_QMOPT_DQREPAIR|
893 XFS_QMOPT_DOWARN),
894 &dqp))) {
895 if (ip)
896 xfs_ilock(ip, XFS_ILOCK_EXCL);
897 return (error);
898 }
899
900 /*
901 * See if this is mount code calling to look at the overall quota limits
902 * which are stored in the id == 0 user or group's dquot.
903 * Since we may not have done a quotacheck by this point, just return
904 * the dquot without attaching it to any hashtables, lists, etc, or even
905 * taking a reference.
906 * The caller must dqdestroy this once done.
907 */
908 if (flags & XFS_QMOPT_DQSUSER) {
909 ASSERT(id == 0);
910 ASSERT(! ip);
911 goto dqret;
912 }
913
914 /*
915 * Dquot lock comes after hashlock in the lock ordering
916 */
917 if (ip) {
918 xfs_ilock(ip, XFS_ILOCK_EXCL);
919
920 /*
921 * A dquot could be attached to this inode by now, since
922 * we had dropped the ilock.
923 */
924 if (type == XFS_DQ_USER) {
925 if (!XFS_IS_UQUOTA_ON(mp)) {
926 /* inode stays locked on return */
927 xfs_qm_dqdestroy(dqp);
928 return XFS_ERROR(ESRCH);
929 }
930 if (ip->i_udquot) {
931 xfs_qm_dqdestroy(dqp);
932 dqp = ip->i_udquot;
933 xfs_dqlock(dqp);
934 goto dqret;
935 }
936 } else {
937 if (!XFS_IS_OQUOTA_ON(mp)) {
938 /* inode stays locked on return */
939 xfs_qm_dqdestroy(dqp);
940 return XFS_ERROR(ESRCH);
941 }
942 if (ip->i_gdquot) {
943 xfs_qm_dqdestroy(dqp);
944 dqp = ip->i_gdquot;
945 xfs_dqlock(dqp);
946 goto dqret;
947 }
948 }
949 }
950
951 /*
952 * Hashlock comes after ilock in lock order
953 */
954 mutex_lock(&h->qh_lock);
955 if (version != h->qh_version) {
956 xfs_dquot_t *tmpdqp;
957 /*
958 * Now, see if somebody else put the dquot in the
959 * hashtable before us. This can happen because we didn't
960 * keep the hashchain lock. We don't have to worry about
961 * lock order between the two dquots here since dqp isn't
962 * on any findable lists yet.
963 */
964 if (xfs_qm_dqlookup(mp, id, h, &tmpdqp) == 0) {
965 /*
966 * Duplicate found. Just throw away the new dquot
967 * and start over.
968 */
969 xfs_qm_dqput(tmpdqp);
970 mutex_unlock(&h->qh_lock);
971 xfs_qm_dqdestroy(dqp);
972 XQM_STATS_INC(xqmstats.xs_qm_dquot_dups);
973 goto again;
974 }
975 }
976
977 /*
978 * Put the dquot at the beginning of the hash-chain and mp's list
979 * LOCK ORDER: hashlock, freelistlock, mplistlock, udqlock, gdqlock ..
980 */
981 ASSERT(mutex_is_locked(&h->qh_lock));
982 dqp->q_hash = h;
983 list_add(&dqp->q_hashlist, &h->qh_list);
984 h->qh_version++;
985
986 /*
987 * Attach this dquot to this filesystem's list of all dquots,
988 * kept inside the mount structure in m_quotainfo field
989 */
990 mutex_lock(&mp->m_quotainfo->qi_dqlist_lock);
991
992 /*
993 * We return a locked dquot to the caller, with a reference taken
994 */
995 xfs_dqlock(dqp);
996 dqp->q_nrefs = 1;
997
998 list_add(&dqp->q_mplist, &mp->m_quotainfo->qi_dqlist);
999 mp->m_quotainfo->qi_dquots++;
1000 mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);
1001 mutex_unlock(&h->qh_lock);
1002 dqret:
1003 ASSERT((ip == NULL) || xfs_isilocked(ip, XFS_ILOCK_EXCL));
1004 trace_xfs_dqget_miss(dqp);
1005 *O_dqpp = dqp;
1006 return (0);
1007}
1008
1009
1010/*
1011 * Release a reference to the dquot (decrement ref-count)
1012 * and unlock it. If there is a group quota attached to this
1013 * dquot, carefully release that too without tripping over
1014 * deadlocks'n'stuff.
1015 */
1016void
1017xfs_qm_dqput(
1018 xfs_dquot_t *dqp)
1019{
1020 xfs_dquot_t *gdqp;
1021
1022 ASSERT(dqp->q_nrefs > 0);
1023 ASSERT(XFS_DQ_IS_LOCKED(dqp));
1024
1025 trace_xfs_dqput(dqp);
1026
1027 if (dqp->q_nrefs != 1) {
1028 dqp->q_nrefs--;
1029 xfs_dqunlock(dqp);
1030 return;
1031 }
1032
1033 /*
1034 * drop the dqlock and acquire the freelist and dqlock
1035 * in the right order; but try to get it out-of-order first
1036 */
1037 if (!mutex_trylock(&xfs_Gqm->qm_dqfrlist_lock)) {
1038 trace_xfs_dqput_wait(dqp);
1039 xfs_dqunlock(dqp);
1040 mutex_lock(&xfs_Gqm->qm_dqfrlist_lock);
1041 xfs_dqlock(dqp);
1042 }
1043
1044 while (1) {
1045 gdqp = NULL;
1046
1047 /* We can't depend on nrefs being == 1 here */
1048 if (--dqp->q_nrefs == 0) {
1049 trace_xfs_dqput_free(dqp);
1050
1051 list_add_tail(&dqp->q_freelist, &xfs_Gqm->qm_dqfrlist);
1052 xfs_Gqm->qm_dqfrlist_cnt++;
1053
1054 /*
1055 * If we just added a udquot to the freelist, then
1056 * we want to release the gdquot reference that
1057 * it (probably) has. Otherwise it'll keep the
1058 * gdquot from getting reclaimed.
1059 */
1060 if ((gdqp = dqp->q_gdquot)) {
1061 /*
1062 * Avoid a recursive dqput call
1063 */
1064 xfs_dqlock(gdqp);
1065 dqp->q_gdquot = NULL;
1066 }
1067 }
1068 xfs_dqunlock(dqp);
1069
1070 /*
1071 * If we had a group quota inside the user quota as a hint,
1072 * release it now.
1073 */
1074 if (! gdqp)
1075 break;
1076 dqp = gdqp;
1077 }
1078 mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
1079}
1080
1081/*
1082 * Release a dquot. Flush it if dirty, then dqput() it.
1083 * dquot must not be locked.
1084 */
1085void
1086xfs_qm_dqrele(
1087 xfs_dquot_t *dqp)
1088{
1089 if (!dqp)
1090 return;
1091
1092 trace_xfs_dqrele(dqp);
1093
1094 xfs_dqlock(dqp);
1095 /*
1096 * We don't care to flush it if the dquot is dirty here.
1097 * That will create stutters that we want to avoid.
1098 * Instead we do a delayed write when we try to reclaim
1099 * a dirty dquot. Also xfs_sync will take part of the burden...
1100 */
1101 xfs_qm_dqput(dqp);
1102}
1103
1104/*
1105 * This is the dquot flushing I/O completion routine. It is called
1106 * from interrupt level when the buffer containing the dquot is
1107 * flushed to disk. It is responsible for removing the dquot logitem
1108 * from the AIL if it has not been re-logged, and unlocking the dquot's
1109 * flush lock. This behavior is very similar to that of inodes..
1110 */
1111STATIC void
1112xfs_qm_dqflush_done(
1113 struct xfs_buf *bp,
1114 struct xfs_log_item *lip)
1115{
1116 xfs_dq_logitem_t *qip = (struct xfs_dq_logitem *)lip;
1117 xfs_dquot_t *dqp = qip->qli_dquot;
1118 struct xfs_ail *ailp = lip->li_ailp;
1119
1120 /*
1121 * We only want to pull the item from the AIL if its
1122 * location in the log has not changed since we started the flush.
1123 * Thus, we only bother if the dquot's lsn has
1124 * not changed. First we check the lsn outside the lock
1125 * since it's cheaper, and then we recheck while
1126 * holding the lock before removing the dquot from the AIL.
1127 */
1128 if ((lip->li_flags & XFS_LI_IN_AIL) &&
1129 lip->li_lsn == qip->qli_flush_lsn) {
1130
1131 /* xfs_trans_ail_delete() drops the AIL lock. */
1132 spin_lock(&ailp->xa_lock);
1133 if (lip->li_lsn == qip->qli_flush_lsn)
1134 xfs_trans_ail_delete(ailp, lip);
1135 else
1136 spin_unlock(&ailp->xa_lock);
1137 }
1138
1139 /*
1140 * Release the dq's flush lock since we're done with it.
1141 */
1142 xfs_dqfunlock(dqp);
1143}
1144
1145/*
1146 * Write a modified dquot to disk.
1147 * The dquot must be locked and the flush lock too taken by caller.
1148 * The flush lock will not be unlocked until the dquot reaches the disk,
1149 * but the dquot is free to be unlocked and modified by the caller
1150 * in the interim. Dquot is still locked on return. This behavior is
1151 * identical to that of inodes.
1152 */
1153int
1154xfs_qm_dqflush(
1155 xfs_dquot_t *dqp,
1156 uint flags)
1157{
1158 struct xfs_mount *mp = dqp->q_mount;
1159 struct xfs_buf *bp;
1160 struct xfs_disk_dquot *ddqp;
1161 int error;
1162
1163 ASSERT(XFS_DQ_IS_LOCKED(dqp));
1164 ASSERT(!completion_done(&dqp->q_flush));
1165
1166 trace_xfs_dqflush(dqp);
1167
1168 /*
1169 * If not dirty, or it's pinned and we are not supposed to block, nada.
1170 */
1171 if (!XFS_DQ_IS_DIRTY(dqp) ||
1172 (!(flags & SYNC_WAIT) && atomic_read(&dqp->q_pincount) > 0)) {
1173 xfs_dqfunlock(dqp);
1174 return 0;
1175 }
1176 xfs_qm_dqunpin_wait(dqp);
1177
1178 /*
1179 * This may have been unpinned because the filesystem is shutting
1180 * down forcibly. If that's the case we must not write this dquot
1181 * to disk, because the log record didn't make it to disk!
1182 */
1183 if (XFS_FORCED_SHUTDOWN(mp)) {
1184 dqp->dq_flags &= ~XFS_DQ_DIRTY;
1185 xfs_dqfunlock(dqp);
1186 return XFS_ERROR(EIO);
1187 }
1188
1189 /*
1190 * Get the buffer containing the on-disk dquot
1191 */
1192 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,
1193 mp->m_quotainfo->qi_dqchunklen, 0, &bp);
1194 if (error) {
1195 ASSERT(error != ENOENT);
1196 xfs_dqfunlock(dqp);
1197 return error;
1198 }
1199
1200 /*
1201 * Calculate the location of the dquot inside the buffer.
1202 */
1203 ddqp = bp->b_addr + dqp->q_bufoffset;
1204
1205 /*
1206 * A simple sanity check in case we got a corrupted dquot..
1207 */
1208 error = xfs_qm_dqcheck(mp, &dqp->q_core, be32_to_cpu(ddqp->d_id), 0,
1209 XFS_QMOPT_DOWARN, "dqflush (incore copy)");
1210 if (error) {
1211 xfs_buf_relse(bp);
1212 xfs_dqfunlock(dqp);
1213 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1214 return XFS_ERROR(EIO);
1215 }
1216
1217 /* This is the only portion of data that needs to persist */
1218 memcpy(ddqp, &dqp->q_core, sizeof(xfs_disk_dquot_t));
1219
1220 /*
1221 * Clear the dirty field and remember the flush lsn for later use.
1222 */
1223 dqp->dq_flags &= ~XFS_DQ_DIRTY;
1224
1225 xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn,
1226 &dqp->q_logitem.qli_item.li_lsn);
1227
1228 /*
1229 * Attach an iodone routine so that we can remove this dquot from the
1230 * AIL and release the flush lock once the dquot is synced to disk.
1231 */
1232 xfs_buf_attach_iodone(bp, xfs_qm_dqflush_done,
1233 &dqp->q_logitem.qli_item);
1234
1235 /*
1236 * If the buffer is pinned then push on the log so we won't
1237 * get stuck waiting in the write for too long.
1238 */
1239 if (xfs_buf_ispinned(bp)) {
1240 trace_xfs_dqflush_force(dqp);
1241 xfs_log_force(mp, 0);
1242 }
1243
1244 if (flags & SYNC_WAIT)
1245 error = xfs_bwrite(mp, bp);
1246 else
1247 xfs_bdwrite(mp, bp);
1248
1249 trace_xfs_dqflush_done(dqp);
1250
1251 /*
1252 * dqp is still locked, but caller is free to unlock it now.
1253 */
1254 return error;
1255
1256}
1257
1258int
1259xfs_qm_dqlock_nowait(
1260 xfs_dquot_t *dqp)
1261{
1262 return mutex_trylock(&dqp->q_qlock);
1263}
1264
1265void
1266xfs_dqlock(
1267 xfs_dquot_t *dqp)
1268{
1269 mutex_lock(&dqp->q_qlock);
1270}
1271
1272void
1273xfs_dqunlock(
1274 xfs_dquot_t *dqp)
1275{
1276 mutex_unlock(&(dqp->q_qlock));
1277 if (dqp->q_logitem.qli_dquot == dqp) {
1278 /* Once was dqp->q_mount, but might just have been cleared */
1279 xfs_trans_unlocked_item(dqp->q_logitem.qli_item.li_ailp,
1280 (xfs_log_item_t*)&(dqp->q_logitem));
1281 }
1282}
1283
1284
1285void
1286xfs_dqunlock_nonotify(
1287 xfs_dquot_t *dqp)
1288{
1289 mutex_unlock(&(dqp->q_qlock));
1290}
1291
1292/*
1293 * Lock two xfs_dquot structures.
1294 *
1295 * To avoid deadlocks we always lock the quota structure with
1296 * the lowerd id first.
1297 */
1298void
1299xfs_dqlock2(
1300 xfs_dquot_t *d1,
1301 xfs_dquot_t *d2)
1302{
1303 if (d1 && d2) {
1304 ASSERT(d1 != d2);
1305 if (be32_to_cpu(d1->q_core.d_id) >
1306 be32_to_cpu(d2->q_core.d_id)) {
1307 mutex_lock(&d2->q_qlock);
1308 mutex_lock_nested(&d1->q_qlock, XFS_QLOCK_NESTED);
1309 } else {
1310 mutex_lock(&d1->q_qlock);
1311 mutex_lock_nested(&d2->q_qlock, XFS_QLOCK_NESTED);
1312 }
1313 } else if (d1) {
1314 mutex_lock(&d1->q_qlock);
1315 } else if (d2) {
1316 mutex_lock(&d2->q_qlock);
1317 }
1318}
1319
1320
1321/*
1322 * Take a dquot out of the mount's dqlist as well as the hashlist.
1323 * This is called via unmount as well as quotaoff, and the purge
1324 * will always succeed unless there are soft (temp) references
1325 * outstanding.
1326 *
1327 * This returns 0 if it was purged, 1 if it wasn't. It's not an error code
1328 * that we're returning! XXXsup - not cool.
1329 */
1330/* ARGSUSED */
1331int
1332xfs_qm_dqpurge(
1333 xfs_dquot_t *dqp)
1334{
1335 xfs_dqhash_t *qh = dqp->q_hash;
1336 xfs_mount_t *mp = dqp->q_mount;
1337
1338 ASSERT(mutex_is_locked(&mp->m_quotainfo->qi_dqlist_lock));
1339 ASSERT(mutex_is_locked(&dqp->q_hash->qh_lock));
1340
1341 xfs_dqlock(dqp);
1342 /*
1343 * We really can't afford to purge a dquot that is
1344 * referenced, because these are hard refs.
1345 * It shouldn't happen in general because we went thru _all_ inodes in
1346 * dqrele_all_inodes before calling this and didn't let the mountlock go.
1347 * However it is possible that we have dquots with temporary
1348 * references that are not attached to an inode. e.g. see xfs_setattr().
1349 */
1350 if (dqp->q_nrefs != 0) {
1351 xfs_dqunlock(dqp);
1352 mutex_unlock(&dqp->q_hash->qh_lock);
1353 return (1);
1354 }
1355
1356 ASSERT(!list_empty(&dqp->q_freelist));
1357
1358 /*
1359 * If we're turning off quotas, we have to make sure that, for
1360 * example, we don't delete quota disk blocks while dquots are
1361 * in the process of getting written to those disk blocks.
1362 * This dquot might well be on AIL, and we can't leave it there
1363 * if we're turning off quotas. Basically, we need this flush
1364 * lock, and are willing to block on it.
1365 */
1366 if (!xfs_dqflock_nowait(dqp)) {
1367 /*
1368 * Block on the flush lock after nudging dquot buffer,
1369 * if it is incore.
1370 */
1371 xfs_qm_dqflock_pushbuf_wait(dqp);
1372 }
1373
1374 /*
1375 * XXXIf we're turning this type of quotas off, we don't care
1376 * about the dirty metadata sitting in this dquot. OTOH, if
1377 * we're unmounting, we do care, so we flush it and wait.
1378 */
1379 if (XFS_DQ_IS_DIRTY(dqp)) {
1380 int error;
1381
1382 /* dqflush unlocks dqflock */
1383 /*
1384 * Given that dqpurge is a very rare occurrence, it is OK
1385 * that we're holding the hashlist and mplist locks
1386 * across the disk write. But, ... XXXsup
1387 *
1388 * We don't care about getting disk errors here. We need
1389 * to purge this dquot anyway, so we go ahead regardless.
1390 */
1391 error = xfs_qm_dqflush(dqp, SYNC_WAIT);
1392 if (error)
1393 xfs_warn(mp, "%s: dquot %p flush failed",
1394 __func__, dqp);
1395 xfs_dqflock(dqp);
1396 }
1397 ASSERT(atomic_read(&dqp->q_pincount) == 0);
1398 ASSERT(XFS_FORCED_SHUTDOWN(mp) ||
1399 !(dqp->q_logitem.qli_item.li_flags & XFS_LI_IN_AIL));
1400
1401 list_del_init(&dqp->q_hashlist);
1402 qh->qh_version++;
1403 list_del_init(&dqp->q_mplist);
1404 mp->m_quotainfo->qi_dqreclaims++;
1405 mp->m_quotainfo->qi_dquots--;
1406 /*
1407 * XXX Move this to the front of the freelist, if we can get the
1408 * freelist lock.
1409 */
1410 ASSERT(!list_empty(&dqp->q_freelist));
1411
1412 dqp->q_mount = NULL;
1413 dqp->q_hash = NULL;
1414 dqp->dq_flags = XFS_DQ_INACTIVE;
1415 memset(&dqp->q_core, 0, sizeof(dqp->q_core));
1416 xfs_dqfunlock(dqp);
1417 xfs_dqunlock(dqp);
1418 mutex_unlock(&qh->qh_lock);
1419 return (0);
1420}
1421
1422
1423/*
1424 * Give the buffer a little push if it is incore and
1425 * wait on the flush lock.
1426 */
1427void
1428xfs_qm_dqflock_pushbuf_wait(
1429 xfs_dquot_t *dqp)
1430{
1431 xfs_mount_t *mp = dqp->q_mount;
1432 xfs_buf_t *bp;
1433
1434 /*
1435 * Check to see if the dquot has been flushed delayed
1436 * write. If so, grab its buffer and send it
1437 * out immediately. We'll be able to acquire
1438 * the flush lock when the I/O completes.
1439 */
1440 bp = xfs_incore(mp->m_ddev_targp, dqp->q_blkno,
1441 mp->m_quotainfo->qi_dqchunklen, XBF_TRYLOCK);
1442 if (!bp)
1443 goto out_lock;
1444
1445 if (XFS_BUF_ISDELAYWRITE(bp)) {
1446 if (xfs_buf_ispinned(bp))
1447 xfs_log_force(mp, 0);
1448 xfs_buf_delwri_promote(bp);
1449 wake_up_process(bp->b_target->bt_task);
1450 }
1451 xfs_buf_relse(bp);
1452out_lock:
1453 xfs_dqflock(dqp);
1454}
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-12 14:25:12 -0400