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/
37 #include "xfs_trans.h"
42 #include "xfs_alloc.h"
43 #include "xfs_dmapi.h"
44 #include "xfs_quota.h"
45 #include "xfs_mount.h"
46 #include "xfs_alloc_btree.h"
47 #include "xfs_bmap_btree.h"
48 #include "xfs_ialloc_btree.h"
49 #include "xfs_btree.h"
50 #include "xfs_ialloc.h"
51 #include "xfs_attr_sf.h"
52 #include "xfs_dir_sf.h"
53 #include "xfs_dir2_sf.h"
54 #include "xfs_dinode.h"
55 #include "xfs_inode.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.
292 xfs_qm_adjust_dqtimers(
299 if (INT_GET(d
->d_blk_hardlimit
, ARCH_CONVERT
))
300 ASSERT(INT_GET(d
->d_blk_softlimit
, ARCH_CONVERT
) <=
301 INT_GET(d
->d_blk_hardlimit
, ARCH_CONVERT
));
302 if (INT_GET(d
->d_ino_hardlimit
, ARCH_CONVERT
))
303 ASSERT(INT_GET(d
->d_ino_softlimit
, ARCH_CONVERT
) <=
304 INT_GET(d
->d_ino_hardlimit
, ARCH_CONVERT
));
305 if (INT_GET(d
->d_rtb_hardlimit
, ARCH_CONVERT
))
306 ASSERT(INT_GET(d
->d_rtb_softlimit
, ARCH_CONVERT
) <=
307 INT_GET(d
->d_rtb_hardlimit
, ARCH_CONVERT
));
310 if ((INT_GET(d
->d_blk_softlimit
, ARCH_CONVERT
) &&
311 (INT_GET(d
->d_bcount
, ARCH_CONVERT
) >=
312 INT_GET(d
->d_blk_softlimit
, ARCH_CONVERT
))) ||
313 (INT_GET(d
->d_blk_hardlimit
, ARCH_CONVERT
) &&
314 (INT_GET(d
->d_bcount
, ARCH_CONVERT
) >=
315 INT_GET(d
->d_blk_hardlimit
, ARCH_CONVERT
)))) {
316 INT_SET(d
->d_btimer
, ARCH_CONVERT
,
317 get_seconds() + XFS_QI_BTIMELIMIT(mp
));
320 if ((!d
->d_blk_softlimit
||
321 (INT_GET(d
->d_bcount
, ARCH_CONVERT
) <
322 INT_GET(d
->d_blk_softlimit
, ARCH_CONVERT
))) &&
323 (!d
->d_blk_hardlimit
||
324 (INT_GET(d
->d_bcount
, ARCH_CONVERT
) <
325 INT_GET(d
->d_blk_hardlimit
, ARCH_CONVERT
)))) {
331 if ((INT_GET(d
->d_ino_softlimit
, ARCH_CONVERT
) &&
332 (INT_GET(d
->d_icount
, ARCH_CONVERT
) >=
333 INT_GET(d
->d_ino_softlimit
, ARCH_CONVERT
))) ||
334 (INT_GET(d
->d_ino_hardlimit
, ARCH_CONVERT
) &&
335 (INT_GET(d
->d_icount
, ARCH_CONVERT
) >=
336 INT_GET(d
->d_ino_hardlimit
, ARCH_CONVERT
)))) {
337 INT_SET(d
->d_itimer
, ARCH_CONVERT
,
338 get_seconds() + XFS_QI_ITIMELIMIT(mp
));
341 if ((!d
->d_ino_softlimit
||
342 (INT_GET(d
->d_icount
, ARCH_CONVERT
) <
343 INT_GET(d
->d_ino_softlimit
, ARCH_CONVERT
))) &&
344 (!d
->d_ino_hardlimit
||
345 (INT_GET(d
->d_icount
, ARCH_CONVERT
) <
346 INT_GET(d
->d_ino_hardlimit
, ARCH_CONVERT
)))) {
351 if (!d
->d_rtbtimer
) {
352 if ((INT_GET(d
->d_rtb_softlimit
, ARCH_CONVERT
) &&
353 (INT_GET(d
->d_rtbcount
, ARCH_CONVERT
) >=
354 INT_GET(d
->d_rtb_softlimit
, ARCH_CONVERT
))) ||
355 (INT_GET(d
->d_rtb_hardlimit
, ARCH_CONVERT
) &&
356 (INT_GET(d
->d_rtbcount
, ARCH_CONVERT
) >=
357 INT_GET(d
->d_rtb_hardlimit
, ARCH_CONVERT
)))) {
358 INT_SET(d
->d_rtbtimer
, ARCH_CONVERT
,
359 get_seconds() + XFS_QI_RTBTIMELIMIT(mp
));
362 if ((!d
->d_rtb_softlimit
||
363 (INT_GET(d
->d_rtbcount
, ARCH_CONVERT
) <
364 INT_GET(d
->d_rtb_softlimit
, ARCH_CONVERT
))) &&
365 (!d
->d_rtb_hardlimit
||
366 (INT_GET(d
->d_rtbcount
, ARCH_CONVERT
) <
367 INT_GET(d
->d_rtb_hardlimit
, ARCH_CONVERT
)))) {
374 * initialize a buffer full of dquots and log the whole thing
377 xfs_qm_init_dquot_blk(
388 ASSERT(XFS_BUF_ISBUSY(bp
));
389 ASSERT(XFS_BUF_VALUSEMA(bp
) <= 0);
391 d
= (xfs_dqblk_t
*)XFS_BUF_PTR(bp
);
394 * ID of the first dquot in the block - id's are zero based.
396 curid
= id
- (id
% XFS_QM_DQPERBLK(mp
));
398 memset(d
, 0, BBTOB(XFS_QI_DQCHUNKLEN(mp
)));
399 for (i
= 0; i
< XFS_QM_DQPERBLK(mp
); i
++, d
++, curid
++)
400 xfs_qm_dqinit_core(curid
, type
, d
);
401 xfs_trans_dquot_buf(tp
, bp
,
402 (type
& XFS_DQ_USER
? XFS_BLI_UDQUOT_BUF
:
403 ((type
& XFS_DQ_PROJ
) ? XFS_BLI_PDQUOT_BUF
:
404 XFS_BLI_GDQUOT_BUF
)));
405 xfs_trans_log_buf(tp
, bp
, 0, BBTOB(XFS_QI_DQCHUNKLEN(mp
)) - 1);
411 * Allocate a block and fill it with dquots.
412 * This is called when the bmapi finds a hole.
420 xfs_fileoff_t offset_fsb
,
423 xfs_fsblock_t firstblock
;
424 xfs_bmap_free_t flist
;
426 int nmaps
, error
, committed
;
430 xfs_dqtrace_entry(dqp
, "DQALLOC");
433 * Initialize the bmap freelist prior to calling bmapi code.
435 XFS_BMAP_INIT(&flist
, &firstblock
);
436 xfs_ilock(quotip
, XFS_ILOCK_EXCL
);
438 * Return if this type of quotas is turned off while we didn't
441 if (XFS_IS_THIS_QUOTA_OFF(dqp
)) {
442 xfs_iunlock(quotip
, XFS_ILOCK_EXCL
);
447 * xfs_trans_commit normally decrements the vnode ref count
448 * when it unlocks the inode. Since we want to keep the quota
449 * inode around, we bump the vnode ref count now.
451 VN_HOLD(XFS_ITOV(quotip
));
453 xfs_trans_ijoin(tp
, quotip
, XFS_ILOCK_EXCL
);
455 if ((error
= xfs_bmapi(tp
, quotip
,
456 offset_fsb
, XFS_DQUOT_CLUSTER_SIZE_FSB
,
457 XFS_BMAPI_METADATA
| XFS_BMAPI_WRITE
,
459 XFS_QM_DQALLOC_SPACE_RES(mp
),
460 &map
, &nmaps
, &flist
))) {
463 ASSERT(map
.br_blockcount
== XFS_DQUOT_CLUSTER_SIZE_FSB
);
465 ASSERT((map
.br_startblock
!= DELAYSTARTBLOCK
) &&
466 (map
.br_startblock
!= HOLESTARTBLOCK
));
469 * Keep track of the blkno to save a lookup later
471 dqp
->q_blkno
= XFS_FSB_TO_DADDR(mp
, map
.br_startblock
);
473 /* now we can just get the buffer (there's nothing to read yet) */
474 bp
= xfs_trans_get_buf(tp
, mp
->m_ddev_targp
,
476 XFS_QI_DQCHUNKLEN(mp
),
478 if (!bp
|| (error
= XFS_BUF_GETERROR(bp
)))
481 * Make a chunk of dquots out of this buffer and log
484 xfs_qm_init_dquot_blk(tp
, mp
, INT_GET(dqp
->q_core
.d_id
, ARCH_CONVERT
),
485 dqp
->dq_flags
& XFS_DQ_ALLTYPES
, bp
);
487 if ((error
= xfs_bmap_finish(&tp
, &flist
, firstblock
, &committed
))) {
495 xfs_bmap_cancel(&flist
);
497 xfs_iunlock(quotip
, XFS_ILOCK_EXCL
);
503 * Maps a dquot to the buffer containing its on-disk version.
504 * This returns a ptr to the buffer containing the on-disk dquot
505 * in the bpp param, and a ptr to the on-disk dquot within that buffer
511 xfs_disk_dquot_t
**O_ddpp
,
520 xfs_disk_dquot_t
*ddq
;
525 id
= INT_GET(dqp
->q_core
.d_id
, ARCH_CONVERT
);
530 * If we don't know where the dquot lives, find out.
532 if (dqp
->q_blkno
== (xfs_daddr_t
) 0) {
533 /* We use the id as an index */
534 dqp
->q_fileoffset
= (xfs_fileoff_t
) ((uint
)id
/
535 XFS_QM_DQPERBLK(mp
));
537 quotip
= XFS_DQ_TO_QIP(dqp
);
538 xfs_ilock(quotip
, XFS_ILOCK_SHARED
);
540 * Return if this type of quotas is turned off while we didn't
543 if (XFS_IS_THIS_QUOTA_OFF(dqp
)) {
544 xfs_iunlock(quotip
, XFS_ILOCK_SHARED
);
548 * Find the block map; no allocations yet
550 error
= xfs_bmapi(NULL
, quotip
, dqp
->q_fileoffset
,
551 XFS_DQUOT_CLUSTER_SIZE_FSB
,
553 NULL
, 0, &map
, &nmaps
, NULL
);
555 xfs_iunlock(quotip
, XFS_ILOCK_SHARED
);
559 ASSERT(map
.br_blockcount
== 1);
562 * offset of dquot in the (fixed sized) dquot chunk.
564 dqp
->q_bufoffset
= (id
% XFS_QM_DQPERBLK(mp
)) *
566 if (map
.br_startblock
== HOLESTARTBLOCK
) {
568 * We don't allocate unless we're asked to
570 if (!(flags
& XFS_QMOPT_DQALLOC
))
574 if ((error
= xfs_qm_dqalloc(tp
, mp
, dqp
, quotip
,
575 dqp
->q_fileoffset
, &bp
)))
580 * store the blkno etc so that we don't have to do the
581 * mapping all the time
583 dqp
->q_blkno
= XFS_FSB_TO_DADDR(mp
, map
.br_startblock
);
586 ASSERT(dqp
->q_blkno
!= DELAYSTARTBLOCK
);
587 ASSERT(dqp
->q_blkno
!= HOLESTARTBLOCK
);
590 * Read in the buffer, unless we've just done the allocation
591 * (in which case we already have the buf).
594 xfs_dqtrace_entry(dqp
, "DQTOBP READBUF");
595 if ((error
= xfs_trans_read_buf(mp
, tp
, mp
->m_ddev_targp
,
597 XFS_QI_DQCHUNKLEN(mp
),
602 return XFS_ERROR(error
);
604 ASSERT(XFS_BUF_ISBUSY(bp
));
605 ASSERT(XFS_BUF_VALUSEMA(bp
) <= 0);
608 * calculate the location of the dquot inside the buffer.
610 ddq
= (xfs_disk_dquot_t
*)((char *)XFS_BUF_PTR(bp
) + dqp
->q_bufoffset
);
613 * A simple sanity check in case we got a corrupted dquot...
615 if (xfs_qm_dqcheck(ddq
, id
, dqp
->dq_flags
& XFS_DQ_ALLTYPES
,
616 flags
& (XFS_QMOPT_DQREPAIR
|XFS_QMOPT_DOWARN
),
618 if (!(flags
& XFS_QMOPT_DQREPAIR
)) {
619 xfs_trans_brelse(tp
, bp
);
620 return XFS_ERROR(EIO
);
622 XFS_BUF_BUSY(bp
); /* We dirtied this */
633 * Read in the ondisk dquot using dqtobp() then copy it to an incore version,
634 * and release the buffer immediately.
642 xfs_dquot_t
*dqp
, /* dquot to get filled in */
645 xfs_disk_dquot_t
*ddqp
;
650 * get a pointer to the on-disk dquot and the buffer containing it
651 * dqp already knows its own type (GROUP/USER).
653 xfs_dqtrace_entry(dqp
, "DQREAD");
654 if ((error
= xfs_qm_dqtobp(tp
, dqp
, &ddqp
, &bp
, flags
))) {
658 /* copy everything from disk dquot to the incore dquot */
659 memcpy(&dqp
->q_core
, ddqp
, sizeof(xfs_disk_dquot_t
));
660 ASSERT(INT_GET(dqp
->q_core
.d_id
, ARCH_CONVERT
) == id
);
661 xfs_qm_dquot_logitem_init(dqp
);
664 * Reservation counters are defined as reservation plus current usage
665 * to avoid having to add everytime.
667 dqp
->q_res_bcount
= INT_GET(ddqp
->d_bcount
, ARCH_CONVERT
);
668 dqp
->q_res_icount
= INT_GET(ddqp
->d_icount
, ARCH_CONVERT
);
669 dqp
->q_res_rtbcount
= INT_GET(ddqp
->d_rtbcount
, ARCH_CONVERT
);
671 /* Mark the buf so that this will stay incore a little longer */
672 XFS_BUF_SET_VTYPE_REF(bp
, B_FS_DQUOT
, XFS_DQUOT_REF
);
675 * We got the buffer with a xfs_trans_read_buf() (in dqtobp())
676 * So we need to release with xfs_trans_brelse().
677 * The strategy here is identical to that of inodes; we lock
678 * the dquot in xfs_qm_dqget() before making it accessible to
679 * others. This is because dquots, like inodes, need a good level of
680 * concurrency, and we don't want to take locks on the entire buffers
681 * for dquot accesses.
682 * Note also that the dquot buffer may even be dirty at this point, if
683 * this particular dquot was repaired. We still aren't afraid to
684 * brelse it because we have the changes incore.
686 ASSERT(XFS_BUF_ISBUSY(bp
));
687 ASSERT(XFS_BUF_VALUSEMA(bp
) <= 0);
688 xfs_trans_brelse(tp
, bp
);
695 * allocate an incore dquot from the kernel heap,
696 * and fill its core with quota information kept on disk.
697 * If XFS_QMOPT_DQALLOC is set, it'll allocate a dquot on disk
698 * if it wasn't already allocated.
703 xfs_dqid_t id
, /* gid or uid, depending on type */
704 uint type
, /* UDQUOT or GDQUOT */
705 uint flags
, /* DQALLOC, DQREPAIR */
706 xfs_dquot_t
**O_dqpp
)/* OUT : incore dquot, not locked */
713 dqp
= xfs_qm_dqinit(mp
, id
, type
);
715 if (flags
& XFS_QMOPT_DQALLOC
) {
716 tp
= xfs_trans_alloc(mp
, XFS_TRANS_QM_DQALLOC
);
717 if ((error
= xfs_trans_reserve(tp
,
718 XFS_QM_DQALLOC_SPACE_RES(mp
),
719 XFS_WRITE_LOG_RES(mp
) +
720 BBTOB(XFS_QI_DQCHUNKLEN(mp
)) - 1 +
723 XFS_TRANS_PERM_LOG_RES
,
724 XFS_WRITE_LOG_COUNT
))) {
728 cancelflags
= XFS_TRANS_RELEASE_LOG_RES
;
732 * Read it from disk; xfs_dqread() takes care of
733 * all the necessary initialization of dquot's fields (locks, etc)
735 if ((error
= xfs_qm_dqread(tp
, id
, dqp
, flags
))) {
737 * This can happen if quotas got turned off (ESRCH),
738 * or if the dquot didn't exist on disk and we ask to
741 xfs_dqtrace_entry(dqp
, "DQREAD FAIL");
742 cancelflags
|= XFS_TRANS_ABORT
;
746 if ((error
= xfs_trans_commit(tp
, XFS_TRANS_RELEASE_LOG_RES
,
757 xfs_trans_cancel(tp
, cancelflags
);
759 xfs_qm_dqdestroy(dqp
);
765 * Lookup a dquot in the incore dquot hashtable. We keep two separate
766 * hashtables for user and group dquots; and, these are global tables
767 * inside the XQM, not per-filesystem tables.
768 * The hash chain must be locked by caller, and it is left locked
769 * on return. Returning dquot is locked.
776 xfs_dquot_t
**O_dqpp
)
782 ASSERT(XFS_DQ_IS_HASH_LOCKED(qh
));
784 flist_locked
= B_FALSE
;
787 * Traverse the hashchain looking for a match
789 for (dqp
= qh
->qh_next
; dqp
!= NULL
; dqp
= dqp
->HL_NEXT
) {
791 * We already have the hashlock. We don't need the
792 * dqlock to look at the id field of the dquot, since the
793 * id can't be modified without the hashlock anyway.
795 if (INT_GET(dqp
->q_core
.d_id
, ARCH_CONVERT
) == id
&& dqp
->q_mount
== mp
) {
796 xfs_dqtrace_entry(dqp
, "DQFOUND BY LOOKUP");
798 * All in core dquots must be on the dqlist of mp
800 ASSERT(dqp
->MPL_PREVP
!= NULL
);
803 if (dqp
->q_nrefs
== 0) {
804 ASSERT (XFS_DQ_IS_ON_FREELIST(dqp
));
805 if (! xfs_qm_freelist_lock_nowait(xfs_Gqm
)) {
806 xfs_dqtrace_entry(dqp
, "DQLOOKUP: WANT");
809 * We may have raced with dqreclaim_one()
810 * (and lost). So, flag that we don't
811 * want the dquot to be reclaimed.
813 dqp
->dq_flags
|= XFS_DQ_WANT
;
815 xfs_qm_freelist_lock(xfs_Gqm
);
817 dqp
->dq_flags
&= ~(XFS_DQ_WANT
);
819 flist_locked
= B_TRUE
;
823 * id couldn't have changed; we had the hashlock all
826 ASSERT(INT_GET(dqp
->q_core
.d_id
, ARCH_CONVERT
) == id
);
829 if (dqp
->q_nrefs
!= 0) {
830 xfs_qm_freelist_unlock(xfs_Gqm
);
831 flist_locked
= B_FALSE
;
834 * take it off the freelist
836 xfs_dqtrace_entry(dqp
,
837 "DQLOOKUP: TAKEOFF FL");
838 XQM_FREELIST_REMOVE(dqp
);
839 /* xfs_qm_freelist_print(&(xfs_Gqm->
851 xfs_qm_freelist_unlock(xfs_Gqm
);
853 * move the dquot to the front of the hashchain
855 ASSERT(XFS_DQ_IS_HASH_LOCKED(qh
));
856 if (dqp
->HL_PREVP
!= &qh
->qh_next
) {
857 xfs_dqtrace_entry(dqp
,
858 "DQLOOKUP: HASH MOVETOFRONT");
859 if ((d
= dqp
->HL_NEXT
))
860 d
->HL_PREVP
= dqp
->HL_PREVP
;
861 *(dqp
->HL_PREVP
) = d
;
863 d
->HL_PREVP
= &dqp
->HL_NEXT
;
865 dqp
->HL_PREVP
= &qh
->qh_next
;
868 xfs_dqtrace_entry(dqp
, "LOOKUP END");
870 ASSERT(XFS_DQ_IS_HASH_LOCKED(qh
));
876 ASSERT(XFS_DQ_IS_HASH_LOCKED(qh
));
881 * Given the file system, inode OR id, and type (UDQUOT/GDQUOT), return a
882 * a locked dquot, doing an allocation (if requested) as needed.
883 * When both an inode and an id are given, the inode's id takes precedence.
884 * That is, if the id changes while we don't hold the ilock inside this
885 * function, the new dquot is returned, not necessarily the one requested
886 * in the id argument.
891 xfs_inode_t
*ip
, /* locked inode (optional) */
892 xfs_dqid_t id
, /* uid/projid/gid depending on type */
893 uint type
, /* XFS_DQ_USER/XFS_DQ_PROJ/XFS_DQ_GROUP */
894 uint flags
, /* DQALLOC, DQSUSER, DQREPAIR, DOWARN */
895 xfs_dquot_t
**O_dqpp
) /* OUT : locked incore dquot */
902 ASSERT(XFS_IS_QUOTA_RUNNING(mp
));
903 if ((! XFS_IS_UQUOTA_ON(mp
) && type
== XFS_DQ_USER
) ||
904 (! XFS_IS_PQUOTA_ON(mp
) && type
== XFS_DQ_PROJ
) ||
905 (! XFS_IS_GQUOTA_ON(mp
) && type
== XFS_DQ_GROUP
)) {
906 printk("XQM: ESRCH1\n");
909 h
= XFS_DQ_HASH(mp
, id
, type
);
912 if (xfs_do_dqerror
) {
913 if ((xfs_dqerror_target
== mp
->m_ddev_targp
) &&
914 (xfs_dqreq_num
++ % xfs_dqerror_mod
) == 0) {
915 cmn_err(CE_DEBUG
, "Returning error in dqget");
924 ASSERT(type
== XFS_DQ_USER
||
925 type
== XFS_DQ_PROJ
||
926 type
== XFS_DQ_GROUP
);
928 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip
));
929 if (type
== XFS_DQ_USER
)
930 ASSERT(ip
->i_udquot
== NULL
);
932 ASSERT(ip
->i_gdquot
== NULL
);
938 * Look in the cache (hashtable).
939 * The chain is kept locked during lookup.
941 if (xfs_qm_dqlookup(mp
, id
, h
, O_dqpp
) == 0) {
942 XQM_STATS_INC(xqmstats
.xs_qm_dqcachehits
);
944 * The dquot was found, moved to the front of the chain,
945 * taken off the freelist if it was on it, and locked
946 * at this point. Just unlock the hashchain and return.
949 ASSERT(XFS_DQ_IS_LOCKED(*O_dqpp
));
950 XFS_DQ_HASH_UNLOCK(h
);
951 xfs_dqtrace_entry(*O_dqpp
, "DQGET DONE (FROM CACHE)");
952 return (0); /* success */
954 XQM_STATS_INC(xqmstats
.xs_qm_dqcachemisses
);
957 * Dquot cache miss. We don't want to keep the inode lock across
958 * a (potential) disk read. Also we don't want to deal with the lock
959 * ordering between quotainode and this inode. OTOH, dropping the inode
960 * lock here means dealing with a chown that can happen before
961 * we re-acquire the lock.
964 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
966 * Save the hashchain version stamp, and unlock the chain, so that
967 * we don't keep the lock across a disk read
969 version
= h
->qh_version
;
970 XFS_DQ_HASH_UNLOCK(h
);
973 * Allocate the dquot on the kernel heap, and read the ondisk
974 * portion off the disk. Also, do all the necessary initialization
975 * This can return ENOENT if dquot didn't exist on disk and we didn't
976 * ask it to allocate; ESRCH if quotas got turned off suddenly.
978 if ((error
= xfs_qm_idtodq(mp
, id
, type
,
979 flags
& (XFS_QMOPT_DQALLOC
|XFS_QMOPT_DQREPAIR
|
983 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
984 if (error
== ESRCH
) printk("XQM: ESRCH2\n");
989 * See if this is mount code calling to look at the overall quota limits
990 * which are stored in the id == 0 user or group's dquot.
991 * Since we may not have done a quotacheck by this point, just return
992 * the dquot without attaching it to any hashtables, lists, etc, or even
993 * taking a reference.
994 * The caller must dqdestroy this once done.
996 if (flags
& XFS_QMOPT_DQSUSER
) {
1003 * Dquot lock comes after hashlock in the lock ordering
1006 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
1007 if (! XFS_IS_DQTYPE_ON(mp
, type
)) {
1008 /* inode stays locked on return */
1009 xfs_qm_dqdestroy(dqp
);
1010 printk("XQM: ESRCH3\n");
1011 return XFS_ERROR(ESRCH
);
1014 * A dquot could be attached to this inode by now, since
1015 * we had dropped the ilock.
1017 if (type
== XFS_DQ_USER
) {
1019 xfs_qm_dqdestroy(dqp
);
1026 xfs_qm_dqdestroy(dqp
);
1035 * Hashlock comes after ilock in lock order
1037 XFS_DQ_HASH_LOCK(h
);
1038 if (version
!= h
->qh_version
) {
1039 xfs_dquot_t
*tmpdqp
;
1041 * Now, see if somebody else put the dquot in the
1042 * hashtable before us. This can happen because we didn't
1043 * keep the hashchain lock. We don't have to worry about
1044 * lock order between the two dquots here since dqp isn't
1045 * on any findable lists yet.
1047 if (xfs_qm_dqlookup(mp
, id
, h
, &tmpdqp
) == 0) {
1049 * Duplicate found. Just throw away the new dquot
1052 xfs_qm_dqput(tmpdqp
);
1053 XFS_DQ_HASH_UNLOCK(h
);
1054 xfs_qm_dqdestroy(dqp
);
1055 XQM_STATS_INC(xqmstats
.xs_qm_dquot_dups
);
1061 * Put the dquot at the beginning of the hash-chain and mp's list
1062 * LOCK ORDER: hashlock, freelistlock, mplistlock, udqlock, gdqlock ..
1064 ASSERT(XFS_DQ_IS_HASH_LOCKED(h
));
1066 XQM_HASHLIST_INSERT(h
, dqp
);
1069 * Attach this dquot to this filesystem's list of all dquots,
1070 * kept inside the mount structure in m_quotainfo field
1072 xfs_qm_mplist_lock(mp
);
1075 * We return a locked dquot to the caller, with a reference taken
1080 XQM_MPLIST_INSERT(&(XFS_QI_MPL_LIST(mp
)), dqp
);
1082 xfs_qm_mplist_unlock(mp
);
1083 XFS_DQ_HASH_UNLOCK(h
);
1085 ASSERT((ip
== NULL
) || XFS_ISLOCKED_INODE_EXCL(ip
));
1086 xfs_dqtrace_entry(dqp
, "DQGET DONE");
1093 * Release a reference to the dquot (decrement ref-count)
1094 * and unlock it. If there is a group quota attached to this
1095 * dquot, carefully release that too without tripping over
1096 * deadlocks'n'stuff.
1104 ASSERT(dqp
->q_nrefs
> 0);
1105 ASSERT(XFS_DQ_IS_LOCKED(dqp
));
1106 xfs_dqtrace_entry(dqp
, "DQPUT");
1108 if (dqp
->q_nrefs
!= 1) {
1115 * drop the dqlock and acquire the freelist and dqlock
1116 * in the right order; but try to get it out-of-order first
1118 if (! xfs_qm_freelist_lock_nowait(xfs_Gqm
)) {
1119 xfs_dqtrace_entry(dqp
, "DQPUT: FLLOCK-WAIT");
1121 xfs_qm_freelist_lock(xfs_Gqm
);
1128 /* We can't depend on nrefs being == 1 here */
1129 if (--dqp
->q_nrefs
== 0) {
1130 xfs_dqtrace_entry(dqp
, "DQPUT: ON FREELIST");
1132 * insert at end of the freelist.
1134 XQM_FREELIST_INSERT(&(xfs_Gqm
->qm_dqfreelist
), dqp
);
1137 * If we just added a udquot to the freelist, then
1138 * we want to release the gdquot reference that
1139 * it (probably) has. Otherwise it'll keep the
1140 * gdquot from getting reclaimed.
1142 if ((gdqp
= dqp
->q_gdquot
)) {
1144 * Avoid a recursive dqput call
1147 dqp
->q_gdquot
= NULL
;
1150 /* xfs_qm_freelist_print(&(xfs_Gqm->qm_dqfreelist),
1151 "@@@@@++ Free list (after append) @@@@@+");
1157 * If we had a group quota inside the user quota as a hint,
1164 xfs_qm_freelist_unlock(xfs_Gqm
);
1168 * Release a dquot. Flush it if dirty, then dqput() it.
1169 * dquot must not be locked.
1176 xfs_dqtrace_entry(dqp
, "DQRELE");
1180 * We don't care to flush it if the dquot is dirty here.
1181 * That will create stutters that we want to avoid.
1182 * Instead we do a delayed write when we try to reclaim
1183 * a dirty dquot. Also xfs_sync will take part of the burden...
1190 * Write a modified dquot to disk.
1191 * The dquot must be locked and the flush lock too taken by caller.
1192 * The flush lock will not be unlocked until the dquot reaches the disk,
1193 * but the dquot is free to be unlocked and modified by the caller
1194 * in the interim. Dquot is still locked on return. This behavior is
1195 * identical to that of inodes.
1204 xfs_disk_dquot_t
*ddqp
;
1208 ASSERT(XFS_DQ_IS_LOCKED(dqp
));
1209 ASSERT(XFS_DQ_IS_FLUSH_LOCKED(dqp
));
1210 xfs_dqtrace_entry(dqp
, "DQFLUSH");
1213 * If not dirty, nada.
1215 if (!XFS_DQ_IS_DIRTY(dqp
)) {
1221 * Cant flush a pinned dquot. Wait for it.
1223 xfs_qm_dqunpin_wait(dqp
);
1226 * This may have been unpinned because the filesystem is shutting
1227 * down forcibly. If that's the case we must not write this dquot
1228 * to disk, because the log record didn't make it to disk!
1230 if (XFS_FORCED_SHUTDOWN(dqp
->q_mount
)) {
1231 dqp
->dq_flags
&= ~(XFS_DQ_DIRTY
);
1233 return XFS_ERROR(EIO
);
1237 * Get the buffer containing the on-disk dquot
1238 * We don't need a transaction envelope because we know that the
1239 * the ondisk-dquot has already been allocated for.
1241 if ((error
= xfs_qm_dqtobp(NULL
, dqp
, &ddqp
, &bp
, XFS_QMOPT_DOWARN
))) {
1242 xfs_dqtrace_entry(dqp
, "DQTOBP FAIL");
1243 ASSERT(error
!= ENOENT
);
1245 * Quotas could have gotten turned off (ESRCH)
1251 if (xfs_qm_dqcheck(&dqp
->q_core
, INT_GET(ddqp
->d_id
, ARCH_CONVERT
),
1252 0, XFS_QMOPT_DOWARN
, "dqflush (incore copy)")) {
1253 xfs_force_shutdown(dqp
->q_mount
, XFS_CORRUPT_INCORE
);
1254 return XFS_ERROR(EIO
);
1257 /* This is the only portion of data that needs to persist */
1258 memcpy(ddqp
, &(dqp
->q_core
), sizeof(xfs_disk_dquot_t
));
1261 * Clear the dirty field and remember the flush lsn for later use.
1263 dqp
->dq_flags
&= ~(XFS_DQ_DIRTY
);
1266 /* lsn is 64 bits */
1268 dqp
->q_logitem
.qli_flush_lsn
= dqp
->q_logitem
.qli_item
.li_lsn
;
1272 * Attach an iodone routine so that we can remove this dquot from the
1273 * AIL and release the flush lock once the dquot is synced to disk.
1275 xfs_buf_attach_iodone(bp
, (void(*)(xfs_buf_t
*, xfs_log_item_t
*))
1276 xfs_qm_dqflush_done
, &(dqp
->q_logitem
.qli_item
));
1278 * If the buffer is pinned then push on the log so we won't
1279 * get stuck waiting in the write for too long.
1281 if (XFS_BUF_ISPINNED(bp
)) {
1282 xfs_dqtrace_entry(dqp
, "DQFLUSH LOG FORCE");
1283 xfs_log_force(mp
, (xfs_lsn_t
)0, XFS_LOG_FORCE
);
1286 if (flags
& XFS_QMOPT_DELWRI
) {
1287 xfs_bdwrite(mp
, bp
);
1288 } else if (flags
& XFS_QMOPT_ASYNC
) {
1289 xfs_bawrite(mp
, bp
);
1291 error
= xfs_bwrite(mp
, bp
);
1293 xfs_dqtrace_entry(dqp
, "DQFLUSH END");
1295 * dqp is still locked, but caller is free to unlock it now.
1302 * This is the dquot flushing I/O completion routine. It is called
1303 * from interrupt level when the buffer containing the dquot is
1304 * flushed to disk. It is responsible for removing the dquot logitem
1305 * from the AIL if it has not been re-logged, and unlocking the dquot's
1306 * flush lock. This behavior is very similar to that of inodes..
1310 xfs_qm_dqflush_done(
1312 xfs_dq_logitem_t
*qip
)
1317 dqp
= qip
->qli_dquot
;
1320 * We only want to pull the item from the AIL if its
1321 * location in the log has not changed since we started the flush.
1322 * Thus, we only bother if the dquot's lsn has
1323 * not changed. First we check the lsn outside the lock
1324 * since it's cheaper, and then we recheck while
1325 * holding the lock before removing the dquot from the AIL.
1327 if ((qip
->qli_item
.li_flags
& XFS_LI_IN_AIL
) &&
1328 qip
->qli_item
.li_lsn
== qip
->qli_flush_lsn
) {
1330 AIL_LOCK(dqp
->q_mount
, s
);
1332 * xfs_trans_delete_ail() drops the AIL lock.
1334 if (qip
->qli_item
.li_lsn
== qip
->qli_flush_lsn
)
1335 xfs_trans_delete_ail(dqp
->q_mount
,
1336 (xfs_log_item_t
*)qip
, s
);
1338 AIL_UNLOCK(dqp
->q_mount
, s
);
1342 * Release the dq's flush lock since we're done with it.
1349 xfs_qm_dqflock_nowait(
1354 locked
= cpsema(&((dqp
)->q_flock
));
1356 /* XXX ifdef these out */
1358 (dqp
)->dq_flags
|= XFS_DQ_FLOCKED
;
1364 xfs_qm_dqlock_nowait(
1367 return (mutex_trylock(&((dqp
)->q_qlock
)));
1374 mutex_lock(&(dqp
->q_qlock
), PINOD
);
1381 mutex_unlock(&(dqp
->q_qlock
));
1382 if (dqp
->q_logitem
.qli_dquot
== dqp
) {
1383 /* Once was dqp->q_mount, but might just have been cleared */
1384 xfs_trans_unlocked_item(dqp
->q_logitem
.qli_item
.li_mountp
,
1385 (xfs_log_item_t
*)&(dqp
->q_logitem
));
1391 xfs_dqunlock_nonotify(
1394 mutex_unlock(&(dqp
->q_qlock
));
1404 if (INT_GET(d1
->q_core
.d_id
, ARCH_CONVERT
) >
1405 INT_GET(d2
->q_core
.d_id
, ARCH_CONVERT
)) {
1423 * Take a dquot out of the mount's dqlist as well as the hashlist.
1424 * This is called via unmount as well as quotaoff, and the purge
1425 * will always succeed unless there are soft (temp) references
1428 * This returns 0 if it was purged, 1 if it wasn't. It's not an error code
1429 * that we're returning! XXXsup - not cool.
1437 xfs_dqhash_t
*thishash
;
1442 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp
));
1443 ASSERT(XFS_DQ_IS_HASH_LOCKED(dqp
->q_hash
));
1447 * We really can't afford to purge a dquot that is
1448 * referenced, because these are hard refs.
1449 * It shouldn't happen in general because we went thru _all_ inodes in
1450 * dqrele_all_inodes before calling this and didn't let the mountlock go.
1451 * However it is possible that we have dquots with temporary
1452 * references that are not attached to an inode. e.g. see xfs_setattr().
1454 if (dqp
->q_nrefs
!= 0) {
1456 XFS_DQ_HASH_UNLOCK(dqp
->q_hash
);
1460 ASSERT(XFS_DQ_IS_ON_FREELIST(dqp
));
1463 * If we're turning off quotas, we have to make sure that, for
1464 * example, we don't delete quota disk blocks while dquots are
1465 * in the process of getting written to those disk blocks.
1466 * This dquot might well be on AIL, and we can't leave it there
1467 * if we're turning off quotas. Basically, we need this flush
1468 * lock, and are willing to block on it.
1470 if (! xfs_qm_dqflock_nowait(dqp
)) {
1472 * Block on the flush lock after nudging dquot buffer,
1475 xfs_qm_dqflock_pushbuf_wait(dqp
);
1479 * XXXIf we're turning this type of quotas off, we don't care
1480 * about the dirty metadata sitting in this dquot. OTOH, if
1481 * we're unmounting, we do care, so we flush it and wait.
1483 if (XFS_DQ_IS_DIRTY(dqp
)) {
1484 xfs_dqtrace_entry(dqp
, "DQPURGE ->DQFLUSH: DQDIRTY");
1485 /* dqflush unlocks dqflock */
1487 * Given that dqpurge is a very rare occurrence, it is OK
1488 * that we're holding the hashlist and mplist locks
1489 * across the disk write. But, ... XXXsup
1491 * We don't care about getting disk errors here. We need
1492 * to purge this dquot anyway, so we go ahead regardless.
1494 (void) xfs_qm_dqflush(dqp
, XFS_QMOPT_SYNC
);
1497 ASSERT(dqp
->q_pincount
== 0);
1498 ASSERT(XFS_FORCED_SHUTDOWN(mp
) ||
1499 !(dqp
->q_logitem
.qli_item
.li_flags
& XFS_LI_IN_AIL
));
1501 thishash
= dqp
->q_hash
;
1502 XQM_HASHLIST_REMOVE(thishash
, dqp
);
1503 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(mp
)), dqp
);
1505 * XXX Move this to the front of the freelist, if we can get the
1508 ASSERT(XFS_DQ_IS_ON_FREELIST(dqp
));
1510 dqp
->q_mount
= NULL
;
1512 dqp
->dq_flags
= XFS_DQ_INACTIVE
;
1513 memset(&dqp
->q_core
, 0, sizeof(dqp
->q_core
));
1516 XFS_DQ_HASH_UNLOCK(thishash
);
1523 xfs_qm_dqprint(xfs_dquot_t
*dqp
)
1525 cmn_err(CE_DEBUG
, "-----------KERNEL DQUOT----------------");
1526 cmn_err(CE_DEBUG
, "---- dquotID = %d",
1527 (int)INT_GET(dqp
->q_core
.d_id
, ARCH_CONVERT
));
1528 cmn_err(CE_DEBUG
, "---- type = %s", DQFLAGTO_TYPESTR(dqp
));
1529 cmn_err(CE_DEBUG
, "---- fs = 0x%p", dqp
->q_mount
);
1530 cmn_err(CE_DEBUG
, "---- blkno = 0x%x", (int) dqp
->q_blkno
);
1531 cmn_err(CE_DEBUG
, "---- boffset = 0x%x", (int) dqp
->q_bufoffset
);
1532 cmn_err(CE_DEBUG
, "---- blkhlimit = %Lu (0x%x)",
1533 INT_GET(dqp
->q_core
.d_blk_hardlimit
, ARCH_CONVERT
),
1534 (int) INT_GET(dqp
->q_core
.d_blk_hardlimit
, ARCH_CONVERT
));
1535 cmn_err(CE_DEBUG
, "---- blkslimit = %Lu (0x%x)",
1536 INT_GET(dqp
->q_core
.d_blk_softlimit
, ARCH_CONVERT
),
1537 (int)INT_GET(dqp
->q_core
.d_blk_softlimit
, ARCH_CONVERT
));
1538 cmn_err(CE_DEBUG
, "---- inohlimit = %Lu (0x%x)",
1539 INT_GET(dqp
->q_core
.d_ino_hardlimit
, ARCH_CONVERT
),
1540 (int)INT_GET(dqp
->q_core
.d_ino_hardlimit
, ARCH_CONVERT
));
1541 cmn_err(CE_DEBUG
, "---- inoslimit = %Lu (0x%x)",
1542 INT_GET(dqp
->q_core
.d_ino_softlimit
, ARCH_CONVERT
),
1543 (int)INT_GET(dqp
->q_core
.d_ino_softlimit
, ARCH_CONVERT
));
1544 cmn_err(CE_DEBUG
, "---- bcount = %Lu (0x%x)",
1545 INT_GET(dqp
->q_core
.d_bcount
, ARCH_CONVERT
),
1546 (int)INT_GET(dqp
->q_core
.d_bcount
, ARCH_CONVERT
));
1547 cmn_err(CE_DEBUG
, "---- icount = %Lu (0x%x)",
1548 INT_GET(dqp
->q_core
.d_icount
, ARCH_CONVERT
),
1549 (int)INT_GET(dqp
->q_core
.d_icount
, ARCH_CONVERT
));
1550 cmn_err(CE_DEBUG
, "---- btimer = %d",
1551 (int)INT_GET(dqp
->q_core
.d_btimer
, ARCH_CONVERT
));
1552 cmn_err(CE_DEBUG
, "---- itimer = %d",
1553 (int)INT_GET(dqp
->q_core
.d_itimer
, ARCH_CONVERT
));
1554 cmn_err(CE_DEBUG
, "---------------------------");
1559 * Give the buffer a little push if it is incore and
1560 * wait on the flush lock.
1563 xfs_qm_dqflock_pushbuf_wait(
1569 * Check to see if the dquot has been flushed delayed
1570 * write. If so, grab its buffer and send it
1571 * out immediately. We'll be able to acquire
1572 * the flush lock when the I/O completes.
1574 bp
= xfs_incore(dqp
->q_mount
->m_ddev_targp
, dqp
->q_blkno
,
1575 XFS_QI_DQCHUNKLEN(dqp
->q_mount
),
1576 XFS_INCORE_TRYLOCK
);
1578 if (XFS_BUF_ISDELAYWRITE(bp
)) {
1579 if (XFS_BUF_ISPINNED(bp
)) {
1580 xfs_log_force(dqp
->q_mount
,
1584 xfs_bawrite(dqp
->q_mount
, bp
);