Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 7ae4440723a413c7a52edd27f654c34680dd4ea2

Authored by Christoph Hellwig 2011-12-07 05:58:25 +0800

Committed by Ben Myers 2011-12-16 04:38:30 +0800

Exists in master and in 6 other branches

xfs: remove XFS_QMOPT_DQSUSER

Just read the id 0 dquot from disk directly in xfs_qm_init_quotainfo instead
of going through dqget and requiring a special flag to not add the dquot to
any lists.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

Showing 4 changed files with 18 additions and 34 deletions Inline Diff

fs/xfs/xfs_dquot.c
fs/xfs/xfs_dquot.h
fs/xfs/xfs_qm.c
fs/xfs/xfs_quota.h

fs/xfs/xfs_dquot.c

Diff comments View file @ 7ae4440

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

fs/xfs/xfs_dquot.h

Diff comments View file @ 7ae4440

 /*
  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef __XFS_DQUOT_H__
 #define __XFS_DQUOT_H__
 /*
  * Dquots are structures that hold quota information about a user or a group,
  * much like inodes are for files. In fact, dquots share many characteristics
  * with inodes. However, dquots can also be a centralized resource, relative
  * to a collection of inodes. In this respect, dquots share some characteristics
  * of the superblock.
  * XFS dquots exploit both those in its algorithms. They make every attempt
  * to not be a bottleneck when quotas are on and have minimal impact, if any,
  * when quotas are off.
  */
 /*
  * The hash chain headers (hash buckets)
  */
 typedef struct xfs_dqhash {
 	struct list_head  qh_list;
 	struct mutex	  qh_lock;
 	uint		  qh_version;	/* ever increasing version */
 	uint		  qh_nelems;	/* number of dquots on the list */
 } xfs_dqhash_t;
 struct xfs_mount;
 struct xfs_trans;
 /*
  * The incore dquot structure
  */
 typedef struct xfs_dquot {
 	uint		 dq_flags;	/* various flags (XFS_DQ_*) */
 	struct list_head q_freelist;	/* global free list of dquots */
 	struct list_head q_mplist;	/* mount's list of dquots */
 	struct list_head q_hashlist;	/* gloabl hash list of dquots */
 	xfs_dqhash_t	*q_hash;	/* the hashchain header */
 	struct xfs_mount*q_mount;	/* filesystem this relates to */
 	struct xfs_trans*q_transp;	/* trans this belongs to currently */
 	uint		 q_nrefs;	/* # active refs from inodes */
 	xfs_daddr_t	 q_blkno;	/* blkno of dquot buffer */
 	int		 q_bufoffset;	/* off of dq in buffer (# dquots) */
 	xfs_fileoff_t	 q_fileoffset;	/* offset in quotas file */
 	struct xfs_dquot*q_gdquot;	/* group dquot, hint only */
 	xfs_disk_dquot_t q_core;	/* actual usage & quotas */
 	xfs_dq_logitem_t q_logitem;	/* dquot log item */
 	xfs_qcnt_t	 q_res_bcount;	/* total regular nblks used+reserved */
 	xfs_qcnt_t	 q_res_icount;	/* total inos allocd+reserved */
 	xfs_qcnt_t	 q_res_rtbcount;/* total realtime blks used+reserved */
 	struct mutex	 q_qlock;	/* quota lock */
 	struct completion q_flush;	/* flush completion queue */
 	atomic_t          q_pincount;	/* dquot pin count */
 	wait_queue_head_t q_pinwait;	/* dquot pinning wait queue */
 } xfs_dquot_t;
 /*
  * Lock hierarchy for q_qlock:
  *	XFS_QLOCK_NORMAL is the implicit default,
  * 	XFS_QLOCK_NESTED is the dquot with the higher id in xfs_dqlock2
  */
 enum {
 	XFS_QLOCK_NORMAL = 0,
 	XFS_QLOCK_NESTED,
 };
 /*
  * Manage the q_flush completion queue embedded in the dquot.  This completion
  * queue synchronizes processes attempting to flush the in-core dquot back to
  * disk.
  */
 static inline void xfs_dqflock(xfs_dquot_t *dqp)
 {
 	wait_for_completion(&dqp->q_flush);
 }
 static inline int xfs_dqflock_nowait(xfs_dquot_t *dqp)
 {
 	return try_wait_for_completion(&dqp->q_flush);
 }
 static inline void xfs_dqfunlock(xfs_dquot_t *dqp)
 {
 	complete(&dqp->q_flush);
 }
 static inline int xfs_dqlock_nowait(struct xfs_dquot *dqp)
 {
 	return mutex_trylock(&dqp->q_qlock);
 }
 static inline void xfs_dqlock(struct xfs_dquot *dqp)
 {
 	mutex_lock(&dqp->q_qlock);
 }
 static inline void xfs_dqunlock_nonotify(struct xfs_dquot *dqp)
 {
 	mutex_unlock(&dqp->q_qlock);
 }
 #define XFS_DQ_IS_LOCKED(dqp)	(mutex_is_locked(&((dqp)->q_qlock)))
 #define XFS_DQ_IS_DIRTY(dqp)	((dqp)->dq_flags & XFS_DQ_DIRTY)
 #define XFS_QM_ISUDQ(dqp)	((dqp)->dq_flags & XFS_DQ_USER)
 #define XFS_QM_ISPDQ(dqp)	((dqp)->dq_flags & XFS_DQ_PROJ)
 #define XFS_QM_ISGDQ(dqp)	((dqp)->dq_flags & XFS_DQ_GROUP)
 #define XFS_DQ_TO_QINF(dqp)	((dqp)->q_mount->m_quotainfo)
 #define XFS_DQ_TO_QIP(dqp)	(XFS_QM_ISUDQ(dqp) ? \
 				 XFS_DQ_TO_QINF(dqp)->qi_uquotaip : \
 				 XFS_DQ_TO_QINF(dqp)->qi_gquotaip)
 #define XFS_IS_THIS_QUOTA_OFF(d) (! (XFS_QM_ISUDQ(d) ? \
 				     (XFS_IS_UQUOTA_ON((d)->q_mount)) : \
 				     (XFS_IS_OQUOTA_ON((d)->q_mount))))
+extern int		xfs_qm_dqread(struct xfs_mount *, xfs_dqid_t, uint,
+					uint, struct xfs_dquot	**);
 extern void		xfs_qm_dqdestroy(xfs_dquot_t *);
 extern int		xfs_qm_dqflush(xfs_dquot_t *, uint);
 extern void		xfs_qm_dqpurge(xfs_dquot_t *);
 extern void		xfs_qm_dqunpin_wait(xfs_dquot_t *);
 extern void		xfs_qm_adjust_dqtimers(xfs_mount_t *,
 					xfs_disk_dquot_t *);
 extern void		xfs_qm_adjust_dqlimits(xfs_mount_t *,
 					xfs_disk_dquot_t *);
 extern int		xfs_qm_dqget(xfs_mount_t *, xfs_inode_t *,
 					xfs_dqid_t, uint, uint, xfs_dquot_t **);
 extern void		xfs_qm_dqput(xfs_dquot_t *);
 extern void		xfs_dqlock2(struct xfs_dquot *, struct xfs_dquot *);
 extern void		xfs_dqunlock(struct xfs_dquot *);
 extern void		xfs_dqflock_pushbuf_wait(struct xfs_dquot *dqp);
 static inline struct xfs_dquot *xfs_qm_dqhold(struct xfs_dquot *dqp)
 {
 	xfs_dqlock(dqp);
 	dqp->q_nrefs++;
 	xfs_dqunlock(dqp);
 	return dqp;
 }
 #endif /* __XFS_DQUOT_H__ */

fs/xfs/xfs_qm.c

Diff comments View file @ 7ae4440

 /*
  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_bit.h"
 #include "xfs_log.h"
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_alloc.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_ialloc.h"
 #include "xfs_itable.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_bmap.h"
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_trans_space.h"
 #include "xfs_utils.h"
 #include "xfs_qm.h"
 #include "xfs_trace.h"
 /*
  * The global quota manager. There is only one of these for the entire
  * system, _not_ one per file system. XQM keeps track of the overall
  * quota functionality, including maintaining the freelist and hash
  * tables of dquots.
  */
 struct mutex	xfs_Gqm_lock;
 struct xfs_qm	*xfs_Gqm;
 uint		ndquot;
 kmem_zone_t	*qm_dqzone;
 kmem_zone_t	*qm_dqtrxzone;
 STATIC void	xfs_qm_list_init(xfs_dqlist_t *, char *, int);
 STATIC void	xfs_qm_list_destroy(xfs_dqlist_t *);
 STATIC int	xfs_qm_init_quotainos(xfs_mount_t *);
 STATIC int	xfs_qm_init_quotainfo(xfs_mount_t *);
 STATIC int	xfs_qm_shake(struct shrinker *, struct shrink_control *);
 static struct shrinker xfs_qm_shaker = {
 	.shrink = xfs_qm_shake,
 	.seeks = DEFAULT_SEEKS,
 };
 /*
  * Initialize the XQM structure.
  * Note that there is not one quota manager per file system.
  */
 STATIC struct xfs_qm *
 xfs_Gqm_init(void)
 {
 	xfs_dqhash_t	*udqhash, *gdqhash;
 	xfs_qm_t	*xqm;
 	size_t		hsize;
 	uint		i;
 	/*
 	 * Initialize the dquot hash tables.
 	 */
 	udqhash = kmem_zalloc_greedy(&hsize,
 				     XFS_QM_HASHSIZE_LOW * sizeof(xfs_dqhash_t),
 				     XFS_QM_HASHSIZE_HIGH * sizeof(xfs_dqhash_t));
 	if (!udqhash)
 		goto out;
 	gdqhash = kmem_zalloc_large(hsize);
 	if (!gdqhash)
 		goto out_free_udqhash;
 	hsize /= sizeof(xfs_dqhash_t);
 	ndquot = hsize << 8;
 	xqm = kmem_zalloc(sizeof(xfs_qm_t), KM_SLEEP);
 	xqm->qm_dqhashmask = hsize - 1;
 	xqm->qm_usr_dqhtable = udqhash;
 	xqm->qm_grp_dqhtable = gdqhash;
 	ASSERT(xqm->qm_usr_dqhtable != NULL);
 	ASSERT(xqm->qm_grp_dqhtable != NULL);
 	for (i = 0; i < hsize; i++) {
 		xfs_qm_list_init(&(xqm->qm_usr_dqhtable[i]), "uxdqh", i);
 		xfs_qm_list_init(&(xqm->qm_grp_dqhtable[i]), "gxdqh", i);
 	}
 	/*
 	 * Freelist of all dquots of all file systems
 	 */
 	INIT_LIST_HEAD(&xqm->qm_dqfrlist);
 	xqm->qm_dqfrlist_cnt = 0;
 	mutex_init(&xqm->qm_dqfrlist_lock);
 	/*
 	 * dquot zone. we register our own low-memory callback.
 	 */
 	if (!qm_dqzone) {
 		xqm->qm_dqzone = kmem_zone_init(sizeof(xfs_dquot_t),
 						"xfs_dquots");
 		qm_dqzone = xqm->qm_dqzone;
 	} else
 		xqm->qm_dqzone = qm_dqzone;
 	register_shrinker(&xfs_qm_shaker);
 	/*
 	 * The t_dqinfo portion of transactions.
 	 */
 	if (!qm_dqtrxzone) {
 		xqm->qm_dqtrxzone = kmem_zone_init(sizeof(xfs_dquot_acct_t),
 						   "xfs_dqtrx");
 		qm_dqtrxzone = xqm->qm_dqtrxzone;
 	} else
 		xqm->qm_dqtrxzone = qm_dqtrxzone;
 	atomic_set(&xqm->qm_totaldquots, 0);
 	xqm->qm_dqfree_ratio = XFS_QM_DQFREE_RATIO;
 	xqm->qm_nrefs = 0;
 	return xqm;
  out_free_udqhash:
 	kmem_free_large(udqhash);
  out:
 	return NULL;
 }
 /*
  * Destroy the global quota manager when its reference count goes to zero.
  */
 STATIC void
 xfs_qm_destroy(
 	struct xfs_qm	*xqm)
 {
 	int		hsize, i;
 	ASSERT(xqm != NULL);
 	ASSERT(xqm->qm_nrefs == 0);
 	unregister_shrinker(&xfs_qm_shaker);
 	mutex_lock(&xqm->qm_dqfrlist_lock);
 	ASSERT(list_empty(&xqm->qm_dqfrlist));
 	mutex_unlock(&xqm->qm_dqfrlist_lock);
 	hsize = xqm->qm_dqhashmask + 1;
 	for (i = 0; i < hsize; i++) {
 		xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));
 		xfs_qm_list_destroy(&(xqm->qm_grp_dqhtable[i]));
 	}
 	kmem_free_large(xqm->qm_usr_dqhtable);
 	kmem_free_large(xqm->qm_grp_dqhtable);
 	xqm->qm_usr_dqhtable = NULL;
 	xqm->qm_grp_dqhtable = NULL;
 	xqm->qm_dqhashmask = 0;
 	kmem_free(xqm);
 }
 /*
  * Called at mount time to let XQM know that another file system is
  * starting quotas. This isn't crucial information as the individual mount
  * structures are pretty independent, but it helps the XQM keep a
  * global view of what's going on.
  */
 /* ARGSUSED */
 STATIC int
 xfs_qm_hold_quotafs_ref(
 	struct xfs_mount *mp)
 {
 	/*
 	 * Need to lock the xfs_Gqm structure for things like this. For example,
 	 * the structure could disappear between the entry to this routine and
 	 * a HOLD operation if not locked.
 	 */
 	mutex_lock(&xfs_Gqm_lock);
 	if (!xfs_Gqm) {
 		xfs_Gqm = xfs_Gqm_init();
 		if (!xfs_Gqm) {
 			mutex_unlock(&xfs_Gqm_lock);
 			return ENOMEM;
 		}
 	}
 	/*
 	 * We can keep a list of all filesystems with quotas mounted for
 	 * debugging and statistical purposes, but ...
 	 * Just take a reference and get out.
 	 */
 	xfs_Gqm->qm_nrefs++;
 	mutex_unlock(&xfs_Gqm_lock);
 	return 0;
 }
 /*
  * Release the reference that a filesystem took at mount time,
  * so that we know when we need to destroy the entire quota manager.
  */
 /* ARGSUSED */
 STATIC void
 xfs_qm_rele_quotafs_ref(
 	struct xfs_mount *mp)
 {
 	ASSERT(xfs_Gqm);
 	ASSERT(xfs_Gqm->qm_nrefs > 0);
 	/*
 	 * Destroy the entire XQM. If somebody mounts with quotaon, this'll
 	 * be restarted.
 	 */
 	mutex_lock(&xfs_Gqm_lock);
 	if (--xfs_Gqm->qm_nrefs == 0) {
 		xfs_qm_destroy(xfs_Gqm);
 		xfs_Gqm = NULL;
 	}
 	mutex_unlock(&xfs_Gqm_lock);
 }
 /*
  * Just destroy the quotainfo structure.
  */
 void
 xfs_qm_unmount(
 	struct xfs_mount	*mp)
 {
 	if (mp->m_quotainfo) {
 		xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
 		xfs_qm_destroy_quotainfo(mp);
 	}
 }
 /*
  * This is called from xfs_mountfs to start quotas and initialize all
  * necessary data structures like quotainfo.  This is also responsible for
  * running a quotacheck as necessary.  We are guaranteed that the superblock
  * is consistently read in at this point.
  *
  * If we fail here, the mount will continue with quota turned off. We don't
  * need to inidicate success or failure at all.
  */
 void
 xfs_qm_mount_quotas(
 	xfs_mount_t	*mp)
 {
 	int		error = 0;
 	uint		sbf;
 	/*
 	 * If quotas on realtime volumes is not supported, we disable
 	 * quotas immediately.
 	 */
 	if (mp->m_sb.sb_rextents) {
 		xfs_notice(mp, "Cannot turn on quotas for realtime filesystem");
 		mp->m_qflags = 0;
 		goto write_changes;
 	}
 	ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 	/*
 	 * Allocate the quotainfo structure inside the mount struct, and
 	 * create quotainode(s), and change/rev superblock if necessary.
 	 */
 	error = xfs_qm_init_quotainfo(mp);
 	if (error) {
 		/*
 		 * We must turn off quotas.
 		 */
 		ASSERT(mp->m_quotainfo == NULL);
 		mp->m_qflags = 0;
 		goto write_changes;
 	}
 	/*
 	 * If any of the quotas are not consistent, do a quotacheck.
 	 */
 	if (XFS_QM_NEED_QUOTACHECK(mp)) {
 		error = xfs_qm_quotacheck(mp);
 		if (error) {
 			/* Quotacheck failed and disabled quotas. */
 			return;
 		}
 	}
 	/*
 	 * If one type of quotas is off, then it will lose its
 	 * quotachecked status, since we won't be doing accounting for
 	 * that type anymore.
 	 */
 	if (!XFS_IS_UQUOTA_ON(mp))
 		mp->m_qflags &= ~XFS_UQUOTA_CHKD;
 	if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp)))
 		mp->m_qflags &= ~XFS_OQUOTA_CHKD;
  write_changes:
 	/*
 	 * We actually don't have to acquire the m_sb_lock at all.
 	 * This can only be called from mount, and that's single threaded. XXX
 	 */
 	spin_lock(&mp->m_sb_lock);
 	sbf = mp->m_sb.sb_qflags;
 	mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
 	spin_unlock(&mp->m_sb_lock);
 	if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
 		if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
 			/*
 			 * We could only have been turning quotas off.
 			 * We aren't in very good shape actually because
 			 * the incore structures are convinced that quotas are
 			 * off, but the on disk superblock doesn't know that !
 			 */
 			ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
 			xfs_alert(mp, "%s: Superblock update failed!",
 				__func__);
 		}
 	}
 	if (error) {
 		xfs_warn(mp, "Failed to initialize disk quotas.");
 		return;
 	}
 }
 /*
  * Called from the vfsops layer.
  */
 void
 xfs_qm_unmount_quotas(
 	xfs_mount_t	*mp)
 {
 	/*
 	 * Release the dquots that root inode, et al might be holding,
 	 * before we flush quotas and blow away the quotainfo structure.
 	 */
 	ASSERT(mp->m_rootip);
 	xfs_qm_dqdetach(mp->m_rootip);
 	if (mp->m_rbmip)
 		xfs_qm_dqdetach(mp->m_rbmip);
 	if (mp->m_rsumip)
 		xfs_qm_dqdetach(mp->m_rsumip);
 	/*
 	 * Release the quota inodes.
 	 */
 	if (mp->m_quotainfo) {
 		if (mp->m_quotainfo->qi_uquotaip) {
 			IRELE(mp->m_quotainfo->qi_uquotaip);
 			mp->m_quotainfo->qi_uquotaip = NULL;
 		}
 		if (mp->m_quotainfo->qi_gquotaip) {
 			IRELE(mp->m_quotainfo->qi_gquotaip);
 			mp->m_quotainfo->qi_gquotaip = NULL;
 		}
 	}
 }
 /*
  * Flush all dquots of the given file system to disk. The dquots are
  * _not_ purged from memory here, just their data written to disk.
  */
 STATIC int
 xfs_qm_dqflush_all(
 	struct xfs_mount	*mp)
 {
 	struct xfs_quotainfo	*q = mp->m_quotainfo;
 	int			recl;
 	struct xfs_dquot	*dqp;
 	int			error;
 	if (!q)
 		return 0;
 again:
 	mutex_lock(&q->qi_dqlist_lock);
 	list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {
 		xfs_dqlock(dqp);
 		if ((dqp->dq_flags & XFS_DQ_FREEING) ||
 		    !XFS_DQ_IS_DIRTY(dqp)) {
 			xfs_dqunlock(dqp);
 			continue;
 		}
 		/* XXX a sentinel would be better */
 		recl = q->qi_dqreclaims;
 		if (!xfs_dqflock_nowait(dqp)) {
 			/*
 			 * If we can't grab the flush lock then check
 			 * to see if the dquot has been flushed delayed
 			 * write.  If so, grab its buffer and send it
 			 * out immediately.  We'll be able to acquire
 			 * the flush lock when the I/O completes.
 			 */
 			xfs_dqflock_pushbuf_wait(dqp);
 		}
 		/*
 		 * Let go of the mplist lock. We don't want to hold it
 		 * across a disk write.
 		 */
 		mutex_unlock(&q->qi_dqlist_lock);
 		error = xfs_qm_dqflush(dqp, 0);
 		xfs_dqunlock(dqp);
 		if (error)
 			return error;
 		mutex_lock(&q->qi_dqlist_lock);
 		if (recl != q->qi_dqreclaims) {
 			mutex_unlock(&q->qi_dqlist_lock);
 			/* XXX restart limit */
 			goto again;
 		}
 	}
 	mutex_unlock(&q->qi_dqlist_lock);
 	/* return ! busy */
 	return 0;
 }
 /*
  * Release the group dquot pointers the user dquots may be
  * carrying around as a hint. mplist is locked on entry and exit.
  */
 STATIC void
 xfs_qm_detach_gdquots(
 	struct xfs_mount	*mp)
 {
 	struct xfs_quotainfo	*q = mp->m_quotainfo;
 	struct xfs_dquot	*dqp, *gdqp;
 	int			nrecl;
  again:
 	ASSERT(mutex_is_locked(&q->qi_dqlist_lock));
 	list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {
 		xfs_dqlock(dqp);
 		if (dqp->dq_flags & XFS_DQ_FREEING) {
 			xfs_dqunlock(dqp);
 			mutex_unlock(&q->qi_dqlist_lock);
 			delay(1);
 			mutex_lock(&q->qi_dqlist_lock);
 			goto again;
 		}
 		if ((gdqp = dqp->q_gdquot)) {
 			xfs_dqlock(gdqp);
 			dqp->q_gdquot = NULL;
 		}
 		xfs_dqunlock(dqp);
 		if (gdqp) {
 			/*
 			 * Can't hold the mplist lock across a dqput.
 			 * XXXmust convert to marker based iterations here.
 			 */
 			nrecl = q->qi_dqreclaims;
 			mutex_unlock(&q->qi_dqlist_lock);
 			xfs_qm_dqput(gdqp);
 			mutex_lock(&q->qi_dqlist_lock);
 			if (nrecl != q->qi_dqreclaims)
 				goto again;
 		}
 	}
 }
 /*
  * Go through all the incore dquots of this file system and take them
  * off the mplist and hashlist, if the dquot type matches the dqtype
  * parameter. This is used when turning off quota accounting for
  * users and/or groups, as well as when the filesystem is unmounting.
  */
 STATIC int
 xfs_qm_dqpurge_int(
 	struct xfs_mount	*mp,
 	uint			flags)
 {
 	struct xfs_quotainfo	*q = mp->m_quotainfo;
 	struct xfs_dquot	*dqp, *n;
 	uint			dqtype;
 	int			nmisses = 0;
 	LIST_HEAD		(dispose_list);
 	if (!q)
 		return 0;
 	dqtype = (flags & XFS_QMOPT_UQUOTA) ? XFS_DQ_USER : 0;
 	dqtype |= (flags & XFS_QMOPT_PQUOTA) ? XFS_DQ_PROJ : 0;
 	dqtype |= (flags & XFS_QMOPT_GQUOTA) ? XFS_DQ_GROUP : 0;
 	mutex_lock(&q->qi_dqlist_lock);
 	/*
 	 * In the first pass through all incore dquots of this filesystem,
 	 * we release the group dquot pointers the user dquots may be
 	 * carrying around as a hint. We need to do this irrespective of
 	 * what's being turned off.
 	 */
 	xfs_qm_detach_gdquots(mp);
 	/*
 	 * Try to get rid of all of the unwanted dquots.
 	 */
 	list_for_each_entry_safe(dqp, n, &q->qi_dqlist, q_mplist) {
 		xfs_dqlock(dqp);
 		if ((dqp->dq_flags & dqtype) != 0 &&
 		    !(dqp->dq_flags & XFS_DQ_FREEING)) {
 			if (dqp->q_nrefs == 0) {
 				dqp->dq_flags |= XFS_DQ_FREEING;
 				list_move_tail(&dqp->q_mplist, &dispose_list);
 			} else
 				nmisses++;
 		}
 		xfs_dqunlock(dqp);
 	}
 	mutex_unlock(&q->qi_dqlist_lock);
 	list_for_each_entry_safe(dqp, n, &dispose_list, q_mplist)
 		xfs_qm_dqpurge(dqp);
 	return nmisses;
 }
 int
 xfs_qm_dqpurge_all(
 	xfs_mount_t	*mp,
 	uint		flags)
 {
 	int		ndquots;
 	/*
 	 * Purge the dquot cache.
 	 * None of the dquots should really be busy at this point.
 	 */
 	if (mp->m_quotainfo) {
 		while ((ndquots = xfs_qm_dqpurge_int(mp, flags))) {
 			delay(ndquots * 10);
 		}
 	}
 	return 0;
 }
 STATIC int
 xfs_qm_dqattach_one(
 	xfs_inode_t	*ip,
 	xfs_dqid_t	id,
 	uint		type,
 	uint		doalloc,
 	xfs_dquot_t	*udqhint, /* hint */
 	xfs_dquot_t	**IO_idqpp)
 {
 	xfs_dquot_t	*dqp;
 	int		error;
 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 	error = 0;
 	/*
 	 * See if we already have it in the inode itself. IO_idqpp is
 	 * &i_udquot or &i_gdquot. This made the code look weird, but
 	 * made the logic a lot simpler.
 	 */
 	dqp = *IO_idqpp;
 	if (dqp) {
 		trace_xfs_dqattach_found(dqp);
 		return 0;
 	}
 	/*
 	 * udqhint is the i_udquot field in inode, and is non-NULL only
 	 * when the type arg is group/project. Its purpose is to save a
 	 * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside
 	 * the user dquot.
 	 */
 	if (udqhint) {
 		ASSERT(type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
 		xfs_dqlock(udqhint);
 		/*
 		 * No need to take dqlock to look at the id.
 		 *
 		 * The ID can't change until it gets reclaimed, and it won't
 		 * be reclaimed as long as we have a ref from inode and we
 		 * hold the ilock.
 		 */
 		dqp = udqhint->q_gdquot;
 		if (dqp && be32_to_cpu(dqp->q_core.d_id) == id) {
 			ASSERT(*IO_idqpp == NULL);
 			*IO_idqpp = xfs_qm_dqhold(dqp);
 			xfs_dqunlock(udqhint);
 			return 0;
 		}
 		/*
 		 * We can't hold a dquot lock when we call the dqget code.
 		 * We'll deadlock in no time, because of (not conforming to)
 		 * lock ordering - the inodelock comes before any dquot lock,
 		 * and we may drop and reacquire the ilock in xfs_qm_dqget().
 		 */
 		xfs_dqunlock(udqhint);
 	}
 	/*
 	 * Find the dquot from somewhere. This bumps the
 	 * reference count of dquot and returns it locked.
 	 * This can return ENOENT if dquot didn't exist on
 	 * disk and we didn't ask it to allocate;
 	 * ESRCH if quotas got turned off suddenly.
 	 */
 	error = xfs_qm_dqget(ip->i_mount, ip, id, type,
 			     doalloc | XFS_QMOPT_DOWARN, &dqp);
 	if (error)
 		return error;
 	trace_xfs_dqattach_get(dqp);
 	/*
 	 * dqget may have dropped and re-acquired the ilock, but it guarantees
 	 * that the dquot returned is the one that should go in the inode.
 	 */
 	*IO_idqpp = dqp;
 	xfs_dqunlock(dqp);
 	return 0;
 }
 /*
  * Given a udquot and gdquot, attach a ptr to the group dquot in the
  * udquot as a hint for future lookups.
  */
 STATIC void
 xfs_qm_dqattach_grouphint(
 	xfs_dquot_t	*udq,
 	xfs_dquot_t	*gdq)
 {
 	xfs_dquot_t	*tmp;
 	xfs_dqlock(udq);
 	tmp = udq->q_gdquot;
 	if (tmp) {
 		if (tmp == gdq)
 			goto done;
 		udq->q_gdquot = NULL;
 		xfs_qm_dqrele(tmp);
 	}
 	udq->q_gdquot = xfs_qm_dqhold(gdq);
 done:
 	xfs_dqunlock(udq);
 }
 /*
  * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
  * into account.
  * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed.
  * Inode may get unlocked and relocked in here, and the caller must deal with
  * the consequences.
  */
 int
 xfs_qm_dqattach_locked(
 	xfs_inode_t	*ip,
 	uint		flags)
 {
 	xfs_mount_t	*mp = ip->i_mount;
 	uint		nquotas = 0;
 	int		error = 0;
 	if (!XFS_IS_QUOTA_RUNNING(mp) ||
 	    !XFS_IS_QUOTA_ON(mp) ||
 	    !XFS_NOT_DQATTACHED(mp, ip) ||
 	    ip->i_ino == mp->m_sb.sb_uquotino ||
 	    ip->i_ino == mp->m_sb.sb_gquotino)
 		return 0;
 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 	if (XFS_IS_UQUOTA_ON(mp)) {
 		error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
 						flags & XFS_QMOPT_DQALLOC,
 						NULL, &ip->i_udquot);
 		if (error)
 			goto done;
 		nquotas++;
 	}
 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 	if (XFS_IS_OQUOTA_ON(mp)) {
 		error = XFS_IS_GQUOTA_ON(mp) ?
 			xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
 						flags & XFS_QMOPT_DQALLOC,
 						ip->i_udquot, &ip->i_gdquot) :
 			xfs_qm_dqattach_one(ip, xfs_get_projid(ip), XFS_DQ_PROJ,
 						flags & XFS_QMOPT_DQALLOC,
 						ip->i_udquot, &ip->i_gdquot);
 		/*
 		 * Don't worry about the udquot that we may have
 		 * attached above. It'll get detached, if not already.
 		 */
 		if (error)
 			goto done;
 		nquotas++;
 	}
 	/*
 	 * Attach this group quota to the user quota as a hint.
 	 * This WON'T, in general, result in a thrash.
 	 */
 	if (nquotas == 2) {
 		ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 		ASSERT(ip->i_udquot);
 		ASSERT(ip->i_gdquot);
 		/*
 		 * We do not have i_udquot locked at this point, but this check
 		 * is OK since we don't depend on the i_gdquot to be accurate
 		 * 100% all the time. It is just a hint, and this will
 		 * succeed in general.
 		 */
 		if (ip->i_udquot->q_gdquot != ip->i_gdquot)
 			xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot);
 	}
  done:
 #ifdef DEBUG
 	if (!error) {
 		if (XFS_IS_UQUOTA_ON(mp))
 			ASSERT(ip->i_udquot);
 		if (XFS_IS_OQUOTA_ON(mp))
 			ASSERT(ip->i_gdquot);
 	}
 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 #endif
 	return error;
 }
 int
 xfs_qm_dqattach(
 	struct xfs_inode	*ip,
 	uint			flags)
 {
 	int			error;
 	xfs_ilock(ip, XFS_ILOCK_EXCL);
 	error = xfs_qm_dqattach_locked(ip, flags);
 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
 	return error;
 }
 /*
  * Release dquots (and their references) if any.
  * The inode should be locked EXCL except when this's called by
  * xfs_ireclaim.
  */
 void
 xfs_qm_dqdetach(
 	xfs_inode_t	*ip)
 {
 	if (!(ip->i_udquot || ip->i_gdquot))
 		return;
 	trace_xfs_dquot_dqdetach(ip);
 	ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
 	ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
 	if (ip->i_udquot) {
 		xfs_qm_dqrele(ip->i_udquot);
 		ip->i_udquot = NULL;
 	}
 	if (ip->i_gdquot) {
 		xfs_qm_dqrele(ip->i_gdquot);
 		ip->i_gdquot = NULL;
 	}
 }
 /*
  * The hash chains and the mplist use the same xfs_dqhash structure as
  * their list head, but we can take the mplist qh_lock and one of the
  * hash qh_locks at the same time without any problem as they aren't
  * related.
  */
 static struct lock_class_key xfs_quota_mplist_class;
 /*
  * This initializes all the quota information that's kept in the
  * mount structure
  */
 STATIC int
 xfs_qm_init_quotainfo(
 	xfs_mount_t	*mp)
 {
 	xfs_quotainfo_t *qinf;
 	int		error;
 	xfs_dquot_t	*dqp;
 	ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 	/*
 	 * Tell XQM that we exist as soon as possible.
 	 */
 	if ((error = xfs_qm_hold_quotafs_ref(mp))) {
 		return error;
 	}
 	qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
 	/*
 	 * See if quotainodes are setup, and if not, allocate them,
 	 * and change the superblock accordingly.
 	 */
 	if ((error = xfs_qm_init_quotainos(mp))) {
 		kmem_free(qinf);
 		mp->m_quotainfo = NULL;
 		return error;
 	}
 	INIT_LIST_HEAD(&qinf->qi_dqlist);
 	mutex_init(&qinf->qi_dqlist_lock);
 	lockdep_set_class(&qinf->qi_dqlist_lock, &xfs_quota_mplist_class);
 	qinf->qi_dqreclaims = 0;
 	/* mutex used to serialize quotaoffs */
 	mutex_init(&qinf->qi_quotaofflock);
 	/* Precalc some constants */
 	qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
 	ASSERT(qinf->qi_dqchunklen);
 	qinf->qi_dqperchunk = BBTOB(qinf->qi_dqchunklen);
 	do_div(qinf->qi_dqperchunk, sizeof(xfs_dqblk_t));
 	mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
 	/*
 	 * We try to get the limits from the superuser's limits fields.
 	 * This is quite hacky, but it is standard quota practice.
+	 *
 	 * We look at the USR dquot with id == 0 first, but if user quotas
 	 * are not enabled we goto the GRP dquot with id == 0.
 	 * We don't really care to keep separate default limits for user
 	 * and group quotas, at least not at this point.
+	 *
+	 * Since we may not have done a quotacheck by this point, just read
+	 * the dquot without attaching it to any hashtables or lists.
 	 */
-	error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)0,
+	error = xfs_qm_dqread(mp, 0,
-			     XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
+			XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
-			     (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
+			 (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
-				XFS_DQ_PROJ),
+			  XFS_DQ_PROJ),
-			     XFS_QMOPT_DQSUSER|XFS_QMOPT_DOWARN,
+			XFS_QMOPT_DOWARN, &dqp);
-			     &dqp);
+	if (!error) {
-	if (! error) {
 		xfs_disk_dquot_t	*ddqp = &dqp->q_core;
 		/*
 		 * The warnings and timers set the grace period given to
 		 * a user or group before he or she can not perform any
 		 * more writing. If it is zero, a default is used.
 		 */
 		qinf->qi_btimelimit = ddqp->d_btimer ?
 			be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;
 		qinf->qi_itimelimit = ddqp->d_itimer ?
 			be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;
 		qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?
 			be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;
 		qinf->qi_bwarnlimit = ddqp->d_bwarns ?
 			be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;
 		qinf->qi_iwarnlimit = ddqp->d_iwarns ?
 			be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
 		qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
 			be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
 		qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
 		qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
 		qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
 		qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
 		qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
 		qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
-		/*
-		 * We sent the XFS_QMOPT_DQSUSER flag to dqget because
-		 * we don't want this dquot cached. We haven't done a
-		 * quotacheck yet, and quotacheck doesn't like incore dquots.
-		 */
 		xfs_qm_dqdestroy(dqp);
 	} else {
 		qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
 		qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
 		qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
 		qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
 		qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
 		qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
 	}
 	return 0;
 }
 /*
  * Gets called when unmounting a filesystem or when all quotas get
  * turned off.
  * This purges the quota inodes, destroys locks and frees itself.
  */
 void
 xfs_qm_destroy_quotainfo(
 	xfs_mount_t	*mp)
 {
 	xfs_quotainfo_t *qi;
 	qi = mp->m_quotainfo;
 	ASSERT(qi != NULL);
 	ASSERT(xfs_Gqm != NULL);
 	/*
 	 * Release the reference that XQM kept, so that we know
 	 * when the XQM structure should be freed. We cannot assume
 	 * that xfs_Gqm is non-null after this point.
 	 */
 	xfs_qm_rele_quotafs_ref(mp);
 	ASSERT(list_empty(&qi->qi_dqlist));
 	mutex_destroy(&qi->qi_dqlist_lock);
 	if (qi->qi_uquotaip) {
 		IRELE(qi->qi_uquotaip);
 		qi->qi_uquotaip = NULL; /* paranoia */
 	}
 	if (qi->qi_gquotaip) {
 		IRELE(qi->qi_gquotaip);
 		qi->qi_gquotaip = NULL;
 	}
 	mutex_destroy(&qi->qi_quotaofflock);
 	kmem_free(qi);
 	mp->m_quotainfo = NULL;
 }
 /* ------------------- PRIVATE STATIC FUNCTIONS ----------------------- */
 /* ARGSUSED */
 STATIC void
 xfs_qm_list_init(
 	xfs_dqlist_t	*list,
 	char		*str,
 	int		n)
 {
 	mutex_init(&list->qh_lock);
 	INIT_LIST_HEAD(&list->qh_list);
 	list->qh_version = 0;
 	list->qh_nelems = 0;
 }
 STATIC void
 xfs_qm_list_destroy(
 	xfs_dqlist_t	*list)
 {
 	mutex_destroy(&(list->qh_lock));
 }
 /*
  * Create an inode and return with a reference already taken, but unlocked
  * This is how we create quota inodes
  */
 STATIC int
 xfs_qm_qino_alloc(
 	xfs_mount_t	*mp,
 	xfs_inode_t	**ip,
 	__int64_t	sbfields,
 	uint		flags)
 {
 	xfs_trans_t	*tp;
 	int		error;
 	int		committed;
 	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
 	if ((error = xfs_trans_reserve(tp,
 				      XFS_QM_QINOCREATE_SPACE_RES(mp),
 				      XFS_CREATE_LOG_RES(mp), 0,
 				      XFS_TRANS_PERM_LOG_RES,
 				      XFS_CREATE_LOG_COUNT))) {
 		xfs_trans_cancel(tp, 0);
 		return error;
 	}
 	error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0, 0, 1, ip, &committed);
 	if (error) {
 		xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
 				 XFS_TRANS_ABORT);
 		return error;
 	}
 	/*
 	 * Make the changes in the superblock, and log those too.
 	 * sbfields arg may contain fields other than *QUOTINO;
 	 * VERSIONNUM for example.
 	 */
 	spin_lock(&mp->m_sb_lock);
 	if (flags & XFS_QMOPT_SBVERSION) {
 		ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
 		ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
 				   XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
 		       (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
 			XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
 		xfs_sb_version_addquota(&mp->m_sb);
 		mp->m_sb.sb_uquotino = NULLFSINO;
 		mp->m_sb.sb_gquotino = NULLFSINO;
 		/* qflags will get updated _after_ quotacheck */
 		mp->m_sb.sb_qflags = 0;
 	}
 	if (flags & XFS_QMOPT_UQUOTA)
 		mp->m_sb.sb_uquotino = (*ip)->i_ino;
 	else
 		mp->m_sb.sb_gquotino = (*ip)->i_ino;
 	spin_unlock(&mp->m_sb_lock);
 	xfs_mod_sb(tp, sbfields);
 	if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) {
 		xfs_alert(mp, "%s failed (error %d)!", __func__, error);
 		return error;
 	}
 	return 0;
 }
 STATIC void
 xfs_qm_reset_dqcounts(
 	xfs_mount_t	*mp,
 	xfs_buf_t	*bp,
 	xfs_dqid_t	id,
 	uint		type)
 {
 	xfs_disk_dquot_t	*ddq;
 	int			j;
 	trace_xfs_reset_dqcounts(bp, _RET_IP_);
 	/*
 	 * Reset all counters and timers. They'll be
 	 * started afresh by xfs_qm_quotacheck.
 	 */
 #ifdef DEBUG
 	j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
 	do_div(j, sizeof(xfs_dqblk_t));
 	ASSERT(mp->m_quotainfo->qi_dqperchunk == j);
 #endif
 	ddq = bp->b_addr;
 	for (j = 0; j < mp->m_quotainfo->qi_dqperchunk; j++) {
 		/*
 		 * Do a sanity check, and if needed, repair the dqblk. Don't
 		 * output any warnings because it's perfectly possible to
 		 * find uninitialised dquot blks. See comment in xfs_qm_dqcheck.
 		 */
 		(void) xfs_qm_dqcheck(mp, ddq, id+j, type, XFS_QMOPT_DQREPAIR,
 				      "xfs_quotacheck");
 		ddq->d_bcount = 0;
 		ddq->d_icount = 0;
 		ddq->d_rtbcount = 0;
 		ddq->d_btimer = 0;
 		ddq->d_itimer = 0;
 		ddq->d_rtbtimer = 0;
 		ddq->d_bwarns = 0;
 		ddq->d_iwarns = 0;
 		ddq->d_rtbwarns = 0;
 		ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);
 	}
 }
 STATIC int
 xfs_qm_dqiter_bufs(
 	xfs_mount_t	*mp,
 	xfs_dqid_t	firstid,
 	xfs_fsblock_t	bno,
 	xfs_filblks_t	blkcnt,
 	uint		flags)
 {
 	xfs_buf_t	*bp;
 	int		error;
 	int		type;
 	ASSERT(blkcnt > 0);
 	type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
 		(flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
 	error = 0;
 	/*
 	 * Blkcnt arg can be a very big number, and might even be
 	 * larger than the log itself. So, we have to break it up into
 	 * manageable-sized transactions.
 	 * Note that we don't start a permanent transaction here; we might
 	 * not be able to get a log reservation for the whole thing up front,
 	 * and we don't really care to either, because we just discard
 	 * everything if we were to crash in the middle of this loop.
 	 */
 	while (blkcnt--) {
 		error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
 			      XFS_FSB_TO_DADDR(mp, bno),
 			      mp->m_quotainfo->qi_dqchunklen, 0, &bp);
 		if (error)
 			break;
 		xfs_qm_reset_dqcounts(mp, bp, firstid, type);
 		xfs_buf_delwri_queue(bp);
 		xfs_buf_relse(bp);
 		/*
 		 * goto the next block.
 		 */
 		bno++;
 		firstid += mp->m_quotainfo->qi_dqperchunk;
 	}
 	return error;
 }
 /*
  * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a
  * caller supplied function for every chunk of dquots that we find.
  */
 STATIC int
 xfs_qm_dqiterate(
 	xfs_mount_t	*mp,
 	xfs_inode_t	*qip,
 	uint		flags)
 {
 	xfs_bmbt_irec_t		*map;
 	int			i, nmaps;	/* number of map entries */
 	int			error;		/* return value */
 	xfs_fileoff_t		lblkno;
 	xfs_filblks_t		maxlblkcnt;
 	xfs_dqid_t		firstid;
 	xfs_fsblock_t		rablkno;
 	xfs_filblks_t		rablkcnt;
 	error = 0;
 	/*
 	 * This looks racy, but we can't keep an inode lock across a
 	 * trans_reserve. But, this gets called during quotacheck, and that
 	 * happens only at mount time which is single threaded.
 	 */
 	if (qip->i_d.di_nblocks == 0)
 		return 0;
 	map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
 	lblkno = 0;
 	maxlblkcnt = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
 	do {
 		nmaps = XFS_DQITER_MAP_SIZE;
 		/*
 		 * We aren't changing the inode itself. Just changing
 		 * some of its data. No new blocks are added here, and
 		 * the inode is never added to the transaction.
 		 */
 		xfs_ilock(qip, XFS_ILOCK_SHARED);
 		error = xfs_bmapi_read(qip, lblkno, maxlblkcnt - lblkno,
 				       map, &nmaps, 0);
 		xfs_iunlock(qip, XFS_ILOCK_SHARED);
 		if (error)
 			break;
 		ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
 		for (i = 0; i < nmaps; i++) {
 			ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
 			ASSERT(map[i].br_blockcount);
 			lblkno += map[i].br_blockcount;
 			if (map[i].br_startblock == HOLESTARTBLOCK)
 				continue;
 			firstid = (xfs_dqid_t) map[i].br_startoff *
 				mp->m_quotainfo->qi_dqperchunk;
 			/*
 			 * Do a read-ahead on the next extent.
 			 */
 			if ((i+1 < nmaps) &&
 			    (map[i+1].br_startblock != HOLESTARTBLOCK)) {
 				rablkcnt =  map[i+1].br_blockcount;
 				rablkno = map[i+1].br_startblock;
 				while (rablkcnt--) {
 					xfs_buf_readahead(mp->m_ddev_targp,
 					       XFS_FSB_TO_DADDR(mp, rablkno),
 					       mp->m_quotainfo->qi_dqchunklen);
 					rablkno++;
 				}
 			}
 			/*
 			 * Iterate thru all the blks in the extent and
 			 * reset the counters of all the dquots inside them.
 			 */
 			if ((error = xfs_qm_dqiter_bufs(mp,
 						       firstid,
 						       map[i].br_startblock,
 						       map[i].br_blockcount,
 						       flags))) {
 				break;
 			}
 		}
 		if (error)
 			break;
 	} while (nmaps > 0);
 	kmem_free(map);
 	return error;
 }
 /*
  * Called by dqusage_adjust in doing a quotacheck.
  *
  * Given the inode, and a dquot id this updates both the incore dqout as well
  * as the buffer copy. This is so that once the quotacheck is done, we can
  * just log all the buffers, as opposed to logging numerous updates to
  * individual dquots.
  */
 STATIC int
 xfs_qm_quotacheck_dqadjust(
 	struct xfs_inode	*ip,
 	xfs_dqid_t		id,
 	uint			type,
 	xfs_qcnt_t		nblks,
 	xfs_qcnt_t		rtblks)
 {
 	struct xfs_mount	*mp = ip->i_mount;
 	struct xfs_dquot	*dqp;
 	int			error;
 	error = xfs_qm_dqget(mp, ip, id, type,
 			     XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN, &dqp);
 	if (error) {
 		/*
 		 * Shouldn't be able to turn off quotas here.
 		 */
 		ASSERT(error != ESRCH);
 		ASSERT(error != ENOENT);
 		return error;
 	}
 	trace_xfs_dqadjust(dqp);
 	/*
 	 * Adjust the inode count and the block count to reflect this inode's
 	 * resource usage.
 	 */
 	be64_add_cpu(&dqp->q_core.d_icount, 1);
 	dqp->q_res_icount++;
 	if (nblks) {
 		be64_add_cpu(&dqp->q_core.d_bcount, nblks);
 		dqp->q_res_bcount += nblks;
 	}
 	if (rtblks) {
 		be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
 		dqp->q_res_rtbcount += rtblks;
 	}
 	/*
 	 * Set default limits, adjust timers (since we changed usages)
 	 *
 	 * There are no timers for the default values set in the root dquot.
 	 */
 	if (dqp->q_core.d_id) {
 		xfs_qm_adjust_dqlimits(mp, &dqp->q_core);
 		xfs_qm_adjust_dqtimers(mp, &dqp->q_core);
 	}
 	dqp->dq_flags |= XFS_DQ_DIRTY;
 	xfs_qm_dqput(dqp);
 	return 0;
 }
 STATIC int
 xfs_qm_get_rtblks(
 	xfs_inode_t	*ip,
 	xfs_qcnt_t	*O_rtblks)
 {
 	xfs_filblks_t	rtblks;			/* total rt blks */
 	xfs_extnum_t	idx;			/* extent record index */
 	xfs_ifork_t	*ifp;			/* inode fork pointer */
 	xfs_extnum_t	nextents;		/* number of extent entries */
 	int		error;
 	ASSERT(XFS_IS_REALTIME_INODE(ip));
 	ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
 	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
 		if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
 			return error;
 	}
 	rtblks = 0;
 	nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
 	for (idx = 0; idx < nextents; idx++)
 		rtblks += xfs_bmbt_get_blockcount(xfs_iext_get_ext(ifp, idx));
 	*O_rtblks = (xfs_qcnt_t)rtblks;
 	return 0;
 }
 /*
  * callback routine supplied to bulkstat(). Given an inumber, find its
  * dquots and update them to account for resources taken by that inode.
  */
 /* ARGSUSED */
 STATIC int
 xfs_qm_dqusage_adjust(
 	xfs_mount_t	*mp,		/* mount point for filesystem */
 	xfs_ino_t	ino,		/* inode number to get data for */
 	void		__user *buffer,	/* not used */
 	int		ubsize,		/* not used */
 	int		*ubused,	/* not used */
 	int		*res)		/* result code value */
 {
 	xfs_inode_t	*ip;
 	xfs_qcnt_t	nblks, rtblks = 0;
 	int		error;
 	ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 	/*
 	 * rootino must have its resources accounted for, not so with the quota
 	 * inodes.
 	 */
 	if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
 		*res = BULKSTAT_RV_NOTHING;
 		return XFS_ERROR(EINVAL);
 	}
 	/*
 	 * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget
 	 * interface expects the inode to be exclusively locked because that's
 	 * the case in all other instances. It's OK that we do this because
 	 * quotacheck is done only at mount time.
 	 */
 	error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip);
 	if (error) {
 		*res = BULKSTAT_RV_NOTHING;
 		return error;
 	}
 	ASSERT(ip->i_delayed_blks == 0);
 	if (XFS_IS_REALTIME_INODE(ip)) {
 		/*
 		 * Walk thru the extent list and count the realtime blocks.
 		 */
 		error = xfs_qm_get_rtblks(ip, &rtblks);
 		if (error)
 			goto error0;
 	}
 	nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
 	/*
 	 * Add the (disk blocks and inode) resources occupied by this
 	 * inode to its dquots. We do this adjustment in the incore dquot,
 	 * and also copy the changes to its buffer.
 	 * We don't care about putting these changes in a transaction
 	 * envelope because if we crash in the middle of a 'quotacheck'
 	 * we have to start from the beginning anyway.
 	 * Once we're done, we'll log all the dquot bufs.
 	 *
 	 * The *QUOTA_ON checks below may look pretty racy, but quotachecks
 	 * and quotaoffs don't race. (Quotachecks happen at mount time only).
 	 */
 	if (XFS_IS_UQUOTA_ON(mp)) {
 		error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_uid,
 						   XFS_DQ_USER, nblks, rtblks);
 		if (error)
 			goto error0;
 	}
 	if (XFS_IS_GQUOTA_ON(mp)) {
 		error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_gid,
 						   XFS_DQ_GROUP, nblks, rtblks);
 		if (error)
 			goto error0;
 	}
 	if (XFS_IS_PQUOTA_ON(mp)) {
 		error = xfs_qm_quotacheck_dqadjust(ip, xfs_get_projid(ip),
 						   XFS_DQ_PROJ, nblks, rtblks);
 		if (error)
 			goto error0;
 	}
 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
 	IRELE(ip);
 	*res = BULKSTAT_RV_DIDONE;
 	return 0;
 error0:
 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
 	IRELE(ip);
 	*res = BULKSTAT_RV_GIVEUP;
 	return error;
 }
 /*
  * Walk thru all the filesystem inodes and construct a consistent view
  * of the disk quota world. If the quotacheck fails, disable quotas.
  */
 int
 xfs_qm_quotacheck(
 	xfs_mount_t	*mp)
 {
 	int		done, count, error;
 	xfs_ino_t	lastino;
 	size_t		structsz;
 	xfs_inode_t	*uip, *gip;
 	uint		flags;
 	count = INT_MAX;
 	structsz = 1;
 	lastino = 0;
 	flags = 0;
 	ASSERT(mp->m_quotainfo->qi_uquotaip || mp->m_quotainfo->qi_gquotaip);
 	ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 	/*
 	 * There should be no cached dquots. The (simplistic) quotacheck
 	 * algorithm doesn't like that.
 	 */
 	ASSERT(list_empty(&mp->m_quotainfo->qi_dqlist));
 	xfs_notice(mp, "Quotacheck needed: Please wait.");
 	/*
 	 * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
 	 * their counters to zero. We need a clean slate.
 	 * We don't log our changes till later.
 	 */
 	uip = mp->m_quotainfo->qi_uquotaip;
 	if (uip) {
 		error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA);
 		if (error)
 			goto error_return;
 		flags |= XFS_UQUOTA_CHKD;
 	}
 	gip = mp->m_quotainfo->qi_gquotaip;
 	if (gip) {
 		error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
 					XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
 		if (error)
 			goto error_return;
 		flags |= XFS_OQUOTA_CHKD;
 	}
 	do {
 		/*
 		 * Iterate thru all the inodes in the file system,
 		 * adjusting the corresponding dquot counters in core.
 		 */
 		error = xfs_bulkstat(mp, &lastino, &count,
 				     xfs_qm_dqusage_adjust,
 				     structsz, NULL, &done);
 		if (error)
 			break;
 	} while (!done);
 	/*
 	 * We've made all the changes that we need to make incore.
 	 * Flush them down to disk buffers if everything was updated
 	 * successfully.
 	 */
 	if (!error)
 		error = xfs_qm_dqflush_all(mp);
 	/*
 	 * We can get this error if we couldn't do a dquot allocation inside
 	 * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
 	 * dirty dquots that might be cached, we just want to get rid of them
 	 * and turn quotaoff. The dquots won't be attached to any of the inodes
 	 * at this point (because we intentionally didn't in dqget_noattach).
 	 */
 	if (error) {
 		xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
 		goto error_return;
 	}
 	/*
 	 * We didn't log anything, because if we crashed, we'll have to
 	 * start the quotacheck from scratch anyway. However, we must make
 	 * sure that our dquot changes are secure before we put the
 	 * quotacheck'd stamp on the superblock. So, here we do a synchronous
 	 * flush.
 	 */
 	xfs_flush_buftarg(mp->m_ddev_targp, 1);
 	/*
 	 * If one type of quotas is off, then it will lose its
 	 * quotachecked status, since we won't be doing accounting for
 	 * that type anymore.
 	 */
 	mp->m_qflags &= ~(XFS_OQUOTA_CHKD | XFS_UQUOTA_CHKD);
 	mp->m_qflags |= flags;
  error_return:
 	if (error) {
 		xfs_warn(mp,
 	"Quotacheck: Unsuccessful (Error %d): Disabling quotas.",
 			error);
 		/*
 		 * We must turn off quotas.
 		 */
 		ASSERT(mp->m_quotainfo != NULL);
 		ASSERT(xfs_Gqm != NULL);
 		xfs_qm_destroy_quotainfo(mp);
 		if (xfs_mount_reset_sbqflags(mp)) {
 			xfs_warn(mp,
 				"Quotacheck: Failed to reset quota flags.");
 		}
 	} else
 		xfs_notice(mp, "Quotacheck: Done.");
 	return (error);
 }
 /*
  * This is called after the superblock has been read in and we're ready to
  * iget the quota inodes.
  */
 STATIC int
 xfs_qm_init_quotainos(
 	xfs_mount_t	*mp)
 {
 	xfs_inode_t	*uip, *gip;
 	int		error;
 	__int64_t	sbflags;
 	uint		flags;
 	ASSERT(mp->m_quotainfo);
 	uip = gip = NULL;
 	sbflags = 0;
 	flags = 0;
 	/*
 	 * Get the uquota and gquota inodes
 	 */
 	if (xfs_sb_version_hasquota(&mp->m_sb)) {
 		if (XFS_IS_UQUOTA_ON(mp) &&
 		    mp->m_sb.sb_uquotino != NULLFSINO) {
 			ASSERT(mp->m_sb.sb_uquotino > 0);
 			if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
 					     0, 0, &uip)))
 				return XFS_ERROR(error);
 		}
 		if (XFS_IS_OQUOTA_ON(mp) &&
 		    mp->m_sb.sb_gquotino != NULLFSINO) {
 			ASSERT(mp->m_sb.sb_gquotino > 0);
 			if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
 					     0, 0, &gip))) {
 				if (uip)
 					IRELE(uip);
 				return XFS_ERROR(error);
 			}
 		}
 	} else {
 		flags |= XFS_QMOPT_SBVERSION;
 		sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
 			    XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
 	}
 	/*
 	 * Create the two inodes, if they don't exist already. The changes
 	 * made above will get added to a transaction and logged in one of
 	 * the qino_alloc calls below.  If the device is readonly,
 	 * temporarily switch to read-write to do this.
 	 */
 	if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
 		if ((error = xfs_qm_qino_alloc(mp, &uip,
 					      sbflags | XFS_SB_UQUOTINO,
 					      flags | XFS_QMOPT_UQUOTA)))
 			return XFS_ERROR(error);
 		flags &= ~XFS_QMOPT_SBVERSION;
 	}
 	if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) {
 		flags |= (XFS_IS_GQUOTA_ON(mp) ?
 				XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
 		error = xfs_qm_qino_alloc(mp, &gip,
 					  sbflags | XFS_SB_GQUOTINO, flags);
 		if (error) {
 			if (uip)
 				IRELE(uip);
 			return XFS_ERROR(error);
 		}
 	}
 	mp->m_quotainfo->qi_uquotaip = uip;
 	mp->m_quotainfo->qi_gquotaip = gip;
 	return 0;
 }
 /*
  * Pop the least recently used dquot off the freelist and recycle it.
  */
 STATIC struct xfs_dquot *
 xfs_qm_dqreclaim_one(void)
 {
 	struct xfs_dquot	*dqp;
 	int			restarts = 0;
 	mutex_lock(&xfs_Gqm->qm_dqfrlist_lock);
 restart:
 	list_for_each_entry(dqp, &xfs_Gqm->qm_dqfrlist, q_freelist) {
 		struct xfs_mount *mp = dqp->q_mount;
 		if (!xfs_dqlock_nowait(dqp))
 			continue;
 		/*
 		 * This dquot has already been grabbed by dqlookup.
 		 * Remove it from the freelist and try again.
 		 */
 		if (dqp->q_nrefs) {
 			trace_xfs_dqreclaim_want(dqp);
 			XQM_STATS_INC(xqmstats.xs_qm_dqwants);
 			list_del_init(&dqp->q_freelist);
 			xfs_Gqm->qm_dqfrlist_cnt--;
 			restarts++;
 			goto dqunlock;
 		}
 		ASSERT(dqp->q_hash);
 		ASSERT(!list_empty(&dqp->q_mplist));
 		/*
 		 * Try to grab the flush lock. If this dquot is in the process
 		 * of getting flushed to disk, we don't want to reclaim it.
 		 */
 		if (!xfs_dqflock_nowait(dqp))
 			goto dqunlock;
 		/*
 		 * We have the flush lock so we know that this is not in the
 		 * process of being flushed. So, if this is dirty, flush it
 		 * DELWRI so that we don't get a freelist infested with
 		 * dirty dquots.
 		 */
 		if (XFS_DQ_IS_DIRTY(dqp)) {
 			int	error;
 			trace_xfs_dqreclaim_dirty(dqp);
 			/*
 			 * We flush it delayed write, so don't bother
 			 * releasing the freelist lock.
 			 */
 			error = xfs_qm_dqflush(dqp, SYNC_TRYLOCK);
 			if (error) {
 				xfs_warn(mp, "%s: dquot %p flush failed",
 					__func__, dqp);
 			}
 			goto dqunlock;
 		}
 		xfs_dqfunlock(dqp);
 		/*
 		 * Prevent lookup now that we are going to reclaim the dquot.
 		 * Once XFS_DQ_FREEING is set lookup won't touch the dquot,
 		 * thus we can drop the lock now.
 		 */
 		dqp->dq_flags |= XFS_DQ_FREEING;
 		xfs_dqunlock(dqp);
 		mutex_lock(&dqp->q_hash->qh_lock);
 		list_del_init(&dqp->q_hashlist);
 		dqp->q_hash->qh_version++;
 		mutex_unlock(&dqp->q_hash->qh_lock);
 		mutex_lock(&mp->m_quotainfo->qi_dqlist_lock);
 		list_del_init(&dqp->q_mplist);
 		mp->m_quotainfo->qi_dquots--;
 		mp->m_quotainfo->qi_dqreclaims++;
 		mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);
 		ASSERT(dqp->q_nrefs == 0);
 		list_del_init(&dqp->q_freelist);
 		xfs_Gqm->qm_dqfrlist_cnt--;
 		mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
 		return dqp;
 dqunlock:
 		xfs_dqunlock(dqp);
 		if (restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
 			break;
 		goto restart;
 	}
 	mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
 	return NULL;
 }
 /*
  * Traverse the freelist of dquots and attempt to reclaim a maximum of
  * 'howmany' dquots. This operation races with dqlookup(), and attempts to
  * favor the lookup function ...
  */
 STATIC int
 xfs_qm_shake_freelist(
 	int	howmany)
 {
 	int		nreclaimed = 0;
 	xfs_dquot_t	*dqp;
 	if (howmany <= 0)
 		return 0;
 	while (nreclaimed < howmany) {
 		dqp = xfs_qm_dqreclaim_one();
 		if (!dqp)
 			return nreclaimed;
 		xfs_qm_dqdestroy(dqp);
 		nreclaimed++;
 	}
 	return nreclaimed;
 }
 /*
  * The kmem_shake interface is invoked when memory is running low.
  */
 /* ARGSUSED */
 STATIC int
 xfs_qm_shake(
 	struct shrinker	*shrink,
 	struct shrink_control *sc)
 {
 	int	ndqused, nfree, n;
 	gfp_t gfp_mask = sc->gfp_mask;
 	if (!kmem_shake_allow(gfp_mask))
 		return 0;
 	if (!xfs_Gqm)
 		return 0;
 	nfree = xfs_Gqm->qm_dqfrlist_cnt; /* free dquots */
 	/* incore dquots in all f/s's */
 	ndqused = atomic_read(&xfs_Gqm->qm_totaldquots) - nfree;
 	ASSERT(ndqused >= 0);
 	if (nfree <= ndqused && nfree < ndquot)
 		return 0;
 	ndqused *= xfs_Gqm->qm_dqfree_ratio;	/* target # of free dquots */
 	n = nfree - ndqused - ndquot;		/* # over target */
 	return xfs_qm_shake_freelist(MAX(nfree, n));
 }
 /*------------------------------------------------------------------*/
 /*
  * Return a new incore dquot. Depending on the number of
  * dquots in the system, we either allocate a new one on the kernel heap,
  * or reclaim a free one.
  * Return value is B_TRUE if we allocated a new dquot, B_FALSE if we managed
  * to reclaim an existing one from the freelist.
  */
 boolean_t
 xfs_qm_dqalloc_incore(
 	xfs_dquot_t **O_dqpp)
 {
 	xfs_dquot_t	*dqp;
 	/*
 	 * Check against high water mark to see if we want to pop
 	 * a nincompoop dquot off the freelist.
 	 */
 	if (atomic_read(&xfs_Gqm->qm_totaldquots) >= ndquot) {
 		/*
 		 * Try to recycle a dquot from the freelist.
 		 */
 		if ((dqp = xfs_qm_dqreclaim_one())) {
 			XQM_STATS_INC(xqmstats.xs_qm_dqreclaims);
 			/*
 			 * Just zero the core here. The rest will get
 			 * reinitialized by caller. XXX we shouldn't even
 			 * do this zero ...
 			 */
 			memset(&dqp->q_core, 0, sizeof(dqp->q_core));
 			*O_dqpp = dqp;
 			return B_FALSE;
 		}
 		XQM_STATS_INC(xqmstats.xs_qm_dqreclaim_misses);
 	}
 	/*
 	 * Allocate a brand new dquot on the kernel heap and return it
 	 * to the caller to initialize.
 	 */
 	ASSERT(xfs_Gqm->qm_dqzone != NULL);
 	*O_dqpp = kmem_zone_zalloc(xfs_Gqm->qm_dqzone, KM_SLEEP);
 	atomic_inc(&xfs_Gqm->qm_totaldquots);
 	return B_TRUE;
 }
 /*
  * Start a transaction and write the incore superblock changes to
  * disk. flags parameter indicates which fields have changed.
  */
 int
 xfs_qm_write_sb_changes(
 	xfs_mount_t	*mp,
 	__int64_t	flags)
 {
 	xfs_trans_t	*tp;
 	int		error;
 	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
 	if ((error = xfs_trans_reserve(tp, 0,
 				      mp->m_sb.sb_sectsize + 128, 0,
 				      0,
 				      XFS_DEFAULT_LOG_COUNT))) {
 		xfs_trans_cancel(tp, 0);
 		return error;
 	}
 	xfs_mod_sb(tp, flags);
 	error = xfs_trans_commit(tp, 0);
 	return error;
 }
 /* --------------- utility functions for vnodeops ---------------- */
 /*
  * Given an inode, a uid, gid and prid make sure that we have
  * allocated relevant dquot(s) on disk, and that we won't exceed inode
  * quotas by creating this file.
  * This also attaches dquot(s) to the given inode after locking it,
  * and returns the dquots corresponding to the uid and/or gid.
  *
  * in	: inode (unlocked)
  * out	: udquot, gdquot with references taken and unlocked
  */
 int
 xfs_qm_vop_dqalloc(
 	struct xfs_inode	*ip,
 	uid_t			uid,
 	gid_t			gid,
 	prid_t			prid,
 	uint			flags,
 	struct xfs_dquot	**O_udqpp,
 	struct xfs_dquot	**O_gdqpp)
 {
 	struct xfs_mount	*mp = ip->i_mount;
 	struct xfs_dquot	*uq, *gq;
 	int			error;
 	uint			lockflags;
 	if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
 		return 0;
 	lockflags = XFS_ILOCK_EXCL;
 	xfs_ilock(ip, lockflags);
 	if ((flags & XFS_QMOPT_INHERIT) && XFS_INHERIT_GID(ip))
 		gid = ip->i_d.di_gid;
 	/*
 	 * Attach the dquot(s) to this inode, doing a dquot allocation
 	 * if necessary. The dquot(s) will not be locked.
 	 */
 	if (XFS_NOT_DQATTACHED(mp, ip)) {
 		error = xfs_qm_dqattach_locked(ip, XFS_QMOPT_DQALLOC);
 		if (error) {
 			xfs_iunlock(ip, lockflags);
 			return error;
 		}
 	}
 	uq = gq = NULL;
 	if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
 		if (ip->i_d.di_uid != uid) {
 			/*
 			 * What we need is the dquot that has this uid, and
 			 * if we send the inode to dqget, the uid of the inode
 			 * takes priority over what's sent in the uid argument.
 			 * We must unlock inode here before calling dqget if
 			 * we're not sending the inode, because otherwise
 			 * we'll deadlock by doing trans_reserve while
 			 * holding ilock.
 			 */
 			xfs_iunlock(ip, lockflags);
 			if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
 						 XFS_DQ_USER,
 						 XFS_QMOPT_DQALLOC |
 						 XFS_QMOPT_DOWARN,
 						 &uq))) {
 				ASSERT(error != ENOENT);
 				return error;
 			}
 			/*
 			 * Get the ilock in the right order.
 			 */
 			xfs_dqunlock(uq);
 			lockflags = XFS_ILOCK_SHARED;
 			xfs_ilock(ip, lockflags);
 		} else {
 			/*
 			 * Take an extra reference, because we'll return
 			 * this to caller
 			 */
 			ASSERT(ip->i_udquot);
 			uq = xfs_qm_dqhold(ip->i_udquot);
 		}
 	}
 	if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
 		if (ip->i_d.di_gid != gid) {
 			xfs_iunlock(ip, lockflags);
 			if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
 						 XFS_DQ_GROUP,
 						 XFS_QMOPT_DQALLOC |
 						 XFS_QMOPT_DOWARN,
 						 &gq))) {
 				if (uq)
 					xfs_qm_dqrele(uq);
 				ASSERT(error != ENOENT);
 				return error;
 			}
 			xfs_dqunlock(gq);
 			lockflags = XFS_ILOCK_SHARED;
 			xfs_ilock(ip, lockflags);
 		} else {
 			ASSERT(ip->i_gdquot);
 			gq = xfs_qm_dqhold(ip->i_gdquot);
 		}
 	} else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
 		if (xfs_get_projid(ip) != prid) {
 			xfs_iunlock(ip, lockflags);
 			if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
 						 XFS_DQ_PROJ,
 						 XFS_QMOPT_DQALLOC |
 						 XFS_QMOPT_DOWARN,
 						 &gq))) {
 				if (uq)
 					xfs_qm_dqrele(uq);
 				ASSERT(error != ENOENT);
 				return (error);
 			}
 			xfs_dqunlock(gq);
 			lockflags = XFS_ILOCK_SHARED;
 			xfs_ilock(ip, lockflags);
 		} else {
 			ASSERT(ip->i_gdquot);
 			gq = xfs_qm_dqhold(ip->i_gdquot);
 		}
 	}
 	if (uq)
 		trace_xfs_dquot_dqalloc(ip);
 	xfs_iunlock(ip, lockflags);
 	if (O_udqpp)
 		*O_udqpp = uq;
 	else if (uq)
 		xfs_qm_dqrele(uq);
 	if (O_gdqpp)
 		*O_gdqpp = gq;
 	else if (gq)
 		xfs_qm_dqrele(gq);
 	return 0;
 }
 /*
  * Actually transfer ownership, and do dquot modifications.
  * These were already reserved.
  */
 xfs_dquot_t *
 xfs_qm_vop_chown(
 	xfs_trans_t	*tp,
 	xfs_inode_t	*ip,
 	xfs_dquot_t	**IO_olddq,
 	xfs_dquot_t	*newdq)
 {
 	xfs_dquot_t	*prevdq;
 	uint		bfield = XFS_IS_REALTIME_INODE(ip) ?
 				 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 	ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
 	/* old dquot */
 	prevdq = *IO_olddq;
 	ASSERT(prevdq);
 	ASSERT(prevdq != newdq);
 	xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
 	xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
 	/* the sparkling new dquot */
 	xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
 	xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
 	/*
 	 * Take an extra reference, because the inode is going to keep
 	 * this dquot pointer even after the trans_commit.
 	 */
 	*IO_olddq = xfs_qm_dqhold(newdq);
 	return prevdq;
 }
 /*
  * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
  */
 int
 xfs_qm_vop_chown_reserve(
 	xfs_trans_t	*tp,
 	xfs_inode_t	*ip,
 	xfs_dquot_t	*udqp,
 	xfs_dquot_t	*gdqp,
 	uint		flags)
 {
 	xfs_mount_t	*mp = ip->i_mount;
 	uint		delblks, blkflags, prjflags = 0;
 	xfs_dquot_t	*unresudq, *unresgdq, *delblksudq, *delblksgdq;
 	int		error;
 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
 	ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 	delblks = ip->i_delayed_blks;
 	delblksudq = delblksgdq = unresudq = unresgdq = NULL;
 	blkflags = XFS_IS_REALTIME_INODE(ip) ?
 			XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
 	if (XFS_IS_UQUOTA_ON(mp) && udqp &&
 	    ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
 		delblksudq = udqp;
 		/*
 		 * If there are delayed allocation blocks, then we have to
 		 * unreserve those from the old dquot, and add them to the
 		 * new dquot.
 		 */
 		if (delblks) {
 			ASSERT(ip->i_udquot);
 			unresudq = ip->i_udquot;
 		}
 	}
 	if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
 		if (XFS_IS_PQUOTA_ON(ip->i_mount) &&
 		     xfs_get_projid(ip) != be32_to_cpu(gdqp->q_core.d_id))
 			prjflags = XFS_QMOPT_ENOSPC;
 		if (prjflags ||
 		    (XFS_IS_GQUOTA_ON(ip->i_mount) &&
 		     ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
 			delblksgdq = gdqp;
 			if (delblks) {
 				ASSERT(ip->i_gdquot);
 				unresgdq = ip->i_gdquot;
 			}
 		}
 	}
 	if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
 				delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
 				flags | blkflags | prjflags)))
 		return (error);
 	/*
 	 * Do the delayed blks reservations/unreservations now. Since, these
 	 * are done without the help of a transaction, if a reservation fails
 	 * its previous reservations won't be automatically undone by trans
 	 * code. So, we have to do it manually here.
 	 */
 	if (delblks) {
 		/*
 		 * Do the reservations first. Unreservation can't fail.
 		 */
 		ASSERT(delblksudq || delblksgdq);
 		ASSERT(unresudq || unresgdq);
 		if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
 				delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
 				flags | blkflags | prjflags)))
 			return (error);
 		xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
 				unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
 				blkflags);
 	}
 	return (0);
 }
 int
 xfs_qm_vop_rename_dqattach(
 	struct xfs_inode	**i_tab)
 {
 	struct xfs_mount	*mp = i_tab[0]->i_mount;
 	int			i;
 	if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
 		return 0;
 	for (i = 0; (i < 4 && i_tab[i]); i++) {
 		struct xfs_inode	*ip = i_tab[i];
 		int			error;
 		/*
 		 * Watch out for duplicate entries in the table.
 		 */
 		if (i == 0 || ip != i_tab[i-1]) {
 			if (XFS_NOT_DQATTACHED(mp, ip)) {
 				error = xfs_qm_dqattach(ip, 0);
 				if (error)
 					return error;
 			}
 		}
 	}
 	return 0;
 }
 void
 xfs_qm_vop_create_dqattach(
 	struct xfs_trans	*tp,
 	struct xfs_inode	*ip,
 	struct xfs_dquot	*udqp,
 	struct xfs_dquot	*gdqp)
 {
 	struct xfs_mount	*mp = tp->t_mountp;
 	if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
 		return;
 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 	ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 	if (udqp) {
 		ASSERT(ip->i_udquot == NULL);
 		ASSERT(XFS_IS_UQUOTA_ON(mp));
 		ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
 		ip->i_udquot = xfs_qm_dqhold(udqp);
 		xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
 	}
 	if (gdqp) {
 		ASSERT(ip->i_gdquot == NULL);
 		ASSERT(XFS_IS_OQUOTA_ON(mp));
 		ASSERT((XFS_IS_GQUOTA_ON(mp) ?
 			ip->i_d.di_gid : xfs_get_projid(ip)) ==
 				be32_to_cpu(gdqp->q_core.d_id));
 		ip->i_gdquot = xfs_qm_dqhold(gdqp);
 		xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);

fs/xfs/xfs_quota.h

Diff comments View file @ 7ae4440

 /*
  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef __XFS_QUOTA_H__
 #define __XFS_QUOTA_H__
 struct xfs_trans;
 /*
  * The ondisk form of a dquot structure.
  */
 #define XFS_DQUOT_MAGIC		0x4451		/* 'DQ' */
 #define XFS_DQUOT_VERSION	(u_int8_t)0x01	/* latest version number */
 /*
  * uid_t and gid_t are hard-coded to 32 bits in the inode.
  * Hence, an 'id' in a dquot is 32 bits..
  */
 typedef __uint32_t	xfs_dqid_t;
 /*
  * Even though users may not have quota limits occupying all 64-bits,
  * they may need 64-bit accounting. Hence, 64-bit quota-counters,
  * and quota-limits. This is a waste in the common case, but hey ...
  */
 typedef __uint64_t	xfs_qcnt_t;
 typedef __uint16_t	xfs_qwarncnt_t;
 /*
  * This is the main portion of the on-disk representation of quota
  * information for a user. This is the q_core of the xfs_dquot_t that
  * is kept in kernel memory. We pad this with some more expansion room
  * to construct the on disk structure.
  */
 typedef struct	xfs_disk_dquot {
 	__be16		d_magic;	/* dquot magic = XFS_DQUOT_MAGIC */
 	__u8		d_version;	/* dquot version */
 	__u8		d_flags;	/* XFS_DQ_USER/PROJ/GROUP */
 	__be32		d_id;		/* user,project,group id */
 	__be64		d_blk_hardlimit;/* absolute limit on disk blks */
 	__be64		d_blk_softlimit;/* preferred limit on disk blks */
 	__be64		d_ino_hardlimit;/* maximum # allocated inodes */
 	__be64		d_ino_softlimit;/* preferred inode limit */
 	__be64		d_bcount;	/* disk blocks owned by the user */
 	__be64		d_icount;	/* inodes owned by the user */
 	__be32		d_itimer;	/* zero if within inode limits if not,
 					   this is when we refuse service */
 	__be32		d_btimer;	/* similar to above; for disk blocks */
 	__be16		d_iwarns;	/* warnings issued wrt num inodes */
 	__be16		d_bwarns;	/* warnings issued wrt disk blocks */
 	__be32		d_pad0;		/* 64 bit align */
 	__be64		d_rtb_hardlimit;/* absolute limit on realtime blks */
 	__be64		d_rtb_softlimit;/* preferred limit on RT disk blks */
 	__be64		d_rtbcount;	/* realtime blocks owned */
 	__be32		d_rtbtimer;	/* similar to above; for RT disk blocks */
 	__be16		d_rtbwarns;	/* warnings issued wrt RT disk blocks */
 	__be16		d_pad;
 } xfs_disk_dquot_t;
 /*
  * This is what goes on disk. This is separated from the xfs_disk_dquot because
  * carrying the unnecessary padding would be a waste of memory.
  */
 typedef struct xfs_dqblk {
 	xfs_disk_dquot_t  dd_diskdq;	/* portion that lives incore as well */
 	char		  dd_fill[32];	/* filling for posterity */
 } xfs_dqblk_t;
 /*
  * flags for q_flags field in the dquot.
  */
 #define XFS_DQ_USER		0x0001		/* a user quota */
 #define XFS_DQ_PROJ		0x0002		/* project quota */
 #define XFS_DQ_GROUP		0x0004		/* a group quota */
 #define XFS_DQ_DIRTY		0x0008		/* dquot is dirty */
 #define XFS_DQ_FREEING		0x0010		/* dquot is beeing torn down */
 #define XFS_DQ_ALLTYPES		(XFS_DQ_USER|XFS_DQ_PROJ|XFS_DQ_GROUP)
 #define XFS_DQ_FLAGS \
 	{ XFS_DQ_USER,		"USER" }, \
 	{ XFS_DQ_PROJ,		"PROJ" }, \
 	{ XFS_DQ_GROUP,		"GROUP" }, \
 	{ XFS_DQ_DIRTY,		"DIRTY" }, \
 	{ XFS_DQ_FREEING,	"FREEING" }
 /*
  * In the worst case, when both user and group quotas are on,
  * we can have a max of three dquots changing in a single transaction.
  */
 #define XFS_DQUOT_LOGRES(mp)	(sizeof(xfs_disk_dquot_t) * 3)
 /*
  * These are the structures used to lay out dquots and quotaoff
  * records on the log. Quite similar to those of inodes.
  */
 /*
  * log format struct for dquots.
  * The first two fields must be the type and size fitting into
  * 32 bits : log_recovery code assumes that.
  */
 typedef struct xfs_dq_logformat {
 	__uint16_t		qlf_type;      /* dquot log item type */
 	__uint16_t		qlf_size;      /* size of this item */
 	xfs_dqid_t		qlf_id;	       /* usr/grp/proj id : 32 bits */
 	__int64_t		qlf_blkno;     /* blkno of dquot buffer */
 	__int32_t		qlf_len;       /* len of dquot buffer */
 	__uint32_t		qlf_boffset;   /* off of dquot in buffer */
 } xfs_dq_logformat_t;
 /*
  * log format struct for QUOTAOFF records.
  * The first two fields must be the type and size fitting into
  * 32 bits : log_recovery code assumes that.
  * We write two LI_QUOTAOFF logitems per quotaoff, the last one keeps a pointer
  * to the first and ensures that the first logitem is taken out of the AIL
  * only when the last one is securely committed.
  */
 typedef struct xfs_qoff_logformat {
 	unsigned short		qf_type;	/* quotaoff log item type */
 	unsigned short		qf_size;	/* size of this item */
 	unsigned int		qf_flags;	/* USR and/or GRP */
 	char			qf_pad[12];	/* padding for future */
 } xfs_qoff_logformat_t;
 /*
  * Disk quotas status in m_qflags, and also sb_qflags. 16 bits.
  */
 #define XFS_UQUOTA_ACCT	0x0001  /* user quota accounting ON */
 #define XFS_UQUOTA_ENFD	0x0002  /* user quota limits enforced */
 #define XFS_UQUOTA_CHKD	0x0004  /* quotacheck run on usr quotas */
 #define XFS_PQUOTA_ACCT	0x0008  /* project quota accounting ON */
 #define XFS_OQUOTA_ENFD	0x0010  /* other (grp/prj) quota limits enforced */
 #define XFS_OQUOTA_CHKD	0x0020  /* quotacheck run on other (grp/prj) quotas */
 #define XFS_GQUOTA_ACCT	0x0040  /* group quota accounting ON */
 /*
  * Quota Accounting/Enforcement flags
  */
 #define XFS_ALL_QUOTA_ACCT	\
 		(XFS_UQUOTA_ACCT | XFS_GQUOTA_ACCT | XFS_PQUOTA_ACCT)
 #define XFS_ALL_QUOTA_ENFD	(XFS_UQUOTA_ENFD | XFS_OQUOTA_ENFD)
 #define XFS_ALL_QUOTA_CHKD	(XFS_UQUOTA_CHKD | XFS_OQUOTA_CHKD)
 #define XFS_IS_QUOTA_RUNNING(mp)	((mp)->m_qflags & XFS_ALL_QUOTA_ACCT)
 #define XFS_IS_UQUOTA_RUNNING(mp)	((mp)->m_qflags & XFS_UQUOTA_ACCT)
 #define XFS_IS_PQUOTA_RUNNING(mp)	((mp)->m_qflags & XFS_PQUOTA_ACCT)
 #define XFS_IS_GQUOTA_RUNNING(mp)	((mp)->m_qflags & XFS_GQUOTA_ACCT)
 #define XFS_IS_UQUOTA_ENFORCED(mp)	((mp)->m_qflags & XFS_UQUOTA_ENFD)
 #define XFS_IS_OQUOTA_ENFORCED(mp)	((mp)->m_qflags & XFS_OQUOTA_ENFD)
 /*
  * Incore only flags for quotaoff - these bits get cleared when quota(s)
  * are in the process of getting turned off. These flags are in m_qflags but
  * never in sb_qflags.
  */
 #define XFS_UQUOTA_ACTIVE	0x0100  /* uquotas are being turned off */
 #define XFS_PQUOTA_ACTIVE	0x0200  /* pquotas are being turned off */
 #define XFS_GQUOTA_ACTIVE	0x0400  /* gquotas are being turned off */
 /*
  * Checking XFS_IS_*QUOTA_ON() while holding any inode lock guarantees
  * quota will be not be switched off as long as that inode lock is held.
  */
 #define XFS_IS_QUOTA_ON(mp)	((mp)->m_qflags & (XFS_UQUOTA_ACTIVE | \
 						   XFS_GQUOTA_ACTIVE | \
 						   XFS_PQUOTA_ACTIVE))
 #define XFS_IS_OQUOTA_ON(mp)	((mp)->m_qflags & (XFS_GQUOTA_ACTIVE | \
 						   XFS_PQUOTA_ACTIVE))
 #define XFS_IS_UQUOTA_ON(mp)	((mp)->m_qflags & XFS_UQUOTA_ACTIVE)
 #define XFS_IS_GQUOTA_ON(mp)	((mp)->m_qflags & XFS_GQUOTA_ACTIVE)
 #define XFS_IS_PQUOTA_ON(mp)	((mp)->m_qflags & XFS_PQUOTA_ACTIVE)
 /*
  * Flags to tell various functions what to do. Not all of these are meaningful
  * to a single function. None of these XFS_QMOPT_* flags are meant to have
  * persistent values (ie. their values can and will change between versions)
  */
 #define XFS_QMOPT_DQALLOC	0x0000002 /* alloc dquot ondisk if needed */
 #define XFS_QMOPT_UQUOTA	0x0000004 /* user dquot requested */
 #define XFS_QMOPT_PQUOTA	0x0000008 /* project dquot requested */
 #define XFS_QMOPT_FORCE_RES	0x0000010 /* ignore quota limits */
-#define XFS_QMOPT_DQSUSER	0x0000020 /* don't cache super users dquot */
 #define XFS_QMOPT_SBVERSION	0x0000040 /* change superblock version num */
 #define XFS_QMOPT_DOWARN        0x0000400 /* increase warning cnt if needed */
 #define XFS_QMOPT_DQREPAIR	0x0001000 /* repair dquot if damaged */
 #define XFS_QMOPT_GQUOTA	0x0002000 /* group dquot requested */
 #define XFS_QMOPT_ENOSPC	0x0004000 /* enospc instead of edquot (prj) */
 /*
  * flags to xfs_trans_mod_dquot to indicate which field needs to be
  * modified.
  */
 #define XFS_QMOPT_RES_REGBLKS	0x0010000
 #define XFS_QMOPT_RES_RTBLKS	0x0020000
 #define XFS_QMOPT_BCOUNT	0x0040000
 #define XFS_QMOPT_ICOUNT	0x0080000
 #define XFS_QMOPT_RTBCOUNT	0x0100000
 #define XFS_QMOPT_DELBCOUNT	0x0200000
 #define XFS_QMOPT_DELRTBCOUNT	0x0400000
 #define XFS_QMOPT_RES_INOS	0x0800000
 /*
  * flags for dqalloc.
  */
 #define XFS_QMOPT_INHERIT	0x1000000
 /*
  * flags to xfs_trans_mod_dquot.
  */
 #define XFS_TRANS_DQ_RES_BLKS	XFS_QMOPT_RES_REGBLKS
 #define XFS_TRANS_DQ_RES_RTBLKS	XFS_QMOPT_RES_RTBLKS
 #define XFS_TRANS_DQ_RES_INOS	XFS_QMOPT_RES_INOS
 #define XFS_TRANS_DQ_BCOUNT	XFS_QMOPT_BCOUNT
 #define XFS_TRANS_DQ_DELBCOUNT	XFS_QMOPT_DELBCOUNT
 #define XFS_TRANS_DQ_ICOUNT	XFS_QMOPT_ICOUNT
 #define XFS_TRANS_DQ_RTBCOUNT	XFS_QMOPT_RTBCOUNT
 #define XFS_TRANS_DQ_DELRTBCOUNT XFS_QMOPT_DELRTBCOUNT
 #define XFS_QMOPT_QUOTALL	\
 		(XFS_QMOPT_UQUOTA | XFS_QMOPT_PQUOTA | XFS_QMOPT_GQUOTA)
 #define XFS_QMOPT_RESBLK_MASK	(XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_RES_RTBLKS)
 #ifdef __KERNEL__
 /*
  * This check is done typically without holding the inode lock;
  * that may seem racy, but it is harmless in the context that it is used.
  * The inode cannot go inactive as long a reference is kept, and
  * therefore if dquot(s) were attached, they'll stay consistent.
  * If, for example, the ownership of the inode changes while
  * we didn't have the inode locked, the appropriate dquot(s) will be
  * attached atomically.
  */
 #define XFS_NOT_DQATTACHED(mp, ip) ((XFS_IS_UQUOTA_ON(mp) &&\
 				     (ip)->i_udquot == NULL) || \
 				    (XFS_IS_OQUOTA_ON(mp) && \
 				     (ip)->i_gdquot == NULL))
 #define XFS_QM_NEED_QUOTACHECK(mp) \
 	((XFS_IS_UQUOTA_ON(mp) && \
 		(mp->m_sb.sb_qflags & XFS_UQUOTA_CHKD) == 0) || \
 	 (XFS_IS_GQUOTA_ON(mp) && \
 		((mp->m_sb.sb_qflags & XFS_OQUOTA_CHKD) == 0 || \
 		 (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT))) || \
 	 (XFS_IS_PQUOTA_ON(mp) && \
 		((mp->m_sb.sb_qflags & XFS_OQUOTA_CHKD) == 0 || \
 		 (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT))))
 #define XFS_MOUNT_QUOTA_SET1	(XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\
 				 XFS_UQUOTA_CHKD|XFS_PQUOTA_ACCT|\
 				 XFS_OQUOTA_ENFD|XFS_OQUOTA_CHKD)
 #define XFS_MOUNT_QUOTA_SET2	(XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\
 				 XFS_UQUOTA_CHKD|XFS_GQUOTA_ACCT|\
 				 XFS_OQUOTA_ENFD|XFS_OQUOTA_CHKD)
 #define XFS_MOUNT_QUOTA_ALL	(XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\
 				 XFS_UQUOTA_CHKD|XFS_PQUOTA_ACCT|\
 				 XFS_OQUOTA_ENFD|XFS_OQUOTA_CHKD|\
 				 XFS_GQUOTA_ACCT)
 /*
  * The structure kept inside the xfs_trans_t keep track of dquot changes
  * within a transaction and apply them later.
  */
 typedef struct xfs_dqtrx {
 	struct xfs_dquot *qt_dquot;	  /* the dquot this refers to */
 	ulong		qt_blk_res;	  /* blks reserved on a dquot */
 	ulong		qt_blk_res_used;  /* blks used from the reservation */
 	ulong		qt_ino_res;	  /* inode reserved on a dquot */
 	ulong		qt_ino_res_used;  /* inodes used from the reservation */
 	long		qt_bcount_delta;  /* dquot blk count changes */
 	long		qt_delbcnt_delta; /* delayed dquot blk count changes */
 	long		qt_icount_delta;  /* dquot inode count changes */
 	ulong		qt_rtblk_res;	  /* # blks reserved on a dquot */
 	ulong		qt_rtblk_res_used;/* # blks used from reservation */
 	long		qt_rtbcount_delta;/* dquot realtime blk changes */
 	long		qt_delrtb_delta;  /* delayed RT blk count changes */
 } xfs_dqtrx_t;
 #ifdef CONFIG_XFS_QUOTA
 extern void xfs_trans_dup_dqinfo(struct xfs_trans *, struct xfs_trans *);
 extern void xfs_trans_free_dqinfo(struct xfs_trans *);
 extern void xfs_trans_mod_dquot_byino(struct xfs_trans *, struct xfs_inode *,
 		uint, long);
 extern void xfs_trans_apply_dquot_deltas(struct xfs_trans *);
 extern void xfs_trans_unreserve_and_mod_dquots(struct xfs_trans *);
 extern int xfs_trans_reserve_quota_nblks(struct xfs_trans *,
 		struct xfs_inode *, long, long, uint);
 extern int xfs_trans_reserve_quota_bydquots(struct xfs_trans *,
 		struct xfs_mount *, struct xfs_dquot *,
 		struct xfs_dquot *, long, long, uint);
 extern int xfs_qm_vop_dqalloc(struct xfs_inode *, uid_t, gid_t, prid_t, uint,
 		struct xfs_dquot **, struct xfs_dquot **);
 extern void xfs_qm_vop_create_dqattach(struct xfs_trans *, struct xfs_inode *,
 		struct xfs_dquot *, struct xfs_dquot *);
 extern int xfs_qm_vop_rename_dqattach(struct xfs_inode **);
 extern struct xfs_dquot *xfs_qm_vop_chown(struct xfs_trans *,
 		struct xfs_inode *, struct xfs_dquot **, struct xfs_dquot *);
 extern int xfs_qm_vop_chown_reserve(struct xfs_trans *, struct xfs_inode *,
 		struct xfs_dquot *, struct xfs_dquot *, uint);
 extern int xfs_qm_dqattach(struct xfs_inode *, uint);
 extern int xfs_qm_dqattach_locked(struct xfs_inode *, uint);
 extern void xfs_qm_dqdetach(struct xfs_inode *);
 extern void xfs_qm_dqrele(struct xfs_dquot *);
 extern void xfs_qm_statvfs(struct xfs_inode *, struct kstatfs *);
 extern int xfs_qm_newmount(struct xfs_mount *, uint *, uint *);
 extern void xfs_qm_mount_quotas(struct xfs_mount *);
 extern void xfs_qm_unmount(struct xfs_mount *);
 extern void xfs_qm_unmount_quotas(struct xfs_mount *);
 #else
 static inline int
 xfs_qm_vop_dqalloc(struct xfs_inode *ip, uid_t uid, gid_t gid, prid_t prid,
 		uint flags, struct xfs_dquot **udqp, struct xfs_dquot **gdqp)
 {
 	*udqp = NULL;
 	*gdqp = NULL;
 	return 0;
 }
 #define xfs_trans_dup_dqinfo(tp, tp2)
 #define xfs_trans_free_dqinfo(tp)
 #define xfs_trans_mod_dquot_byino(tp, ip, fields, delta)
 #define xfs_trans_apply_dquot_deltas(tp)
 #define xfs_trans_unreserve_and_mod_dquots(tp)
 static inline int xfs_trans_reserve_quota_nblks(struct xfs_trans *tp,
 		struct xfs_inode *ip, long nblks, long ninos, uint flags)
 {
 	return 0;
 }
 static inline int xfs_trans_reserve_quota_bydquots(struct xfs_trans *tp,
 		struct xfs_mount *mp, struct xfs_dquot *udqp,
 		struct xfs_dquot *gdqp, long nblks, long nions, uint flags)
 {
 	return 0;
 }
 #define xfs_qm_vop_create_dqattach(tp, ip, u, g)
 #define xfs_qm_vop_rename_dqattach(it)					(0)
 #define xfs_qm_vop_chown(tp, ip, old, new)				(NULL)
 #define xfs_qm_vop_chown_reserve(tp, ip, u, g, fl)			(0)
 #define xfs_qm_dqattach(ip, fl)						(0)
 #define xfs_qm_dqattach_locked(ip, fl)					(0)
 #define xfs_qm_dqdetach(ip)
 #define xfs_qm_dqrele(d)
 #define xfs_qm_statvfs(ip, s)
 #define xfs_qm_newmount(mp, a, b)					(0)
 #define xfs_qm_mount_quotas(mp)
 #define xfs_qm_unmount(mp)
 #define xfs_qm_unmount_quotas(mp)
 #endif /* CONFIG_XFS_QUOTA */
 #define xfs_trans_unreserve_quota_nblks(tp, ip, nblks, ninos, flags) \
 	xfs_trans_reserve_quota_nblks(tp, ip, -(nblks), -(ninos), flags)
 #define xfs_trans_reserve_quota(tp, mp, ud, gd, nb, ni, f) \
 	xfs_trans_reserve_quota_bydquots(tp, mp, ud, gd, nb, ni, \
 				f | XFS_QMOPT_RES_REGBLKS)
 extern int xfs_qm_dqcheck(struct xfs_mount *, xfs_disk_dquot_t *,
 				xfs_dqid_t, uint, uint, char *);
 extern int xfs_mount_reset_sbqflags(struct xfs_mount *);
 #endif	/* __KERNEL__ */
 #endif	/* __XFS_QUOTA_H__ */