2 * Copyright (c) 2000-2003 Silicon Graphics, Inc. All Rights Reserved.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of version 2 of the GNU General Public License as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it would be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12 * Further, this software is distributed without any warranty that it is
13 * free of the rightful claim of any third person regarding infringement
14 * or the like. Any license provided herein, whether implied or
15 * otherwise, applies only to this software file. Patent licenses, if
16 * any, provided herein do not apply to combinations of this program with
17 * other software, or any other product whatsoever.
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write the Free Software Foundation, Inc., 59
21 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
23 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24 * Mountain View, CA 94043, or:
28 * For further information regarding this notice, see:
30 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
38 #include "xfs_trans.h"
43 #include "xfs_alloc.h"
44 #include "xfs_dmapi.h"
45 #include "xfs_quota.h"
46 #include "xfs_mount.h"
47 #include "xfs_bmap_btree.h"
48 #include "xfs_alloc_btree.h"
49 #include "xfs_ialloc_btree.h"
50 #include "xfs_dir_sf.h"
51 #include "xfs_dir2_sf.h"
52 #include "xfs_attr_sf.h"
53 #include "xfs_dinode.h"
54 #include "xfs_inode.h"
55 #include "xfs_btree.h"
56 #include "xfs_ialloc.h"
58 #include "xfs_rtalloc.h"
59 #include "xfs_error.h"
60 #include "xfs_itable.h"
66 #include "xfs_buf_item.h"
67 #include "xfs_trans_space.h"
68 #include "xfs_trans_priv.h"
77 dquot hash-chain lock (hashlock)
78 xqm dquot freelist lock (freelistlock
79 mount's dquot list lock (mplistlock)
80 user dquot lock - lock ordering among dquots is based on the uid or gid
81 group dquot lock - similar to udquots. Between the two dquots, the udquot
82 has to be locked first.
83 pin lock - the dquot lock must be held to take this lock.
87 STATIC void xfs_qm_dqflush_done(xfs_buf_t *, xfs_dq_logitem_t *);
90 xfs_buftarg_t *xfs_dqerror_target;
93 int xfs_dqerror_mod = 33;
97 * Allocate and initialize a dquot. We don't always allocate fresh memory;
98 * we try to reclaim a free dquot if the number of incore dquots are above
100 * The only field inside the core that gets initialized at this point
101 * is the d_id field. The idea is to fill in the entire q_core
102 * when we read in the on disk dquot.
111 boolean_t brandnewdquot;
113 brandnewdquot = xfs_qm_dqalloc_incore(&dqp);
114 dqp->dq_flags = type;
115 INT_SET(dqp->q_core.d_id, ARCH_CONVERT, id);
119 * No need to re-initialize these if this is a reclaimed dquot.
122 dqp->dq_flnext = dqp->dq_flprev = dqp;
123 mutex_init(&dqp->q_qlock, MUTEX_DEFAULT, "xdq");
124 initnsema(&dqp->q_flock, 1, "fdq");
125 sv_init(&dqp->q_pinwait, SV_DEFAULT, "pdq");
127 #ifdef XFS_DQUOT_TRACE
128 dqp->q_trace = ktrace_alloc(DQUOT_TRACE_SIZE, KM_SLEEP);
129 xfs_dqtrace_entry(dqp, "DQINIT");
133 * Only the q_core portion was zeroed in dqreclaim_one().
134 * So, we need to reset others.
138 dqp->MPL_NEXT = dqp->HL_NEXT = NULL;
139 dqp->HL_PREVP = dqp->MPL_PREVP = NULL;
140 dqp->q_bufoffset = 0;
141 dqp->q_fileoffset = 0;
142 dqp->q_transp = NULL;
143 dqp->q_gdquot = NULL;
144 dqp->q_res_bcount = 0;
145 dqp->q_res_icount = 0;
146 dqp->q_res_rtbcount = 0;
149 ASSERT(dqp->dq_flnext == dqp->dq_flprev);
151 #ifdef XFS_DQUOT_TRACE
152 ASSERT(dqp->q_trace);
153 xfs_dqtrace_entry(dqp, "DQRECLAIMED_INIT");
158 * log item gets initialized later
164 * This is called to free all the memory associated with a dquot
170 ASSERT(! XFS_DQ_IS_ON_FREELIST(dqp));
172 mutex_destroy(&dqp->q_qlock);
173 freesema(&dqp->q_flock);
174 sv_destroy(&dqp->q_pinwait);
176 #ifdef XFS_DQUOT_TRACE
178 ktrace_free(dqp->q_trace);
181 kmem_zone_free(xfs_Gqm->qm_dqzone, dqp);
182 atomic_dec(&xfs_Gqm->qm_totaldquots);
186 * This is what a 'fresh' dquot inside a dquot chunk looks like on disk.
195 * Caller has zero'd the entire dquot 'chunk' already.
197 INT_SET(d->dd_diskdq.d_magic, ARCH_CONVERT, XFS_DQUOT_MAGIC);
198 INT_SET(d->dd_diskdq.d_version, ARCH_CONVERT, XFS_DQUOT_VERSION);
199 INT_SET(d->dd_diskdq.d_id, ARCH_CONVERT, id);
200 INT_SET(d->dd_diskdq.d_flags, ARCH_CONVERT, type);
204 #ifdef XFS_DQUOT_TRACE
206 * Dquot tracing for debugging.
216 xfs_dquot_t *udqp = NULL;
219 ASSERT(dqp->q_trace);
224 ktrace_enter(dqp->q_trace,
225 (void *)(__psint_t)DQUOT_KTRACE_ENTRY,
227 (void *)(__psint_t)dqp->q_nrefs,
228 (void *)(__psint_t)dqp->dq_flags,
229 (void *)(__psint_t)dqp->q_res_bcount,
230 (void *)(__psint_t)INT_GET(dqp->q_core.d_bcount,
232 (void *)(__psint_t)INT_GET(dqp->q_core.d_icount,
234 (void *)(__psint_t)INT_GET(dqp->q_core.d_blk_hardlimit,
236 (void *)(__psint_t)INT_GET(dqp->q_core.d_blk_softlimit,
238 (void *)(__psint_t)INT_GET(dqp->q_core.d_ino_hardlimit,
240 (void *)(__psint_t)INT_GET(dqp->q_core.d_ino_softlimit,
242 (void *)(__psint_t)INT_GET(dqp->q_core.d_id, ARCH_CONVERT),
243 (void *)(__psint_t)current_pid(),
244 (void *)(__psint_t)ino,
245 (void *)(__psint_t)retaddr,
246 (void *)(__psint_t)udqp);
253 * If default limits are in force, push them into the dquot now.
254 * We overwrite the dquot limits only if they are zero and this
255 * is not the root dquot.
258 xfs_qm_adjust_dqlimits(
262 xfs_quotainfo_t *q = mp->m_quotainfo;
266 if (q->qi_bsoftlimit && !d->d_blk_softlimit)
267 INT_SET(d->d_blk_softlimit, ARCH_CONVERT, q->qi_bsoftlimit);
268 if (q->qi_bhardlimit && !d->d_blk_hardlimit)
269 INT_SET(d->d_blk_hardlimit, ARCH_CONVERT, q->qi_bhardlimit);
270 if (q->qi_isoftlimit && !d->d_ino_softlimit)
271 INT_SET(d->d_ino_softlimit, ARCH_CONVERT, q->qi_isoftlimit);
272 if (q->qi_ihardlimit && !d->d_ino_hardlimit)
273 INT_SET(d->d_ino_hardlimit, ARCH_CONVERT, q->qi_ihardlimit);
274 if (q->qi_rtbsoftlimit && !d->d_rtb_softlimit)
275 INT_SET(d->d_rtb_softlimit, ARCH_CONVERT, q->qi_rtbsoftlimit);
276 if (q->qi_rtbhardlimit && !d->d_rtb_hardlimit)
277 INT_SET(d->d_rtb_hardlimit, ARCH_CONVERT, q->qi_rtbhardlimit);
281 * Check the limits and timers of a dquot and start or reset timers
283 * This gets called even when quota enforcement is OFF, which makes our
284 * life a little less complicated. (We just don't reject any quota
285 * reservations in that case, when enforcement is off).
286 * We also return 0 as the values of the timers in Q_GETQUOTA calls, when
288 * In contrast, warnings are a little different in that they don't
289 * 'automatically' get started when limits get exceeded. They do
290 * get reset to zero, however, when we find the count to be under
291 * the soft limit (they are only ever set non-zero via userspace).
294 xfs_qm_adjust_dqtimers(
301 if (INT_GET(d->d_blk_hardlimit, ARCH_CONVERT))
302 ASSERT(INT_GET(d->d_blk_softlimit, ARCH_CONVERT) <=
303 INT_GET(d->d_blk_hardlimit, ARCH_CONVERT));
304 if (INT_GET(d->d_ino_hardlimit, ARCH_CONVERT))
305 ASSERT(INT_GET(d->d_ino_softlimit, ARCH_CONVERT) <=
306 INT_GET(d->d_ino_hardlimit, ARCH_CONVERT));
307 if (INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT))
308 ASSERT(INT_GET(d->d_rtb_softlimit, ARCH_CONVERT) <=
309 INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT));
312 if ((INT_GET(d->d_blk_softlimit, ARCH_CONVERT) &&
313 (INT_GET(d->d_bcount, ARCH_CONVERT) >=
314 INT_GET(d->d_blk_softlimit, ARCH_CONVERT))) ||
315 (INT_GET(d->d_blk_hardlimit, ARCH_CONVERT) &&
316 (INT_GET(d->d_bcount, ARCH_CONVERT) >=
317 INT_GET(d->d_blk_hardlimit, ARCH_CONVERT)))) {
318 INT_SET(d->d_btimer, ARCH_CONVERT,
319 get_seconds() + XFS_QI_BTIMELIMIT(mp));
324 if ((!d->d_blk_softlimit ||
325 (INT_GET(d->d_bcount, ARCH_CONVERT) <
326 INT_GET(d->d_blk_softlimit, ARCH_CONVERT))) &&
327 (!d->d_blk_hardlimit ||
328 (INT_GET(d->d_bcount, ARCH_CONVERT) <
329 INT_GET(d->d_blk_hardlimit, ARCH_CONVERT)))) {
335 if ((INT_GET(d->d_ino_softlimit, ARCH_CONVERT) &&
336 (INT_GET(d->d_icount, ARCH_CONVERT) >=
337 INT_GET(d->d_ino_softlimit, ARCH_CONVERT))) ||
338 (INT_GET(d->d_ino_hardlimit, ARCH_CONVERT) &&
339 (INT_GET(d->d_icount, ARCH_CONVERT) >=
340 INT_GET(d->d_ino_hardlimit, ARCH_CONVERT)))) {
341 INT_SET(d->d_itimer, ARCH_CONVERT,
342 get_seconds() + XFS_QI_ITIMELIMIT(mp));
347 if ((!d->d_ino_softlimit ||
348 (INT_GET(d->d_icount, ARCH_CONVERT) <
349 INT_GET(d->d_ino_softlimit, ARCH_CONVERT))) &&
350 (!d->d_ino_hardlimit ||
351 (INT_GET(d->d_icount, ARCH_CONVERT) <
352 INT_GET(d->d_ino_hardlimit, ARCH_CONVERT)))) {
357 if (!d->d_rtbtimer) {
358 if ((INT_GET(d->d_rtb_softlimit, ARCH_CONVERT) &&
359 (INT_GET(d->d_rtbcount, ARCH_CONVERT) >=
360 INT_GET(d->d_rtb_softlimit, ARCH_CONVERT))) ||
361 (INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT) &&
362 (INT_GET(d->d_rtbcount, ARCH_CONVERT) >=
363 INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT)))) {
364 INT_SET(d->d_rtbtimer, ARCH_CONVERT,
365 get_seconds() + XFS_QI_RTBTIMELIMIT(mp));
370 if ((!d->d_rtb_softlimit ||
371 (INT_GET(d->d_rtbcount, ARCH_CONVERT) <
372 INT_GET(d->d_rtb_softlimit, ARCH_CONVERT))) &&
373 (!d->d_rtb_hardlimit ||
374 (INT_GET(d->d_rtbcount, ARCH_CONVERT) <
375 INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT)))) {
382 * initialize a buffer full of dquots and log the whole thing
385 xfs_qm_init_dquot_blk(
396 ASSERT(XFS_BUF_ISBUSY(bp));
397 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
399 d = (xfs_dqblk_t *)XFS_BUF_PTR(bp);
402 * ID of the first dquot in the block - id's are zero based.
404 curid = id - (id % XFS_QM_DQPERBLK(mp));
406 memset(d, 0, BBTOB(XFS_QI_DQCHUNKLEN(mp)));
407 for (i = 0; i < XFS_QM_DQPERBLK(mp); i++, d++, curid++)
408 xfs_qm_dqinit_core(curid, type, d);
409 xfs_trans_dquot_buf(tp, bp,
410 (type & XFS_DQ_USER ? XFS_BLI_UDQUOT_BUF :
411 ((type & XFS_DQ_PROJ) ? XFS_BLI_PDQUOT_BUF :
412 XFS_BLI_GDQUOT_BUF)));
413 xfs_trans_log_buf(tp, bp, 0, BBTOB(XFS_QI_DQCHUNKLEN(mp)) - 1);
419 * Allocate a block and fill it with dquots.
420 * This is called when the bmapi finds a hole.
428 xfs_fileoff_t offset_fsb,
431 xfs_fsblock_t firstblock;
432 xfs_bmap_free_t flist;
434 int nmaps, error, committed;
436 xfs_trans_t *tp = *tpp;
439 xfs_dqtrace_entry(dqp, "DQALLOC");
442 * Initialize the bmap freelist prior to calling bmapi code.
444 XFS_BMAP_INIT(&flist, &firstblock);
445 xfs_ilock(quotip, XFS_ILOCK_EXCL);
447 * Return if this type of quotas is turned off while we didn't
450 if (XFS_IS_THIS_QUOTA_OFF(dqp)) {
451 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
456 * xfs_trans_commit normally decrements the vnode ref count
457 * when it unlocks the inode. Since we want to keep the quota
458 * inode around, we bump the vnode ref count now.
460 VN_HOLD(XFS_ITOV(quotip));
462 xfs_trans_ijoin(tp, quotip, XFS_ILOCK_EXCL);
464 if ((error = xfs_bmapi(tp, quotip,
465 offset_fsb, XFS_DQUOT_CLUSTER_SIZE_FSB,
466 XFS_BMAPI_METADATA | XFS_BMAPI_WRITE,
468 XFS_QM_DQALLOC_SPACE_RES(mp),
469 &map, &nmaps, &flist))) {
472 ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB);
474 ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
475 (map.br_startblock != HOLESTARTBLOCK));
478 * Keep track of the blkno to save a lookup later
480 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
482 /* now we can just get the buffer (there's nothing to read yet) */
483 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
485 XFS_QI_DQCHUNKLEN(mp),
487 if (!bp || (error = XFS_BUF_GETERROR(bp)))
490 * Make a chunk of dquots out of this buffer and log
493 xfs_qm_init_dquot_blk(tp, mp, INT_GET(dqp->q_core.d_id, ARCH_CONVERT),
494 dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
497 * xfs_bmap_finish() may commit the current transaction and
498 * start a second transaction if the freelist is not empty.
500 * Since we still want to modify this buffer, we need to
501 * ensure that the buffer is not released on commit of
502 * the first transaction and ensure the buffer is added to the
503 * second transaction.
505 * If there is only one transaction then don't stop the buffer
506 * from being released when it commits later on.
509 xfs_trans_bhold(tp, bp);
511 if ((error = xfs_bmap_finish(tpp, &flist, firstblock, &committed))) {
517 xfs_trans_bjoin(tp, bp);
519 xfs_trans_bhold_release(tp, bp);
526 xfs_bmap_cancel(&flist);
528 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
534 * Maps a dquot to the buffer containing its on-disk version.
535 * This returns a ptr to the buffer containing the on-disk dquot
536 * in the bpp param, and a ptr to the on-disk dquot within that buffer
542 xfs_disk_dquot_t **O_ddpp,
551 xfs_disk_dquot_t *ddq;
554 xfs_trans_t *tp = (tpp ? *tpp : NULL);
557 id = INT_GET(dqp->q_core.d_id, ARCH_CONVERT);
562 * If we don't know where the dquot lives, find out.
564 if (dqp->q_blkno == (xfs_daddr_t) 0) {
565 /* We use the id as an index */
566 dqp->q_fileoffset = (xfs_fileoff_t)id / XFS_QM_DQPERBLK(mp);
568 quotip = XFS_DQ_TO_QIP(dqp);
569 xfs_ilock(quotip, XFS_ILOCK_SHARED);
571 * Return if this type of quotas is turned off while we didn't
574 if (XFS_IS_THIS_QUOTA_OFF(dqp)) {
575 xfs_iunlock(quotip, XFS_ILOCK_SHARED);
579 * Find the block map; no allocations yet
581 error = xfs_bmapi(NULL, quotip, dqp->q_fileoffset,
582 XFS_DQUOT_CLUSTER_SIZE_FSB,
584 NULL, 0, &map, &nmaps, NULL);
586 xfs_iunlock(quotip, XFS_ILOCK_SHARED);
590 ASSERT(map.br_blockcount == 1);
593 * offset of dquot in the (fixed sized) dquot chunk.
595 dqp->q_bufoffset = (id % XFS_QM_DQPERBLK(mp)) *
597 if (map.br_startblock == HOLESTARTBLOCK) {
599 * We don't allocate unless we're asked to
601 if (!(flags & XFS_QMOPT_DQALLOC))
605 if ((error = xfs_qm_dqalloc(tpp, mp, dqp, quotip,
606 dqp->q_fileoffset, &bp)))
612 * store the blkno etc so that we don't have to do the
613 * mapping all the time
615 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
618 ASSERT(dqp->q_blkno != DELAYSTARTBLOCK);
619 ASSERT(dqp->q_blkno != HOLESTARTBLOCK);
622 * Read in the buffer, unless we've just done the allocation
623 * (in which case we already have the buf).
626 xfs_dqtrace_entry(dqp, "DQTOBP READBUF");
627 if ((error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
629 XFS_QI_DQCHUNKLEN(mp),
634 return XFS_ERROR(error);
636 ASSERT(XFS_BUF_ISBUSY(bp));
637 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
640 * calculate the location of the dquot inside the buffer.
642 ddq = (xfs_disk_dquot_t *)((char *)XFS_BUF_PTR(bp) + dqp->q_bufoffset);
645 * A simple sanity check in case we got a corrupted dquot...
647 if (xfs_qm_dqcheck(ddq, id, dqp->dq_flags & XFS_DQ_ALLTYPES,
648 flags & (XFS_QMOPT_DQREPAIR|XFS_QMOPT_DOWARN),
650 if (!(flags & XFS_QMOPT_DQREPAIR)) {
651 xfs_trans_brelse(tp, bp);
652 return XFS_ERROR(EIO);
654 XFS_BUF_BUSY(bp); /* We dirtied this */
665 * Read in the ondisk dquot using dqtobp() then copy it to an incore version,
666 * and release the buffer immediately.
674 xfs_dquot_t *dqp, /* dquot to get filled in */
677 xfs_disk_dquot_t *ddqp;
685 * get a pointer to the on-disk dquot and the buffer containing it
686 * dqp already knows its own type (GROUP/USER).
688 xfs_dqtrace_entry(dqp, "DQREAD");
689 if ((error = xfs_qm_dqtobp(tpp, dqp, &ddqp, &bp, flags))) {
694 /* copy everything from disk dquot to the incore dquot */
695 memcpy(&dqp->q_core, ddqp, sizeof(xfs_disk_dquot_t));
696 ASSERT(INT_GET(dqp->q_core.d_id, ARCH_CONVERT) == id);
697 xfs_qm_dquot_logitem_init(dqp);
700 * Reservation counters are defined as reservation plus current usage
701 * to avoid having to add everytime.
703 dqp->q_res_bcount = INT_GET(ddqp->d_bcount, ARCH_CONVERT);
704 dqp->q_res_icount = INT_GET(ddqp->d_icount, ARCH_CONVERT);
705 dqp->q_res_rtbcount = INT_GET(ddqp->d_rtbcount, ARCH_CONVERT);
707 /* Mark the buf so that this will stay incore a little longer */
708 XFS_BUF_SET_VTYPE_REF(bp, B_FS_DQUOT, XFS_DQUOT_REF);
711 * We got the buffer with a xfs_trans_read_buf() (in dqtobp())
712 * So we need to release with xfs_trans_brelse().
713 * The strategy here is identical to that of inodes; we lock
714 * the dquot in xfs_qm_dqget() before making it accessible to
715 * others. This is because dquots, like inodes, need a good level of
716 * concurrency, and we don't want to take locks on the entire buffers
717 * for dquot accesses.
718 * Note also that the dquot buffer may even be dirty at this point, if
719 * this particular dquot was repaired. We still aren't afraid to
720 * brelse it because we have the changes incore.
722 ASSERT(XFS_BUF_ISBUSY(bp));
723 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
724 xfs_trans_brelse(tp, bp);
731 * allocate an incore dquot from the kernel heap,
732 * and fill its core with quota information kept on disk.
733 * If XFS_QMOPT_DQALLOC is set, it'll allocate a dquot on disk
734 * if it wasn't already allocated.
739 xfs_dqid_t id, /* gid or uid, depending on type */
740 uint type, /* UDQUOT or GDQUOT */
741 uint flags, /* DQALLOC, DQREPAIR */
742 xfs_dquot_t **O_dqpp)/* OUT : incore dquot, not locked */
749 dqp = xfs_qm_dqinit(mp, id, type);
751 if (flags & XFS_QMOPT_DQALLOC) {
752 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_DQALLOC);
753 if ((error = xfs_trans_reserve(tp,
754 XFS_QM_DQALLOC_SPACE_RES(mp),
755 XFS_WRITE_LOG_RES(mp) +
756 BBTOB(XFS_QI_DQCHUNKLEN(mp)) - 1 +
759 XFS_TRANS_PERM_LOG_RES,
760 XFS_WRITE_LOG_COUNT))) {
764 cancelflags = XFS_TRANS_RELEASE_LOG_RES;
768 * Read it from disk; xfs_dqread() takes care of
769 * all the necessary initialization of dquot's fields (locks, etc)
771 if ((error = xfs_qm_dqread(&tp, id, dqp, flags))) {
773 * This can happen if quotas got turned off (ESRCH),
774 * or if the dquot didn't exist on disk and we ask to
777 xfs_dqtrace_entry(dqp, "DQREAD FAIL");
778 cancelflags |= XFS_TRANS_ABORT;
782 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES,
793 xfs_trans_cancel(tp, cancelflags);
795 xfs_qm_dqdestroy(dqp);
801 * Lookup a dquot in the incore dquot hashtable. We keep two separate
802 * hashtables for user and group dquots; and, these are global tables
803 * inside the XQM, not per-filesystem tables.
804 * The hash chain must be locked by caller, and it is left locked
805 * on return. Returning dquot is locked.
812 xfs_dquot_t **O_dqpp)
818 ASSERT(XFS_DQ_IS_HASH_LOCKED(qh));
820 flist_locked = B_FALSE;
823 * Traverse the hashchain looking for a match
825 for (dqp = qh->qh_next; dqp != NULL; dqp = dqp->HL_NEXT) {
827 * We already have the hashlock. We don't need the
828 * dqlock to look at the id field of the dquot, since the
829 * id can't be modified without the hashlock anyway.
831 if (INT_GET(dqp->q_core.d_id, ARCH_CONVERT) == id && dqp->q_mount == mp) {
832 xfs_dqtrace_entry(dqp, "DQFOUND BY LOOKUP");
834 * All in core dquots must be on the dqlist of mp
836 ASSERT(dqp->MPL_PREVP != NULL);
839 if (dqp->q_nrefs == 0) {
840 ASSERT (XFS_DQ_IS_ON_FREELIST(dqp));
841 if (! xfs_qm_freelist_lock_nowait(xfs_Gqm)) {
842 xfs_dqtrace_entry(dqp, "DQLOOKUP: WANT");
845 * We may have raced with dqreclaim_one()
846 * (and lost). So, flag that we don't
847 * want the dquot to be reclaimed.
849 dqp->dq_flags |= XFS_DQ_WANT;
851 xfs_qm_freelist_lock(xfs_Gqm);
853 dqp->dq_flags &= ~(XFS_DQ_WANT);
855 flist_locked = B_TRUE;
859 * id couldn't have changed; we had the hashlock all
862 ASSERT(INT_GET(dqp->q_core.d_id, ARCH_CONVERT) == id);
865 if (dqp->q_nrefs != 0) {
866 xfs_qm_freelist_unlock(xfs_Gqm);
867 flist_locked = B_FALSE;
870 * take it off the freelist
872 xfs_dqtrace_entry(dqp,
873 "DQLOOKUP: TAKEOFF FL");
874 XQM_FREELIST_REMOVE(dqp);
875 /* xfs_qm_freelist_print(&(xfs_Gqm->
887 xfs_qm_freelist_unlock(xfs_Gqm);
889 * move the dquot to the front of the hashchain
891 ASSERT(XFS_DQ_IS_HASH_LOCKED(qh));
892 if (dqp->HL_PREVP != &qh->qh_next) {
893 xfs_dqtrace_entry(dqp,
894 "DQLOOKUP: HASH MOVETOFRONT");
895 if ((d = dqp->HL_NEXT))
896 d->HL_PREVP = dqp->HL_PREVP;
897 *(dqp->HL_PREVP) = d;
899 d->HL_PREVP = &dqp->HL_NEXT;
901 dqp->HL_PREVP = &qh->qh_next;
904 xfs_dqtrace_entry(dqp, "LOOKUP END");
906 ASSERT(XFS_DQ_IS_HASH_LOCKED(qh));
912 ASSERT(XFS_DQ_IS_HASH_LOCKED(qh));
917 * Given the file system, inode OR id, and type (UDQUOT/GDQUOT), return a
918 * a locked dquot, doing an allocation (if requested) as needed.
919 * When both an inode and an id are given, the inode's id takes precedence.
920 * That is, if the id changes while we don't hold the ilock inside this
921 * function, the new dquot is returned, not necessarily the one requested
922 * in the id argument.
927 xfs_inode_t *ip, /* locked inode (optional) */
928 xfs_dqid_t id, /* uid/projid/gid depending on type */
929 uint type, /* XFS_DQ_USER/XFS_DQ_PROJ/XFS_DQ_GROUP */
930 uint flags, /* DQALLOC, DQSUSER, DQREPAIR, DOWARN */
931 xfs_dquot_t **O_dqpp) /* OUT : locked incore dquot */
938 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
939 if ((! XFS_IS_UQUOTA_ON(mp) && type == XFS_DQ_USER) ||
940 (! XFS_IS_PQUOTA_ON(mp) && type == XFS_DQ_PROJ) ||
941 (! XFS_IS_GQUOTA_ON(mp) && type == XFS_DQ_GROUP)) {
944 h = XFS_DQ_HASH(mp, id, type);
947 if (xfs_do_dqerror) {
948 if ((xfs_dqerror_target == mp->m_ddev_targp) &&
949 (xfs_dqreq_num++ % xfs_dqerror_mod) == 0) {
950 cmn_err(CE_DEBUG, "Returning error in dqget");
959 ASSERT(type == XFS_DQ_USER ||
960 type == XFS_DQ_PROJ ||
961 type == XFS_DQ_GROUP);
963 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
964 if (type == XFS_DQ_USER)
965 ASSERT(ip->i_udquot == NULL);
967 ASSERT(ip->i_gdquot == NULL);
973 * Look in the cache (hashtable).
974 * The chain is kept locked during lookup.
976 if (xfs_qm_dqlookup(mp, id, h, O_dqpp) == 0) {
977 XQM_STATS_INC(xqmstats.xs_qm_dqcachehits);
979 * The dquot was found, moved to the front of the chain,
980 * taken off the freelist if it was on it, and locked
981 * at this point. Just unlock the hashchain and return.
984 ASSERT(XFS_DQ_IS_LOCKED(*O_dqpp));
985 XFS_DQ_HASH_UNLOCK(h);
986 xfs_dqtrace_entry(*O_dqpp, "DQGET DONE (FROM CACHE)");
987 return (0); /* success */
989 XQM_STATS_INC(xqmstats.xs_qm_dqcachemisses);
992 * Dquot cache miss. We don't want to keep the inode lock across
993 * a (potential) disk read. Also we don't want to deal with the lock
994 * ordering between quotainode and this inode. OTOH, dropping the inode
995 * lock here means dealing with a chown that can happen before
996 * we re-acquire the lock.
999 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1001 * Save the hashchain version stamp, and unlock the chain, so that
1002 * we don't keep the lock across a disk read
1004 version = h->qh_version;
1005 XFS_DQ_HASH_UNLOCK(h);
1008 * Allocate the dquot on the kernel heap, and read the ondisk
1009 * portion off the disk. Also, do all the necessary initialization
1010 * This can return ENOENT if dquot didn't exist on disk and we didn't
1011 * ask it to allocate; ESRCH if quotas got turned off suddenly.
1013 if ((error = xfs_qm_idtodq(mp, id, type,
1014 flags & (XFS_QMOPT_DQALLOC|XFS_QMOPT_DQREPAIR|
1018 xfs_ilock(ip, XFS_ILOCK_EXCL);
1023 * See if this is mount code calling to look at the overall quota limits
1024 * which are stored in the id == 0 user or group's dquot.
1025 * Since we may not have done a quotacheck by this point, just return
1026 * the dquot without attaching it to any hashtables, lists, etc, or even
1027 * taking a reference.
1028 * The caller must dqdestroy this once done.
1030 if (flags & XFS_QMOPT_DQSUSER) {
1037 * Dquot lock comes after hashlock in the lock ordering
1040 xfs_ilock(ip, XFS_ILOCK_EXCL);
1041 if (! XFS_IS_DQTYPE_ON(mp, type)) {
1042 /* inode stays locked on return */
1043 xfs_qm_dqdestroy(dqp);
1044 return XFS_ERROR(ESRCH);
1047 * A dquot could be attached to this inode by now, since
1048 * we had dropped the ilock.
1050 if (type == XFS_DQ_USER) {
1052 xfs_qm_dqdestroy(dqp);
1059 xfs_qm_dqdestroy(dqp);
1068 * Hashlock comes after ilock in lock order
1070 XFS_DQ_HASH_LOCK(h);
1071 if (version != h->qh_version) {
1072 xfs_dquot_t *tmpdqp;
1074 * Now, see if somebody else put the dquot in the
1075 * hashtable before us. This can happen because we didn't
1076 * keep the hashchain lock. We don't have to worry about
1077 * lock order between the two dquots here since dqp isn't
1078 * on any findable lists yet.
1080 if (xfs_qm_dqlookup(mp, id, h, &tmpdqp) == 0) {
1082 * Duplicate found. Just throw away the new dquot
1085 xfs_qm_dqput(tmpdqp);
1086 XFS_DQ_HASH_UNLOCK(h);
1087 xfs_qm_dqdestroy(dqp);
1088 XQM_STATS_INC(xqmstats.xs_qm_dquot_dups);
1094 * Put the dquot at the beginning of the hash-chain and mp's list
1095 * LOCK ORDER: hashlock, freelistlock, mplistlock, udqlock, gdqlock ..
1097 ASSERT(XFS_DQ_IS_HASH_LOCKED(h));
1099 XQM_HASHLIST_INSERT(h, dqp);
1102 * Attach this dquot to this filesystem's list of all dquots,
1103 * kept inside the mount structure in m_quotainfo field
1105 xfs_qm_mplist_lock(mp);
1108 * We return a locked dquot to the caller, with a reference taken
1113 XQM_MPLIST_INSERT(&(XFS_QI_MPL_LIST(mp)), dqp);
1115 xfs_qm_mplist_unlock(mp);
1116 XFS_DQ_HASH_UNLOCK(h);
1118 ASSERT((ip == NULL) || XFS_ISLOCKED_INODE_EXCL(ip));
1119 xfs_dqtrace_entry(dqp, "DQGET DONE");
1126 * Release a reference to the dquot (decrement ref-count)
1127 * and unlock it. If there is a group quota attached to this
1128 * dquot, carefully release that too without tripping over
1129 * deadlocks'n'stuff.
1137 ASSERT(dqp->q_nrefs > 0);
1138 ASSERT(XFS_DQ_IS_LOCKED(dqp));
1139 xfs_dqtrace_entry(dqp, "DQPUT");
1141 if (dqp->q_nrefs != 1) {
1148 * drop the dqlock and acquire the freelist and dqlock
1149 * in the right order; but try to get it out-of-order first
1151 if (! xfs_qm_freelist_lock_nowait(xfs_Gqm)) {
1152 xfs_dqtrace_entry(dqp, "DQPUT: FLLOCK-WAIT");
1154 xfs_qm_freelist_lock(xfs_Gqm);
1161 /* We can't depend on nrefs being == 1 here */
1162 if (--dqp->q_nrefs == 0) {
1163 xfs_dqtrace_entry(dqp, "DQPUT: ON FREELIST");
1165 * insert at end of the freelist.
1167 XQM_FREELIST_INSERT(&(xfs_Gqm->qm_dqfreelist), dqp);
1170 * If we just added a udquot to the freelist, then
1171 * we want to release the gdquot reference that
1172 * it (probably) has. Otherwise it'll keep the
1173 * gdquot from getting reclaimed.
1175 if ((gdqp = dqp->q_gdquot)) {
1177 * Avoid a recursive dqput call
1180 dqp->q_gdquot = NULL;
1183 /* xfs_qm_freelist_print(&(xfs_Gqm->qm_dqfreelist),
1184 "@@@@@++ Free list (after append) @@@@@+");
1190 * If we had a group quota inside the user quota as a hint,
1197 xfs_qm_freelist_unlock(xfs_Gqm);
1201 * Release a dquot. Flush it if dirty, then dqput() it.
1202 * dquot must not be locked.
1209 xfs_dqtrace_entry(dqp, "DQRELE");
1213 * We don't care to flush it if the dquot is dirty here.
1214 * That will create stutters that we want to avoid.
1215 * Instead we do a delayed write when we try to reclaim
1216 * a dirty dquot. Also xfs_sync will take part of the burden...
1223 * Write a modified dquot to disk.
1224 * The dquot must be locked and the flush lock too taken by caller.
1225 * The flush lock will not be unlocked until the dquot reaches the disk,
1226 * but the dquot is free to be unlocked and modified by the caller
1227 * in the interim. Dquot is still locked on return. This behavior is
1228 * identical to that of inodes.
1237 xfs_disk_dquot_t *ddqp;
1241 ASSERT(XFS_DQ_IS_LOCKED(dqp));
1242 ASSERT(XFS_DQ_IS_FLUSH_LOCKED(dqp));
1243 xfs_dqtrace_entry(dqp, "DQFLUSH");
1246 * If not dirty, nada.
1248 if (!XFS_DQ_IS_DIRTY(dqp)) {
1254 * Cant flush a pinned dquot. Wait for it.
1256 xfs_qm_dqunpin_wait(dqp);
1259 * This may have been unpinned because the filesystem is shutting
1260 * down forcibly. If that's the case we must not write this dquot
1261 * to disk, because the log record didn't make it to disk!
1263 if (XFS_FORCED_SHUTDOWN(dqp->q_mount)) {
1264 dqp->dq_flags &= ~(XFS_DQ_DIRTY);
1266 return XFS_ERROR(EIO);
1270 * Get the buffer containing the on-disk dquot
1271 * We don't need a transaction envelope because we know that the
1272 * the ondisk-dquot has already been allocated for.
1274 if ((error = xfs_qm_dqtobp(NULL, dqp, &ddqp, &bp, XFS_QMOPT_DOWARN))) {
1275 xfs_dqtrace_entry(dqp, "DQTOBP FAIL");
1276 ASSERT(error != ENOENT);
1278 * Quotas could have gotten turned off (ESRCH)
1284 if (xfs_qm_dqcheck(&dqp->q_core, INT_GET(ddqp->d_id, ARCH_CONVERT),
1285 0, XFS_QMOPT_DOWARN, "dqflush (incore copy)")) {
1286 xfs_force_shutdown(dqp->q_mount, XFS_CORRUPT_INCORE);
1287 return XFS_ERROR(EIO);
1290 /* This is the only portion of data that needs to persist */
1291 memcpy(ddqp, &(dqp->q_core), sizeof(xfs_disk_dquot_t));
1294 * Clear the dirty field and remember the flush lsn for later use.
1296 dqp->dq_flags &= ~(XFS_DQ_DIRTY);
1299 /* lsn is 64 bits */
1301 dqp->q_logitem.qli_flush_lsn = dqp->q_logitem.qli_item.li_lsn;
1305 * Attach an iodone routine so that we can remove this dquot from the
1306 * AIL and release the flush lock once the dquot is synced to disk.
1308 xfs_buf_attach_iodone(bp, (void(*)(xfs_buf_t *, xfs_log_item_t *))
1309 xfs_qm_dqflush_done, &(dqp->q_logitem.qli_item));
1311 * If the buffer is pinned then push on the log so we won't
1312 * get stuck waiting in the write for too long.
1314 if (XFS_BUF_ISPINNED(bp)) {
1315 xfs_dqtrace_entry(dqp, "DQFLUSH LOG FORCE");
1316 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE);
1319 if (flags & XFS_QMOPT_DELWRI) {
1320 xfs_bdwrite(mp, bp);
1321 } else if (flags & XFS_QMOPT_ASYNC) {
1322 xfs_bawrite(mp, bp);
1324 error = xfs_bwrite(mp, bp);
1326 xfs_dqtrace_entry(dqp, "DQFLUSH END");
1328 * dqp is still locked, but caller is free to unlock it now.
1335 * This is the dquot flushing I/O completion routine. It is called
1336 * from interrupt level when the buffer containing the dquot is
1337 * flushed to disk. It is responsible for removing the dquot logitem
1338 * from the AIL if it has not been re-logged, and unlocking the dquot's
1339 * flush lock. This behavior is very similar to that of inodes..
1343 xfs_qm_dqflush_done(
1345 xfs_dq_logitem_t *qip)
1350 dqp = qip->qli_dquot;
1353 * We only want to pull the item from the AIL if its
1354 * location in the log has not changed since we started the flush.
1355 * Thus, we only bother if the dquot's lsn has
1356 * not changed. First we check the lsn outside the lock
1357 * since it's cheaper, and then we recheck while
1358 * holding the lock before removing the dquot from the AIL.
1360 if ((qip->qli_item.li_flags & XFS_LI_IN_AIL) &&
1361 qip->qli_item.li_lsn == qip->qli_flush_lsn) {
1363 AIL_LOCK(dqp->q_mount, s);
1365 * xfs_trans_delete_ail() drops the AIL lock.
1367 if (qip->qli_item.li_lsn == qip->qli_flush_lsn)
1368 xfs_trans_delete_ail(dqp->q_mount,
1369 (xfs_log_item_t*)qip, s);
1371 AIL_UNLOCK(dqp->q_mount, s);
1375 * Release the dq's flush lock since we're done with it.
1382 xfs_qm_dqflock_nowait(
1387 locked = cpsema(&((dqp)->q_flock));
1389 /* XXX ifdef these out */
1391 (dqp)->dq_flags |= XFS_DQ_FLOCKED;
1397 xfs_qm_dqlock_nowait(
1400 return (mutex_trylock(&((dqp)->q_qlock)));
1407 mutex_lock(&(dqp->q_qlock), PINOD);
1414 mutex_unlock(&(dqp->q_qlock));
1415 if (dqp->q_logitem.qli_dquot == dqp) {
1416 /* Once was dqp->q_mount, but might just have been cleared */
1417 xfs_trans_unlocked_item(dqp->q_logitem.qli_item.li_mountp,
1418 (xfs_log_item_t*)&(dqp->q_logitem));
1424 xfs_dqunlock_nonotify(
1427 mutex_unlock(&(dqp->q_qlock));
1437 if (INT_GET(d1->q_core.d_id, ARCH_CONVERT) >
1438 INT_GET(d2->q_core.d_id, ARCH_CONVERT)) {
1456 * Take a dquot out of the mount's dqlist as well as the hashlist.
1457 * This is called via unmount as well as quotaoff, and the purge
1458 * will always succeed unless there are soft (temp) references
1461 * This returns 0 if it was purged, 1 if it wasn't. It's not an error code
1462 * that we're returning! XXXsup - not cool.
1470 xfs_dqhash_t *thishash;
1475 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
1476 ASSERT(XFS_DQ_IS_HASH_LOCKED(dqp->q_hash));
1480 * We really can't afford to purge a dquot that is
1481 * referenced, because these are hard refs.
1482 * It shouldn't happen in general because we went thru _all_ inodes in
1483 * dqrele_all_inodes before calling this and didn't let the mountlock go.
1484 * However it is possible that we have dquots with temporary
1485 * references that are not attached to an inode. e.g. see xfs_setattr().
1487 if (dqp->q_nrefs != 0) {
1489 XFS_DQ_HASH_UNLOCK(dqp->q_hash);
1493 ASSERT(XFS_DQ_IS_ON_FREELIST(dqp));
1496 * If we're turning off quotas, we have to make sure that, for
1497 * example, we don't delete quota disk blocks while dquots are
1498 * in the process of getting written to those disk blocks.
1499 * This dquot might well be on AIL, and we can't leave it there
1500 * if we're turning off quotas. Basically, we need this flush
1501 * lock, and are willing to block on it.
1503 if (! xfs_qm_dqflock_nowait(dqp)) {
1505 * Block on the flush lock after nudging dquot buffer,
1508 xfs_qm_dqflock_pushbuf_wait(dqp);
1512 * XXXIf we're turning this type of quotas off, we don't care
1513 * about the dirty metadata sitting in this dquot. OTOH, if
1514 * we're unmounting, we do care, so we flush it and wait.
1516 if (XFS_DQ_IS_DIRTY(dqp)) {
1517 xfs_dqtrace_entry(dqp, "DQPURGE ->DQFLUSH: DQDIRTY");
1518 /* dqflush unlocks dqflock */
1520 * Given that dqpurge is a very rare occurrence, it is OK
1521 * that we're holding the hashlist and mplist locks
1522 * across the disk write. But, ... XXXsup
1524 * We don't care about getting disk errors here. We need
1525 * to purge this dquot anyway, so we go ahead regardless.
1527 (void) xfs_qm_dqflush(dqp, XFS_QMOPT_SYNC);
1530 ASSERT(dqp->q_pincount == 0);
1531 ASSERT(XFS_FORCED_SHUTDOWN(mp) ||
1532 !(dqp->q_logitem.qli_item.li_flags & XFS_LI_IN_AIL));
1534 thishash = dqp->q_hash;
1535 XQM_HASHLIST_REMOVE(thishash, dqp);
1536 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(mp)), dqp);
1538 * XXX Move this to the front of the freelist, if we can get the
1541 ASSERT(XFS_DQ_IS_ON_FREELIST(dqp));
1543 dqp->q_mount = NULL;
1545 dqp->dq_flags = XFS_DQ_INACTIVE;
1546 memset(&dqp->q_core, 0, sizeof(dqp->q_core));
1549 XFS_DQ_HASH_UNLOCK(thishash);
1556 xfs_qm_dqprint(xfs_dquot_t *dqp)
1558 cmn_err(CE_DEBUG, "-----------KERNEL DQUOT----------------");
1559 cmn_err(CE_DEBUG, "---- dquotID = %d",
1560 (int)INT_GET(dqp->q_core.d_id, ARCH_CONVERT));
1561 cmn_err(CE_DEBUG, "---- type = %s", DQFLAGTO_TYPESTR(dqp));
1562 cmn_err(CE_DEBUG, "---- fs = 0x%p", dqp->q_mount);
1563 cmn_err(CE_DEBUG, "---- blkno = 0x%x", (int) dqp->q_blkno);
1564 cmn_err(CE_DEBUG, "---- boffset = 0x%x", (int) dqp->q_bufoffset);
1565 cmn_err(CE_DEBUG, "---- blkhlimit = %Lu (0x%x)",
1566 INT_GET(dqp->q_core.d_blk_hardlimit, ARCH_CONVERT),
1567 (int) INT_GET(dqp->q_core.d_blk_hardlimit, ARCH_CONVERT));
1568 cmn_err(CE_DEBUG, "---- blkslimit = %Lu (0x%x)",
1569 INT_GET(dqp->q_core.d_blk_softlimit, ARCH_CONVERT),
1570 (int)INT_GET(dqp->q_core.d_blk_softlimit, ARCH_CONVERT));
1571 cmn_err(CE_DEBUG, "---- inohlimit = %Lu (0x%x)",
1572 INT_GET(dqp->q_core.d_ino_hardlimit, ARCH_CONVERT),
1573 (int)INT_GET(dqp->q_core.d_ino_hardlimit, ARCH_CONVERT));
1574 cmn_err(CE_DEBUG, "---- inoslimit = %Lu (0x%x)",
1575 INT_GET(dqp->q_core.d_ino_softlimit, ARCH_CONVERT),
1576 (int)INT_GET(dqp->q_core.d_ino_softlimit, ARCH_CONVERT));
1577 cmn_err(CE_DEBUG, "---- bcount = %Lu (0x%x)",
1578 INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT),
1579 (int)INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT));
1580 cmn_err(CE_DEBUG, "---- icount = %Lu (0x%x)",
1581 INT_GET(dqp->q_core.d_icount, ARCH_CONVERT),
1582 (int)INT_GET(dqp->q_core.d_icount, ARCH_CONVERT));
1583 cmn_err(CE_DEBUG, "---- btimer = %d",
1584 (int)INT_GET(dqp->q_core.d_btimer, ARCH_CONVERT));
1585 cmn_err(CE_DEBUG, "---- itimer = %d",
1586 (int)INT_GET(dqp->q_core.d_itimer, ARCH_CONVERT));
1587 cmn_err(CE_DEBUG, "---------------------------");
1592 * Give the buffer a little push if it is incore and
1593 * wait on the flush lock.
1596 xfs_qm_dqflock_pushbuf_wait(
1602 * Check to see if the dquot has been flushed delayed
1603 * write. If so, grab its buffer and send it
1604 * out immediately. We'll be able to acquire
1605 * the flush lock when the I/O completes.
1607 bp = xfs_incore(dqp->q_mount->m_ddev_targp, dqp->q_blkno,
1608 XFS_QI_DQCHUNKLEN(dqp->q_mount),
1609 XFS_INCORE_TRYLOCK);
1611 if (XFS_BUF_ISDELAYWRITE(bp)) {
1612 if (XFS_BUF_ISPINNED(bp)) {
1613 xfs_log_force(dqp->q_mount,
1617 xfs_bawrite(dqp->q_mount, bp);