blob: cde5c508f0e01d90b562957e69cc62c00087a423 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott4ce31212005-11-02 14:59:41 +11002 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott4ce31212005-11-02 14:59:41 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott4ce31212005-11-02 14:59:41 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott4ce31212005-11-02 14:59:41 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
19#include "xfs_fs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110020#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110022#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include "xfs_clnt.h"
24#include "xfs_trans.h"
25#include "xfs_sb.h"
26#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "xfs_dir2.h"
28#include "xfs_alloc.h"
29#include "xfs_dmapi.h"
30#include "xfs_quota.h"
31#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110033#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include "xfs_dir2_sf.h"
Nathan Scotta844f452005-11-02 14:38:42 +110036#include "xfs_attr_sf.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include "xfs_dinode.h"
38#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110039#include "xfs_btree.h"
40#include "xfs_ialloc.h"
41#include "xfs_itable.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include "xfs_rtalloc.h"
43#include "xfs_error.h"
Nathan Scotta844f452005-11-02 14:38:42 +110044#include "xfs_bmap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include "xfs_rw.h"
46#include "xfs_acl.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include "xfs_attr.h"
48#include "xfs_buf_item.h"
49#include "xfs_trans_space.h"
50#include "xfs_utils.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include "xfs_qm.h"
52
53/*
54 * The global quota manager. There is only one of these for the entire
55 * system, _not_ one per file system. XQM keeps track of the overall
56 * quota functionality, including maintaining the freelist and hash
57 * tables of dquots.
58 */
Nathan Scott6b3f6b52005-11-02 15:08:25 +110059mutex_t xfs_Gqm_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060struct xfs_qm *xfs_Gqm;
Nathan Scott6b3f6b52005-11-02 15:08:25 +110061uint ndquot;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63kmem_zone_t *qm_dqzone;
64kmem_zone_t *qm_dqtrxzone;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
David Chinner7989cb82007-02-10 18:34:56 +110066static cred_t xfs_zerocr;
Nathan Scottdae81d42006-02-28 12:30:13 +110067
Linus Torvalds1da177e2005-04-16 15:20:36 -070068STATIC void xfs_qm_list_init(xfs_dqlist_t *, char *, int);
69STATIC void xfs_qm_list_destroy(xfs_dqlist_t *);
70
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100071STATIC void xfs_qm_freelist_init(xfs_frlist_t *);
72STATIC void xfs_qm_freelist_destroy(xfs_frlist_t *);
73STATIC int xfs_qm_mplist_nowait(xfs_mount_t *);
74STATIC int xfs_qm_dqhashlock_nowait(xfs_dquot_t *);
75
Linus Torvalds1da177e2005-04-16 15:20:36 -070076STATIC int xfs_qm_init_quotainos(xfs_mount_t *);
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100077STATIC int xfs_qm_init_quotainfo(xfs_mount_t *);
Al Viro51bfb752005-12-15 09:17:24 +000078STATIC int xfs_qm_shake(int, gfp_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Rusty Russell8e1f9362007-07-17 04:03:17 -070080static struct shrinker xfs_qm_shaker = {
81 .shrink = xfs_qm_shake,
82 .seeks = DEFAULT_SEEKS,
83};
84
Linus Torvalds1da177e2005-04-16 15:20:36 -070085#ifdef DEBUG
86extern mutex_t qcheck_lock;
87#endif
88
89#ifdef QUOTADEBUG
90#define XQM_LIST_PRINT(l, NXT, title) \
91{ \
92 xfs_dquot_t *dqp; int i = 0; \
93 cmn_err(CE_DEBUG, "%s (#%d)", title, (int) (l)->qh_nelems); \
94 for (dqp = (l)->qh_next; dqp != NULL; dqp = dqp->NXT) { \
95 cmn_err(CE_DEBUG, " %d. \"%d (%s)\" " \
96 "bcnt = %d, icnt = %d, refs = %d", \
Christoph Hellwig1149d962005-11-02 15:01:12 +110097 ++i, (int) be32_to_cpu(dqp->q_core.d_id), \
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 DQFLAGTO_TYPESTR(dqp), \
Christoph Hellwig1149d962005-11-02 15:01:12 +110099 (int) be64_to_cpu(dqp->q_core.d_bcount), \
100 (int) be64_to_cpu(dqp->q_core.d_icount), \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 (int) dqp->q_nrefs); } \
102}
103#else
104#define XQM_LIST_PRINT(l, NXT, title) do { } while (0)
105#endif
106
107/*
108 * Initialize the XQM structure.
109 * Note that there is not one quota manager per file system.
110 */
111STATIC struct xfs_qm *
112xfs_Gqm_init(void)
113{
Nathan Scott6b3f6b52005-11-02 15:08:25 +1100114 xfs_dqhash_t *udqhash, *gdqhash;
115 xfs_qm_t *xqm;
Nathan Scott215101c2006-09-28 11:04:43 +1000116 size_t hsize;
117 uint i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
119 /*
120 * Initialize the dquot hash tables.
121 */
Nathan Scott77e46352006-09-28 11:03:27 +1000122 udqhash = kmem_zalloc_greedy(&hsize,
Eric Sandeen5995cb72007-08-16 16:49:11 +1000123 XFS_QM_HASHSIZE_LOW * sizeof(xfs_dqhash_t),
124 XFS_QM_HASHSIZE_HIGH * sizeof(xfs_dqhash_t),
Nathan Scott77e46352006-09-28 11:03:27 +1000125 KM_SLEEP | KM_MAYFAIL | KM_LARGE);
126 gdqhash = kmem_zalloc(hsize, KM_SLEEP | KM_LARGE);
127 hsize /= sizeof(xfs_dqhash_t);
Nathan Scott6b3f6b52005-11-02 15:08:25 +1100128 ndquot = hsize << 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
Nathan Scott6b3f6b52005-11-02 15:08:25 +1100130 xqm = kmem_zalloc(sizeof(xfs_qm_t), KM_SLEEP);
131 xqm->qm_dqhashmask = hsize - 1;
132 xqm->qm_usr_dqhtable = udqhash;
133 xqm->qm_grp_dqhtable = gdqhash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 ASSERT(xqm->qm_usr_dqhtable != NULL);
135 ASSERT(xqm->qm_grp_dqhtable != NULL);
136
137 for (i = 0; i < hsize; i++) {
138 xfs_qm_list_init(&(xqm->qm_usr_dqhtable[i]), "uxdqh", i);
139 xfs_qm_list_init(&(xqm->qm_grp_dqhtable[i]), "gxdqh", i);
140 }
141
142 /*
143 * Freelist of all dquots of all file systems
144 */
145 xfs_qm_freelist_init(&(xqm->qm_dqfreelist));
146
147 /*
148 * dquot zone. we register our own low-memory callback.
149 */
150 if (!qm_dqzone) {
151 xqm->qm_dqzone = kmem_zone_init(sizeof(xfs_dquot_t),
152 "xfs_dquots");
153 qm_dqzone = xqm->qm_dqzone;
154 } else
155 xqm->qm_dqzone = qm_dqzone;
156
Rusty Russell8e1f9362007-07-17 04:03:17 -0700157 register_shrinker(&xfs_qm_shaker);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
159 /*
160 * The t_dqinfo portion of transactions.
161 */
162 if (!qm_dqtrxzone) {
163 xqm->qm_dqtrxzone = kmem_zone_init(sizeof(xfs_dquot_acct_t),
164 "xfs_dqtrx");
165 qm_dqtrxzone = xqm->qm_dqtrxzone;
166 } else
167 xqm->qm_dqtrxzone = qm_dqtrxzone;
168
169 atomic_set(&xqm->qm_totaldquots, 0);
170 xqm->qm_dqfree_ratio = XFS_QM_DQFREE_RATIO;
171 xqm->qm_nrefs = 0;
172#ifdef DEBUG
Nathan Scottc2e81432006-01-16 16:21:34 +1100173 mutex_init(&qcheck_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174#endif
175 return xqm;
176}
177
178/*
179 * Destroy the global quota manager when its reference count goes to zero.
180 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000181STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182xfs_qm_destroy(
183 struct xfs_qm *xqm)
184{
185 int hsize, i;
186
187 ASSERT(xqm != NULL);
188 ASSERT(xqm->qm_nrefs == 0);
Rusty Russell8e1f9362007-07-17 04:03:17 -0700189 unregister_shrinker(&xfs_qm_shaker);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 hsize = xqm->qm_dqhashmask + 1;
191 for (i = 0; i < hsize; i++) {
192 xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));
193 xfs_qm_list_destroy(&(xqm->qm_grp_dqhtable[i]));
194 }
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000195 kmem_free(xqm->qm_usr_dqhtable);
196 kmem_free(xqm->qm_grp_dqhtable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 xqm->qm_usr_dqhtable = NULL;
198 xqm->qm_grp_dqhtable = NULL;
199 xqm->qm_dqhashmask = 0;
200 xfs_qm_freelist_destroy(&(xqm->qm_dqfreelist));
201#ifdef DEBUG
202 mutex_destroy(&qcheck_lock);
203#endif
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000204 kmem_free(xqm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205}
206
207/*
208 * Called at mount time to let XQM know that another file system is
209 * starting quotas. This isn't crucial information as the individual mount
210 * structures are pretty independent, but it helps the XQM keep a
211 * global view of what's going on.
212 */
213/* ARGSUSED */
214STATIC int
215xfs_qm_hold_quotafs_ref(
216 struct xfs_mount *mp)
217{
218 /*
219 * Need to lock the xfs_Gqm structure for things like this. For example,
220 * the structure could disappear between the entry to this routine and
221 * a HOLD operation if not locked.
222 */
223 XFS_QM_LOCK(xfs_Gqm);
224
225 if (xfs_Gqm == NULL)
226 xfs_Gqm = xfs_Gqm_init();
227 /*
228 * We can keep a list of all filesystems with quotas mounted for
229 * debugging and statistical purposes, but ...
230 * Just take a reference and get out.
231 */
232 XFS_QM_HOLD(xfs_Gqm);
233 XFS_QM_UNLOCK(xfs_Gqm);
234
235 return 0;
236}
237
238
239/*
240 * Release the reference that a filesystem took at mount time,
241 * so that we know when we need to destroy the entire quota manager.
242 */
243/* ARGSUSED */
244STATIC void
245xfs_qm_rele_quotafs_ref(
246 struct xfs_mount *mp)
247{
248 xfs_dquot_t *dqp, *nextdqp;
249
250 ASSERT(xfs_Gqm);
251 ASSERT(xfs_Gqm->qm_nrefs > 0);
252
253 /*
254 * Go thru the freelist and destroy all inactive dquots.
255 */
256 xfs_qm_freelist_lock(xfs_Gqm);
257
258 for (dqp = xfs_Gqm->qm_dqfreelist.qh_next;
259 dqp != (xfs_dquot_t *)&(xfs_Gqm->qm_dqfreelist); ) {
260 xfs_dqlock(dqp);
261 nextdqp = dqp->dq_flnext;
262 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
263 ASSERT(dqp->q_mount == NULL);
264 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
265 ASSERT(dqp->HL_PREVP == NULL);
266 ASSERT(dqp->MPL_PREVP == NULL);
267 XQM_FREELIST_REMOVE(dqp);
268 xfs_dqunlock(dqp);
269 xfs_qm_dqdestroy(dqp);
270 } else {
271 xfs_dqunlock(dqp);
272 }
273 dqp = nextdqp;
274 }
275 xfs_qm_freelist_unlock(xfs_Gqm);
276
277 /*
278 * Destroy the entire XQM. If somebody mounts with quotaon, this'll
279 * be restarted.
280 */
281 XFS_QM_LOCK(xfs_Gqm);
282 XFS_QM_RELE(xfs_Gqm);
283 if (xfs_Gqm->qm_nrefs == 0) {
284 xfs_qm_destroy(xfs_Gqm);
285 xfs_Gqm = NULL;
286 }
287 XFS_QM_UNLOCK(xfs_Gqm);
288}
289
290/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 * Just destroy the quotainfo structure.
292 */
293void
294xfs_qm_unmount_quotadestroy(
295 xfs_mount_t *mp)
296{
297 if (mp->m_quotainfo)
298 xfs_qm_destroy_quotainfo(mp);
299}
300
301
302/*
303 * This is called from xfs_mountfs to start quotas and initialize all
304 * necessary data structures like quotainfo. This is also responsible for
305 * running a quotacheck as necessary. We are guaranteed that the superblock
306 * is consistently read in at this point.
David Chinner53aa7912008-04-10 12:20:31 +1000307 *
308 * If we fail here, the mount will continue with quota turned off. We don't
309 * need to inidicate success or failure at all.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 */
David Chinner53aa7912008-04-10 12:20:31 +1000311void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312xfs_qm_mount_quotas(
313 xfs_mount_t *mp,
314 int mfsi_flags)
315{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 int error = 0;
317 uint sbf;
318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 /*
320 * If quotas on realtime volumes is not supported, we disable
321 * quotas immediately.
322 */
323 if (mp->m_sb.sb_rextents) {
324 cmn_err(CE_NOTE,
325 "Cannot turn on quotas for realtime filesystem %s",
326 mp->m_fsname);
327 mp->m_qflags = 0;
328 goto write_changes;
329 }
330
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
Nathan Scott155ffd02005-09-02 16:43:48 +1000332
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 /*
334 * Allocate the quotainfo structure inside the mount struct, and
335 * create quotainode(s), and change/rev superblock if necessary.
336 */
David Chinner53aa7912008-04-10 12:20:31 +1000337 error = xfs_qm_init_quotainfo(mp);
338 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 /*
340 * We must turn off quotas.
341 */
342 ASSERT(mp->m_quotainfo == NULL);
343 mp->m_qflags = 0;
344 goto write_changes;
345 }
346 /*
347 * If any of the quotas are not consistent, do a quotacheck.
348 */
349 if (XFS_QM_NEED_QUOTACHECK(mp) &&
David Chinner53aa7912008-04-10 12:20:31 +1000350 !(mfsi_flags & XFS_MFSI_NO_QUOTACHECK)) {
351 error = xfs_qm_quotacheck(mp);
352 if (error) {
353 /* Quotacheck failed and disabled quotas. */
354 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 }
Donald Douwsma646d5bd2007-05-08 13:49:09 +1000357 /*
358 * If one type of quotas is off, then it will lose its
359 * quotachecked status, since we won't be doing accounting for
360 * that type anymore.
361 */
David Chinner53aa7912008-04-10 12:20:31 +1000362 if (!XFS_IS_UQUOTA_ON(mp))
Donald Douwsma646d5bd2007-05-08 13:49:09 +1000363 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
David Chinner53aa7912008-04-10 12:20:31 +1000364 if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp)))
Donald Douwsma646d5bd2007-05-08 13:49:09 +1000365 mp->m_qflags &= ~XFS_OQUOTA_CHKD;
Nathan Scott155ffd02005-09-02 16:43:48 +1000366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 write_changes:
368 /*
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000369 * We actually don't have to acquire the m_sb_lock at all.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 * This can only be called from mount, and that's single threaded. XXX
371 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000372 spin_lock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 sbf = mp->m_sb.sb_qflags;
374 mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000375 spin_unlock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
377 if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
378 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
379 /*
380 * We could only have been turning quotas off.
381 * We aren't in very good shape actually because
382 * the incore structures are convinced that quotas are
383 * off, but the on disk superblock doesn't know that !
384 */
385 ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
386 xfs_fs_cmn_err(CE_ALERT, mp,
387 "XFS mount_quotas: Superblock update failed!");
388 }
389 }
390
391 if (error) {
392 xfs_fs_cmn_err(CE_WARN, mp,
393 "Failed to initialize disk quotas.");
394 }
David Chinner53aa7912008-04-10 12:20:31 +1000395 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396}
397
398/*
399 * Called from the vfsops layer.
400 */
401int
402xfs_qm_unmount_quotas(
403 xfs_mount_t *mp)
404{
405 xfs_inode_t *uqp, *gqp;
406 int error = 0;
407
408 /*
409 * Release the dquots that root inode, et al might be holding,
410 * before we flush quotas and blow away the quotainfo structure.
411 */
412 ASSERT(mp->m_rootip);
413 xfs_qm_dqdetach(mp->m_rootip);
414 if (mp->m_rbmip)
415 xfs_qm_dqdetach(mp->m_rbmip);
416 if (mp->m_rsumip)
417 xfs_qm_dqdetach(mp->m_rsumip);
418
419 /*
420 * Flush out the quota inodes.
421 */
422 uqp = gqp = NULL;
423 if (mp->m_quotainfo) {
424 if ((uqp = mp->m_quotainfo->qi_uquotaip) != NULL) {
425 xfs_ilock(uqp, XFS_ILOCK_EXCL);
426 xfs_iflock(uqp);
427 error = xfs_iflush(uqp, XFS_IFLUSH_SYNC);
428 xfs_iunlock(uqp, XFS_ILOCK_EXCL);
429 if (unlikely(error == EFSCORRUPTED)) {
430 XFS_ERROR_REPORT("xfs_qm_unmount_quotas(1)",
431 XFS_ERRLEVEL_LOW, mp);
432 goto out;
433 }
434 }
435 if ((gqp = mp->m_quotainfo->qi_gquotaip) != NULL) {
436 xfs_ilock(gqp, XFS_ILOCK_EXCL);
437 xfs_iflock(gqp);
438 error = xfs_iflush(gqp, XFS_IFLUSH_SYNC);
439 xfs_iunlock(gqp, XFS_ILOCK_EXCL);
440 if (unlikely(error == EFSCORRUPTED)) {
441 XFS_ERROR_REPORT("xfs_qm_unmount_quotas(2)",
442 XFS_ERRLEVEL_LOW, mp);
443 goto out;
444 }
445 }
446 }
447 if (uqp) {
448 XFS_PURGE_INODE(uqp);
449 mp->m_quotainfo->qi_uquotaip = NULL;
450 }
451 if (gqp) {
452 XFS_PURGE_INODE(gqp);
453 mp->m_quotainfo->qi_gquotaip = NULL;
454 }
455out:
456 return XFS_ERROR(error);
457}
458
459/*
460 * Flush all dquots of the given file system to disk. The dquots are
461 * _not_ purged from memory here, just their data written to disk.
462 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000463STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464xfs_qm_dqflush_all(
465 xfs_mount_t *mp,
466 int flags)
467{
468 int recl;
469 xfs_dquot_t *dqp;
470 int niters;
471 int error;
472
473 if (mp->m_quotainfo == NULL)
Jesper Juhl014c2542006-01-15 02:37:08 +0100474 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 niters = 0;
476again:
477 xfs_qm_mplist_lock(mp);
478 FOREACH_DQUOT_IN_MP(dqp, mp) {
479 xfs_dqlock(dqp);
480 if (! XFS_DQ_IS_DIRTY(dqp)) {
481 xfs_dqunlock(dqp);
482 continue;
483 }
484 xfs_dqtrace_entry(dqp, "FLUSHALL: DQDIRTY");
485 /* XXX a sentinel would be better */
486 recl = XFS_QI_MPLRECLAIMS(mp);
487 if (! xfs_qm_dqflock_nowait(dqp)) {
488 /*
489 * If we can't grab the flush lock then check
490 * to see if the dquot has been flushed delayed
491 * write. If so, grab its buffer and send it
492 * out immediately. We'll be able to acquire
493 * the flush lock when the I/O completes.
494 */
495 xfs_qm_dqflock_pushbuf_wait(dqp);
496 }
497 /*
498 * Let go of the mplist lock. We don't want to hold it
499 * across a disk write.
500 */
501 xfs_qm_mplist_unlock(mp);
502 error = xfs_qm_dqflush(dqp, flags);
503 xfs_dqunlock(dqp);
504 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +0100505 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
507 xfs_qm_mplist_lock(mp);
508 if (recl != XFS_QI_MPLRECLAIMS(mp)) {
509 xfs_qm_mplist_unlock(mp);
510 /* XXX restart limit */
511 goto again;
512 }
513 }
514
515 xfs_qm_mplist_unlock(mp);
516 /* return ! busy */
Jesper Juhl014c2542006-01-15 02:37:08 +0100517 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518}
519/*
520 * Release the group dquot pointers the user dquots may be
521 * carrying around as a hint. mplist is locked on entry and exit.
522 */
523STATIC void
524xfs_qm_detach_gdquots(
525 xfs_mount_t *mp)
526{
527 xfs_dquot_t *dqp, *gdqp;
528 int nrecl;
529
530 again:
531 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
532 dqp = XFS_QI_MPLNEXT(mp);
533 while (dqp) {
534 xfs_dqlock(dqp);
535 if ((gdqp = dqp->q_gdquot)) {
536 xfs_dqlock(gdqp);
537 dqp->q_gdquot = NULL;
538 }
539 xfs_dqunlock(dqp);
540
541 if (gdqp) {
542 /*
543 * Can't hold the mplist lock across a dqput.
544 * XXXmust convert to marker based iterations here.
545 */
546 nrecl = XFS_QI_MPLRECLAIMS(mp);
547 xfs_qm_mplist_unlock(mp);
548 xfs_qm_dqput(gdqp);
549
550 xfs_qm_mplist_lock(mp);
551 if (nrecl != XFS_QI_MPLRECLAIMS(mp))
552 goto again;
553 }
554 dqp = dqp->MPL_NEXT;
555 }
556}
557
558/*
559 * Go through all the incore dquots of this file system and take them
560 * off the mplist and hashlist, if the dquot type matches the dqtype
561 * parameter. This is used when turning off quota accounting for
562 * users and/or groups, as well as when the filesystem is unmounting.
563 */
564STATIC int
565xfs_qm_dqpurge_int(
566 xfs_mount_t *mp,
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000567 uint flags) /* QUOTAOFF/UMOUNTING/UQUOTA/PQUOTA/GQUOTA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568{
569 xfs_dquot_t *dqp;
570 uint dqtype;
571 int nrecl;
572 xfs_dquot_t *nextdqp;
573 int nmisses;
574
575 if (mp->m_quotainfo == NULL)
Jesper Juhl014c2542006-01-15 02:37:08 +0100576 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
578 dqtype = (flags & XFS_QMOPT_UQUOTA) ? XFS_DQ_USER : 0;
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000579 dqtype |= (flags & XFS_QMOPT_PQUOTA) ? XFS_DQ_PROJ : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 dqtype |= (flags & XFS_QMOPT_GQUOTA) ? XFS_DQ_GROUP : 0;
581
582 xfs_qm_mplist_lock(mp);
583
584 /*
585 * In the first pass through all incore dquots of this filesystem,
586 * we release the group dquot pointers the user dquots may be
587 * carrying around as a hint. We need to do this irrespective of
588 * what's being turned off.
589 */
590 xfs_qm_detach_gdquots(mp);
591
592 again:
593 nmisses = 0;
594 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
595 /*
596 * Try to get rid of all of the unwanted dquots. The idea is to
597 * get them off mplist and hashlist, but leave them on freelist.
598 */
599 dqp = XFS_QI_MPLNEXT(mp);
600 while (dqp) {
601 /*
602 * It's OK to look at the type without taking dqlock here.
603 * We're holding the mplist lock here, and that's needed for
604 * a dqreclaim.
605 */
606 if ((dqp->dq_flags & dqtype) == 0) {
607 dqp = dqp->MPL_NEXT;
608 continue;
609 }
610
611 if (! xfs_qm_dqhashlock_nowait(dqp)) {
612 nrecl = XFS_QI_MPLRECLAIMS(mp);
613 xfs_qm_mplist_unlock(mp);
614 XFS_DQ_HASH_LOCK(dqp->q_hash);
615 xfs_qm_mplist_lock(mp);
616
617 /*
618 * XXXTheoretically, we can get into a very long
619 * ping pong game here.
620 * No one can be adding dquots to the mplist at
621 * this point, but somebody might be taking things off.
622 */
623 if (nrecl != XFS_QI_MPLRECLAIMS(mp)) {
624 XFS_DQ_HASH_UNLOCK(dqp->q_hash);
625 goto again;
626 }
627 }
628
629 /*
630 * Take the dquot off the mplist and hashlist. It may remain on
631 * freelist in INACTIVE state.
632 */
633 nextdqp = dqp->MPL_NEXT;
634 nmisses += xfs_qm_dqpurge(dqp, flags);
635 dqp = nextdqp;
636 }
637 xfs_qm_mplist_unlock(mp);
638 return nmisses;
639}
640
641int
642xfs_qm_dqpurge_all(
643 xfs_mount_t *mp,
644 uint flags)
645{
646 int ndquots;
647
648 /*
649 * Purge the dquot cache.
650 * None of the dquots should really be busy at this point.
651 */
652 if (mp->m_quotainfo) {
653 while ((ndquots = xfs_qm_dqpurge_int(mp, flags))) {
654 delay(ndquots * 10);
655 }
656 }
657 return 0;
658}
659
660STATIC int
661xfs_qm_dqattach_one(
662 xfs_inode_t *ip,
663 xfs_dqid_t id,
664 uint type,
665 uint doalloc,
666 uint dolock,
667 xfs_dquot_t *udqhint, /* hint */
668 xfs_dquot_t **IO_idqpp)
669{
670 xfs_dquot_t *dqp;
671 int error;
672
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000673 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 error = 0;
675 /*
676 * See if we already have it in the inode itself. IO_idqpp is
677 * &i_udquot or &i_gdquot. This made the code look weird, but
678 * made the logic a lot simpler.
679 */
680 if ((dqp = *IO_idqpp)) {
681 if (dolock)
682 xfs_dqlock(dqp);
683 xfs_dqtrace_entry(dqp, "DQATTACH: found in ip");
684 goto done;
685 }
686
687 /*
688 * udqhint is the i_udquot field in inode, and is non-NULL only
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000689 * when the type arg is group/project. Its purpose is to save a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside
691 * the user dquot.
692 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000693 ASSERT(!udqhint || type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 if (udqhint && !dolock)
695 xfs_dqlock(udqhint);
696
697 /*
698 * No need to take dqlock to look at the id.
699 * The ID can't change until it gets reclaimed, and it won't
700 * be reclaimed as long as we have a ref from inode and we hold
701 * the ilock.
702 */
703 if (udqhint &&
704 (dqp = udqhint->q_gdquot) &&
Christoph Hellwig1149d962005-11-02 15:01:12 +1100705 (be32_to_cpu(dqp->q_core.d_id) == id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 ASSERT(XFS_DQ_IS_LOCKED(udqhint));
707 xfs_dqlock(dqp);
708 XFS_DQHOLD(dqp);
709 ASSERT(*IO_idqpp == NULL);
710 *IO_idqpp = dqp;
711 if (!dolock) {
712 xfs_dqunlock(dqp);
713 xfs_dqunlock(udqhint);
714 }
715 goto done;
716 }
717 /*
718 * We can't hold a dquot lock when we call the dqget code.
719 * We'll deadlock in no time, because of (not conforming to)
720 * lock ordering - the inodelock comes before any dquot lock,
721 * and we may drop and reacquire the ilock in xfs_qm_dqget().
722 */
723 if (udqhint)
724 xfs_dqunlock(udqhint);
725 /*
726 * Find the dquot from somewhere. This bumps the
727 * reference count of dquot and returns it locked.
728 * This can return ENOENT if dquot didn't exist on
729 * disk and we didn't ask it to allocate;
730 * ESRCH if quotas got turned off suddenly.
731 */
732 if ((error = xfs_qm_dqget(ip->i_mount, ip, id, type,
733 doalloc|XFS_QMOPT_DOWARN, &dqp))) {
734 if (udqhint && dolock)
735 xfs_dqlock(udqhint);
736 goto done;
737 }
738
739 xfs_dqtrace_entry(dqp, "DQATTACH: found by dqget");
740 /*
741 * dqget may have dropped and re-acquired the ilock, but it guarantees
742 * that the dquot returned is the one that should go in the inode.
743 */
744 *IO_idqpp = dqp;
745 ASSERT(dqp);
746 ASSERT(XFS_DQ_IS_LOCKED(dqp));
747 if (! dolock) {
748 xfs_dqunlock(dqp);
749 goto done;
750 }
751 if (! udqhint)
752 goto done;
753
754 ASSERT(udqhint);
755 ASSERT(dolock);
756 ASSERT(XFS_DQ_IS_LOCKED(dqp));
757 if (! xfs_qm_dqlock_nowait(udqhint)) {
758 xfs_dqunlock(dqp);
759 xfs_dqlock(udqhint);
760 xfs_dqlock(dqp);
761 }
762 done:
763#ifdef QUOTADEBUG
764 if (udqhint) {
765 if (dolock)
766 ASSERT(XFS_DQ_IS_LOCKED(udqhint));
767 }
768 if (! error) {
769 if (dolock)
770 ASSERT(XFS_DQ_IS_LOCKED(dqp));
771 }
772#endif
Jesper Juhl014c2542006-01-15 02:37:08 +0100773 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774}
775
776
777/*
778 * Given a udquot and gdquot, attach a ptr to the group dquot in the
779 * udquot as a hint for future lookups. The idea sounds simple, but the
780 * execution isn't, because the udquot might have a group dquot attached
Nathan Scottc41564b2006-03-29 08:55:14 +1000781 * already and getting rid of that gets us into lock ordering constraints.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 * The process is complicated more by the fact that the dquots may or may not
783 * be locked on entry.
784 */
785STATIC void
786xfs_qm_dqattach_grouphint(
787 xfs_dquot_t *udq,
788 xfs_dquot_t *gdq,
789 uint locked)
790{
791 xfs_dquot_t *tmp;
792
793#ifdef QUOTADEBUG
794 if (locked) {
795 ASSERT(XFS_DQ_IS_LOCKED(udq));
796 ASSERT(XFS_DQ_IS_LOCKED(gdq));
797 }
798#endif
799 if (! locked)
800 xfs_dqlock(udq);
801
802 if ((tmp = udq->q_gdquot)) {
803 if (tmp == gdq) {
804 if (! locked)
805 xfs_dqunlock(udq);
806 return;
807 }
808
809 udq->q_gdquot = NULL;
810 /*
811 * We can't keep any dqlocks when calling dqrele,
812 * because the freelist lock comes before dqlocks.
813 */
814 xfs_dqunlock(udq);
815 if (locked)
816 xfs_dqunlock(gdq);
817 /*
818 * we took a hard reference once upon a time in dqget,
819 * so give it back when the udquot no longer points at it
820 * dqput() does the unlocking of the dquot.
821 */
822 xfs_qm_dqrele(tmp);
823
824 xfs_dqlock(udq);
825 xfs_dqlock(gdq);
826
827 } else {
828 ASSERT(XFS_DQ_IS_LOCKED(udq));
829 if (! locked) {
830 xfs_dqlock(gdq);
831 }
832 }
833
834 ASSERT(XFS_DQ_IS_LOCKED(udq));
835 ASSERT(XFS_DQ_IS_LOCKED(gdq));
836 /*
837 * Somebody could have attached a gdquot here,
838 * when we dropped the uqlock. If so, just do nothing.
839 */
840 if (udq->q_gdquot == NULL) {
841 XFS_DQHOLD(gdq);
842 udq->q_gdquot = gdq;
843 }
844 if (! locked) {
845 xfs_dqunlock(gdq);
846 xfs_dqunlock(udq);
847 }
848}
849
850
851/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000852 * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
853 * into account.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed.
855 * If XFS_QMOPT_DQLOCK, the dquot(s) will be returned locked. This option pretty
856 * much made this code a complete mess, but it has been pretty useful.
857 * If XFS_QMOPT_ILOCKED, then inode sent is already locked EXCL.
858 * Inode may get unlocked and relocked in here, and the caller must deal with
859 * the consequences.
860 */
861int
862xfs_qm_dqattach(
863 xfs_inode_t *ip,
864 uint flags)
865{
866 xfs_mount_t *mp = ip->i_mount;
867 uint nquotas = 0;
868 int error = 0;
869
870 if ((! XFS_IS_QUOTA_ON(mp)) ||
871 (! XFS_NOT_DQATTACHED(mp, ip)) ||
872 (ip->i_ino == mp->m_sb.sb_uquotino) ||
873 (ip->i_ino == mp->m_sb.sb_gquotino))
Jesper Juhl014c2542006-01-15 02:37:08 +0100874 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875
876 ASSERT((flags & XFS_QMOPT_ILOCKED) == 0 ||
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000877 xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
879 if (! (flags & XFS_QMOPT_ILOCKED))
880 xfs_ilock(ip, XFS_ILOCK_EXCL);
881
882 if (XFS_IS_UQUOTA_ON(mp)) {
883 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
884 flags & XFS_QMOPT_DQALLOC,
885 flags & XFS_QMOPT_DQLOCK,
886 NULL, &ip->i_udquot);
887 if (error)
888 goto done;
889 nquotas++;
890 }
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000891
892 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000893 if (XFS_IS_OQUOTA_ON(mp)) {
894 error = XFS_IS_GQUOTA_ON(mp) ?
895 xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
896 flags & XFS_QMOPT_DQALLOC,
897 flags & XFS_QMOPT_DQLOCK,
898 ip->i_udquot, &ip->i_gdquot) :
899 xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQ_PROJ,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 flags & XFS_QMOPT_DQALLOC,
901 flags & XFS_QMOPT_DQLOCK,
902 ip->i_udquot, &ip->i_gdquot);
903 /*
904 * Don't worry about the udquot that we may have
905 * attached above. It'll get detached, if not already.
906 */
907 if (error)
908 goto done;
909 nquotas++;
910 }
911
912 /*
913 * Attach this group quota to the user quota as a hint.
914 * This WON'T, in general, result in a thrash.
915 */
916 if (nquotas == 2) {
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000917 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 ASSERT(ip->i_udquot);
919 ASSERT(ip->i_gdquot);
920
921 /*
922 * We may or may not have the i_udquot locked at this point,
923 * but this check is OK since we don't depend on the i_gdquot to
924 * be accurate 100% all the time. It is just a hint, and this
925 * will succeed in general.
926 */
927 if (ip->i_udquot->q_gdquot == ip->i_gdquot)
928 goto done;
929 /*
930 * Attach i_gdquot to the gdquot hint inside the i_udquot.
931 */
932 xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot,
933 flags & XFS_QMOPT_DQLOCK);
934 }
935
936 done:
937
938#ifdef QUOTADEBUG
939 if (! error) {
940 if (ip->i_udquot) {
941 if (flags & XFS_QMOPT_DQLOCK)
942 ASSERT(XFS_DQ_IS_LOCKED(ip->i_udquot));
943 }
944 if (ip->i_gdquot) {
945 if (flags & XFS_QMOPT_DQLOCK)
946 ASSERT(XFS_DQ_IS_LOCKED(ip->i_gdquot));
947 }
948 if (XFS_IS_UQUOTA_ON(mp))
949 ASSERT(ip->i_udquot);
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000950 if (XFS_IS_OQUOTA_ON(mp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 ASSERT(ip->i_gdquot);
952 }
953#endif
954
955 if (! (flags & XFS_QMOPT_ILOCKED))
956 xfs_iunlock(ip, XFS_ILOCK_EXCL);
957
958#ifdef QUOTADEBUG
959 else
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000960 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961#endif
Jesper Juhl014c2542006-01-15 02:37:08 +0100962 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963}
964
965/*
966 * Release dquots (and their references) if any.
967 * The inode should be locked EXCL except when this's called by
968 * xfs_ireclaim.
969 */
970void
971xfs_qm_dqdetach(
972 xfs_inode_t *ip)
973{
974 if (!(ip->i_udquot || ip->i_gdquot))
975 return;
976
977 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
978 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 if (ip->i_udquot) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000980 xfs_dqtrace_entry_ino(ip->i_udquot, "DQDETTACH", ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 xfs_qm_dqrele(ip->i_udquot);
982 ip->i_udquot = NULL;
983 }
984 if (ip->i_gdquot) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000985 xfs_dqtrace_entry_ino(ip->i_gdquot, "DQDETTACH", ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 xfs_qm_dqrele(ip->i_gdquot);
987 ip->i_gdquot = NULL;
988 }
989}
990
991/*
992 * This is called by VFS_SYNC and flags arg determines the caller,
993 * and its motives, as done in xfs_sync.
994 *
995 * vfs_sync: SYNC_FSDATA|SYNC_ATTR|SYNC_BDFLUSH 0x31
996 * syscall sync: SYNC_FSDATA|SYNC_ATTR|SYNC_DELWRI 0x25
997 * umountroot : SYNC_WAIT | SYNC_CLOSE | SYNC_ATTR | SYNC_FSDATA
998 */
999
1000int
1001xfs_qm_sync(
1002 xfs_mount_t *mp,
Christoph Hellwigb09cc772007-08-30 17:19:57 +10001003 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004{
1005 int recl, restarts;
1006 xfs_dquot_t *dqp;
1007 uint flush_flags;
1008 boolean_t nowait;
1009 int error;
1010
Donald Douwsmad7577622007-11-23 16:27:42 +11001011 if (! XFS_IS_QUOTA_ON(mp))
1012 return 0;
1013
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 restarts = 0;
1015 /*
1016 * We won't block unless we are asked to.
1017 */
1018 nowait = (boolean_t)(flags & SYNC_BDFLUSH || (flags & SYNC_WAIT) == 0);
1019
1020 again:
1021 xfs_qm_mplist_lock(mp);
1022 /*
1023 * dqpurge_all() also takes the mplist lock and iterate thru all dquots
1024 * in quotaoff. However, if the QUOTA_ACTIVE bits are not cleared
1025 * when we have the mplist lock, we know that dquots will be consistent
1026 * as long as we have it locked.
1027 */
1028 if (! XFS_IS_QUOTA_ON(mp)) {
1029 xfs_qm_mplist_unlock(mp);
Jesper Juhl014c2542006-01-15 02:37:08 +01001030 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 }
1032 FOREACH_DQUOT_IN_MP(dqp, mp) {
1033 /*
1034 * If this is vfs_sync calling, then skip the dquots that
1035 * don't 'seem' to be dirty. ie. don't acquire dqlock.
1036 * This is very similar to what xfs_sync does with inodes.
1037 */
1038 if (flags & SYNC_BDFLUSH) {
1039 if (! XFS_DQ_IS_DIRTY(dqp))
1040 continue;
1041 }
1042
1043 if (nowait) {
1044 /*
1045 * Try to acquire the dquot lock. We are NOT out of
1046 * lock order, but we just don't want to wait for this
1047 * lock, unless somebody wanted us to.
1048 */
1049 if (! xfs_qm_dqlock_nowait(dqp))
1050 continue;
1051 } else {
1052 xfs_dqlock(dqp);
1053 }
1054
1055 /*
1056 * Now, find out for sure if this dquot is dirty or not.
1057 */
1058 if (! XFS_DQ_IS_DIRTY(dqp)) {
1059 xfs_dqunlock(dqp);
1060 continue;
1061 }
1062
1063 /* XXX a sentinel would be better */
1064 recl = XFS_QI_MPLRECLAIMS(mp);
1065 if (! xfs_qm_dqflock_nowait(dqp)) {
1066 if (nowait) {
1067 xfs_dqunlock(dqp);
1068 continue;
1069 }
1070 /*
1071 * If we can't grab the flush lock then if the caller
Nathan Scottc41564b2006-03-29 08:55:14 +10001072 * really wanted us to give this our best shot, so
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 * see if we can give a push to the buffer before we wait
1074 * on the flush lock. At this point, we know that
Nathan Scottc41564b2006-03-29 08:55:14 +10001075 * even though the dquot is being flushed,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 * it has (new) dirty data.
1077 */
1078 xfs_qm_dqflock_pushbuf_wait(dqp);
1079 }
1080 /*
1081 * Let go of the mplist lock. We don't want to hold it
1082 * across a disk write
1083 */
1084 flush_flags = (nowait) ? XFS_QMOPT_DELWRI : XFS_QMOPT_SYNC;
1085 xfs_qm_mplist_unlock(mp);
1086 xfs_dqtrace_entry(dqp, "XQM_SYNC: DQFLUSH");
1087 error = xfs_qm_dqflush(dqp, flush_flags);
1088 xfs_dqunlock(dqp);
1089 if (error && XFS_FORCED_SHUTDOWN(mp))
Jesper Juhl014c2542006-01-15 02:37:08 +01001090 return 0; /* Need to prevent umount failure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 else if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01001092 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093
1094 xfs_qm_mplist_lock(mp);
1095 if (recl != XFS_QI_MPLRECLAIMS(mp)) {
1096 if (++restarts >= XFS_QM_SYNC_MAX_RESTARTS)
1097 break;
1098
1099 xfs_qm_mplist_unlock(mp);
1100 goto again;
1101 }
1102 }
1103
1104 xfs_qm_mplist_unlock(mp);
Jesper Juhl014c2542006-01-15 02:37:08 +01001105 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106}
1107
1108
1109/*
1110 * This initializes all the quota information that's kept in the
1111 * mount structure
1112 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10001113STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114xfs_qm_init_quotainfo(
1115 xfs_mount_t *mp)
1116{
1117 xfs_quotainfo_t *qinf;
1118 int error;
1119 xfs_dquot_t *dqp;
1120
1121 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1122
1123 /*
1124 * Tell XQM that we exist as soon as possible.
1125 */
1126 if ((error = xfs_qm_hold_quotafs_ref(mp))) {
Jesper Juhl014c2542006-01-15 02:37:08 +01001127 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 }
1129
1130 qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
1131
1132 /*
1133 * See if quotainodes are setup, and if not, allocate them,
1134 * and change the superblock accordingly.
1135 */
1136 if ((error = xfs_qm_init_quotainos(mp))) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001137 kmem_free(qinf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 mp->m_quotainfo = NULL;
Jesper Juhl014c2542006-01-15 02:37:08 +01001139 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 }
1141
Eric Sandeen007c61c2007-10-11 17:43:56 +10001142 spin_lock_init(&qinf->qi_pinlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 xfs_qm_list_init(&qinf->qi_dqlist, "mpdqlist", 0);
1144 qinf->qi_dqreclaims = 0;
1145
1146 /* mutex used to serialize quotaoffs */
Jes Sorensen794ee1b2006-01-09 15:59:21 -08001147 mutex_init(&qinf->qi_quotaofflock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
1149 /* Precalc some constants */
1150 qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1151 ASSERT(qinf->qi_dqchunklen);
1152 qinf->qi_dqperchunk = BBTOB(qinf->qi_dqchunklen);
1153 do_div(qinf->qi_dqperchunk, sizeof(xfs_dqblk_t));
1154
1155 mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
1156
1157 /*
1158 * We try to get the limits from the superuser's limits fields.
1159 * This is quite hacky, but it is standard quota practice.
1160 * We look at the USR dquot with id == 0 first, but if user quotas
1161 * are not enabled we goto the GRP dquot with id == 0.
1162 * We don't really care to keep separate default limits for user
1163 * and group quotas, at least not at this point.
1164 */
1165 error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)0,
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001166 XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
1167 (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
1168 XFS_DQ_PROJ),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 XFS_QMOPT_DQSUSER|XFS_QMOPT_DOWARN,
1170 &dqp);
1171 if (! error) {
1172 xfs_disk_dquot_t *ddqp = &dqp->q_core;
1173
1174 /*
1175 * The warnings and timers set the grace period given to
1176 * a user or group before he or she can not perform any
1177 * more writing. If it is zero, a default is used.
1178 */
Christoph Hellwig1149d962005-11-02 15:01:12 +11001179 qinf->qi_btimelimit = ddqp->d_btimer ?
1180 be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;
1181 qinf->qi_itimelimit = ddqp->d_itimer ?
1182 be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;
1183 qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?
1184 be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;
1185 qinf->qi_bwarnlimit = ddqp->d_bwarns ?
1186 be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;
1187 qinf->qi_iwarnlimit = ddqp->d_iwarns ?
1188 be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
1189 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
1190 be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
1191 qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
1192 qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
1193 qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
1194 qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
1195 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
1196 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197
1198 /*
1199 * We sent the XFS_QMOPT_DQSUSER flag to dqget because
1200 * we don't want this dquot cached. We haven't done a
1201 * quotacheck yet, and quotacheck doesn't like incore dquots.
1202 */
1203 xfs_qm_dqdestroy(dqp);
1204 } else {
1205 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
1206 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
1207 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
1208 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
1209 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
Nathan Scott06d10dd2005-06-21 15:48:47 +10001210 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 }
1212
Jesper Juhl014c2542006-01-15 02:37:08 +01001213 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214}
1215
1216
1217/*
1218 * Gets called when unmounting a filesystem or when all quotas get
1219 * turned off.
1220 * This purges the quota inodes, destroys locks and frees itself.
1221 */
1222void
1223xfs_qm_destroy_quotainfo(
1224 xfs_mount_t *mp)
1225{
1226 xfs_quotainfo_t *qi;
1227
1228 qi = mp->m_quotainfo;
1229 ASSERT(qi != NULL);
1230 ASSERT(xfs_Gqm != NULL);
1231
1232 /*
1233 * Release the reference that XQM kept, so that we know
1234 * when the XQM structure should be freed. We cannot assume
1235 * that xfs_Gqm is non-null after this point.
1236 */
1237 xfs_qm_rele_quotafs_ref(mp);
1238
1239 spinlock_destroy(&qi->qi_pinlock);
1240 xfs_qm_list_destroy(&qi->qi_dqlist);
1241
1242 if (qi->qi_uquotaip) {
1243 XFS_PURGE_INODE(qi->qi_uquotaip);
1244 qi->qi_uquotaip = NULL; /* paranoia */
1245 }
1246 if (qi->qi_gquotaip) {
1247 XFS_PURGE_INODE(qi->qi_gquotaip);
1248 qi->qi_gquotaip = NULL;
1249 }
1250 mutex_destroy(&qi->qi_quotaofflock);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001251 kmem_free(qi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 mp->m_quotainfo = NULL;
1253}
1254
1255
1256
1257/* ------------------- PRIVATE STATIC FUNCTIONS ----------------------- */
1258
1259/* ARGSUSED */
1260STATIC void
1261xfs_qm_list_init(
1262 xfs_dqlist_t *list,
1263 char *str,
1264 int n)
1265{
Jes Sorensen794ee1b2006-01-09 15:59:21 -08001266 mutex_init(&list->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 list->qh_next = NULL;
1268 list->qh_version = 0;
1269 list->qh_nelems = 0;
1270}
1271
1272STATIC void
1273xfs_qm_list_destroy(
1274 xfs_dqlist_t *list)
1275{
1276 mutex_destroy(&(list->qh_lock));
1277}
1278
1279
1280/*
1281 * Stripped down version of dqattach. This doesn't attach, or even look at the
1282 * dquots attached to the inode. The rationale is that there won't be any
1283 * attached at the time this is called from quotacheck.
1284 */
1285STATIC int
1286xfs_qm_dqget_noattach(
1287 xfs_inode_t *ip,
1288 xfs_dquot_t **O_udqpp,
1289 xfs_dquot_t **O_gdqpp)
1290{
1291 int error;
1292 xfs_mount_t *mp;
1293 xfs_dquot_t *udqp, *gdqp;
1294
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10001295 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 mp = ip->i_mount;
1297 udqp = NULL;
1298 gdqp = NULL;
1299
1300 if (XFS_IS_UQUOTA_ON(mp)) {
1301 ASSERT(ip->i_udquot == NULL);
1302 /*
1303 * We want the dquot allocated if it doesn't exist.
1304 */
1305 if ((error = xfs_qm_dqget(mp, ip, ip->i_d.di_uid, XFS_DQ_USER,
1306 XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN,
1307 &udqp))) {
1308 /*
1309 * Shouldn't be able to turn off quotas here.
1310 */
1311 ASSERT(error != ESRCH);
1312 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01001313 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 }
1315 ASSERT(udqp);
1316 }
1317
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001318 if (XFS_IS_OQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 ASSERT(ip->i_gdquot == NULL);
1320 if (udqp)
1321 xfs_dqunlock(udqp);
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001322 error = XFS_IS_GQUOTA_ON(mp) ?
1323 xfs_qm_dqget(mp, ip,
1324 ip->i_d.di_gid, XFS_DQ_GROUP,
1325 XFS_QMOPT_DQALLOC|XFS_QMOPT_DOWARN,
1326 &gdqp) :
1327 xfs_qm_dqget(mp, ip,
1328 ip->i_d.di_projid, XFS_DQ_PROJ,
1329 XFS_QMOPT_DQALLOC|XFS_QMOPT_DOWARN,
1330 &gdqp);
1331 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 if (udqp)
1333 xfs_qm_dqrele(udqp);
1334 ASSERT(error != ESRCH);
1335 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01001336 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 }
1338 ASSERT(gdqp);
1339
1340 /* Reacquire the locks in the right order */
1341 if (udqp) {
1342 if (! xfs_qm_dqlock_nowait(udqp)) {
1343 xfs_dqunlock(gdqp);
1344 xfs_dqlock(udqp);
1345 xfs_dqlock(gdqp);
1346 }
1347 }
1348 }
1349
1350 *O_udqpp = udqp;
1351 *O_gdqpp = gdqp;
1352
1353#ifdef QUOTADEBUG
1354 if (udqp) ASSERT(XFS_DQ_IS_LOCKED(udqp));
1355 if (gdqp) ASSERT(XFS_DQ_IS_LOCKED(gdqp));
1356#endif
Jesper Juhl014c2542006-01-15 02:37:08 +01001357 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358}
1359
1360/*
1361 * Create an inode and return with a reference already taken, but unlocked
1362 * This is how we create quota inodes
1363 */
1364STATIC int
1365xfs_qm_qino_alloc(
1366 xfs_mount_t *mp,
1367 xfs_inode_t **ip,
1368 __int64_t sbfields,
1369 uint flags)
1370{
1371 xfs_trans_t *tp;
1372 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 int committed;
1374
Nathan Scott061f7202006-01-11 15:27:50 +11001375 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 if ((error = xfs_trans_reserve(tp,
1377 XFS_QM_QINOCREATE_SPACE_RES(mp),
1378 XFS_CREATE_LOG_RES(mp), 0,
1379 XFS_TRANS_PERM_LOG_RES,
1380 XFS_CREATE_LOG_COUNT))) {
1381 xfs_trans_cancel(tp, 0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001382 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384
David Chinnerb11f94d2007-07-11 11:09:33 +10001385 if ((error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0,
Nathan Scottdae81d42006-02-28 12:30:13 +11001386 &xfs_zerocr, 0, 1, ip, &committed))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
1388 XFS_TRANS_ABORT);
Jesper Juhl014c2542006-01-15 02:37:08 +01001389 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 }
1391
1392 /*
1393 * Keep an extra reference to this quota inode. This inode is
1394 * locked exclusively and joined to the transaction already.
1395 */
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10001396 ASSERT(xfs_isilocked(*ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 VN_HOLD(XFS_ITOV((*ip)));
1398
1399 /*
1400 * Make the changes in the superblock, and log those too.
1401 * sbfields arg may contain fields other than *QUOTINO;
1402 * VERSIONNUM for example.
1403 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001404 spin_lock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 if (flags & XFS_QMOPT_SBVERSION) {
1406#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
1407 unsigned oldv = mp->m_sb.sb_versionnum;
1408#endif
Eric Sandeen62118702008-03-06 13:44:28 +11001409 ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1411 XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
1412 (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1413 XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
1414
Eric Sandeen62118702008-03-06 13:44:28 +11001415 xfs_sb_version_addquota(&mp->m_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 mp->m_sb.sb_uquotino = NULLFSINO;
1417 mp->m_sb.sb_gquotino = NULLFSINO;
1418
1419 /* qflags will get updated _after_ quotacheck */
1420 mp->m_sb.sb_qflags = 0;
1421#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
1422 cmn_err(CE_NOTE,
1423 "Old superblock version %x, converting to %x.",
1424 oldv, mp->m_sb.sb_versionnum);
1425#endif
1426 }
1427 if (flags & XFS_QMOPT_UQUOTA)
1428 mp->m_sb.sb_uquotino = (*ip)->i_ino;
1429 else
1430 mp->m_sb.sb_gquotino = (*ip)->i_ino;
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001431 spin_unlock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 xfs_mod_sb(tp, sbfields);
1433
Eric Sandeen1c72bf92007-05-08 13:48:42 +10001434 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 xfs_fs_cmn_err(CE_ALERT, mp, "XFS qino_alloc failed!");
Jesper Juhl014c2542006-01-15 02:37:08 +01001436 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001438 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439}
1440
1441
David Chinner5b139732008-04-10 12:20:10 +10001442STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443xfs_qm_reset_dqcounts(
1444 xfs_mount_t *mp,
1445 xfs_buf_t *bp,
1446 xfs_dqid_t id,
1447 uint type)
1448{
1449 xfs_disk_dquot_t *ddq;
1450 int j;
1451
1452 xfs_buftrace("RESET DQUOTS", bp);
1453 /*
1454 * Reset all counters and timers. They'll be
1455 * started afresh by xfs_qm_quotacheck.
1456 */
1457#ifdef DEBUG
1458 j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1459 do_div(j, sizeof(xfs_dqblk_t));
1460 ASSERT(XFS_QM_DQPERBLK(mp) == j);
1461#endif
1462 ddq = (xfs_disk_dquot_t *)XFS_BUF_PTR(bp);
1463 for (j = 0; j < XFS_QM_DQPERBLK(mp); j++) {
1464 /*
1465 * Do a sanity check, and if needed, repair the dqblk. Don't
1466 * output any warnings because it's perfectly possible to
Nathan Scottc41564b2006-03-29 08:55:14 +10001467 * find uninitialised dquot blks. See comment in xfs_qm_dqcheck.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 */
1469 (void) xfs_qm_dqcheck(ddq, id+j, type, XFS_QMOPT_DQREPAIR,
1470 "xfs_quotacheck");
Christoph Hellwig1149d962005-11-02 15:01:12 +11001471 ddq->d_bcount = 0;
1472 ddq->d_icount = 0;
1473 ddq->d_rtbcount = 0;
1474 ddq->d_btimer = 0;
1475 ddq->d_itimer = 0;
1476 ddq->d_rtbtimer = 0;
1477 ddq->d_bwarns = 0;
1478 ddq->d_iwarns = 0;
1479 ddq->d_rtbwarns = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);
1481 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482}
1483
1484STATIC int
1485xfs_qm_dqiter_bufs(
1486 xfs_mount_t *mp,
1487 xfs_dqid_t firstid,
1488 xfs_fsblock_t bno,
1489 xfs_filblks_t blkcnt,
1490 uint flags)
1491{
1492 xfs_buf_t *bp;
1493 int error;
1494 int notcommitted;
1495 int incr;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001496 int type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497
1498 ASSERT(blkcnt > 0);
1499 notcommitted = 0;
1500 incr = (blkcnt > XFS_QM_MAX_DQCLUSTER_LOGSZ) ?
1501 XFS_QM_MAX_DQCLUSTER_LOGSZ : blkcnt;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001502 type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
1503 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 error = 0;
1505
1506 /*
1507 * Blkcnt arg can be a very big number, and might even be
1508 * larger than the log itself. So, we have to break it up into
1509 * manageable-sized transactions.
1510 * Note that we don't start a permanent transaction here; we might
1511 * not be able to get a log reservation for the whole thing up front,
1512 * and we don't really care to either, because we just discard
1513 * everything if we were to crash in the middle of this loop.
1514 */
1515 while (blkcnt--) {
1516 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1517 XFS_FSB_TO_DADDR(mp, bno),
1518 (int)XFS_QI_DQCHUNKLEN(mp), 0, &bp);
1519 if (error)
1520 break;
1521
David Chinner5b139732008-04-10 12:20:10 +10001522 xfs_qm_reset_dqcounts(mp, bp, firstid, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 xfs_bdwrite(mp, bp);
1524 /*
1525 * goto the next block.
1526 */
1527 bno++;
1528 firstid += XFS_QM_DQPERBLK(mp);
1529 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001530 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531}
1532
1533/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001534 * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 * caller supplied function for every chunk of dquots that we find.
1536 */
1537STATIC int
1538xfs_qm_dqiterate(
1539 xfs_mount_t *mp,
1540 xfs_inode_t *qip,
1541 uint flags)
1542{
1543 xfs_bmbt_irec_t *map;
1544 int i, nmaps; /* number of map entries */
1545 int error; /* return value */
1546 xfs_fileoff_t lblkno;
1547 xfs_filblks_t maxlblkcnt;
1548 xfs_dqid_t firstid;
1549 xfs_fsblock_t rablkno;
1550 xfs_filblks_t rablkcnt;
1551
1552 error = 0;
1553 /*
Nathan Scottc41564b2006-03-29 08:55:14 +10001554 * This looks racy, but we can't keep an inode lock across a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 * trans_reserve. But, this gets called during quotacheck, and that
1556 * happens only at mount time which is single threaded.
1557 */
1558 if (qip->i_d.di_nblocks == 0)
Jesper Juhl014c2542006-01-15 02:37:08 +01001559 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560
1561 map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
1562
1563 lblkno = 0;
1564 maxlblkcnt = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
1565 do {
1566 nmaps = XFS_DQITER_MAP_SIZE;
1567 /*
1568 * We aren't changing the inode itself. Just changing
1569 * some of its data. No new blocks are added here, and
1570 * the inode is never added to the transaction.
1571 */
1572 xfs_ilock(qip, XFS_ILOCK_SHARED);
1573 error = xfs_bmapi(NULL, qip, lblkno,
1574 maxlblkcnt - lblkno,
1575 XFS_BMAPI_METADATA,
1576 NULL,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10001577 0, map, &nmaps, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1579 if (error)
1580 break;
1581
1582 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
1583 for (i = 0; i < nmaps; i++) {
1584 ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
1585 ASSERT(map[i].br_blockcount);
1586
1587
1588 lblkno += map[i].br_blockcount;
1589
1590 if (map[i].br_startblock == HOLESTARTBLOCK)
1591 continue;
1592
1593 firstid = (xfs_dqid_t) map[i].br_startoff *
1594 XFS_QM_DQPERBLK(mp);
1595 /*
1596 * Do a read-ahead on the next extent.
1597 */
1598 if ((i+1 < nmaps) &&
1599 (map[i+1].br_startblock != HOLESTARTBLOCK)) {
1600 rablkcnt = map[i+1].br_blockcount;
1601 rablkno = map[i+1].br_startblock;
1602 while (rablkcnt--) {
1603 xfs_baread(mp->m_ddev_targp,
1604 XFS_FSB_TO_DADDR(mp, rablkno),
1605 (int)XFS_QI_DQCHUNKLEN(mp));
1606 rablkno++;
1607 }
1608 }
1609 /*
1610 * Iterate thru all the blks in the extent and
1611 * reset the counters of all the dquots inside them.
1612 */
1613 if ((error = xfs_qm_dqiter_bufs(mp,
1614 firstid,
1615 map[i].br_startblock,
1616 map[i].br_blockcount,
1617 flags))) {
1618 break;
1619 }
1620 }
1621
1622 if (error)
1623 break;
1624 } while (nmaps > 0);
1625
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001626 kmem_free(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627
Jesper Juhl014c2542006-01-15 02:37:08 +01001628 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629}
1630
1631/*
1632 * Called by dqusage_adjust in doing a quotacheck.
1633 * Given the inode, and a dquot (either USR or GRP, doesn't matter),
1634 * this updates its incore copy as well as the buffer copy. This is
1635 * so that once the quotacheck is done, we can just log all the buffers,
1636 * as opposed to logging numerous updates to individual dquots.
1637 */
1638STATIC void
1639xfs_qm_quotacheck_dqadjust(
1640 xfs_dquot_t *dqp,
1641 xfs_qcnt_t nblks,
1642 xfs_qcnt_t rtblks)
1643{
1644 ASSERT(XFS_DQ_IS_LOCKED(dqp));
1645 xfs_dqtrace_entry(dqp, "QCHECK DQADJUST");
1646 /*
1647 * Adjust the inode count and the block count to reflect this inode's
1648 * resource usage.
1649 */
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001650 be64_add_cpu(&dqp->q_core.d_icount, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 dqp->q_res_icount++;
1652 if (nblks) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001653 be64_add_cpu(&dqp->q_core.d_bcount, nblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 dqp->q_res_bcount += nblks;
1655 }
1656 if (rtblks) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001657 be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 dqp->q_res_rtbcount += rtblks;
1659 }
1660
1661 /*
1662 * Set default limits, adjust timers (since we changed usages)
1663 */
1664 if (! XFS_IS_SUSER_DQUOT(dqp)) {
1665 xfs_qm_adjust_dqlimits(dqp->q_mount, &dqp->q_core);
1666 xfs_qm_adjust_dqtimers(dqp->q_mount, &dqp->q_core);
1667 }
1668
1669 dqp->dq_flags |= XFS_DQ_DIRTY;
1670}
1671
1672STATIC int
1673xfs_qm_get_rtblks(
1674 xfs_inode_t *ip,
1675 xfs_qcnt_t *O_rtblks)
1676{
1677 xfs_filblks_t rtblks; /* total rt blks */
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11001678 xfs_extnum_t idx; /* extent record index */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 xfs_ifork_t *ifp; /* inode fork pointer */
1680 xfs_extnum_t nextents; /* number of extent entries */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 int error;
1682
1683 ASSERT(XFS_IS_REALTIME_INODE(ip));
1684 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1685 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1686 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
Jesper Juhl014c2542006-01-15 02:37:08 +01001687 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 }
1689 rtblks = 0;
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11001690 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10001691 for (idx = 0; idx < nextents; idx++)
1692 rtblks += xfs_bmbt_get_blockcount(xfs_iext_get_ext(ifp, idx));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 *O_rtblks = (xfs_qcnt_t)rtblks;
Jesper Juhl014c2542006-01-15 02:37:08 +01001694 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695}
1696
1697/*
1698 * callback routine supplied to bulkstat(). Given an inumber, find its
1699 * dquots and update them to account for resources taken by that inode.
1700 */
1701/* ARGSUSED */
1702STATIC int
1703xfs_qm_dqusage_adjust(
1704 xfs_mount_t *mp, /* mount point for filesystem */
1705 xfs_ino_t ino, /* inode number to get data for */
1706 void __user *buffer, /* not used */
1707 int ubsize, /* not used */
1708 void *private_data, /* not used */
1709 xfs_daddr_t bno, /* starting block of inode cluster */
1710 int *ubused, /* not used */
1711 void *dip, /* on-disk inode pointer (not used) */
1712 int *res) /* result code value */
1713{
1714 xfs_inode_t *ip;
1715 xfs_dquot_t *udqp, *gdqp;
1716 xfs_qcnt_t nblks, rtblks;
1717 int error;
1718
1719 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1720
1721 /*
1722 * rootino must have its resources accounted for, not so with the quota
1723 * inodes.
1724 */
1725 if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1726 *res = BULKSTAT_RV_NOTHING;
1727 return XFS_ERROR(EINVAL);
1728 }
1729
1730 /*
1731 * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget
1732 * interface expects the inode to be exclusively locked because that's
1733 * the case in all other instances. It's OK that we do this because
1734 * quotacheck is done only at mount time.
1735 */
1736 if ((error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip, bno))) {
1737 *res = BULKSTAT_RV_NOTHING;
Jesper Juhl014c2542006-01-15 02:37:08 +01001738 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 }
1740
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 /*
1742 * Obtain the locked dquots. In case of an error (eg. allocation
1743 * fails for ENOSPC), we return the negative of the error number
1744 * to bulkstat, so that it can get propagated to quotacheck() and
1745 * making us disable quotas for the file system.
1746 */
1747 if ((error = xfs_qm_dqget_noattach(ip, &udqp, &gdqp))) {
1748 xfs_iput(ip, XFS_ILOCK_EXCL);
1749 *res = BULKSTAT_RV_GIVEUP;
Jesper Juhl014c2542006-01-15 02:37:08 +01001750 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 }
1752
1753 rtblks = 0;
1754 if (! XFS_IS_REALTIME_INODE(ip)) {
1755 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks;
1756 } else {
1757 /*
1758 * Walk thru the extent list and count the realtime blocks.
1759 */
1760 if ((error = xfs_qm_get_rtblks(ip, &rtblks))) {
1761 xfs_iput(ip, XFS_ILOCK_EXCL);
1762 if (udqp)
1763 xfs_qm_dqput(udqp);
1764 if (gdqp)
1765 xfs_qm_dqput(gdqp);
1766 *res = BULKSTAT_RV_GIVEUP;
Jesper Juhl014c2542006-01-15 02:37:08 +01001767 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 }
1769 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
1770 }
1771 ASSERT(ip->i_delayed_blks == 0);
1772
1773 /*
1774 * We can't release the inode while holding its dquot locks.
1775 * The inode can go into inactive and might try to acquire the dquotlocks.
1776 * So, just unlock here and do a vn_rele at the end.
1777 */
1778 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1779
1780 /*
1781 * Add the (disk blocks and inode) resources occupied by this
1782 * inode to its dquots. We do this adjustment in the incore dquot,
1783 * and also copy the changes to its buffer.
1784 * We don't care about putting these changes in a transaction
1785 * envelope because if we crash in the middle of a 'quotacheck'
1786 * we have to start from the beginning anyway.
1787 * Once we're done, we'll log all the dquot bufs.
1788 *
Nathan Scottc41564b2006-03-29 08:55:14 +10001789 * The *QUOTA_ON checks below may look pretty racy, but quotachecks
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 * and quotaoffs don't race. (Quotachecks happen at mount time only).
1791 */
1792 if (XFS_IS_UQUOTA_ON(mp)) {
1793 ASSERT(udqp);
1794 xfs_qm_quotacheck_dqadjust(udqp, nblks, rtblks);
1795 xfs_qm_dqput(udqp);
1796 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001797 if (XFS_IS_OQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 ASSERT(gdqp);
1799 xfs_qm_quotacheck_dqadjust(gdqp, nblks, rtblks);
1800 xfs_qm_dqput(gdqp);
1801 }
1802 /*
1803 * Now release the inode. This will send it to 'inactive', and
1804 * possibly even free blocks.
1805 */
Christoph Hellwig43355092008-03-27 18:01:08 +11001806 IRELE(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807
1808 /*
1809 * Goto next inode.
1810 */
1811 *res = BULKSTAT_RV_DIDONE;
Jesper Juhl014c2542006-01-15 02:37:08 +01001812 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813}
1814
1815/*
1816 * Walk thru all the filesystem inodes and construct a consistent view
1817 * of the disk quota world. If the quotacheck fails, disable quotas.
1818 */
1819int
1820xfs_qm_quotacheck(
1821 xfs_mount_t *mp)
1822{
1823 int done, count, error;
1824 xfs_ino_t lastino;
1825 size_t structsz;
1826 xfs_inode_t *uip, *gip;
1827 uint flags;
1828
1829 count = INT_MAX;
1830 structsz = 1;
1831 lastino = 0;
1832 flags = 0;
1833
1834 ASSERT(XFS_QI_UQIP(mp) || XFS_QI_GQIP(mp));
1835 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1836
1837 /*
1838 * There should be no cached dquots. The (simplistic) quotacheck
1839 * algorithm doesn't like that.
1840 */
1841 ASSERT(XFS_QI_MPLNDQUOTS(mp) == 0);
1842
1843 cmn_err(CE_NOTE, "XFS quotacheck %s: Please wait.", mp->m_fsname);
1844
1845 /*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001846 * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 * their counters to zero. We need a clean slate.
1848 * We don't log our changes till later.
1849 */
1850 if ((uip = XFS_QI_UQIP(mp))) {
1851 if ((error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA)))
1852 goto error_return;
1853 flags |= XFS_UQUOTA_CHKD;
1854 }
1855
1856 if ((gip = XFS_QI_GQIP(mp))) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001857 if ((error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
1858 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 goto error_return;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001860 flags |= XFS_OQUOTA_CHKD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 }
1862
1863 do {
1864 /*
1865 * Iterate thru all the inodes in the file system,
1866 * adjusting the corresponding dquot counters in core.
1867 */
1868 if ((error = xfs_bulkstat(mp, &lastino, &count,
1869 xfs_qm_dqusage_adjust, NULL,
Nathan Scott9c488762006-06-09 15:29:22 +10001870 structsz, NULL, BULKSTAT_FG_IGET, &done)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 break;
1872
1873 } while (! done);
1874
1875 /*
David Chinner4b8879d2008-04-10 12:20:17 +10001876 * We've made all the changes that we need to make incore.
1877 * Flush them down to disk buffers if everything was updated
1878 * successfully.
1879 */
1880 if (!error)
1881 error = xfs_qm_dqflush_all(mp, XFS_QMOPT_DELWRI);
1882
1883 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 * We can get this error if we couldn't do a dquot allocation inside
1885 * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
1886 * dirty dquots that might be cached, we just want to get rid of them
1887 * and turn quotaoff. The dquots won't be attached to any of the inodes
1888 * at this point (because we intentionally didn't in dqget_noattach).
1889 */
1890 if (error) {
Nathan Scottee2a4f72006-01-11 15:33:36 +11001891 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL | XFS_QMOPT_QUOTAOFF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 goto error_return;
1893 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894
1895 /*
1896 * We didn't log anything, because if we crashed, we'll have to
1897 * start the quotacheck from scratch anyway. However, we must make
1898 * sure that our dquot changes are secure before we put the
1899 * quotacheck'd stamp on the superblock. So, here we do a synchronous
1900 * flush.
1901 */
1902 XFS_bflush(mp->m_ddev_targp);
1903
1904 /*
1905 * If one type of quotas is off, then it will lose its
1906 * quotachecked status, since we won't be doing accounting for
1907 * that type anymore.
1908 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001909 mp->m_qflags &= ~(XFS_OQUOTA_CHKD | XFS_UQUOTA_CHKD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 mp->m_qflags |= flags;
1911
1912 XQM_LIST_PRINT(&(XFS_QI_MPL_LIST(mp)), MPL_NEXT, "++++ Mp list +++");
1913
1914 error_return:
1915 if (error) {
1916 cmn_err(CE_WARN, "XFS quotacheck %s: Unsuccessful (Error %d): "
1917 "Disabling quotas.",
1918 mp->m_fsname, error);
1919 /*
1920 * We must turn off quotas.
1921 */
1922 ASSERT(mp->m_quotainfo != NULL);
1923 ASSERT(xfs_Gqm != NULL);
1924 xfs_qm_destroy_quotainfo(mp);
David Chinner31d55772008-04-10 12:20:38 +10001925 if (xfs_mount_reset_sbqflags(mp)) {
1926 cmn_err(CE_WARN, "XFS quotacheck %s: "
1927 "Failed to reset quota flags.", mp->m_fsname);
1928 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 } else {
1930 cmn_err(CE_NOTE, "XFS quotacheck %s: Done.", mp->m_fsname);
1931 }
1932 return (error);
1933}
1934
1935/*
1936 * This is called after the superblock has been read in and we're ready to
1937 * iget the quota inodes.
1938 */
1939STATIC int
1940xfs_qm_init_quotainos(
1941 xfs_mount_t *mp)
1942{
1943 xfs_inode_t *uip, *gip;
1944 int error;
1945 __int64_t sbflags;
1946 uint flags;
1947
1948 ASSERT(mp->m_quotainfo);
1949 uip = gip = NULL;
1950 sbflags = 0;
1951 flags = 0;
1952
1953 /*
1954 * Get the uquota and gquota inodes
1955 */
Eric Sandeen62118702008-03-06 13:44:28 +11001956 if (xfs_sb_version_hasquota(&mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 if (XFS_IS_UQUOTA_ON(mp) &&
1958 mp->m_sb.sb_uquotino != NULLFSINO) {
1959 ASSERT(mp->m_sb.sb_uquotino > 0);
1960 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
1961 0, 0, &uip, 0)))
1962 return XFS_ERROR(error);
1963 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001964 if (XFS_IS_OQUOTA_ON(mp) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 mp->m_sb.sb_gquotino != NULLFSINO) {
1966 ASSERT(mp->m_sb.sb_gquotino > 0);
1967 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
1968 0, 0, &gip, 0))) {
1969 if (uip)
Christoph Hellwig43355092008-03-27 18:01:08 +11001970 IRELE(uip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 return XFS_ERROR(error);
1972 }
1973 }
1974 } else {
1975 flags |= XFS_QMOPT_SBVERSION;
1976 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1977 XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
1978 }
1979
1980 /*
1981 * Create the two inodes, if they don't exist already. The changes
1982 * made above will get added to a transaction and logged in one of
1983 * the qino_alloc calls below. If the device is readonly,
1984 * temporarily switch to read-write to do this.
1985 */
1986 if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
1987 if ((error = xfs_qm_qino_alloc(mp, &uip,
1988 sbflags | XFS_SB_UQUOTINO,
1989 flags | XFS_QMOPT_UQUOTA)))
1990 return XFS_ERROR(error);
1991
1992 flags &= ~XFS_QMOPT_SBVERSION;
1993 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001994 if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) {
1995 flags |= (XFS_IS_GQUOTA_ON(mp) ?
1996 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
1997 error = xfs_qm_qino_alloc(mp, &gip,
1998 sbflags | XFS_SB_GQUOTINO, flags);
1999 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 if (uip)
Christoph Hellwig43355092008-03-27 18:01:08 +11002001 IRELE(uip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002
2003 return XFS_ERROR(error);
2004 }
2005 }
2006
2007 XFS_QI_UQIP(mp) = uip;
2008 XFS_QI_GQIP(mp) = gip;
2009
Jesper Juhl014c2542006-01-15 02:37:08 +01002010 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011}
2012
2013
2014/*
2015 * Traverse the freelist of dquots and attempt to reclaim a maximum of
2016 * 'howmany' dquots. This operation races with dqlookup(), and attempts to
2017 * favor the lookup function ...
2018 * XXXsup merge this with qm_reclaim_one().
2019 */
2020STATIC int
2021xfs_qm_shake_freelist(
2022 int howmany)
2023{
2024 int nreclaimed;
2025 xfs_dqhash_t *hash;
2026 xfs_dquot_t *dqp, *nextdqp;
2027 int restarts;
2028 int nflushes;
2029
2030 if (howmany <= 0)
Jesper Juhl014c2542006-01-15 02:37:08 +01002031 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032
2033 nreclaimed = 0;
2034 restarts = 0;
2035 nflushes = 0;
2036
2037#ifdef QUOTADEBUG
2038 cmn_err(CE_DEBUG, "Shake free 0x%x", howmany);
2039#endif
2040 /* lock order is : hashchainlock, freelistlock, mplistlock */
2041 tryagain:
2042 xfs_qm_freelist_lock(xfs_Gqm);
2043
2044 for (dqp = xfs_Gqm->qm_dqfreelist.qh_next;
2045 ((dqp != (xfs_dquot_t *) &xfs_Gqm->qm_dqfreelist) &&
2046 nreclaimed < howmany); ) {
2047 xfs_dqlock(dqp);
2048
2049 /*
2050 * We are racing with dqlookup here. Naturally we don't
2051 * want to reclaim a dquot that lookup wants.
2052 */
2053 if (dqp->dq_flags & XFS_DQ_WANT) {
2054 xfs_dqunlock(dqp);
2055 xfs_qm_freelist_unlock(xfs_Gqm);
2056 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
Jesper Juhl014c2542006-01-15 02:37:08 +01002057 return nreclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 XQM_STATS_INC(xqmstats.xs_qm_dqwants);
2059 goto tryagain;
2060 }
2061
2062 /*
2063 * If the dquot is inactive, we are assured that it is
2064 * not on the mplist or the hashlist, and that makes our
2065 * life easier.
2066 */
2067 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
2068 ASSERT(dqp->q_mount == NULL);
2069 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
2070 ASSERT(dqp->HL_PREVP == NULL);
2071 ASSERT(dqp->MPL_PREVP == NULL);
2072 XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
2073 nextdqp = dqp->dq_flnext;
2074 goto off_freelist;
2075 }
2076
2077 ASSERT(dqp->MPL_PREVP);
2078 /*
2079 * Try to grab the flush lock. If this dquot is in the process of
2080 * getting flushed to disk, we don't want to reclaim it.
2081 */
2082 if (! xfs_qm_dqflock_nowait(dqp)) {
2083 xfs_dqunlock(dqp);
2084 dqp = dqp->dq_flnext;
2085 continue;
2086 }
2087
2088 /*
2089 * We have the flush lock so we know that this is not in the
2090 * process of being flushed. So, if this is dirty, flush it
2091 * DELWRI so that we don't get a freelist infested with
2092 * dirty dquots.
2093 */
2094 if (XFS_DQ_IS_DIRTY(dqp)) {
David Chinner3c568362008-04-10 12:20:24 +10002095 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 xfs_dqtrace_entry(dqp, "DQSHAKE: DQDIRTY");
2097 /*
2098 * We flush it delayed write, so don't bother
2099 * releasing the mplock.
2100 */
David Chinner3c568362008-04-10 12:20:24 +10002101 error = xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
2102 if (error) {
2103 xfs_fs_cmn_err(CE_WARN, dqp->q_mount,
2104 "xfs_qm_dqflush_all: dquot %p flush failed", dqp);
2105 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
2107 dqp = dqp->dq_flnext;
2108 continue;
2109 }
2110 /*
2111 * We're trying to get the hashlock out of order. This races
2112 * with dqlookup; so, we giveup and goto the next dquot if
2113 * we couldn't get the hashlock. This way, we won't starve
2114 * a dqlookup process that holds the hashlock that is
2115 * waiting for the freelist lock.
2116 */
2117 if (! xfs_qm_dqhashlock_nowait(dqp)) {
2118 xfs_dqfunlock(dqp);
2119 xfs_dqunlock(dqp);
2120 dqp = dqp->dq_flnext;
2121 continue;
2122 }
2123 /*
2124 * This races with dquot allocation code as well as dqflush_all
2125 * and reclaim code. So, if we failed to grab the mplist lock,
2126 * giveup everything and start over.
2127 */
2128 hash = dqp->q_hash;
2129 ASSERT(hash);
2130 if (! xfs_qm_mplist_nowait(dqp->q_mount)) {
2131 /* XXX put a sentinel so that we can come back here */
2132 xfs_dqfunlock(dqp);
2133 xfs_dqunlock(dqp);
2134 XFS_DQ_HASH_UNLOCK(hash);
2135 xfs_qm_freelist_unlock(xfs_Gqm);
2136 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
Jesper Juhl014c2542006-01-15 02:37:08 +01002137 return nreclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 goto tryagain;
2139 }
2140 xfs_dqtrace_entry(dqp, "DQSHAKE: UNLINKING");
2141#ifdef QUOTADEBUG
2142 cmn_err(CE_DEBUG, "Shake 0x%p, ID 0x%x\n",
Christoph Hellwig1149d962005-11-02 15:01:12 +11002143 dqp, be32_to_cpu(dqp->q_core.d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144#endif
2145 ASSERT(dqp->q_nrefs == 0);
2146 nextdqp = dqp->dq_flnext;
2147 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(dqp->q_mount)), dqp);
2148 XQM_HASHLIST_REMOVE(hash, dqp);
2149 xfs_dqfunlock(dqp);
2150 xfs_qm_mplist_unlock(dqp->q_mount);
2151 XFS_DQ_HASH_UNLOCK(hash);
2152
2153 off_freelist:
2154 XQM_FREELIST_REMOVE(dqp);
2155 xfs_dqunlock(dqp);
2156 nreclaimed++;
2157 XQM_STATS_INC(xqmstats.xs_qm_dqshake_reclaims);
2158 xfs_qm_dqdestroy(dqp);
2159 dqp = nextdqp;
2160 }
2161 xfs_qm_freelist_unlock(xfs_Gqm);
Jesper Juhl014c2542006-01-15 02:37:08 +01002162 return nreclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163}
2164
2165
2166/*
2167 * The kmem_shake interface is invoked when memory is running low.
2168 */
2169/* ARGSUSED */
2170STATIC int
Al Viro51bfb752005-12-15 09:17:24 +00002171xfs_qm_shake(int nr_to_scan, gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172{
2173 int ndqused, nfree, n;
2174
2175 if (!kmem_shake_allow(gfp_mask))
Jesper Juhl014c2542006-01-15 02:37:08 +01002176 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 if (!xfs_Gqm)
Jesper Juhl014c2542006-01-15 02:37:08 +01002178 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179
2180 nfree = xfs_Gqm->qm_dqfreelist.qh_nelems; /* free dquots */
2181 /* incore dquots in all f/s's */
2182 ndqused = atomic_read(&xfs_Gqm->qm_totaldquots) - nfree;
2183
2184 ASSERT(ndqused >= 0);
2185
2186 if (nfree <= ndqused && nfree < ndquot)
Jesper Juhl014c2542006-01-15 02:37:08 +01002187 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188
2189 ndqused *= xfs_Gqm->qm_dqfree_ratio; /* target # of free dquots */
2190 n = nfree - ndqused - ndquot; /* # over target */
2191
2192 return xfs_qm_shake_freelist(MAX(nfree, n));
2193}
2194
2195
2196/*
2197 * Just pop the least recently used dquot off the freelist and
2198 * recycle it. The returned dquot is locked.
2199 */
2200STATIC xfs_dquot_t *
2201xfs_qm_dqreclaim_one(void)
2202{
2203 xfs_dquot_t *dqpout;
2204 xfs_dquot_t *dqp;
2205 int restarts;
2206 int nflushes;
2207
2208 restarts = 0;
2209 dqpout = NULL;
2210 nflushes = 0;
2211
2212 /* lockorder: hashchainlock, freelistlock, mplistlock, dqlock, dqflock */
2213 startagain:
2214 xfs_qm_freelist_lock(xfs_Gqm);
2215
2216 FOREACH_DQUOT_IN_FREELIST(dqp, &(xfs_Gqm->qm_dqfreelist)) {
2217 xfs_dqlock(dqp);
2218
2219 /*
2220 * We are racing with dqlookup here. Naturally we don't
2221 * want to reclaim a dquot that lookup wants. We release the
2222 * freelist lock and start over, so that lookup will grab
2223 * both the dquot and the freelistlock.
2224 */
2225 if (dqp->dq_flags & XFS_DQ_WANT) {
2226 ASSERT(! (dqp->dq_flags & XFS_DQ_INACTIVE));
2227 xfs_dqtrace_entry(dqp, "DQRECLAIM: DQWANT");
2228 xfs_dqunlock(dqp);
2229 xfs_qm_freelist_unlock(xfs_Gqm);
2230 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
Jesper Juhl014c2542006-01-15 02:37:08 +01002231 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 XQM_STATS_INC(xqmstats.xs_qm_dqwants);
2233 goto startagain;
2234 }
2235
2236 /*
2237 * If the dquot is inactive, we are assured that it is
2238 * not on the mplist or the hashlist, and that makes our
2239 * life easier.
2240 */
2241 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
2242 ASSERT(dqp->q_mount == NULL);
2243 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
2244 ASSERT(dqp->HL_PREVP == NULL);
2245 ASSERT(dqp->MPL_PREVP == NULL);
2246 XQM_FREELIST_REMOVE(dqp);
2247 xfs_dqunlock(dqp);
2248 dqpout = dqp;
2249 XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
2250 break;
2251 }
2252
2253 ASSERT(dqp->q_hash);
2254 ASSERT(dqp->MPL_PREVP);
2255
2256 /*
2257 * Try to grab the flush lock. If this dquot is in the process of
2258 * getting flushed to disk, we don't want to reclaim it.
2259 */
2260 if (! xfs_qm_dqflock_nowait(dqp)) {
2261 xfs_dqunlock(dqp);
2262 continue;
2263 }
2264
2265 /*
2266 * We have the flush lock so we know that this is not in the
2267 * process of being flushed. So, if this is dirty, flush it
2268 * DELWRI so that we don't get a freelist infested with
2269 * dirty dquots.
2270 */
2271 if (XFS_DQ_IS_DIRTY(dqp)) {
David Chinner3c568362008-04-10 12:20:24 +10002272 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 xfs_dqtrace_entry(dqp, "DQRECLAIM: DQDIRTY");
2274 /*
2275 * We flush it delayed write, so don't bother
2276 * releasing the freelist lock.
2277 */
David Chinner3c568362008-04-10 12:20:24 +10002278 error = xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
2279 if (error) {
2280 xfs_fs_cmn_err(CE_WARN, dqp->q_mount,
2281 "xfs_qm_dqreclaim: dquot %p flush failed", dqp);
2282 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
2284 continue;
2285 }
2286
2287 if (! xfs_qm_mplist_nowait(dqp->q_mount)) {
2288 xfs_dqfunlock(dqp);
2289 xfs_dqunlock(dqp);
2290 continue;
2291 }
2292
2293 if (! xfs_qm_dqhashlock_nowait(dqp))
2294 goto mplistunlock;
2295
2296 ASSERT(dqp->q_nrefs == 0);
2297 xfs_dqtrace_entry(dqp, "DQRECLAIM: UNLINKING");
2298 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(dqp->q_mount)), dqp);
2299 XQM_HASHLIST_REMOVE(dqp->q_hash, dqp);
2300 XQM_FREELIST_REMOVE(dqp);
2301 dqpout = dqp;
2302 XFS_DQ_HASH_UNLOCK(dqp->q_hash);
2303 mplistunlock:
2304 xfs_qm_mplist_unlock(dqp->q_mount);
2305 xfs_dqfunlock(dqp);
2306 xfs_dqunlock(dqp);
2307 if (dqpout)
2308 break;
2309 }
2310
2311 xfs_qm_freelist_unlock(xfs_Gqm);
Jesper Juhl014c2542006-01-15 02:37:08 +01002312 return dqpout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313}
2314
2315
2316/*------------------------------------------------------------------*/
2317
2318/*
2319 * Return a new incore dquot. Depending on the number of
2320 * dquots in the system, we either allocate a new one on the kernel heap,
2321 * or reclaim a free one.
2322 * Return value is B_TRUE if we allocated a new dquot, B_FALSE if we managed
2323 * to reclaim an existing one from the freelist.
2324 */
2325boolean_t
2326xfs_qm_dqalloc_incore(
2327 xfs_dquot_t **O_dqpp)
2328{
2329 xfs_dquot_t *dqp;
2330
2331 /*
2332 * Check against high water mark to see if we want to pop
2333 * a nincompoop dquot off the freelist.
2334 */
2335 if (atomic_read(&xfs_Gqm->qm_totaldquots) >= ndquot) {
2336 /*
2337 * Try to recycle a dquot from the freelist.
2338 */
2339 if ((dqp = xfs_qm_dqreclaim_one())) {
2340 XQM_STATS_INC(xqmstats.xs_qm_dqreclaims);
2341 /*
2342 * Just zero the core here. The rest will get
2343 * reinitialized by caller. XXX we shouldn't even
2344 * do this zero ...
2345 */
2346 memset(&dqp->q_core, 0, sizeof(dqp->q_core));
2347 *O_dqpp = dqp;
Jesper Juhl014c2542006-01-15 02:37:08 +01002348 return B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 }
2350 XQM_STATS_INC(xqmstats.xs_qm_dqreclaim_misses);
2351 }
2352
2353 /*
2354 * Allocate a brand new dquot on the kernel heap and return it
2355 * to the caller to initialize.
2356 */
2357 ASSERT(xfs_Gqm->qm_dqzone != NULL);
2358 *O_dqpp = kmem_zone_zalloc(xfs_Gqm->qm_dqzone, KM_SLEEP);
2359 atomic_inc(&xfs_Gqm->qm_totaldquots);
2360
Jesper Juhl014c2542006-01-15 02:37:08 +01002361 return B_TRUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362}
2363
2364
2365/*
2366 * Start a transaction and write the incore superblock changes to
2367 * disk. flags parameter indicates which fields have changed.
2368 */
2369int
2370xfs_qm_write_sb_changes(
2371 xfs_mount_t *mp,
2372 __int64_t flags)
2373{
2374 xfs_trans_t *tp;
2375 int error;
2376
2377#ifdef QUOTADEBUG
2378 cmn_err(CE_NOTE, "Writing superblock quota changes :%s", mp->m_fsname);
2379#endif
2380 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
2381 if ((error = xfs_trans_reserve(tp, 0,
2382 mp->m_sb.sb_sectsize + 128, 0,
2383 0,
2384 XFS_DEFAULT_LOG_COUNT))) {
2385 xfs_trans_cancel(tp, 0);
Jesper Juhl014c2542006-01-15 02:37:08 +01002386 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 }
2388
2389 xfs_mod_sb(tp, flags);
David Chinnere5720ee2008-04-10 12:21:18 +10002390 error = xfs_trans_commit(tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391
David Chinnere5720ee2008-04-10 12:21:18 +10002392 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393}
2394
2395
2396/* --------------- utility functions for vnodeops ---------------- */
2397
2398
2399/*
2400 * Given an inode, a uid and gid (from cred_t) make sure that we have
2401 * allocated relevant dquot(s) on disk, and that we won't exceed inode
2402 * quotas by creating this file.
2403 * This also attaches dquot(s) to the given inode after locking it,
2404 * and returns the dquots corresponding to the uid and/or gid.
2405 *
2406 * in : inode (unlocked)
2407 * out : udquot, gdquot with references taken and unlocked
2408 */
2409int
2410xfs_qm_vop_dqalloc(
2411 xfs_mount_t *mp,
2412 xfs_inode_t *ip,
2413 uid_t uid,
2414 gid_t gid,
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002415 prid_t prid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416 uint flags,
2417 xfs_dquot_t **O_udqpp,
2418 xfs_dquot_t **O_gdqpp)
2419{
2420 int error;
2421 xfs_dquot_t *uq, *gq;
2422 uint lockflags;
2423
2424 if (!XFS_IS_QUOTA_ON(mp))
2425 return 0;
2426
2427 lockflags = XFS_ILOCK_EXCL;
2428 xfs_ilock(ip, lockflags);
2429
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10002430 if ((flags & XFS_QMOPT_INHERIT) && XFS_INHERIT_GID(ip))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 gid = ip->i_d.di_gid;
2432
2433 /*
2434 * Attach the dquot(s) to this inode, doing a dquot allocation
2435 * if necessary. The dquot(s) will not be locked.
2436 */
2437 if (XFS_NOT_DQATTACHED(mp, ip)) {
2438 if ((error = xfs_qm_dqattach(ip, XFS_QMOPT_DQALLOC |
2439 XFS_QMOPT_ILOCKED))) {
2440 xfs_iunlock(ip, lockflags);
Jesper Juhl014c2542006-01-15 02:37:08 +01002441 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442 }
2443 }
2444
2445 uq = gq = NULL;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002446 if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447 if (ip->i_d.di_uid != uid) {
2448 /*
2449 * What we need is the dquot that has this uid, and
2450 * if we send the inode to dqget, the uid of the inode
2451 * takes priority over what's sent in the uid argument.
2452 * We must unlock inode here before calling dqget if
2453 * we're not sending the inode, because otherwise
2454 * we'll deadlock by doing trans_reserve while
2455 * holding ilock.
2456 */
2457 xfs_iunlock(ip, lockflags);
2458 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
2459 XFS_DQ_USER,
2460 XFS_QMOPT_DQALLOC |
2461 XFS_QMOPT_DOWARN,
2462 &uq))) {
2463 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01002464 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 }
2466 /*
2467 * Get the ilock in the right order.
2468 */
2469 xfs_dqunlock(uq);
2470 lockflags = XFS_ILOCK_SHARED;
2471 xfs_ilock(ip, lockflags);
2472 } else {
2473 /*
2474 * Take an extra reference, because we'll return
2475 * this to caller
2476 */
2477 ASSERT(ip->i_udquot);
2478 uq = ip->i_udquot;
2479 xfs_dqlock(uq);
2480 XFS_DQHOLD(uq);
2481 xfs_dqunlock(uq);
2482 }
2483 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002484 if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485 if (ip->i_d.di_gid != gid) {
2486 xfs_iunlock(ip, lockflags);
2487 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
2488 XFS_DQ_GROUP,
2489 XFS_QMOPT_DQALLOC |
2490 XFS_QMOPT_DOWARN,
2491 &gq))) {
2492 if (uq)
2493 xfs_qm_dqrele(uq);
2494 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01002495 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 }
2497 xfs_dqunlock(gq);
2498 lockflags = XFS_ILOCK_SHARED;
2499 xfs_ilock(ip, lockflags);
2500 } else {
2501 ASSERT(ip->i_gdquot);
2502 gq = ip->i_gdquot;
2503 xfs_dqlock(gq);
2504 XFS_DQHOLD(gq);
2505 xfs_dqunlock(gq);
2506 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002507 } else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
2508 if (ip->i_d.di_projid != prid) {
2509 xfs_iunlock(ip, lockflags);
2510 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
2511 XFS_DQ_PROJ,
2512 XFS_QMOPT_DQALLOC |
2513 XFS_QMOPT_DOWARN,
2514 &gq))) {
2515 if (uq)
2516 xfs_qm_dqrele(uq);
2517 ASSERT(error != ENOENT);
2518 return (error);
2519 }
2520 xfs_dqunlock(gq);
2521 lockflags = XFS_ILOCK_SHARED;
2522 xfs_ilock(ip, lockflags);
2523 } else {
2524 ASSERT(ip->i_gdquot);
2525 gq = ip->i_gdquot;
2526 xfs_dqlock(gq);
2527 XFS_DQHOLD(gq);
2528 xfs_dqunlock(gq);
2529 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002530 }
2531 if (uq)
2532 xfs_dqtrace_entry_ino(uq, "DQALLOC", ip);
2533
2534 xfs_iunlock(ip, lockflags);
2535 if (O_udqpp)
2536 *O_udqpp = uq;
2537 else if (uq)
2538 xfs_qm_dqrele(uq);
2539 if (O_gdqpp)
2540 *O_gdqpp = gq;
2541 else if (gq)
2542 xfs_qm_dqrele(gq);
Jesper Juhl014c2542006-01-15 02:37:08 +01002543 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544}
2545
2546/*
2547 * Actually transfer ownership, and do dquot modifications.
2548 * These were already reserved.
2549 */
2550xfs_dquot_t *
2551xfs_qm_vop_chown(
2552 xfs_trans_t *tp,
2553 xfs_inode_t *ip,
2554 xfs_dquot_t **IO_olddq,
2555 xfs_dquot_t *newdq)
2556{
2557 xfs_dquot_t *prevdq;
Nathan Scott06d10dd2005-06-21 15:48:47 +10002558 uint bfield = XFS_IS_REALTIME_INODE(ip) ?
2559 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
2560
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10002561 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
2563
2564 /* old dquot */
2565 prevdq = *IO_olddq;
2566 ASSERT(prevdq);
2567 ASSERT(prevdq != newdq);
2568
Nathan Scott06d10dd2005-06-21 15:48:47 +10002569 xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
2570 xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571
2572 /* the sparkling new dquot */
Nathan Scott06d10dd2005-06-21 15:48:47 +10002573 xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
2574 xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575
2576 /*
2577 * Take an extra reference, because the inode
2578 * is going to keep this dquot pointer even
2579 * after the trans_commit.
2580 */
2581 xfs_dqlock(newdq);
2582 XFS_DQHOLD(newdq);
2583 xfs_dqunlock(newdq);
2584 *IO_olddq = newdq;
2585
Jesper Juhl014c2542006-01-15 02:37:08 +01002586 return prevdq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002587}
2588
2589/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002590 * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591 */
2592int
2593xfs_qm_vop_chown_reserve(
2594 xfs_trans_t *tp,
2595 xfs_inode_t *ip,
2596 xfs_dquot_t *udqp,
2597 xfs_dquot_t *gdqp,
2598 uint flags)
2599{
2600 int error;
2601 xfs_mount_t *mp;
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002602 uint delblks, blkflags, prjflags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603 xfs_dquot_t *unresudq, *unresgdq, *delblksudq, *delblksgdq;
2604
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10002605 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606 mp = ip->i_mount;
2607 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2608
2609 delblks = ip->i_delayed_blks;
2610 delblksudq = delblksgdq = unresudq = unresgdq = NULL;
Nathan Scott06d10dd2005-06-21 15:48:47 +10002611 blkflags = XFS_IS_REALTIME_INODE(ip) ?
2612 XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613
2614 if (XFS_IS_UQUOTA_ON(mp) && udqp &&
Christoph Hellwig1149d962005-11-02 15:01:12 +11002615 ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002616 delblksudq = udqp;
2617 /*
2618 * If there are delayed allocation blocks, then we have to
2619 * unreserve those from the old dquot, and add them to the
2620 * new dquot.
2621 */
2622 if (delblks) {
2623 ASSERT(ip->i_udquot);
2624 unresudq = ip->i_udquot;
2625 }
2626 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002627 if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002628 if (XFS_IS_PQUOTA_ON(ip->i_mount) &&
2629 ip->i_d.di_projid != be32_to_cpu(gdqp->q_core.d_id))
2630 prjflags = XFS_QMOPT_ENOSPC;
2631
2632 if (prjflags ||
2633 (XFS_IS_GQUOTA_ON(ip->i_mount) &&
2634 ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002635 delblksgdq = gdqp;
2636 if (delblks) {
2637 ASSERT(ip->i_gdquot);
2638 unresgdq = ip->i_gdquot;
2639 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 }
2641 }
2642
2643 if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
2644 delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002645 flags | blkflags | prjflags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646 return (error);
2647
2648 /*
2649 * Do the delayed blks reservations/unreservations now. Since, these
2650 * are done without the help of a transaction, if a reservation fails
2651 * its previous reservations won't be automatically undone by trans
2652 * code. So, we have to do it manually here.
2653 */
2654 if (delblks) {
2655 /*
2656 * Do the reservations first. Unreservation can't fail.
2657 */
2658 ASSERT(delblksudq || delblksgdq);
2659 ASSERT(unresudq || unresgdq);
2660 if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2661 delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002662 flags | blkflags | prjflags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002663 return (error);
2664 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2665 unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
Nathan Scott06d10dd2005-06-21 15:48:47 +10002666 blkflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 }
2668
2669 return (0);
2670}
2671
2672int
2673xfs_qm_vop_rename_dqattach(
2674 xfs_inode_t **i_tab)
2675{
2676 xfs_inode_t *ip;
2677 int i;
2678 int error;
2679
2680 ip = i_tab[0];
2681
2682 if (! XFS_IS_QUOTA_ON(ip->i_mount))
Jesper Juhl014c2542006-01-15 02:37:08 +01002683 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684
2685 if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
2686 error = xfs_qm_dqattach(ip, 0);
2687 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01002688 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002689 }
2690 for (i = 1; (i < 4 && i_tab[i]); i++) {
2691 /*
2692 * Watch out for duplicate entries in the table.
2693 */
2694 if ((ip = i_tab[i]) != i_tab[i-1]) {
2695 if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
2696 error = xfs_qm_dqattach(ip, 0);
2697 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01002698 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699 }
2700 }
2701 }
Jesper Juhl014c2542006-01-15 02:37:08 +01002702 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703}
2704
2705void
2706xfs_qm_vop_dqattach_and_dqmod_newinode(
2707 xfs_trans_t *tp,
2708 xfs_inode_t *ip,
2709 xfs_dquot_t *udqp,
2710 xfs_dquot_t *gdqp)
2711{
2712 if (!XFS_IS_QUOTA_ON(tp->t_mountp))
2713 return;
2714
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10002715 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716 ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp));
2717
2718 if (udqp) {
2719 xfs_dqlock(udqp);
2720 XFS_DQHOLD(udqp);
2721 xfs_dqunlock(udqp);
2722 ASSERT(ip->i_udquot == NULL);
2723 ip->i_udquot = udqp;
Nathan Scottee2a4f72006-01-11 15:33:36 +11002724 ASSERT(XFS_IS_UQUOTA_ON(tp->t_mountp));
Christoph Hellwig1149d962005-11-02 15:01:12 +11002725 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002726 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
2727 }
2728 if (gdqp) {
2729 xfs_dqlock(gdqp);
2730 XFS_DQHOLD(gdqp);
2731 xfs_dqunlock(gdqp);
2732 ASSERT(ip->i_gdquot == NULL);
2733 ip->i_gdquot = gdqp;
Nathan Scottee2a4f72006-01-11 15:33:36 +11002734 ASSERT(XFS_IS_OQUOTA_ON(tp->t_mountp));
2735 ASSERT((XFS_IS_GQUOTA_ON(tp->t_mountp) ?
2736 ip->i_d.di_gid : ip->i_d.di_projid) ==
2737 be32_to_cpu(gdqp->q_core.d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002738 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
2739 }
2740}
2741
2742/* ------------- list stuff -----------------*/
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002743STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002744xfs_qm_freelist_init(xfs_frlist_t *ql)
2745{
2746 ql->qh_next = ql->qh_prev = (xfs_dquot_t *) ql;
Jes Sorensen794ee1b2006-01-09 15:59:21 -08002747 mutex_init(&ql->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748 ql->qh_version = 0;
2749 ql->qh_nelems = 0;
2750}
2751
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002752STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002753xfs_qm_freelist_destroy(xfs_frlist_t *ql)
2754{
2755 xfs_dquot_t *dqp, *nextdqp;
2756
Jes Sorensen794ee1b2006-01-09 15:59:21 -08002757 mutex_lock(&ql->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758 for (dqp = ql->qh_next;
2759 dqp != (xfs_dquot_t *)ql; ) {
2760 xfs_dqlock(dqp);
2761 nextdqp = dqp->dq_flnext;
2762#ifdef QUOTADEBUG
2763 cmn_err(CE_DEBUG, "FREELIST destroy 0x%p", dqp);
2764#endif
2765 XQM_FREELIST_REMOVE(dqp);
2766 xfs_dqunlock(dqp);
2767 xfs_qm_dqdestroy(dqp);
2768 dqp = nextdqp;
2769 }
Nathan Scott20722a92006-03-14 13:19:08 +11002770 mutex_unlock(&ql->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771 mutex_destroy(&ql->qh_lock);
2772
2773 ASSERT(ql->qh_nelems == 0);
2774}
2775
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002776STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002777xfs_qm_freelist_insert(xfs_frlist_t *ql, xfs_dquot_t *dq)
2778{
2779 dq->dq_flnext = ql->qh_next;
2780 dq->dq_flprev = (xfs_dquot_t *)ql;
2781 ql->qh_next = dq;
2782 dq->dq_flnext->dq_flprev = dq;
2783 xfs_Gqm->qm_dqfreelist.qh_nelems++;
2784 xfs_Gqm->qm_dqfreelist.qh_version++;
2785}
2786
2787void
2788xfs_qm_freelist_unlink(xfs_dquot_t *dq)
2789{
2790 xfs_dquot_t *next = dq->dq_flnext;
2791 xfs_dquot_t *prev = dq->dq_flprev;
2792
2793 next->dq_flprev = prev;
2794 prev->dq_flnext = next;
2795 dq->dq_flnext = dq->dq_flprev = dq;
2796 xfs_Gqm->qm_dqfreelist.qh_nelems--;
2797 xfs_Gqm->qm_dqfreelist.qh_version++;
2798}
2799
2800void
2801xfs_qm_freelist_append(xfs_frlist_t *ql, xfs_dquot_t *dq)
2802{
2803 xfs_qm_freelist_insert((xfs_frlist_t *)ql->qh_prev, dq);
2804}
2805
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002806STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807xfs_qm_dqhashlock_nowait(
2808 xfs_dquot_t *dqp)
2809{
2810 int locked;
2811
2812 locked = mutex_trylock(&((dqp)->q_hash->qh_lock));
Jesper Juhl014c2542006-01-15 02:37:08 +01002813 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814}
2815
2816int
2817xfs_qm_freelist_lock_nowait(
2818 xfs_qm_t *xqm)
2819{
2820 int locked;
2821
2822 locked = mutex_trylock(&(xqm->qm_dqfreelist.qh_lock));
Jesper Juhl014c2542006-01-15 02:37:08 +01002823 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824}
2825
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002826STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827xfs_qm_mplist_nowait(
2828 xfs_mount_t *mp)
2829{
2830 int locked;
2831
2832 ASSERT(mp->m_quotainfo);
2833 locked = mutex_trylock(&(XFS_QI_MPLLOCK(mp)));
Jesper Juhl014c2542006-01-15 02:37:08 +01002834 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835}