blob: 2d274b23ade51aeebf552cc0f17c81f38b9700ba [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,
123 XFS_QM_HASHSIZE_LOW, XFS_QM_HASHSIZE_HIGH,
124 KM_SLEEP | KM_MAYFAIL | KM_LARGE);
125 gdqhash = kmem_zalloc(hsize, KM_SLEEP | KM_LARGE);
126 hsize /= sizeof(xfs_dqhash_t);
Nathan Scott6b3f6b52005-11-02 15:08:25 +1100127 ndquot = hsize << 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
Nathan Scott6b3f6b52005-11-02 15:08:25 +1100129 xqm = kmem_zalloc(sizeof(xfs_qm_t), KM_SLEEP);
130 xqm->qm_dqhashmask = hsize - 1;
131 xqm->qm_usr_dqhtable = udqhash;
132 xqm->qm_grp_dqhtable = gdqhash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 ASSERT(xqm->qm_usr_dqhtable != NULL);
134 ASSERT(xqm->qm_grp_dqhtable != NULL);
135
136 for (i = 0; i < hsize; i++) {
137 xfs_qm_list_init(&(xqm->qm_usr_dqhtable[i]), "uxdqh", i);
138 xfs_qm_list_init(&(xqm->qm_grp_dqhtable[i]), "gxdqh", i);
139 }
140
141 /*
142 * Freelist of all dquots of all file systems
143 */
144 xfs_qm_freelist_init(&(xqm->qm_dqfreelist));
145
146 /*
147 * dquot zone. we register our own low-memory callback.
148 */
149 if (!qm_dqzone) {
150 xqm->qm_dqzone = kmem_zone_init(sizeof(xfs_dquot_t),
151 "xfs_dquots");
152 qm_dqzone = xqm->qm_dqzone;
153 } else
154 xqm->qm_dqzone = qm_dqzone;
155
Rusty Russell8e1f9362007-07-17 04:03:17 -0700156 register_shrinker(&xfs_qm_shaker);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
158 /*
159 * The t_dqinfo portion of transactions.
160 */
161 if (!qm_dqtrxzone) {
162 xqm->qm_dqtrxzone = kmem_zone_init(sizeof(xfs_dquot_acct_t),
163 "xfs_dqtrx");
164 qm_dqtrxzone = xqm->qm_dqtrxzone;
165 } else
166 xqm->qm_dqtrxzone = qm_dqtrxzone;
167
168 atomic_set(&xqm->qm_totaldquots, 0);
169 xqm->qm_dqfree_ratio = XFS_QM_DQFREE_RATIO;
170 xqm->qm_nrefs = 0;
171#ifdef DEBUG
Nathan Scottc2e81432006-01-16 16:21:34 +1100172 mutex_init(&qcheck_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173#endif
174 return xqm;
175}
176
177/*
178 * Destroy the global quota manager when its reference count goes to zero.
179 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000180STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181xfs_qm_destroy(
182 struct xfs_qm *xqm)
183{
184 int hsize, i;
185
186 ASSERT(xqm != NULL);
187 ASSERT(xqm->qm_nrefs == 0);
Rusty Russell8e1f9362007-07-17 04:03:17 -0700188 unregister_shrinker(&xfs_qm_shaker);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 hsize = xqm->qm_dqhashmask + 1;
190 for (i = 0; i < hsize; i++) {
191 xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));
192 xfs_qm_list_destroy(&(xqm->qm_grp_dqhtable[i]));
193 }
194 kmem_free(xqm->qm_usr_dqhtable, hsize * sizeof(xfs_dqhash_t));
195 kmem_free(xqm->qm_grp_dqhtable, hsize * sizeof(xfs_dqhash_t));
196 xqm->qm_usr_dqhtable = NULL;
197 xqm->qm_grp_dqhtable = NULL;
198 xqm->qm_dqhashmask = 0;
199 xfs_qm_freelist_destroy(&(xqm->qm_dqfreelist));
200#ifdef DEBUG
201 mutex_destroy(&qcheck_lock);
202#endif
203 kmem_free(xqm, sizeof(xfs_qm_t));
204}
205
206/*
207 * Called at mount time to let XQM know that another file system is
208 * starting quotas. This isn't crucial information as the individual mount
209 * structures are pretty independent, but it helps the XQM keep a
210 * global view of what's going on.
211 */
212/* ARGSUSED */
213STATIC int
214xfs_qm_hold_quotafs_ref(
215 struct xfs_mount *mp)
216{
217 /*
218 * Need to lock the xfs_Gqm structure for things like this. For example,
219 * the structure could disappear between the entry to this routine and
220 * a HOLD operation if not locked.
221 */
222 XFS_QM_LOCK(xfs_Gqm);
223
224 if (xfs_Gqm == NULL)
225 xfs_Gqm = xfs_Gqm_init();
226 /*
227 * We can keep a list of all filesystems with quotas mounted for
228 * debugging and statistical purposes, but ...
229 * Just take a reference and get out.
230 */
231 XFS_QM_HOLD(xfs_Gqm);
232 XFS_QM_UNLOCK(xfs_Gqm);
233
234 return 0;
235}
236
237
238/*
239 * Release the reference that a filesystem took at mount time,
240 * so that we know when we need to destroy the entire quota manager.
241 */
242/* ARGSUSED */
243STATIC void
244xfs_qm_rele_quotafs_ref(
245 struct xfs_mount *mp)
246{
247 xfs_dquot_t *dqp, *nextdqp;
248
249 ASSERT(xfs_Gqm);
250 ASSERT(xfs_Gqm->qm_nrefs > 0);
251
252 /*
253 * Go thru the freelist and destroy all inactive dquots.
254 */
255 xfs_qm_freelist_lock(xfs_Gqm);
256
257 for (dqp = xfs_Gqm->qm_dqfreelist.qh_next;
258 dqp != (xfs_dquot_t *)&(xfs_Gqm->qm_dqfreelist); ) {
259 xfs_dqlock(dqp);
260 nextdqp = dqp->dq_flnext;
261 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
262 ASSERT(dqp->q_mount == NULL);
263 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
264 ASSERT(dqp->HL_PREVP == NULL);
265 ASSERT(dqp->MPL_PREVP == NULL);
266 XQM_FREELIST_REMOVE(dqp);
267 xfs_dqunlock(dqp);
268 xfs_qm_dqdestroy(dqp);
269 } else {
270 xfs_dqunlock(dqp);
271 }
272 dqp = nextdqp;
273 }
274 xfs_qm_freelist_unlock(xfs_Gqm);
275
276 /*
277 * Destroy the entire XQM. If somebody mounts with quotaon, this'll
278 * be restarted.
279 */
280 XFS_QM_LOCK(xfs_Gqm);
281 XFS_QM_RELE(xfs_Gqm);
282 if (xfs_Gqm->qm_nrefs == 0) {
283 xfs_qm_destroy(xfs_Gqm);
284 xfs_Gqm = NULL;
285 }
286 XFS_QM_UNLOCK(xfs_Gqm);
287}
288
289/*
290 * This is called at mount time from xfs_mountfs to initialize the quotainfo
Nathan Scottc41564b2006-03-29 08:55:14 +1000291 * structure and start the global quota manager (xfs_Gqm) if it hasn't done
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 * so already. Note that the superblock has not been read in yet.
293 */
294void
295xfs_qm_mount_quotainit(
296 xfs_mount_t *mp,
297 uint flags)
298{
299 /*
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000300 * User, projects or group quotas has to be on.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000302 ASSERT(flags & (XFSMNT_UQUOTA | XFSMNT_PQUOTA | XFSMNT_GQUOTA));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
304 /*
305 * Initialize the flags in the mount structure. From this point
306 * onwards we look at m_qflags to figure out if quotas's ON/OFF, etc.
307 * Note that we enforce nothing if accounting is off.
308 * ie. XFSMNT_*QUOTA must be ON for XFSMNT_*QUOTAENF.
309 * It isn't necessary to take the quotaoff lock to do this; this is
310 * called from mount.
311 */
312 if (flags & XFSMNT_UQUOTA) {
313 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
314 if (flags & XFSMNT_UQUOTAENF)
315 mp->m_qflags |= XFS_UQUOTA_ENFD;
316 }
317 if (flags & XFSMNT_GQUOTA) {
318 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
319 if (flags & XFSMNT_GQUOTAENF)
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000320 mp->m_qflags |= XFS_OQUOTA_ENFD;
321 } else if (flags & XFSMNT_PQUOTA) {
322 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
323 if (flags & XFSMNT_PQUOTAENF)
324 mp->m_qflags |= XFS_OQUOTA_ENFD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 }
326}
327
328/*
329 * Just destroy the quotainfo structure.
330 */
331void
332xfs_qm_unmount_quotadestroy(
333 xfs_mount_t *mp)
334{
335 if (mp->m_quotainfo)
336 xfs_qm_destroy_quotainfo(mp);
337}
338
339
340/*
341 * This is called from xfs_mountfs to start quotas and initialize all
342 * necessary data structures like quotainfo. This is also responsible for
343 * running a quotacheck as necessary. We are guaranteed that the superblock
344 * is consistently read in at this point.
345 */
346int
347xfs_qm_mount_quotas(
348 xfs_mount_t *mp,
349 int mfsi_flags)
350{
351 unsigned long s;
352 int error = 0;
353 uint sbf;
354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
356 /*
357 * If quotas on realtime volumes is not supported, we disable
358 * quotas immediately.
359 */
360 if (mp->m_sb.sb_rextents) {
361 cmn_err(CE_NOTE,
362 "Cannot turn on quotas for realtime filesystem %s",
363 mp->m_fsname);
364 mp->m_qflags = 0;
365 goto write_changes;
366 }
367
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
Nathan Scott155ffd02005-09-02 16:43:48 +1000369
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 /*
371 * Allocate the quotainfo structure inside the mount struct, and
372 * create quotainode(s), and change/rev superblock if necessary.
373 */
374 if ((error = xfs_qm_init_quotainfo(mp))) {
375 /*
376 * We must turn off quotas.
377 */
378 ASSERT(mp->m_quotainfo == NULL);
379 mp->m_qflags = 0;
380 goto write_changes;
381 }
382 /*
383 * If any of the quotas are not consistent, do a quotacheck.
384 */
385 if (XFS_QM_NEED_QUOTACHECK(mp) &&
386 !(mfsi_flags & XFS_MFSI_NO_QUOTACHECK)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 if ((error = xfs_qm_quotacheck(mp))) {
388 /* Quotacheck has failed and quotas have
389 * been disabled.
390 */
391 return XFS_ERROR(error);
392 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 }
Donald Douwsma646d5bd2007-05-08 13:49:09 +1000394 /*
395 * If one type of quotas is off, then it will lose its
396 * quotachecked status, since we won't be doing accounting for
397 * that type anymore.
398 */
399 if (!XFS_IS_UQUOTA_ON(mp)) {
400 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
401 }
402 if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp))) {
403 mp->m_qflags &= ~XFS_OQUOTA_CHKD;
404 }
Nathan Scott155ffd02005-09-02 16:43:48 +1000405
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 write_changes:
407 /*
408 * We actually don't have to acquire the SB_LOCK at all.
409 * This can only be called from mount, and that's single threaded. XXX
410 */
411 s = XFS_SB_LOCK(mp);
412 sbf = mp->m_sb.sb_qflags;
413 mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
414 XFS_SB_UNLOCK(mp, s);
415
416 if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
417 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
418 /*
419 * We could only have been turning quotas off.
420 * We aren't in very good shape actually because
421 * the incore structures are convinced that quotas are
422 * off, but the on disk superblock doesn't know that !
423 */
424 ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
425 xfs_fs_cmn_err(CE_ALERT, mp,
426 "XFS mount_quotas: Superblock update failed!");
427 }
428 }
429
430 if (error) {
431 xfs_fs_cmn_err(CE_WARN, mp,
432 "Failed to initialize disk quotas.");
433 }
434 return XFS_ERROR(error);
435}
436
437/*
438 * Called from the vfsops layer.
439 */
440int
441xfs_qm_unmount_quotas(
442 xfs_mount_t *mp)
443{
444 xfs_inode_t *uqp, *gqp;
445 int error = 0;
446
447 /*
448 * Release the dquots that root inode, et al might be holding,
449 * before we flush quotas and blow away the quotainfo structure.
450 */
451 ASSERT(mp->m_rootip);
452 xfs_qm_dqdetach(mp->m_rootip);
453 if (mp->m_rbmip)
454 xfs_qm_dqdetach(mp->m_rbmip);
455 if (mp->m_rsumip)
456 xfs_qm_dqdetach(mp->m_rsumip);
457
458 /*
459 * Flush out the quota inodes.
460 */
461 uqp = gqp = NULL;
462 if (mp->m_quotainfo) {
463 if ((uqp = mp->m_quotainfo->qi_uquotaip) != NULL) {
464 xfs_ilock(uqp, XFS_ILOCK_EXCL);
465 xfs_iflock(uqp);
466 error = xfs_iflush(uqp, XFS_IFLUSH_SYNC);
467 xfs_iunlock(uqp, XFS_ILOCK_EXCL);
468 if (unlikely(error == EFSCORRUPTED)) {
469 XFS_ERROR_REPORT("xfs_qm_unmount_quotas(1)",
470 XFS_ERRLEVEL_LOW, mp);
471 goto out;
472 }
473 }
474 if ((gqp = mp->m_quotainfo->qi_gquotaip) != NULL) {
475 xfs_ilock(gqp, XFS_ILOCK_EXCL);
476 xfs_iflock(gqp);
477 error = xfs_iflush(gqp, XFS_IFLUSH_SYNC);
478 xfs_iunlock(gqp, XFS_ILOCK_EXCL);
479 if (unlikely(error == EFSCORRUPTED)) {
480 XFS_ERROR_REPORT("xfs_qm_unmount_quotas(2)",
481 XFS_ERRLEVEL_LOW, mp);
482 goto out;
483 }
484 }
485 }
486 if (uqp) {
487 XFS_PURGE_INODE(uqp);
488 mp->m_quotainfo->qi_uquotaip = NULL;
489 }
490 if (gqp) {
491 XFS_PURGE_INODE(gqp);
492 mp->m_quotainfo->qi_gquotaip = NULL;
493 }
494out:
495 return XFS_ERROR(error);
496}
497
498/*
499 * Flush all dquots of the given file system to disk. The dquots are
500 * _not_ purged from memory here, just their data written to disk.
501 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000502STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503xfs_qm_dqflush_all(
504 xfs_mount_t *mp,
505 int flags)
506{
507 int recl;
508 xfs_dquot_t *dqp;
509 int niters;
510 int error;
511
512 if (mp->m_quotainfo == NULL)
Jesper Juhl014c2542006-01-15 02:37:08 +0100513 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 niters = 0;
515again:
516 xfs_qm_mplist_lock(mp);
517 FOREACH_DQUOT_IN_MP(dqp, mp) {
518 xfs_dqlock(dqp);
519 if (! XFS_DQ_IS_DIRTY(dqp)) {
520 xfs_dqunlock(dqp);
521 continue;
522 }
523 xfs_dqtrace_entry(dqp, "FLUSHALL: DQDIRTY");
524 /* XXX a sentinel would be better */
525 recl = XFS_QI_MPLRECLAIMS(mp);
526 if (! xfs_qm_dqflock_nowait(dqp)) {
527 /*
528 * If we can't grab the flush lock then check
529 * to see if the dquot has been flushed delayed
530 * write. If so, grab its buffer and send it
531 * out immediately. We'll be able to acquire
532 * the flush lock when the I/O completes.
533 */
534 xfs_qm_dqflock_pushbuf_wait(dqp);
535 }
536 /*
537 * Let go of the mplist lock. We don't want to hold it
538 * across a disk write.
539 */
540 xfs_qm_mplist_unlock(mp);
541 error = xfs_qm_dqflush(dqp, flags);
542 xfs_dqunlock(dqp);
543 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +0100544 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
546 xfs_qm_mplist_lock(mp);
547 if (recl != XFS_QI_MPLRECLAIMS(mp)) {
548 xfs_qm_mplist_unlock(mp);
549 /* XXX restart limit */
550 goto again;
551 }
552 }
553
554 xfs_qm_mplist_unlock(mp);
555 /* return ! busy */
Jesper Juhl014c2542006-01-15 02:37:08 +0100556 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557}
558/*
559 * Release the group dquot pointers the user dquots may be
560 * carrying around as a hint. mplist is locked on entry and exit.
561 */
562STATIC void
563xfs_qm_detach_gdquots(
564 xfs_mount_t *mp)
565{
566 xfs_dquot_t *dqp, *gdqp;
567 int nrecl;
568
569 again:
570 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
571 dqp = XFS_QI_MPLNEXT(mp);
572 while (dqp) {
573 xfs_dqlock(dqp);
574 if ((gdqp = dqp->q_gdquot)) {
575 xfs_dqlock(gdqp);
576 dqp->q_gdquot = NULL;
577 }
578 xfs_dqunlock(dqp);
579
580 if (gdqp) {
581 /*
582 * Can't hold the mplist lock across a dqput.
583 * XXXmust convert to marker based iterations here.
584 */
585 nrecl = XFS_QI_MPLRECLAIMS(mp);
586 xfs_qm_mplist_unlock(mp);
587 xfs_qm_dqput(gdqp);
588
589 xfs_qm_mplist_lock(mp);
590 if (nrecl != XFS_QI_MPLRECLAIMS(mp))
591 goto again;
592 }
593 dqp = dqp->MPL_NEXT;
594 }
595}
596
597/*
598 * Go through all the incore dquots of this file system and take them
599 * off the mplist and hashlist, if the dquot type matches the dqtype
600 * parameter. This is used when turning off quota accounting for
601 * users and/or groups, as well as when the filesystem is unmounting.
602 */
603STATIC int
604xfs_qm_dqpurge_int(
605 xfs_mount_t *mp,
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000606 uint flags) /* QUOTAOFF/UMOUNTING/UQUOTA/PQUOTA/GQUOTA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607{
608 xfs_dquot_t *dqp;
609 uint dqtype;
610 int nrecl;
611 xfs_dquot_t *nextdqp;
612 int nmisses;
613
614 if (mp->m_quotainfo == NULL)
Jesper Juhl014c2542006-01-15 02:37:08 +0100615 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 dqtype = (flags & XFS_QMOPT_UQUOTA) ? XFS_DQ_USER : 0;
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000618 dqtype |= (flags & XFS_QMOPT_PQUOTA) ? XFS_DQ_PROJ : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 dqtype |= (flags & XFS_QMOPT_GQUOTA) ? XFS_DQ_GROUP : 0;
620
621 xfs_qm_mplist_lock(mp);
622
623 /*
624 * In the first pass through all incore dquots of this filesystem,
625 * we release the group dquot pointers the user dquots may be
626 * carrying around as a hint. We need to do this irrespective of
627 * what's being turned off.
628 */
629 xfs_qm_detach_gdquots(mp);
630
631 again:
632 nmisses = 0;
633 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
634 /*
635 * Try to get rid of all of the unwanted dquots. The idea is to
636 * get them off mplist and hashlist, but leave them on freelist.
637 */
638 dqp = XFS_QI_MPLNEXT(mp);
639 while (dqp) {
640 /*
641 * It's OK to look at the type without taking dqlock here.
642 * We're holding the mplist lock here, and that's needed for
643 * a dqreclaim.
644 */
645 if ((dqp->dq_flags & dqtype) == 0) {
646 dqp = dqp->MPL_NEXT;
647 continue;
648 }
649
650 if (! xfs_qm_dqhashlock_nowait(dqp)) {
651 nrecl = XFS_QI_MPLRECLAIMS(mp);
652 xfs_qm_mplist_unlock(mp);
653 XFS_DQ_HASH_LOCK(dqp->q_hash);
654 xfs_qm_mplist_lock(mp);
655
656 /*
657 * XXXTheoretically, we can get into a very long
658 * ping pong game here.
659 * No one can be adding dquots to the mplist at
660 * this point, but somebody might be taking things off.
661 */
662 if (nrecl != XFS_QI_MPLRECLAIMS(mp)) {
663 XFS_DQ_HASH_UNLOCK(dqp->q_hash);
664 goto again;
665 }
666 }
667
668 /*
669 * Take the dquot off the mplist and hashlist. It may remain on
670 * freelist in INACTIVE state.
671 */
672 nextdqp = dqp->MPL_NEXT;
673 nmisses += xfs_qm_dqpurge(dqp, flags);
674 dqp = nextdqp;
675 }
676 xfs_qm_mplist_unlock(mp);
677 return nmisses;
678}
679
680int
681xfs_qm_dqpurge_all(
682 xfs_mount_t *mp,
683 uint flags)
684{
685 int ndquots;
686
687 /*
688 * Purge the dquot cache.
689 * None of the dquots should really be busy at this point.
690 */
691 if (mp->m_quotainfo) {
692 while ((ndquots = xfs_qm_dqpurge_int(mp, flags))) {
693 delay(ndquots * 10);
694 }
695 }
696 return 0;
697}
698
699STATIC int
700xfs_qm_dqattach_one(
701 xfs_inode_t *ip,
702 xfs_dqid_t id,
703 uint type,
704 uint doalloc,
705 uint dolock,
706 xfs_dquot_t *udqhint, /* hint */
707 xfs_dquot_t **IO_idqpp)
708{
709 xfs_dquot_t *dqp;
710 int error;
711
712 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
713 error = 0;
714 /*
715 * See if we already have it in the inode itself. IO_idqpp is
716 * &i_udquot or &i_gdquot. This made the code look weird, but
717 * made the logic a lot simpler.
718 */
719 if ((dqp = *IO_idqpp)) {
720 if (dolock)
721 xfs_dqlock(dqp);
722 xfs_dqtrace_entry(dqp, "DQATTACH: found in ip");
723 goto done;
724 }
725
726 /*
727 * udqhint is the i_udquot field in inode, and is non-NULL only
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000728 * when the type arg is group/project. Its purpose is to save a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside
730 * the user dquot.
731 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000732 ASSERT(!udqhint || type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 if (udqhint && !dolock)
734 xfs_dqlock(udqhint);
735
736 /*
737 * No need to take dqlock to look at the id.
738 * The ID can't change until it gets reclaimed, and it won't
739 * be reclaimed as long as we have a ref from inode and we hold
740 * the ilock.
741 */
742 if (udqhint &&
743 (dqp = udqhint->q_gdquot) &&
Christoph Hellwig1149d962005-11-02 15:01:12 +1100744 (be32_to_cpu(dqp->q_core.d_id) == id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 ASSERT(XFS_DQ_IS_LOCKED(udqhint));
746 xfs_dqlock(dqp);
747 XFS_DQHOLD(dqp);
748 ASSERT(*IO_idqpp == NULL);
749 *IO_idqpp = dqp;
750 if (!dolock) {
751 xfs_dqunlock(dqp);
752 xfs_dqunlock(udqhint);
753 }
754 goto done;
755 }
756 /*
757 * We can't hold a dquot lock when we call the dqget code.
758 * We'll deadlock in no time, because of (not conforming to)
759 * lock ordering - the inodelock comes before any dquot lock,
760 * and we may drop and reacquire the ilock in xfs_qm_dqget().
761 */
762 if (udqhint)
763 xfs_dqunlock(udqhint);
764 /*
765 * Find the dquot from somewhere. This bumps the
766 * reference count of dquot and returns it locked.
767 * This can return ENOENT if dquot didn't exist on
768 * disk and we didn't ask it to allocate;
769 * ESRCH if quotas got turned off suddenly.
770 */
771 if ((error = xfs_qm_dqget(ip->i_mount, ip, id, type,
772 doalloc|XFS_QMOPT_DOWARN, &dqp))) {
773 if (udqhint && dolock)
774 xfs_dqlock(udqhint);
775 goto done;
776 }
777
778 xfs_dqtrace_entry(dqp, "DQATTACH: found by dqget");
779 /*
780 * dqget may have dropped and re-acquired the ilock, but it guarantees
781 * that the dquot returned is the one that should go in the inode.
782 */
783 *IO_idqpp = dqp;
784 ASSERT(dqp);
785 ASSERT(XFS_DQ_IS_LOCKED(dqp));
786 if (! dolock) {
787 xfs_dqunlock(dqp);
788 goto done;
789 }
790 if (! udqhint)
791 goto done;
792
793 ASSERT(udqhint);
794 ASSERT(dolock);
795 ASSERT(XFS_DQ_IS_LOCKED(dqp));
796 if (! xfs_qm_dqlock_nowait(udqhint)) {
797 xfs_dqunlock(dqp);
798 xfs_dqlock(udqhint);
799 xfs_dqlock(dqp);
800 }
801 done:
802#ifdef QUOTADEBUG
803 if (udqhint) {
804 if (dolock)
805 ASSERT(XFS_DQ_IS_LOCKED(udqhint));
806 }
807 if (! error) {
808 if (dolock)
809 ASSERT(XFS_DQ_IS_LOCKED(dqp));
810 }
811#endif
Jesper Juhl014c2542006-01-15 02:37:08 +0100812 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813}
814
815
816/*
817 * Given a udquot and gdquot, attach a ptr to the group dquot in the
818 * udquot as a hint for future lookups. The idea sounds simple, but the
819 * execution isn't, because the udquot might have a group dquot attached
Nathan Scottc41564b2006-03-29 08:55:14 +1000820 * already and getting rid of that gets us into lock ordering constraints.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 * The process is complicated more by the fact that the dquots may or may not
822 * be locked on entry.
823 */
824STATIC void
825xfs_qm_dqattach_grouphint(
826 xfs_dquot_t *udq,
827 xfs_dquot_t *gdq,
828 uint locked)
829{
830 xfs_dquot_t *tmp;
831
832#ifdef QUOTADEBUG
833 if (locked) {
834 ASSERT(XFS_DQ_IS_LOCKED(udq));
835 ASSERT(XFS_DQ_IS_LOCKED(gdq));
836 }
837#endif
838 if (! locked)
839 xfs_dqlock(udq);
840
841 if ((tmp = udq->q_gdquot)) {
842 if (tmp == gdq) {
843 if (! locked)
844 xfs_dqunlock(udq);
845 return;
846 }
847
848 udq->q_gdquot = NULL;
849 /*
850 * We can't keep any dqlocks when calling dqrele,
851 * because the freelist lock comes before dqlocks.
852 */
853 xfs_dqunlock(udq);
854 if (locked)
855 xfs_dqunlock(gdq);
856 /*
857 * we took a hard reference once upon a time in dqget,
858 * so give it back when the udquot no longer points at it
859 * dqput() does the unlocking of the dquot.
860 */
861 xfs_qm_dqrele(tmp);
862
863 xfs_dqlock(udq);
864 xfs_dqlock(gdq);
865
866 } else {
867 ASSERT(XFS_DQ_IS_LOCKED(udq));
868 if (! locked) {
869 xfs_dqlock(gdq);
870 }
871 }
872
873 ASSERT(XFS_DQ_IS_LOCKED(udq));
874 ASSERT(XFS_DQ_IS_LOCKED(gdq));
875 /*
876 * Somebody could have attached a gdquot here,
877 * when we dropped the uqlock. If so, just do nothing.
878 */
879 if (udq->q_gdquot == NULL) {
880 XFS_DQHOLD(gdq);
881 udq->q_gdquot = gdq;
882 }
883 if (! locked) {
884 xfs_dqunlock(gdq);
885 xfs_dqunlock(udq);
886 }
887}
888
889
890/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000891 * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
892 * into account.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed.
894 * If XFS_QMOPT_DQLOCK, the dquot(s) will be returned locked. This option pretty
895 * much made this code a complete mess, but it has been pretty useful.
896 * If XFS_QMOPT_ILOCKED, then inode sent is already locked EXCL.
897 * Inode may get unlocked and relocked in here, and the caller must deal with
898 * the consequences.
899 */
900int
901xfs_qm_dqattach(
902 xfs_inode_t *ip,
903 uint flags)
904{
905 xfs_mount_t *mp = ip->i_mount;
906 uint nquotas = 0;
907 int error = 0;
908
909 if ((! XFS_IS_QUOTA_ON(mp)) ||
910 (! XFS_NOT_DQATTACHED(mp, ip)) ||
911 (ip->i_ino == mp->m_sb.sb_uquotino) ||
912 (ip->i_ino == mp->m_sb.sb_gquotino))
Jesper Juhl014c2542006-01-15 02:37:08 +0100913 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914
915 ASSERT((flags & XFS_QMOPT_ILOCKED) == 0 ||
916 XFS_ISLOCKED_INODE_EXCL(ip));
917
918 if (! (flags & XFS_QMOPT_ILOCKED))
919 xfs_ilock(ip, XFS_ILOCK_EXCL);
920
921 if (XFS_IS_UQUOTA_ON(mp)) {
922 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
923 flags & XFS_QMOPT_DQALLOC,
924 flags & XFS_QMOPT_DQLOCK,
925 NULL, &ip->i_udquot);
926 if (error)
927 goto done;
928 nquotas++;
929 }
930 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000931 if (XFS_IS_OQUOTA_ON(mp)) {
932 error = XFS_IS_GQUOTA_ON(mp) ?
933 xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
934 flags & XFS_QMOPT_DQALLOC,
935 flags & XFS_QMOPT_DQLOCK,
936 ip->i_udquot, &ip->i_gdquot) :
937 xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQ_PROJ,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 flags & XFS_QMOPT_DQALLOC,
939 flags & XFS_QMOPT_DQLOCK,
940 ip->i_udquot, &ip->i_gdquot);
941 /*
942 * Don't worry about the udquot that we may have
943 * attached above. It'll get detached, if not already.
944 */
945 if (error)
946 goto done;
947 nquotas++;
948 }
949
950 /*
951 * Attach this group quota to the user quota as a hint.
952 * This WON'T, in general, result in a thrash.
953 */
954 if (nquotas == 2) {
955 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
956 ASSERT(ip->i_udquot);
957 ASSERT(ip->i_gdquot);
958
959 /*
960 * We may or may not have the i_udquot locked at this point,
961 * but this check is OK since we don't depend on the i_gdquot to
962 * be accurate 100% all the time. It is just a hint, and this
963 * will succeed in general.
964 */
965 if (ip->i_udquot->q_gdquot == ip->i_gdquot)
966 goto done;
967 /*
968 * Attach i_gdquot to the gdquot hint inside the i_udquot.
969 */
970 xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot,
971 flags & XFS_QMOPT_DQLOCK);
972 }
973
974 done:
975
976#ifdef QUOTADEBUG
977 if (! error) {
978 if (ip->i_udquot) {
979 if (flags & XFS_QMOPT_DQLOCK)
980 ASSERT(XFS_DQ_IS_LOCKED(ip->i_udquot));
981 }
982 if (ip->i_gdquot) {
983 if (flags & XFS_QMOPT_DQLOCK)
984 ASSERT(XFS_DQ_IS_LOCKED(ip->i_gdquot));
985 }
986 if (XFS_IS_UQUOTA_ON(mp))
987 ASSERT(ip->i_udquot);
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000988 if (XFS_IS_OQUOTA_ON(mp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 ASSERT(ip->i_gdquot);
990 }
991#endif
992
993 if (! (flags & XFS_QMOPT_ILOCKED))
994 xfs_iunlock(ip, XFS_ILOCK_EXCL);
995
996#ifdef QUOTADEBUG
997 else
998 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
999#endif
Jesper Juhl014c2542006-01-15 02:37:08 +01001000 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001}
1002
1003/*
1004 * Release dquots (and their references) if any.
1005 * The inode should be locked EXCL except when this's called by
1006 * xfs_ireclaim.
1007 */
1008void
1009xfs_qm_dqdetach(
1010 xfs_inode_t *ip)
1011{
1012 if (!(ip->i_udquot || ip->i_gdquot))
1013 return;
1014
1015 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
1016 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 if (ip->i_udquot) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001018 xfs_dqtrace_entry_ino(ip->i_udquot, "DQDETTACH", ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 xfs_qm_dqrele(ip->i_udquot);
1020 ip->i_udquot = NULL;
1021 }
1022 if (ip->i_gdquot) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001023 xfs_dqtrace_entry_ino(ip->i_gdquot, "DQDETTACH", ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 xfs_qm_dqrele(ip->i_gdquot);
1025 ip->i_gdquot = NULL;
1026 }
1027}
1028
1029/*
1030 * This is called by VFS_SYNC and flags arg determines the caller,
1031 * and its motives, as done in xfs_sync.
1032 *
1033 * vfs_sync: SYNC_FSDATA|SYNC_ATTR|SYNC_BDFLUSH 0x31
1034 * syscall sync: SYNC_FSDATA|SYNC_ATTR|SYNC_DELWRI 0x25
1035 * umountroot : SYNC_WAIT | SYNC_CLOSE | SYNC_ATTR | SYNC_FSDATA
1036 */
1037
1038int
1039xfs_qm_sync(
1040 xfs_mount_t *mp,
1041 short flags)
1042{
1043 int recl, restarts;
1044 xfs_dquot_t *dqp;
1045 uint flush_flags;
1046 boolean_t nowait;
1047 int error;
1048
1049 restarts = 0;
1050 /*
1051 * We won't block unless we are asked to.
1052 */
1053 nowait = (boolean_t)(flags & SYNC_BDFLUSH || (flags & SYNC_WAIT) == 0);
1054
1055 again:
1056 xfs_qm_mplist_lock(mp);
1057 /*
1058 * dqpurge_all() also takes the mplist lock and iterate thru all dquots
1059 * in quotaoff. However, if the QUOTA_ACTIVE bits are not cleared
1060 * when we have the mplist lock, we know that dquots will be consistent
1061 * as long as we have it locked.
1062 */
1063 if (! XFS_IS_QUOTA_ON(mp)) {
1064 xfs_qm_mplist_unlock(mp);
Jesper Juhl014c2542006-01-15 02:37:08 +01001065 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 }
1067 FOREACH_DQUOT_IN_MP(dqp, mp) {
1068 /*
1069 * If this is vfs_sync calling, then skip the dquots that
1070 * don't 'seem' to be dirty. ie. don't acquire dqlock.
1071 * This is very similar to what xfs_sync does with inodes.
1072 */
1073 if (flags & SYNC_BDFLUSH) {
1074 if (! XFS_DQ_IS_DIRTY(dqp))
1075 continue;
1076 }
1077
1078 if (nowait) {
1079 /*
1080 * Try to acquire the dquot lock. We are NOT out of
1081 * lock order, but we just don't want to wait for this
1082 * lock, unless somebody wanted us to.
1083 */
1084 if (! xfs_qm_dqlock_nowait(dqp))
1085 continue;
1086 } else {
1087 xfs_dqlock(dqp);
1088 }
1089
1090 /*
1091 * Now, find out for sure if this dquot is dirty or not.
1092 */
1093 if (! XFS_DQ_IS_DIRTY(dqp)) {
1094 xfs_dqunlock(dqp);
1095 continue;
1096 }
1097
1098 /* XXX a sentinel would be better */
1099 recl = XFS_QI_MPLRECLAIMS(mp);
1100 if (! xfs_qm_dqflock_nowait(dqp)) {
1101 if (nowait) {
1102 xfs_dqunlock(dqp);
1103 continue;
1104 }
1105 /*
1106 * If we can't grab the flush lock then if the caller
Nathan Scottc41564b2006-03-29 08:55:14 +10001107 * really wanted us to give this our best shot, so
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 * see if we can give a push to the buffer before we wait
1109 * on the flush lock. At this point, we know that
Nathan Scottc41564b2006-03-29 08:55:14 +10001110 * even though the dquot is being flushed,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 * it has (new) dirty data.
1112 */
1113 xfs_qm_dqflock_pushbuf_wait(dqp);
1114 }
1115 /*
1116 * Let go of the mplist lock. We don't want to hold it
1117 * across a disk write
1118 */
1119 flush_flags = (nowait) ? XFS_QMOPT_DELWRI : XFS_QMOPT_SYNC;
1120 xfs_qm_mplist_unlock(mp);
1121 xfs_dqtrace_entry(dqp, "XQM_SYNC: DQFLUSH");
1122 error = xfs_qm_dqflush(dqp, flush_flags);
1123 xfs_dqunlock(dqp);
1124 if (error && XFS_FORCED_SHUTDOWN(mp))
Jesper Juhl014c2542006-01-15 02:37:08 +01001125 return 0; /* Need to prevent umount failure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 else if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01001127 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128
1129 xfs_qm_mplist_lock(mp);
1130 if (recl != XFS_QI_MPLRECLAIMS(mp)) {
1131 if (++restarts >= XFS_QM_SYNC_MAX_RESTARTS)
1132 break;
1133
1134 xfs_qm_mplist_unlock(mp);
1135 goto again;
1136 }
1137 }
1138
1139 xfs_qm_mplist_unlock(mp);
Jesper Juhl014c2542006-01-15 02:37:08 +01001140 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141}
1142
1143
1144/*
1145 * This initializes all the quota information that's kept in the
1146 * mount structure
1147 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10001148STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149xfs_qm_init_quotainfo(
1150 xfs_mount_t *mp)
1151{
1152 xfs_quotainfo_t *qinf;
1153 int error;
1154 xfs_dquot_t *dqp;
1155
1156 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1157
1158 /*
1159 * Tell XQM that we exist as soon as possible.
1160 */
1161 if ((error = xfs_qm_hold_quotafs_ref(mp))) {
Jesper Juhl014c2542006-01-15 02:37:08 +01001162 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 }
1164
1165 qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
1166
1167 /*
1168 * See if quotainodes are setup, and if not, allocate them,
1169 * and change the superblock accordingly.
1170 */
1171 if ((error = xfs_qm_init_quotainos(mp))) {
1172 kmem_free(qinf, sizeof(xfs_quotainfo_t));
1173 mp->m_quotainfo = NULL;
Jesper Juhl014c2542006-01-15 02:37:08 +01001174 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 }
1176
1177 spinlock_init(&qinf->qi_pinlock, "xfs_qinf_pin");
1178 xfs_qm_list_init(&qinf->qi_dqlist, "mpdqlist", 0);
1179 qinf->qi_dqreclaims = 0;
1180
1181 /* mutex used to serialize quotaoffs */
Jes Sorensen794ee1b2006-01-09 15:59:21 -08001182 mutex_init(&qinf->qi_quotaofflock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183
1184 /* Precalc some constants */
1185 qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1186 ASSERT(qinf->qi_dqchunklen);
1187 qinf->qi_dqperchunk = BBTOB(qinf->qi_dqchunklen);
1188 do_div(qinf->qi_dqperchunk, sizeof(xfs_dqblk_t));
1189
1190 mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
1191
1192 /*
1193 * We try to get the limits from the superuser's limits fields.
1194 * This is quite hacky, but it is standard quota practice.
1195 * We look at the USR dquot with id == 0 first, but if user quotas
1196 * are not enabled we goto the GRP dquot with id == 0.
1197 * We don't really care to keep separate default limits for user
1198 * and group quotas, at least not at this point.
1199 */
1200 error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)0,
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001201 XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
1202 (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
1203 XFS_DQ_PROJ),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 XFS_QMOPT_DQSUSER|XFS_QMOPT_DOWARN,
1205 &dqp);
1206 if (! error) {
1207 xfs_disk_dquot_t *ddqp = &dqp->q_core;
1208
1209 /*
1210 * The warnings and timers set the grace period given to
1211 * a user or group before he or she can not perform any
1212 * more writing. If it is zero, a default is used.
1213 */
Christoph Hellwig1149d962005-11-02 15:01:12 +11001214 qinf->qi_btimelimit = ddqp->d_btimer ?
1215 be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;
1216 qinf->qi_itimelimit = ddqp->d_itimer ?
1217 be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;
1218 qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?
1219 be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;
1220 qinf->qi_bwarnlimit = ddqp->d_bwarns ?
1221 be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;
1222 qinf->qi_iwarnlimit = ddqp->d_iwarns ?
1223 be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
1224 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
1225 be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
1226 qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
1227 qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
1228 qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
1229 qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
1230 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
1231 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232
1233 /*
1234 * We sent the XFS_QMOPT_DQSUSER flag to dqget because
1235 * we don't want this dquot cached. We haven't done a
1236 * quotacheck yet, and quotacheck doesn't like incore dquots.
1237 */
1238 xfs_qm_dqdestroy(dqp);
1239 } else {
1240 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
1241 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
1242 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
1243 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
1244 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
Nathan Scott06d10dd2005-06-21 15:48:47 +10001245 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 }
1247
Jesper Juhl014c2542006-01-15 02:37:08 +01001248 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249}
1250
1251
1252/*
1253 * Gets called when unmounting a filesystem or when all quotas get
1254 * turned off.
1255 * This purges the quota inodes, destroys locks and frees itself.
1256 */
1257void
1258xfs_qm_destroy_quotainfo(
1259 xfs_mount_t *mp)
1260{
1261 xfs_quotainfo_t *qi;
1262
1263 qi = mp->m_quotainfo;
1264 ASSERT(qi != NULL);
1265 ASSERT(xfs_Gqm != NULL);
1266
1267 /*
1268 * Release the reference that XQM kept, so that we know
1269 * when the XQM structure should be freed. We cannot assume
1270 * that xfs_Gqm is non-null after this point.
1271 */
1272 xfs_qm_rele_quotafs_ref(mp);
1273
1274 spinlock_destroy(&qi->qi_pinlock);
1275 xfs_qm_list_destroy(&qi->qi_dqlist);
1276
1277 if (qi->qi_uquotaip) {
1278 XFS_PURGE_INODE(qi->qi_uquotaip);
1279 qi->qi_uquotaip = NULL; /* paranoia */
1280 }
1281 if (qi->qi_gquotaip) {
1282 XFS_PURGE_INODE(qi->qi_gquotaip);
1283 qi->qi_gquotaip = NULL;
1284 }
1285 mutex_destroy(&qi->qi_quotaofflock);
1286 kmem_free(qi, sizeof(xfs_quotainfo_t));
1287 mp->m_quotainfo = NULL;
1288}
1289
1290
1291
1292/* ------------------- PRIVATE STATIC FUNCTIONS ----------------------- */
1293
1294/* ARGSUSED */
1295STATIC void
1296xfs_qm_list_init(
1297 xfs_dqlist_t *list,
1298 char *str,
1299 int n)
1300{
Jes Sorensen794ee1b2006-01-09 15:59:21 -08001301 mutex_init(&list->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 list->qh_next = NULL;
1303 list->qh_version = 0;
1304 list->qh_nelems = 0;
1305}
1306
1307STATIC void
1308xfs_qm_list_destroy(
1309 xfs_dqlist_t *list)
1310{
1311 mutex_destroy(&(list->qh_lock));
1312}
1313
1314
1315/*
1316 * Stripped down version of dqattach. This doesn't attach, or even look at the
1317 * dquots attached to the inode. The rationale is that there won't be any
1318 * attached at the time this is called from quotacheck.
1319 */
1320STATIC int
1321xfs_qm_dqget_noattach(
1322 xfs_inode_t *ip,
1323 xfs_dquot_t **O_udqpp,
1324 xfs_dquot_t **O_gdqpp)
1325{
1326 int error;
1327 xfs_mount_t *mp;
1328 xfs_dquot_t *udqp, *gdqp;
1329
1330 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
1331 mp = ip->i_mount;
1332 udqp = NULL;
1333 gdqp = NULL;
1334
1335 if (XFS_IS_UQUOTA_ON(mp)) {
1336 ASSERT(ip->i_udquot == NULL);
1337 /*
1338 * We want the dquot allocated if it doesn't exist.
1339 */
1340 if ((error = xfs_qm_dqget(mp, ip, ip->i_d.di_uid, XFS_DQ_USER,
1341 XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN,
1342 &udqp))) {
1343 /*
1344 * Shouldn't be able to turn off quotas here.
1345 */
1346 ASSERT(error != ESRCH);
1347 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01001348 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 }
1350 ASSERT(udqp);
1351 }
1352
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001353 if (XFS_IS_OQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 ASSERT(ip->i_gdquot == NULL);
1355 if (udqp)
1356 xfs_dqunlock(udqp);
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001357 error = XFS_IS_GQUOTA_ON(mp) ?
1358 xfs_qm_dqget(mp, ip,
1359 ip->i_d.di_gid, XFS_DQ_GROUP,
1360 XFS_QMOPT_DQALLOC|XFS_QMOPT_DOWARN,
1361 &gdqp) :
1362 xfs_qm_dqget(mp, ip,
1363 ip->i_d.di_projid, XFS_DQ_PROJ,
1364 XFS_QMOPT_DQALLOC|XFS_QMOPT_DOWARN,
1365 &gdqp);
1366 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 if (udqp)
1368 xfs_qm_dqrele(udqp);
1369 ASSERT(error != ESRCH);
1370 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01001371 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 }
1373 ASSERT(gdqp);
1374
1375 /* Reacquire the locks in the right order */
1376 if (udqp) {
1377 if (! xfs_qm_dqlock_nowait(udqp)) {
1378 xfs_dqunlock(gdqp);
1379 xfs_dqlock(udqp);
1380 xfs_dqlock(gdqp);
1381 }
1382 }
1383 }
1384
1385 *O_udqpp = udqp;
1386 *O_gdqpp = gdqp;
1387
1388#ifdef QUOTADEBUG
1389 if (udqp) ASSERT(XFS_DQ_IS_LOCKED(udqp));
1390 if (gdqp) ASSERT(XFS_DQ_IS_LOCKED(gdqp));
1391#endif
Jesper Juhl014c2542006-01-15 02:37:08 +01001392 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393}
1394
1395/*
1396 * Create an inode and return with a reference already taken, but unlocked
1397 * This is how we create quota inodes
1398 */
1399STATIC int
1400xfs_qm_qino_alloc(
1401 xfs_mount_t *mp,
1402 xfs_inode_t **ip,
1403 __int64_t sbfields,
1404 uint flags)
1405{
1406 xfs_trans_t *tp;
1407 int error;
Nathan Scott061f7202006-01-11 15:27:50 +11001408 unsigned long s;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 int committed;
1410
Nathan Scott061f7202006-01-11 15:27:50 +11001411 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 if ((error = xfs_trans_reserve(tp,
1413 XFS_QM_QINOCREATE_SPACE_RES(mp),
1414 XFS_CREATE_LOG_RES(mp), 0,
1415 XFS_TRANS_PERM_LOG_RES,
1416 XFS_CREATE_LOG_COUNT))) {
1417 xfs_trans_cancel(tp, 0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001418 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
David Chinnerb11f94d2007-07-11 11:09:33 +10001421 if ((error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0,
Nathan Scottdae81d42006-02-28 12:30:13 +11001422 &xfs_zerocr, 0, 1, ip, &committed))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
1424 XFS_TRANS_ABORT);
Jesper Juhl014c2542006-01-15 02:37:08 +01001425 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 }
1427
1428 /*
1429 * Keep an extra reference to this quota inode. This inode is
1430 * locked exclusively and joined to the transaction already.
1431 */
1432 ASSERT(XFS_ISLOCKED_INODE_EXCL(*ip));
1433 VN_HOLD(XFS_ITOV((*ip)));
1434
1435 /*
1436 * Make the changes in the superblock, and log those too.
1437 * sbfields arg may contain fields other than *QUOTINO;
1438 * VERSIONNUM for example.
1439 */
1440 s = XFS_SB_LOCK(mp);
1441 if (flags & XFS_QMOPT_SBVERSION) {
1442#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
1443 unsigned oldv = mp->m_sb.sb_versionnum;
1444#endif
1445 ASSERT(!XFS_SB_VERSION_HASQUOTA(&mp->m_sb));
1446 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1447 XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
1448 (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1449 XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
1450
1451 XFS_SB_VERSION_ADDQUOTA(&mp->m_sb);
1452 mp->m_sb.sb_uquotino = NULLFSINO;
1453 mp->m_sb.sb_gquotino = NULLFSINO;
1454
1455 /* qflags will get updated _after_ quotacheck */
1456 mp->m_sb.sb_qflags = 0;
1457#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
1458 cmn_err(CE_NOTE,
1459 "Old superblock version %x, converting to %x.",
1460 oldv, mp->m_sb.sb_versionnum);
1461#endif
1462 }
1463 if (flags & XFS_QMOPT_UQUOTA)
1464 mp->m_sb.sb_uquotino = (*ip)->i_ino;
1465 else
1466 mp->m_sb.sb_gquotino = (*ip)->i_ino;
1467 XFS_SB_UNLOCK(mp, s);
1468 xfs_mod_sb(tp, sbfields);
1469
Eric Sandeen1c72bf92007-05-08 13:48:42 +10001470 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 xfs_fs_cmn_err(CE_ALERT, mp, "XFS qino_alloc failed!");
Jesper Juhl014c2542006-01-15 02:37:08 +01001472 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001474 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475}
1476
1477
1478STATIC int
1479xfs_qm_reset_dqcounts(
1480 xfs_mount_t *mp,
1481 xfs_buf_t *bp,
1482 xfs_dqid_t id,
1483 uint type)
1484{
1485 xfs_disk_dquot_t *ddq;
1486 int j;
1487
1488 xfs_buftrace("RESET DQUOTS", bp);
1489 /*
1490 * Reset all counters and timers. They'll be
1491 * started afresh by xfs_qm_quotacheck.
1492 */
1493#ifdef DEBUG
1494 j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1495 do_div(j, sizeof(xfs_dqblk_t));
1496 ASSERT(XFS_QM_DQPERBLK(mp) == j);
1497#endif
1498 ddq = (xfs_disk_dquot_t *)XFS_BUF_PTR(bp);
1499 for (j = 0; j < XFS_QM_DQPERBLK(mp); j++) {
1500 /*
1501 * Do a sanity check, and if needed, repair the dqblk. Don't
1502 * output any warnings because it's perfectly possible to
Nathan Scottc41564b2006-03-29 08:55:14 +10001503 * find uninitialised dquot blks. See comment in xfs_qm_dqcheck.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 */
1505 (void) xfs_qm_dqcheck(ddq, id+j, type, XFS_QMOPT_DQREPAIR,
1506 "xfs_quotacheck");
Christoph Hellwig1149d962005-11-02 15:01:12 +11001507 ddq->d_bcount = 0;
1508 ddq->d_icount = 0;
1509 ddq->d_rtbcount = 0;
1510 ddq->d_btimer = 0;
1511 ddq->d_itimer = 0;
1512 ddq->d_rtbtimer = 0;
1513 ddq->d_bwarns = 0;
1514 ddq->d_iwarns = 0;
1515 ddq->d_rtbwarns = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);
1517 }
1518
Jesper Juhl014c2542006-01-15 02:37:08 +01001519 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520}
1521
1522STATIC int
1523xfs_qm_dqiter_bufs(
1524 xfs_mount_t *mp,
1525 xfs_dqid_t firstid,
1526 xfs_fsblock_t bno,
1527 xfs_filblks_t blkcnt,
1528 uint flags)
1529{
1530 xfs_buf_t *bp;
1531 int error;
1532 int notcommitted;
1533 int incr;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001534 int type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535
1536 ASSERT(blkcnt > 0);
1537 notcommitted = 0;
1538 incr = (blkcnt > XFS_QM_MAX_DQCLUSTER_LOGSZ) ?
1539 XFS_QM_MAX_DQCLUSTER_LOGSZ : blkcnt;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001540 type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
1541 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 error = 0;
1543
1544 /*
1545 * Blkcnt arg can be a very big number, and might even be
1546 * larger than the log itself. So, we have to break it up into
1547 * manageable-sized transactions.
1548 * Note that we don't start a permanent transaction here; we might
1549 * not be able to get a log reservation for the whole thing up front,
1550 * and we don't really care to either, because we just discard
1551 * everything if we were to crash in the middle of this loop.
1552 */
1553 while (blkcnt--) {
1554 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1555 XFS_FSB_TO_DADDR(mp, bno),
1556 (int)XFS_QI_DQCHUNKLEN(mp), 0, &bp);
1557 if (error)
1558 break;
1559
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001560 (void) xfs_qm_reset_dqcounts(mp, bp, firstid, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 xfs_bdwrite(mp, bp);
1562 /*
1563 * goto the next block.
1564 */
1565 bno++;
1566 firstid += XFS_QM_DQPERBLK(mp);
1567 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001568 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569}
1570
1571/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001572 * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 * caller supplied function for every chunk of dquots that we find.
1574 */
1575STATIC int
1576xfs_qm_dqiterate(
1577 xfs_mount_t *mp,
1578 xfs_inode_t *qip,
1579 uint flags)
1580{
1581 xfs_bmbt_irec_t *map;
1582 int i, nmaps; /* number of map entries */
1583 int error; /* return value */
1584 xfs_fileoff_t lblkno;
1585 xfs_filblks_t maxlblkcnt;
1586 xfs_dqid_t firstid;
1587 xfs_fsblock_t rablkno;
1588 xfs_filblks_t rablkcnt;
1589
1590 error = 0;
1591 /*
Nathan Scottc41564b2006-03-29 08:55:14 +10001592 * This looks racy, but we can't keep an inode lock across a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 * trans_reserve. But, this gets called during quotacheck, and that
1594 * happens only at mount time which is single threaded.
1595 */
1596 if (qip->i_d.di_nblocks == 0)
Jesper Juhl014c2542006-01-15 02:37:08 +01001597 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598
1599 map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
1600
1601 lblkno = 0;
1602 maxlblkcnt = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
1603 do {
1604 nmaps = XFS_DQITER_MAP_SIZE;
1605 /*
1606 * We aren't changing the inode itself. Just changing
1607 * some of its data. No new blocks are added here, and
1608 * the inode is never added to the transaction.
1609 */
1610 xfs_ilock(qip, XFS_ILOCK_SHARED);
1611 error = xfs_bmapi(NULL, qip, lblkno,
1612 maxlblkcnt - lblkno,
1613 XFS_BMAPI_METADATA,
1614 NULL,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10001615 0, map, &nmaps, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1617 if (error)
1618 break;
1619
1620 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
1621 for (i = 0; i < nmaps; i++) {
1622 ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
1623 ASSERT(map[i].br_blockcount);
1624
1625
1626 lblkno += map[i].br_blockcount;
1627
1628 if (map[i].br_startblock == HOLESTARTBLOCK)
1629 continue;
1630
1631 firstid = (xfs_dqid_t) map[i].br_startoff *
1632 XFS_QM_DQPERBLK(mp);
1633 /*
1634 * Do a read-ahead on the next extent.
1635 */
1636 if ((i+1 < nmaps) &&
1637 (map[i+1].br_startblock != HOLESTARTBLOCK)) {
1638 rablkcnt = map[i+1].br_blockcount;
1639 rablkno = map[i+1].br_startblock;
1640 while (rablkcnt--) {
1641 xfs_baread(mp->m_ddev_targp,
1642 XFS_FSB_TO_DADDR(mp, rablkno),
1643 (int)XFS_QI_DQCHUNKLEN(mp));
1644 rablkno++;
1645 }
1646 }
1647 /*
1648 * Iterate thru all the blks in the extent and
1649 * reset the counters of all the dquots inside them.
1650 */
1651 if ((error = xfs_qm_dqiter_bufs(mp,
1652 firstid,
1653 map[i].br_startblock,
1654 map[i].br_blockcount,
1655 flags))) {
1656 break;
1657 }
1658 }
1659
1660 if (error)
1661 break;
1662 } while (nmaps > 0);
1663
1664 kmem_free(map, XFS_DQITER_MAP_SIZE * sizeof(*map));
1665
Jesper Juhl014c2542006-01-15 02:37:08 +01001666 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667}
1668
1669/*
1670 * Called by dqusage_adjust in doing a quotacheck.
1671 * Given the inode, and a dquot (either USR or GRP, doesn't matter),
1672 * this updates its incore copy as well as the buffer copy. This is
1673 * so that once the quotacheck is done, we can just log all the buffers,
1674 * as opposed to logging numerous updates to individual dquots.
1675 */
1676STATIC void
1677xfs_qm_quotacheck_dqadjust(
1678 xfs_dquot_t *dqp,
1679 xfs_qcnt_t nblks,
1680 xfs_qcnt_t rtblks)
1681{
1682 ASSERT(XFS_DQ_IS_LOCKED(dqp));
1683 xfs_dqtrace_entry(dqp, "QCHECK DQADJUST");
1684 /*
1685 * Adjust the inode count and the block count to reflect this inode's
1686 * resource usage.
1687 */
Christoph Hellwig1149d962005-11-02 15:01:12 +11001688 be64_add(&dqp->q_core.d_icount, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 dqp->q_res_icount++;
1690 if (nblks) {
Christoph Hellwig1149d962005-11-02 15:01:12 +11001691 be64_add(&dqp->q_core.d_bcount, nblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 dqp->q_res_bcount += nblks;
1693 }
1694 if (rtblks) {
Christoph Hellwig1149d962005-11-02 15:01:12 +11001695 be64_add(&dqp->q_core.d_rtbcount, rtblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 dqp->q_res_rtbcount += rtblks;
1697 }
1698
1699 /*
1700 * Set default limits, adjust timers (since we changed usages)
1701 */
1702 if (! XFS_IS_SUSER_DQUOT(dqp)) {
1703 xfs_qm_adjust_dqlimits(dqp->q_mount, &dqp->q_core);
1704 xfs_qm_adjust_dqtimers(dqp->q_mount, &dqp->q_core);
1705 }
1706
1707 dqp->dq_flags |= XFS_DQ_DIRTY;
1708}
1709
1710STATIC int
1711xfs_qm_get_rtblks(
1712 xfs_inode_t *ip,
1713 xfs_qcnt_t *O_rtblks)
1714{
1715 xfs_filblks_t rtblks; /* total rt blks */
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11001716 xfs_extnum_t idx; /* extent record index */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 xfs_ifork_t *ifp; /* inode fork pointer */
1718 xfs_extnum_t nextents; /* number of extent entries */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 xfs_bmbt_rec_t *ep; /* pointer to an extent entry */
1720 int error;
1721
1722 ASSERT(XFS_IS_REALTIME_INODE(ip));
1723 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1724 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1725 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
Jesper Juhl014c2542006-01-15 02:37:08 +01001726 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 }
1728 rtblks = 0;
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11001729 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
1730 for (idx = 0; idx < nextents; idx++) {
1731 ep = xfs_iext_get_ext(ifp, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 rtblks += xfs_bmbt_get_blockcount(ep);
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11001733 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 *O_rtblks = (xfs_qcnt_t)rtblks;
Jesper Juhl014c2542006-01-15 02:37:08 +01001735 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736}
1737
1738/*
1739 * callback routine supplied to bulkstat(). Given an inumber, find its
1740 * dquots and update them to account for resources taken by that inode.
1741 */
1742/* ARGSUSED */
1743STATIC int
1744xfs_qm_dqusage_adjust(
1745 xfs_mount_t *mp, /* mount point for filesystem */
1746 xfs_ino_t ino, /* inode number to get data for */
1747 void __user *buffer, /* not used */
1748 int ubsize, /* not used */
1749 void *private_data, /* not used */
1750 xfs_daddr_t bno, /* starting block of inode cluster */
1751 int *ubused, /* not used */
1752 void *dip, /* on-disk inode pointer (not used) */
1753 int *res) /* result code value */
1754{
1755 xfs_inode_t *ip;
1756 xfs_dquot_t *udqp, *gdqp;
1757 xfs_qcnt_t nblks, rtblks;
1758 int error;
1759
1760 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1761
1762 /*
1763 * rootino must have its resources accounted for, not so with the quota
1764 * inodes.
1765 */
1766 if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1767 *res = BULKSTAT_RV_NOTHING;
1768 return XFS_ERROR(EINVAL);
1769 }
1770
1771 /*
1772 * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget
1773 * interface expects the inode to be exclusively locked because that's
1774 * the case in all other instances. It's OK that we do this because
1775 * quotacheck is done only at mount time.
1776 */
1777 if ((error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip, bno))) {
1778 *res = BULKSTAT_RV_NOTHING;
Jesper Juhl014c2542006-01-15 02:37:08 +01001779 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 }
1781
1782 if (ip->i_d.di_mode == 0) {
1783 xfs_iput_new(ip, XFS_ILOCK_EXCL);
1784 *res = BULKSTAT_RV_NOTHING;
1785 return XFS_ERROR(ENOENT);
1786 }
1787
1788 /*
1789 * Obtain the locked dquots. In case of an error (eg. allocation
1790 * fails for ENOSPC), we return the negative of the error number
1791 * to bulkstat, so that it can get propagated to quotacheck() and
1792 * making us disable quotas for the file system.
1793 */
1794 if ((error = xfs_qm_dqget_noattach(ip, &udqp, &gdqp))) {
1795 xfs_iput(ip, XFS_ILOCK_EXCL);
1796 *res = BULKSTAT_RV_GIVEUP;
Jesper Juhl014c2542006-01-15 02:37:08 +01001797 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 }
1799
1800 rtblks = 0;
1801 if (! XFS_IS_REALTIME_INODE(ip)) {
1802 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks;
1803 } else {
1804 /*
1805 * Walk thru the extent list and count the realtime blocks.
1806 */
1807 if ((error = xfs_qm_get_rtblks(ip, &rtblks))) {
1808 xfs_iput(ip, XFS_ILOCK_EXCL);
1809 if (udqp)
1810 xfs_qm_dqput(udqp);
1811 if (gdqp)
1812 xfs_qm_dqput(gdqp);
1813 *res = BULKSTAT_RV_GIVEUP;
Jesper Juhl014c2542006-01-15 02:37:08 +01001814 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 }
1816 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
1817 }
1818 ASSERT(ip->i_delayed_blks == 0);
1819
1820 /*
1821 * We can't release the inode while holding its dquot locks.
1822 * The inode can go into inactive and might try to acquire the dquotlocks.
1823 * So, just unlock here and do a vn_rele at the end.
1824 */
1825 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1826
1827 /*
1828 * Add the (disk blocks and inode) resources occupied by this
1829 * inode to its dquots. We do this adjustment in the incore dquot,
1830 * and also copy the changes to its buffer.
1831 * We don't care about putting these changes in a transaction
1832 * envelope because if we crash in the middle of a 'quotacheck'
1833 * we have to start from the beginning anyway.
1834 * Once we're done, we'll log all the dquot bufs.
1835 *
Nathan Scottc41564b2006-03-29 08:55:14 +10001836 * The *QUOTA_ON checks below may look pretty racy, but quotachecks
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 * and quotaoffs don't race. (Quotachecks happen at mount time only).
1838 */
1839 if (XFS_IS_UQUOTA_ON(mp)) {
1840 ASSERT(udqp);
1841 xfs_qm_quotacheck_dqadjust(udqp, nblks, rtblks);
1842 xfs_qm_dqput(udqp);
1843 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001844 if (XFS_IS_OQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 ASSERT(gdqp);
1846 xfs_qm_quotacheck_dqadjust(gdqp, nblks, rtblks);
1847 xfs_qm_dqput(gdqp);
1848 }
1849 /*
1850 * Now release the inode. This will send it to 'inactive', and
1851 * possibly even free blocks.
1852 */
1853 VN_RELE(XFS_ITOV(ip));
1854
1855 /*
1856 * Goto next inode.
1857 */
1858 *res = BULKSTAT_RV_DIDONE;
Jesper Juhl014c2542006-01-15 02:37:08 +01001859 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860}
1861
1862/*
1863 * Walk thru all the filesystem inodes and construct a consistent view
1864 * of the disk quota world. If the quotacheck fails, disable quotas.
1865 */
1866int
1867xfs_qm_quotacheck(
1868 xfs_mount_t *mp)
1869{
1870 int done, count, error;
1871 xfs_ino_t lastino;
1872 size_t structsz;
1873 xfs_inode_t *uip, *gip;
1874 uint flags;
1875
1876 count = INT_MAX;
1877 structsz = 1;
1878 lastino = 0;
1879 flags = 0;
1880
1881 ASSERT(XFS_QI_UQIP(mp) || XFS_QI_GQIP(mp));
1882 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1883
1884 /*
1885 * There should be no cached dquots. The (simplistic) quotacheck
1886 * algorithm doesn't like that.
1887 */
1888 ASSERT(XFS_QI_MPLNDQUOTS(mp) == 0);
1889
1890 cmn_err(CE_NOTE, "XFS quotacheck %s: Please wait.", mp->m_fsname);
1891
1892 /*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001893 * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 * their counters to zero. We need a clean slate.
1895 * We don't log our changes till later.
1896 */
1897 if ((uip = XFS_QI_UQIP(mp))) {
1898 if ((error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA)))
1899 goto error_return;
1900 flags |= XFS_UQUOTA_CHKD;
1901 }
1902
1903 if ((gip = XFS_QI_GQIP(mp))) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001904 if ((error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
1905 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 goto error_return;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001907 flags |= XFS_OQUOTA_CHKD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 }
1909
1910 do {
1911 /*
1912 * Iterate thru all the inodes in the file system,
1913 * adjusting the corresponding dquot counters in core.
1914 */
1915 if ((error = xfs_bulkstat(mp, &lastino, &count,
1916 xfs_qm_dqusage_adjust, NULL,
Nathan Scott9c488762006-06-09 15:29:22 +10001917 structsz, NULL, BULKSTAT_FG_IGET, &done)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 break;
1919
1920 } while (! done);
1921
1922 /*
1923 * We can get this error if we couldn't do a dquot allocation inside
1924 * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
1925 * dirty dquots that might be cached, we just want to get rid of them
1926 * and turn quotaoff. The dquots won't be attached to any of the inodes
1927 * at this point (because we intentionally didn't in dqget_noattach).
1928 */
1929 if (error) {
Nathan Scottee2a4f72006-01-11 15:33:36 +11001930 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL | XFS_QMOPT_QUOTAOFF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 goto error_return;
1932 }
1933 /*
1934 * We've made all the changes that we need to make incore.
1935 * Now flush_them down to disk buffers.
1936 */
1937 xfs_qm_dqflush_all(mp, XFS_QMOPT_DELWRI);
1938
1939 /*
1940 * We didn't log anything, because if we crashed, we'll have to
1941 * start the quotacheck from scratch anyway. However, we must make
1942 * sure that our dquot changes are secure before we put the
1943 * quotacheck'd stamp on the superblock. So, here we do a synchronous
1944 * flush.
1945 */
1946 XFS_bflush(mp->m_ddev_targp);
1947
1948 /*
1949 * If one type of quotas is off, then it will lose its
1950 * quotachecked status, since we won't be doing accounting for
1951 * that type anymore.
1952 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001953 mp->m_qflags &= ~(XFS_OQUOTA_CHKD | XFS_UQUOTA_CHKD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 mp->m_qflags |= flags;
1955
1956 XQM_LIST_PRINT(&(XFS_QI_MPL_LIST(mp)), MPL_NEXT, "++++ Mp list +++");
1957
1958 error_return:
1959 if (error) {
1960 cmn_err(CE_WARN, "XFS quotacheck %s: Unsuccessful (Error %d): "
1961 "Disabling quotas.",
1962 mp->m_fsname, error);
1963 /*
1964 * We must turn off quotas.
1965 */
1966 ASSERT(mp->m_quotainfo != NULL);
1967 ASSERT(xfs_Gqm != NULL);
1968 xfs_qm_destroy_quotainfo(mp);
Tim Shimmin4cd4a032005-09-05 08:24:10 +10001969 (void)xfs_mount_reset_sbqflags(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 } else {
1971 cmn_err(CE_NOTE, "XFS quotacheck %s: Done.", mp->m_fsname);
1972 }
1973 return (error);
1974}
1975
1976/*
1977 * This is called after the superblock has been read in and we're ready to
1978 * iget the quota inodes.
1979 */
1980STATIC int
1981xfs_qm_init_quotainos(
1982 xfs_mount_t *mp)
1983{
1984 xfs_inode_t *uip, *gip;
1985 int error;
1986 __int64_t sbflags;
1987 uint flags;
1988
1989 ASSERT(mp->m_quotainfo);
1990 uip = gip = NULL;
1991 sbflags = 0;
1992 flags = 0;
1993
1994 /*
1995 * Get the uquota and gquota inodes
1996 */
1997 if (XFS_SB_VERSION_HASQUOTA(&mp->m_sb)) {
1998 if (XFS_IS_UQUOTA_ON(mp) &&
1999 mp->m_sb.sb_uquotino != NULLFSINO) {
2000 ASSERT(mp->m_sb.sb_uquotino > 0);
2001 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
2002 0, 0, &uip, 0)))
2003 return XFS_ERROR(error);
2004 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002005 if (XFS_IS_OQUOTA_ON(mp) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 mp->m_sb.sb_gquotino != NULLFSINO) {
2007 ASSERT(mp->m_sb.sb_gquotino > 0);
2008 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
2009 0, 0, &gip, 0))) {
2010 if (uip)
2011 VN_RELE(XFS_ITOV(uip));
2012 return XFS_ERROR(error);
2013 }
2014 }
2015 } else {
2016 flags |= XFS_QMOPT_SBVERSION;
2017 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
2018 XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
2019 }
2020
2021 /*
2022 * Create the two inodes, if they don't exist already. The changes
2023 * made above will get added to a transaction and logged in one of
2024 * the qino_alloc calls below. If the device is readonly,
2025 * temporarily switch to read-write to do this.
2026 */
2027 if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
2028 if ((error = xfs_qm_qino_alloc(mp, &uip,
2029 sbflags | XFS_SB_UQUOTINO,
2030 flags | XFS_QMOPT_UQUOTA)))
2031 return XFS_ERROR(error);
2032
2033 flags &= ~XFS_QMOPT_SBVERSION;
2034 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002035 if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) {
2036 flags |= (XFS_IS_GQUOTA_ON(mp) ?
2037 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
2038 error = xfs_qm_qino_alloc(mp, &gip,
2039 sbflags | XFS_SB_GQUOTINO, flags);
2040 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 if (uip)
2042 VN_RELE(XFS_ITOV(uip));
2043
2044 return XFS_ERROR(error);
2045 }
2046 }
2047
2048 XFS_QI_UQIP(mp) = uip;
2049 XFS_QI_GQIP(mp) = gip;
2050
Jesper Juhl014c2542006-01-15 02:37:08 +01002051 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052}
2053
2054
2055/*
2056 * Traverse the freelist of dquots and attempt to reclaim a maximum of
2057 * 'howmany' dquots. This operation races with dqlookup(), and attempts to
2058 * favor the lookup function ...
2059 * XXXsup merge this with qm_reclaim_one().
2060 */
2061STATIC int
2062xfs_qm_shake_freelist(
2063 int howmany)
2064{
2065 int nreclaimed;
2066 xfs_dqhash_t *hash;
2067 xfs_dquot_t *dqp, *nextdqp;
2068 int restarts;
2069 int nflushes;
2070
2071 if (howmany <= 0)
Jesper Juhl014c2542006-01-15 02:37:08 +01002072 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073
2074 nreclaimed = 0;
2075 restarts = 0;
2076 nflushes = 0;
2077
2078#ifdef QUOTADEBUG
2079 cmn_err(CE_DEBUG, "Shake free 0x%x", howmany);
2080#endif
2081 /* lock order is : hashchainlock, freelistlock, mplistlock */
2082 tryagain:
2083 xfs_qm_freelist_lock(xfs_Gqm);
2084
2085 for (dqp = xfs_Gqm->qm_dqfreelist.qh_next;
2086 ((dqp != (xfs_dquot_t *) &xfs_Gqm->qm_dqfreelist) &&
2087 nreclaimed < howmany); ) {
2088 xfs_dqlock(dqp);
2089
2090 /*
2091 * We are racing with dqlookup here. Naturally we don't
2092 * want to reclaim a dquot that lookup wants.
2093 */
2094 if (dqp->dq_flags & XFS_DQ_WANT) {
2095 xfs_dqunlock(dqp);
2096 xfs_qm_freelist_unlock(xfs_Gqm);
2097 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
Jesper Juhl014c2542006-01-15 02:37:08 +01002098 return nreclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 XQM_STATS_INC(xqmstats.xs_qm_dqwants);
2100 goto tryagain;
2101 }
2102
2103 /*
2104 * If the dquot is inactive, we are assured that it is
2105 * not on the mplist or the hashlist, and that makes our
2106 * life easier.
2107 */
2108 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
2109 ASSERT(dqp->q_mount == NULL);
2110 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
2111 ASSERT(dqp->HL_PREVP == NULL);
2112 ASSERT(dqp->MPL_PREVP == NULL);
2113 XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
2114 nextdqp = dqp->dq_flnext;
2115 goto off_freelist;
2116 }
2117
2118 ASSERT(dqp->MPL_PREVP);
2119 /*
2120 * Try to grab the flush lock. If this dquot is in the process of
2121 * getting flushed to disk, we don't want to reclaim it.
2122 */
2123 if (! xfs_qm_dqflock_nowait(dqp)) {
2124 xfs_dqunlock(dqp);
2125 dqp = dqp->dq_flnext;
2126 continue;
2127 }
2128
2129 /*
2130 * We have the flush lock so we know that this is not in the
2131 * process of being flushed. So, if this is dirty, flush it
2132 * DELWRI so that we don't get a freelist infested with
2133 * dirty dquots.
2134 */
2135 if (XFS_DQ_IS_DIRTY(dqp)) {
2136 xfs_dqtrace_entry(dqp, "DQSHAKE: DQDIRTY");
2137 /*
2138 * We flush it delayed write, so don't bother
2139 * releasing the mplock.
2140 */
2141 (void) xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
2142 xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
2143 dqp = dqp->dq_flnext;
2144 continue;
2145 }
2146 /*
2147 * We're trying to get the hashlock out of order. This races
2148 * with dqlookup; so, we giveup and goto the next dquot if
2149 * we couldn't get the hashlock. This way, we won't starve
2150 * a dqlookup process that holds the hashlock that is
2151 * waiting for the freelist lock.
2152 */
2153 if (! xfs_qm_dqhashlock_nowait(dqp)) {
2154 xfs_dqfunlock(dqp);
2155 xfs_dqunlock(dqp);
2156 dqp = dqp->dq_flnext;
2157 continue;
2158 }
2159 /*
2160 * This races with dquot allocation code as well as dqflush_all
2161 * and reclaim code. So, if we failed to grab the mplist lock,
2162 * giveup everything and start over.
2163 */
2164 hash = dqp->q_hash;
2165 ASSERT(hash);
2166 if (! xfs_qm_mplist_nowait(dqp->q_mount)) {
2167 /* XXX put a sentinel so that we can come back here */
2168 xfs_dqfunlock(dqp);
2169 xfs_dqunlock(dqp);
2170 XFS_DQ_HASH_UNLOCK(hash);
2171 xfs_qm_freelist_unlock(xfs_Gqm);
2172 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
Jesper Juhl014c2542006-01-15 02:37:08 +01002173 return nreclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 goto tryagain;
2175 }
2176 xfs_dqtrace_entry(dqp, "DQSHAKE: UNLINKING");
2177#ifdef QUOTADEBUG
2178 cmn_err(CE_DEBUG, "Shake 0x%p, ID 0x%x\n",
Christoph Hellwig1149d962005-11-02 15:01:12 +11002179 dqp, be32_to_cpu(dqp->q_core.d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180#endif
2181 ASSERT(dqp->q_nrefs == 0);
2182 nextdqp = dqp->dq_flnext;
2183 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(dqp->q_mount)), dqp);
2184 XQM_HASHLIST_REMOVE(hash, dqp);
2185 xfs_dqfunlock(dqp);
2186 xfs_qm_mplist_unlock(dqp->q_mount);
2187 XFS_DQ_HASH_UNLOCK(hash);
2188
2189 off_freelist:
2190 XQM_FREELIST_REMOVE(dqp);
2191 xfs_dqunlock(dqp);
2192 nreclaimed++;
2193 XQM_STATS_INC(xqmstats.xs_qm_dqshake_reclaims);
2194 xfs_qm_dqdestroy(dqp);
2195 dqp = nextdqp;
2196 }
2197 xfs_qm_freelist_unlock(xfs_Gqm);
Jesper Juhl014c2542006-01-15 02:37:08 +01002198 return nreclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199}
2200
2201
2202/*
2203 * The kmem_shake interface is invoked when memory is running low.
2204 */
2205/* ARGSUSED */
2206STATIC int
Al Viro51bfb752005-12-15 09:17:24 +00002207xfs_qm_shake(int nr_to_scan, gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208{
2209 int ndqused, nfree, n;
2210
2211 if (!kmem_shake_allow(gfp_mask))
Jesper Juhl014c2542006-01-15 02:37:08 +01002212 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 if (!xfs_Gqm)
Jesper Juhl014c2542006-01-15 02:37:08 +01002214 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215
2216 nfree = xfs_Gqm->qm_dqfreelist.qh_nelems; /* free dquots */
2217 /* incore dquots in all f/s's */
2218 ndqused = atomic_read(&xfs_Gqm->qm_totaldquots) - nfree;
2219
2220 ASSERT(ndqused >= 0);
2221
2222 if (nfree <= ndqused && nfree < ndquot)
Jesper Juhl014c2542006-01-15 02:37:08 +01002223 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224
2225 ndqused *= xfs_Gqm->qm_dqfree_ratio; /* target # of free dquots */
2226 n = nfree - ndqused - ndquot; /* # over target */
2227
2228 return xfs_qm_shake_freelist(MAX(nfree, n));
2229}
2230
2231
2232/*
2233 * Just pop the least recently used dquot off the freelist and
2234 * recycle it. The returned dquot is locked.
2235 */
2236STATIC xfs_dquot_t *
2237xfs_qm_dqreclaim_one(void)
2238{
2239 xfs_dquot_t *dqpout;
2240 xfs_dquot_t *dqp;
2241 int restarts;
2242 int nflushes;
2243
2244 restarts = 0;
2245 dqpout = NULL;
2246 nflushes = 0;
2247
2248 /* lockorder: hashchainlock, freelistlock, mplistlock, dqlock, dqflock */
2249 startagain:
2250 xfs_qm_freelist_lock(xfs_Gqm);
2251
2252 FOREACH_DQUOT_IN_FREELIST(dqp, &(xfs_Gqm->qm_dqfreelist)) {
2253 xfs_dqlock(dqp);
2254
2255 /*
2256 * We are racing with dqlookup here. Naturally we don't
2257 * want to reclaim a dquot that lookup wants. We release the
2258 * freelist lock and start over, so that lookup will grab
2259 * both the dquot and the freelistlock.
2260 */
2261 if (dqp->dq_flags & XFS_DQ_WANT) {
2262 ASSERT(! (dqp->dq_flags & XFS_DQ_INACTIVE));
2263 xfs_dqtrace_entry(dqp, "DQRECLAIM: DQWANT");
2264 xfs_dqunlock(dqp);
2265 xfs_qm_freelist_unlock(xfs_Gqm);
2266 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
Jesper Juhl014c2542006-01-15 02:37:08 +01002267 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268 XQM_STATS_INC(xqmstats.xs_qm_dqwants);
2269 goto startagain;
2270 }
2271
2272 /*
2273 * If the dquot is inactive, we are assured that it is
2274 * not on the mplist or the hashlist, and that makes our
2275 * life easier.
2276 */
2277 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
2278 ASSERT(dqp->q_mount == NULL);
2279 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
2280 ASSERT(dqp->HL_PREVP == NULL);
2281 ASSERT(dqp->MPL_PREVP == NULL);
2282 XQM_FREELIST_REMOVE(dqp);
2283 xfs_dqunlock(dqp);
2284 dqpout = dqp;
2285 XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
2286 break;
2287 }
2288
2289 ASSERT(dqp->q_hash);
2290 ASSERT(dqp->MPL_PREVP);
2291
2292 /*
2293 * Try to grab the flush lock. If this dquot is in the process of
2294 * getting flushed to disk, we don't want to reclaim it.
2295 */
2296 if (! xfs_qm_dqflock_nowait(dqp)) {
2297 xfs_dqunlock(dqp);
2298 continue;
2299 }
2300
2301 /*
2302 * We have the flush lock so we know that this is not in the
2303 * process of being flushed. So, if this is dirty, flush it
2304 * DELWRI so that we don't get a freelist infested with
2305 * dirty dquots.
2306 */
2307 if (XFS_DQ_IS_DIRTY(dqp)) {
2308 xfs_dqtrace_entry(dqp, "DQRECLAIM: DQDIRTY");
2309 /*
2310 * We flush it delayed write, so don't bother
2311 * releasing the freelist lock.
2312 */
2313 (void) xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
2314 xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
2315 continue;
2316 }
2317
2318 if (! xfs_qm_mplist_nowait(dqp->q_mount)) {
2319 xfs_dqfunlock(dqp);
2320 xfs_dqunlock(dqp);
2321 continue;
2322 }
2323
2324 if (! xfs_qm_dqhashlock_nowait(dqp))
2325 goto mplistunlock;
2326
2327 ASSERT(dqp->q_nrefs == 0);
2328 xfs_dqtrace_entry(dqp, "DQRECLAIM: UNLINKING");
2329 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(dqp->q_mount)), dqp);
2330 XQM_HASHLIST_REMOVE(dqp->q_hash, dqp);
2331 XQM_FREELIST_REMOVE(dqp);
2332 dqpout = dqp;
2333 XFS_DQ_HASH_UNLOCK(dqp->q_hash);
2334 mplistunlock:
2335 xfs_qm_mplist_unlock(dqp->q_mount);
2336 xfs_dqfunlock(dqp);
2337 xfs_dqunlock(dqp);
2338 if (dqpout)
2339 break;
2340 }
2341
2342 xfs_qm_freelist_unlock(xfs_Gqm);
Jesper Juhl014c2542006-01-15 02:37:08 +01002343 return dqpout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344}
2345
2346
2347/*------------------------------------------------------------------*/
2348
2349/*
2350 * Return a new incore dquot. Depending on the number of
2351 * dquots in the system, we either allocate a new one on the kernel heap,
2352 * or reclaim a free one.
2353 * Return value is B_TRUE if we allocated a new dquot, B_FALSE if we managed
2354 * to reclaim an existing one from the freelist.
2355 */
2356boolean_t
2357xfs_qm_dqalloc_incore(
2358 xfs_dquot_t **O_dqpp)
2359{
2360 xfs_dquot_t *dqp;
2361
2362 /*
2363 * Check against high water mark to see if we want to pop
2364 * a nincompoop dquot off the freelist.
2365 */
2366 if (atomic_read(&xfs_Gqm->qm_totaldquots) >= ndquot) {
2367 /*
2368 * Try to recycle a dquot from the freelist.
2369 */
2370 if ((dqp = xfs_qm_dqreclaim_one())) {
2371 XQM_STATS_INC(xqmstats.xs_qm_dqreclaims);
2372 /*
2373 * Just zero the core here. The rest will get
2374 * reinitialized by caller. XXX we shouldn't even
2375 * do this zero ...
2376 */
2377 memset(&dqp->q_core, 0, sizeof(dqp->q_core));
2378 *O_dqpp = dqp;
Jesper Juhl014c2542006-01-15 02:37:08 +01002379 return B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 }
2381 XQM_STATS_INC(xqmstats.xs_qm_dqreclaim_misses);
2382 }
2383
2384 /*
2385 * Allocate a brand new dquot on the kernel heap and return it
2386 * to the caller to initialize.
2387 */
2388 ASSERT(xfs_Gqm->qm_dqzone != NULL);
2389 *O_dqpp = kmem_zone_zalloc(xfs_Gqm->qm_dqzone, KM_SLEEP);
2390 atomic_inc(&xfs_Gqm->qm_totaldquots);
2391
Jesper Juhl014c2542006-01-15 02:37:08 +01002392 return B_TRUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393}
2394
2395
2396/*
2397 * Start a transaction and write the incore superblock changes to
2398 * disk. flags parameter indicates which fields have changed.
2399 */
2400int
2401xfs_qm_write_sb_changes(
2402 xfs_mount_t *mp,
2403 __int64_t flags)
2404{
2405 xfs_trans_t *tp;
2406 int error;
2407
2408#ifdef QUOTADEBUG
2409 cmn_err(CE_NOTE, "Writing superblock quota changes :%s", mp->m_fsname);
2410#endif
2411 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
2412 if ((error = xfs_trans_reserve(tp, 0,
2413 mp->m_sb.sb_sectsize + 128, 0,
2414 0,
2415 XFS_DEFAULT_LOG_COUNT))) {
2416 xfs_trans_cancel(tp, 0);
Jesper Juhl014c2542006-01-15 02:37:08 +01002417 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 }
2419
2420 xfs_mod_sb(tp, flags);
Eric Sandeen1c72bf92007-05-08 13:48:42 +10002421 (void) xfs_trans_commit(tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422
Jesper Juhl014c2542006-01-15 02:37:08 +01002423 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424}
2425
2426
2427/* --------------- utility functions for vnodeops ---------------- */
2428
2429
2430/*
2431 * Given an inode, a uid and gid (from cred_t) make sure that we have
2432 * allocated relevant dquot(s) on disk, and that we won't exceed inode
2433 * quotas by creating this file.
2434 * This also attaches dquot(s) to the given inode after locking it,
2435 * and returns the dquots corresponding to the uid and/or gid.
2436 *
2437 * in : inode (unlocked)
2438 * out : udquot, gdquot with references taken and unlocked
2439 */
2440int
2441xfs_qm_vop_dqalloc(
2442 xfs_mount_t *mp,
2443 xfs_inode_t *ip,
2444 uid_t uid,
2445 gid_t gid,
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002446 prid_t prid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447 uint flags,
2448 xfs_dquot_t **O_udqpp,
2449 xfs_dquot_t **O_gdqpp)
2450{
2451 int error;
2452 xfs_dquot_t *uq, *gq;
2453 uint lockflags;
2454
2455 if (!XFS_IS_QUOTA_ON(mp))
2456 return 0;
2457
2458 lockflags = XFS_ILOCK_EXCL;
2459 xfs_ilock(ip, lockflags);
2460
2461 if ((flags & XFS_QMOPT_INHERIT) &&
2462 XFS_INHERIT_GID(ip, XFS_MTOVFS(mp)))
2463 gid = ip->i_d.di_gid;
2464
2465 /*
2466 * Attach the dquot(s) to this inode, doing a dquot allocation
2467 * if necessary. The dquot(s) will not be locked.
2468 */
2469 if (XFS_NOT_DQATTACHED(mp, ip)) {
2470 if ((error = xfs_qm_dqattach(ip, XFS_QMOPT_DQALLOC |
2471 XFS_QMOPT_ILOCKED))) {
2472 xfs_iunlock(ip, lockflags);
Jesper Juhl014c2542006-01-15 02:37:08 +01002473 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474 }
2475 }
2476
2477 uq = gq = NULL;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002478 if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479 if (ip->i_d.di_uid != uid) {
2480 /*
2481 * What we need is the dquot that has this uid, and
2482 * if we send the inode to dqget, the uid of the inode
2483 * takes priority over what's sent in the uid argument.
2484 * We must unlock inode here before calling dqget if
2485 * we're not sending the inode, because otherwise
2486 * we'll deadlock by doing trans_reserve while
2487 * holding ilock.
2488 */
2489 xfs_iunlock(ip, lockflags);
2490 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
2491 XFS_DQ_USER,
2492 XFS_QMOPT_DQALLOC |
2493 XFS_QMOPT_DOWARN,
2494 &uq))) {
2495 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01002496 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497 }
2498 /*
2499 * Get the ilock in the right order.
2500 */
2501 xfs_dqunlock(uq);
2502 lockflags = XFS_ILOCK_SHARED;
2503 xfs_ilock(ip, lockflags);
2504 } else {
2505 /*
2506 * Take an extra reference, because we'll return
2507 * this to caller
2508 */
2509 ASSERT(ip->i_udquot);
2510 uq = ip->i_udquot;
2511 xfs_dqlock(uq);
2512 XFS_DQHOLD(uq);
2513 xfs_dqunlock(uq);
2514 }
2515 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002516 if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517 if (ip->i_d.di_gid != gid) {
2518 xfs_iunlock(ip, lockflags);
2519 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
2520 XFS_DQ_GROUP,
2521 XFS_QMOPT_DQALLOC |
2522 XFS_QMOPT_DOWARN,
2523 &gq))) {
2524 if (uq)
2525 xfs_qm_dqrele(uq);
2526 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01002527 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528 }
2529 xfs_dqunlock(gq);
2530 lockflags = XFS_ILOCK_SHARED;
2531 xfs_ilock(ip, lockflags);
2532 } else {
2533 ASSERT(ip->i_gdquot);
2534 gq = ip->i_gdquot;
2535 xfs_dqlock(gq);
2536 XFS_DQHOLD(gq);
2537 xfs_dqunlock(gq);
2538 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002539 } else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
2540 if (ip->i_d.di_projid != prid) {
2541 xfs_iunlock(ip, lockflags);
2542 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
2543 XFS_DQ_PROJ,
2544 XFS_QMOPT_DQALLOC |
2545 XFS_QMOPT_DOWARN,
2546 &gq))) {
2547 if (uq)
2548 xfs_qm_dqrele(uq);
2549 ASSERT(error != ENOENT);
2550 return (error);
2551 }
2552 xfs_dqunlock(gq);
2553 lockflags = XFS_ILOCK_SHARED;
2554 xfs_ilock(ip, lockflags);
2555 } else {
2556 ASSERT(ip->i_gdquot);
2557 gq = ip->i_gdquot;
2558 xfs_dqlock(gq);
2559 XFS_DQHOLD(gq);
2560 xfs_dqunlock(gq);
2561 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 }
2563 if (uq)
2564 xfs_dqtrace_entry_ino(uq, "DQALLOC", ip);
2565
2566 xfs_iunlock(ip, lockflags);
2567 if (O_udqpp)
2568 *O_udqpp = uq;
2569 else if (uq)
2570 xfs_qm_dqrele(uq);
2571 if (O_gdqpp)
2572 *O_gdqpp = gq;
2573 else if (gq)
2574 xfs_qm_dqrele(gq);
Jesper Juhl014c2542006-01-15 02:37:08 +01002575 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576}
2577
2578/*
2579 * Actually transfer ownership, and do dquot modifications.
2580 * These were already reserved.
2581 */
2582xfs_dquot_t *
2583xfs_qm_vop_chown(
2584 xfs_trans_t *tp,
2585 xfs_inode_t *ip,
2586 xfs_dquot_t **IO_olddq,
2587 xfs_dquot_t *newdq)
2588{
2589 xfs_dquot_t *prevdq;
Nathan Scott06d10dd2005-06-21 15:48:47 +10002590 uint bfield = XFS_IS_REALTIME_INODE(ip) ?
2591 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
2592
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
2594 ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
2595
2596 /* old dquot */
2597 prevdq = *IO_olddq;
2598 ASSERT(prevdq);
2599 ASSERT(prevdq != newdq);
2600
Nathan Scott06d10dd2005-06-21 15:48:47 +10002601 xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
2602 xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603
2604 /* the sparkling new dquot */
Nathan Scott06d10dd2005-06-21 15:48:47 +10002605 xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
2606 xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607
2608 /*
2609 * Take an extra reference, because the inode
2610 * is going to keep this dquot pointer even
2611 * after the trans_commit.
2612 */
2613 xfs_dqlock(newdq);
2614 XFS_DQHOLD(newdq);
2615 xfs_dqunlock(newdq);
2616 *IO_olddq = newdq;
2617
Jesper Juhl014c2542006-01-15 02:37:08 +01002618 return prevdq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619}
2620
2621/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002622 * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623 */
2624int
2625xfs_qm_vop_chown_reserve(
2626 xfs_trans_t *tp,
2627 xfs_inode_t *ip,
2628 xfs_dquot_t *udqp,
2629 xfs_dquot_t *gdqp,
2630 uint flags)
2631{
2632 int error;
2633 xfs_mount_t *mp;
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002634 uint delblks, blkflags, prjflags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635 xfs_dquot_t *unresudq, *unresgdq, *delblksudq, *delblksgdq;
2636
2637 ASSERT(XFS_ISLOCKED_INODE(ip));
2638 mp = ip->i_mount;
2639 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2640
2641 delblks = ip->i_delayed_blks;
2642 delblksudq = delblksgdq = unresudq = unresgdq = NULL;
Nathan Scott06d10dd2005-06-21 15:48:47 +10002643 blkflags = XFS_IS_REALTIME_INODE(ip) ?
2644 XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645
2646 if (XFS_IS_UQUOTA_ON(mp) && udqp &&
Christoph Hellwig1149d962005-11-02 15:01:12 +11002647 ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648 delblksudq = udqp;
2649 /*
2650 * If there are delayed allocation blocks, then we have to
2651 * unreserve those from the old dquot, and add them to the
2652 * new dquot.
2653 */
2654 if (delblks) {
2655 ASSERT(ip->i_udquot);
2656 unresudq = ip->i_udquot;
2657 }
2658 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002659 if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002660 if (XFS_IS_PQUOTA_ON(ip->i_mount) &&
2661 ip->i_d.di_projid != be32_to_cpu(gdqp->q_core.d_id))
2662 prjflags = XFS_QMOPT_ENOSPC;
2663
2664 if (prjflags ||
2665 (XFS_IS_GQUOTA_ON(ip->i_mount) &&
2666 ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002667 delblksgdq = gdqp;
2668 if (delblks) {
2669 ASSERT(ip->i_gdquot);
2670 unresgdq = ip->i_gdquot;
2671 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002672 }
2673 }
2674
2675 if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
2676 delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002677 flags | blkflags | prjflags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678 return (error);
2679
2680 /*
2681 * Do the delayed blks reservations/unreservations now. Since, these
2682 * are done without the help of a transaction, if a reservation fails
2683 * its previous reservations won't be automatically undone by trans
2684 * code. So, we have to do it manually here.
2685 */
2686 if (delblks) {
2687 /*
2688 * Do the reservations first. Unreservation can't fail.
2689 */
2690 ASSERT(delblksudq || delblksgdq);
2691 ASSERT(unresudq || unresgdq);
2692 if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2693 delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002694 flags | blkflags | prjflags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002695 return (error);
2696 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2697 unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
Nathan Scott06d10dd2005-06-21 15:48:47 +10002698 blkflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699 }
2700
2701 return (0);
2702}
2703
2704int
2705xfs_qm_vop_rename_dqattach(
2706 xfs_inode_t **i_tab)
2707{
2708 xfs_inode_t *ip;
2709 int i;
2710 int error;
2711
2712 ip = i_tab[0];
2713
2714 if (! XFS_IS_QUOTA_ON(ip->i_mount))
Jesper Juhl014c2542006-01-15 02:37:08 +01002715 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716
2717 if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
2718 error = xfs_qm_dqattach(ip, 0);
2719 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01002720 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721 }
2722 for (i = 1; (i < 4 && i_tab[i]); i++) {
2723 /*
2724 * Watch out for duplicate entries in the table.
2725 */
2726 if ((ip = i_tab[i]) != i_tab[i-1]) {
2727 if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
2728 error = xfs_qm_dqattach(ip, 0);
2729 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01002730 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731 }
2732 }
2733 }
Jesper Juhl014c2542006-01-15 02:37:08 +01002734 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002735}
2736
2737void
2738xfs_qm_vop_dqattach_and_dqmod_newinode(
2739 xfs_trans_t *tp,
2740 xfs_inode_t *ip,
2741 xfs_dquot_t *udqp,
2742 xfs_dquot_t *gdqp)
2743{
2744 if (!XFS_IS_QUOTA_ON(tp->t_mountp))
2745 return;
2746
2747 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
2748 ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp));
2749
2750 if (udqp) {
2751 xfs_dqlock(udqp);
2752 XFS_DQHOLD(udqp);
2753 xfs_dqunlock(udqp);
2754 ASSERT(ip->i_udquot == NULL);
2755 ip->i_udquot = udqp;
Nathan Scottee2a4f72006-01-11 15:33:36 +11002756 ASSERT(XFS_IS_UQUOTA_ON(tp->t_mountp));
Christoph Hellwig1149d962005-11-02 15:01:12 +11002757 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
2759 }
2760 if (gdqp) {
2761 xfs_dqlock(gdqp);
2762 XFS_DQHOLD(gdqp);
2763 xfs_dqunlock(gdqp);
2764 ASSERT(ip->i_gdquot == NULL);
2765 ip->i_gdquot = gdqp;
Nathan Scottee2a4f72006-01-11 15:33:36 +11002766 ASSERT(XFS_IS_OQUOTA_ON(tp->t_mountp));
2767 ASSERT((XFS_IS_GQUOTA_ON(tp->t_mountp) ?
2768 ip->i_d.di_gid : ip->i_d.di_projid) ==
2769 be32_to_cpu(gdqp->q_core.d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
2771 }
2772}
2773
2774/* ------------- list stuff -----------------*/
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002775STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776xfs_qm_freelist_init(xfs_frlist_t *ql)
2777{
2778 ql->qh_next = ql->qh_prev = (xfs_dquot_t *) ql;
Jes Sorensen794ee1b2006-01-09 15:59:21 -08002779 mutex_init(&ql->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 ql->qh_version = 0;
2781 ql->qh_nelems = 0;
2782}
2783
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002784STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785xfs_qm_freelist_destroy(xfs_frlist_t *ql)
2786{
2787 xfs_dquot_t *dqp, *nextdqp;
2788
Jes Sorensen794ee1b2006-01-09 15:59:21 -08002789 mutex_lock(&ql->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790 for (dqp = ql->qh_next;
2791 dqp != (xfs_dquot_t *)ql; ) {
2792 xfs_dqlock(dqp);
2793 nextdqp = dqp->dq_flnext;
2794#ifdef QUOTADEBUG
2795 cmn_err(CE_DEBUG, "FREELIST destroy 0x%p", dqp);
2796#endif
2797 XQM_FREELIST_REMOVE(dqp);
2798 xfs_dqunlock(dqp);
2799 xfs_qm_dqdestroy(dqp);
2800 dqp = nextdqp;
2801 }
Nathan Scott20722a92006-03-14 13:19:08 +11002802 mutex_unlock(&ql->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803 mutex_destroy(&ql->qh_lock);
2804
2805 ASSERT(ql->qh_nelems == 0);
2806}
2807
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002808STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002809xfs_qm_freelist_insert(xfs_frlist_t *ql, xfs_dquot_t *dq)
2810{
2811 dq->dq_flnext = ql->qh_next;
2812 dq->dq_flprev = (xfs_dquot_t *)ql;
2813 ql->qh_next = dq;
2814 dq->dq_flnext->dq_flprev = dq;
2815 xfs_Gqm->qm_dqfreelist.qh_nelems++;
2816 xfs_Gqm->qm_dqfreelist.qh_version++;
2817}
2818
2819void
2820xfs_qm_freelist_unlink(xfs_dquot_t *dq)
2821{
2822 xfs_dquot_t *next = dq->dq_flnext;
2823 xfs_dquot_t *prev = dq->dq_flprev;
2824
2825 next->dq_flprev = prev;
2826 prev->dq_flnext = next;
2827 dq->dq_flnext = dq->dq_flprev = dq;
2828 xfs_Gqm->qm_dqfreelist.qh_nelems--;
2829 xfs_Gqm->qm_dqfreelist.qh_version++;
2830}
2831
2832void
2833xfs_qm_freelist_append(xfs_frlist_t *ql, xfs_dquot_t *dq)
2834{
2835 xfs_qm_freelist_insert((xfs_frlist_t *)ql->qh_prev, dq);
2836}
2837
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002838STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002839xfs_qm_dqhashlock_nowait(
2840 xfs_dquot_t *dqp)
2841{
2842 int locked;
2843
2844 locked = mutex_trylock(&((dqp)->q_hash->qh_lock));
Jesper Juhl014c2542006-01-15 02:37:08 +01002845 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002846}
2847
2848int
2849xfs_qm_freelist_lock_nowait(
2850 xfs_qm_t *xqm)
2851{
2852 int locked;
2853
2854 locked = mutex_trylock(&(xqm->qm_dqfreelist.qh_lock));
Jesper Juhl014c2542006-01-15 02:37:08 +01002855 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856}
2857
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002858STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002859xfs_qm_mplist_nowait(
2860 xfs_mount_t *mp)
2861{
2862 int locked;
2863
2864 ASSERT(mp->m_quotainfo);
2865 locked = mutex_trylock(&(XFS_QI_MPLLOCK(mp)));
Jesper Juhl014c2542006-01-15 02:37:08 +01002866 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867}