blob: 9567d1846ee50bb04271b0db2fae1926d643ebe8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott4ce31212005-11-02 14:59:41 +11002 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott4ce31212005-11-02 14:59:41 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott4ce31212005-11-02 14:59:41 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott4ce31212005-11-02 14:59:41 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
19#include "xfs_fs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110020#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110022#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include "xfs_clnt.h"
24#include "xfs_trans.h"
25#include "xfs_sb.h"
26#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "xfs_dir2.h"
28#include "xfs_alloc.h"
29#include "xfs_dmapi.h"
30#include "xfs_quota.h"
31#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110033#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include "xfs_dir2_sf.h"
Nathan Scotta844f452005-11-02 14:38:42 +110036#include "xfs_attr_sf.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include "xfs_dinode.h"
38#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110039#include "xfs_btree.h"
40#include "xfs_ialloc.h"
41#include "xfs_itable.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include "xfs_rtalloc.h"
43#include "xfs_error.h"
Nathan Scotta844f452005-11-02 14:38:42 +110044#include "xfs_bmap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include "xfs_rw.h"
46#include "xfs_acl.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include "xfs_attr.h"
48#include "xfs_buf_item.h"
49#include "xfs_trans_space.h"
50#include "xfs_utils.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include "xfs_qm.h"
52
53/*
54 * The global quota manager. There is only one of these for the entire
55 * system, _not_ one per file system. XQM keeps track of the overall
56 * quota functionality, including maintaining the freelist and hash
57 * tables of dquots.
58 */
Nathan Scott6b3f6b52005-11-02 15:08:25 +110059mutex_t xfs_Gqm_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060struct xfs_qm *xfs_Gqm;
Nathan Scott6b3f6b52005-11-02 15:08:25 +110061uint ndquot;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63kmem_zone_t *qm_dqzone;
64kmem_zone_t *qm_dqtrxzone;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
David Chinner7989cb82007-02-10 18:34:56 +110066static cred_t xfs_zerocr;
Nathan Scottdae81d42006-02-28 12:30:13 +110067
Linus Torvalds1da177e2005-04-16 15:20:36 -070068STATIC void xfs_qm_list_init(xfs_dqlist_t *, char *, int);
69STATIC void xfs_qm_list_destroy(xfs_dqlist_t *);
70
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100071STATIC void xfs_qm_freelist_init(xfs_frlist_t *);
72STATIC void xfs_qm_freelist_destroy(xfs_frlist_t *);
73STATIC int xfs_qm_mplist_nowait(xfs_mount_t *);
74STATIC int xfs_qm_dqhashlock_nowait(xfs_dquot_t *);
75
Linus Torvalds1da177e2005-04-16 15:20:36 -070076STATIC int xfs_qm_init_quotainos(xfs_mount_t *);
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100077STATIC int xfs_qm_init_quotainfo(xfs_mount_t *);
Al Viro51bfb752005-12-15 09:17:24 +000078STATIC int xfs_qm_shake(int, gfp_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Rusty Russell8e1f9362007-07-17 04:03:17 -070080static struct shrinker xfs_qm_shaker = {
81 .shrink = xfs_qm_shake,
82 .seeks = DEFAULT_SEEKS,
83};
84
Linus Torvalds1da177e2005-04-16 15:20:36 -070085#ifdef DEBUG
86extern mutex_t qcheck_lock;
87#endif
88
89#ifdef QUOTADEBUG
90#define XQM_LIST_PRINT(l, NXT, title) \
91{ \
92 xfs_dquot_t *dqp; int i = 0; \
93 cmn_err(CE_DEBUG, "%s (#%d)", title, (int) (l)->qh_nelems); \
94 for (dqp = (l)->qh_next; dqp != NULL; dqp = dqp->NXT) { \
95 cmn_err(CE_DEBUG, " %d. \"%d (%s)\" " \
96 "bcnt = %d, icnt = %d, refs = %d", \
Christoph Hellwig1149d962005-11-02 15:01:12 +110097 ++i, (int) be32_to_cpu(dqp->q_core.d_id), \
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 DQFLAGTO_TYPESTR(dqp), \
Christoph Hellwig1149d962005-11-02 15:01:12 +110099 (int) be64_to_cpu(dqp->q_core.d_bcount), \
100 (int) be64_to_cpu(dqp->q_core.d_icount), \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 (int) dqp->q_nrefs); } \
102}
103#else
104#define XQM_LIST_PRINT(l, NXT, title) do { } while (0)
105#endif
106
107/*
108 * Initialize the XQM structure.
109 * Note that there is not one quota manager per file system.
110 */
111STATIC struct xfs_qm *
112xfs_Gqm_init(void)
113{
Nathan Scott6b3f6b52005-11-02 15:08:25 +1100114 xfs_dqhash_t *udqhash, *gdqhash;
115 xfs_qm_t *xqm;
Nathan Scott215101c2006-09-28 11:04:43 +1000116 size_t hsize;
117 uint i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
119 /*
120 * Initialize the dquot hash tables.
121 */
Nathan Scott77e46352006-09-28 11:03:27 +1000122 udqhash = kmem_zalloc_greedy(&hsize,
Eric Sandeen5995cb72007-08-16 16:49:11 +1000123 XFS_QM_HASHSIZE_LOW * sizeof(xfs_dqhash_t),
124 XFS_QM_HASHSIZE_HIGH * sizeof(xfs_dqhash_t),
Nathan Scott77e46352006-09-28 11:03:27 +1000125 KM_SLEEP | KM_MAYFAIL | KM_LARGE);
126 gdqhash = kmem_zalloc(hsize, KM_SLEEP | KM_LARGE);
127 hsize /= sizeof(xfs_dqhash_t);
Nathan Scott6b3f6b52005-11-02 15:08:25 +1100128 ndquot = hsize << 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
Nathan Scott6b3f6b52005-11-02 15:08:25 +1100130 xqm = kmem_zalloc(sizeof(xfs_qm_t), KM_SLEEP);
131 xqm->qm_dqhashmask = hsize - 1;
132 xqm->qm_usr_dqhtable = udqhash;
133 xqm->qm_grp_dqhtable = gdqhash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 ASSERT(xqm->qm_usr_dqhtable != NULL);
135 ASSERT(xqm->qm_grp_dqhtable != NULL);
136
137 for (i = 0; i < hsize; i++) {
138 xfs_qm_list_init(&(xqm->qm_usr_dqhtable[i]), "uxdqh", i);
139 xfs_qm_list_init(&(xqm->qm_grp_dqhtable[i]), "gxdqh", i);
140 }
141
142 /*
143 * Freelist of all dquots of all file systems
144 */
145 xfs_qm_freelist_init(&(xqm->qm_dqfreelist));
146
147 /*
148 * dquot zone. we register our own low-memory callback.
149 */
150 if (!qm_dqzone) {
151 xqm->qm_dqzone = kmem_zone_init(sizeof(xfs_dquot_t),
152 "xfs_dquots");
153 qm_dqzone = xqm->qm_dqzone;
154 } else
155 xqm->qm_dqzone = qm_dqzone;
156
Rusty Russell8e1f9362007-07-17 04:03:17 -0700157 register_shrinker(&xfs_qm_shaker);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
159 /*
160 * The t_dqinfo portion of transactions.
161 */
162 if (!qm_dqtrxzone) {
163 xqm->qm_dqtrxzone = kmem_zone_init(sizeof(xfs_dquot_acct_t),
164 "xfs_dqtrx");
165 qm_dqtrxzone = xqm->qm_dqtrxzone;
166 } else
167 xqm->qm_dqtrxzone = qm_dqtrxzone;
168
169 atomic_set(&xqm->qm_totaldquots, 0);
170 xqm->qm_dqfree_ratio = XFS_QM_DQFREE_RATIO;
171 xqm->qm_nrefs = 0;
172#ifdef DEBUG
Nathan Scottc2e81432006-01-16 16:21:34 +1100173 mutex_init(&qcheck_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174#endif
175 return xqm;
176}
177
178/*
179 * Destroy the global quota manager when its reference count goes to zero.
180 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000181STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182xfs_qm_destroy(
183 struct xfs_qm *xqm)
184{
185 int hsize, i;
186
187 ASSERT(xqm != NULL);
188 ASSERT(xqm->qm_nrefs == 0);
Rusty Russell8e1f9362007-07-17 04:03:17 -0700189 unregister_shrinker(&xfs_qm_shaker);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 hsize = xqm->qm_dqhashmask + 1;
191 for (i = 0; i < hsize; i++) {
192 xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));
193 xfs_qm_list_destroy(&(xqm->qm_grp_dqhtable[i]));
194 }
195 kmem_free(xqm->qm_usr_dqhtable, hsize * sizeof(xfs_dqhash_t));
196 kmem_free(xqm->qm_grp_dqhtable, hsize * sizeof(xfs_dqhash_t));
197 xqm->qm_usr_dqhtable = NULL;
198 xqm->qm_grp_dqhtable = NULL;
199 xqm->qm_dqhashmask = 0;
200 xfs_qm_freelist_destroy(&(xqm->qm_dqfreelist));
201#ifdef DEBUG
202 mutex_destroy(&qcheck_lock);
203#endif
204 kmem_free(xqm, sizeof(xfs_qm_t));
205}
206
207/*
208 * Called at mount time to let XQM know that another file system is
209 * starting quotas. This isn't crucial information as the individual mount
210 * structures are pretty independent, but it helps the XQM keep a
211 * global view of what's going on.
212 */
213/* ARGSUSED */
214STATIC int
215xfs_qm_hold_quotafs_ref(
216 struct xfs_mount *mp)
217{
218 /*
219 * Need to lock the xfs_Gqm structure for things like this. For example,
220 * the structure could disappear between the entry to this routine and
221 * a HOLD operation if not locked.
222 */
223 XFS_QM_LOCK(xfs_Gqm);
224
225 if (xfs_Gqm == NULL)
226 xfs_Gqm = xfs_Gqm_init();
227 /*
228 * We can keep a list of all filesystems with quotas mounted for
229 * debugging and statistical purposes, but ...
230 * Just take a reference and get out.
231 */
232 XFS_QM_HOLD(xfs_Gqm);
233 XFS_QM_UNLOCK(xfs_Gqm);
234
235 return 0;
236}
237
238
239/*
240 * Release the reference that a filesystem took at mount time,
241 * so that we know when we need to destroy the entire quota manager.
242 */
243/* ARGSUSED */
244STATIC void
245xfs_qm_rele_quotafs_ref(
246 struct xfs_mount *mp)
247{
248 xfs_dquot_t *dqp, *nextdqp;
249
250 ASSERT(xfs_Gqm);
251 ASSERT(xfs_Gqm->qm_nrefs > 0);
252
253 /*
254 * Go thru the freelist and destroy all inactive dquots.
255 */
256 xfs_qm_freelist_lock(xfs_Gqm);
257
258 for (dqp = xfs_Gqm->qm_dqfreelist.qh_next;
259 dqp != (xfs_dquot_t *)&(xfs_Gqm->qm_dqfreelist); ) {
260 xfs_dqlock(dqp);
261 nextdqp = dqp->dq_flnext;
262 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
263 ASSERT(dqp->q_mount == NULL);
264 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
265 ASSERT(dqp->HL_PREVP == NULL);
266 ASSERT(dqp->MPL_PREVP == NULL);
267 XQM_FREELIST_REMOVE(dqp);
268 xfs_dqunlock(dqp);
269 xfs_qm_dqdestroy(dqp);
270 } else {
271 xfs_dqunlock(dqp);
272 }
273 dqp = nextdqp;
274 }
275 xfs_qm_freelist_unlock(xfs_Gqm);
276
277 /*
278 * Destroy the entire XQM. If somebody mounts with quotaon, this'll
279 * be restarted.
280 */
281 XFS_QM_LOCK(xfs_Gqm);
282 XFS_QM_RELE(xfs_Gqm);
283 if (xfs_Gqm->qm_nrefs == 0) {
284 xfs_qm_destroy(xfs_Gqm);
285 xfs_Gqm = NULL;
286 }
287 XFS_QM_UNLOCK(xfs_Gqm);
288}
289
290/*
291 * This is called at mount time from xfs_mountfs to initialize the quotainfo
Nathan Scottc41564b2006-03-29 08:55:14 +1000292 * structure and start the global quota manager (xfs_Gqm) if it hasn't done
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 * so already. Note that the superblock has not been read in yet.
294 */
295void
296xfs_qm_mount_quotainit(
297 xfs_mount_t *mp,
298 uint flags)
299{
300 /*
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000301 * User, projects or group quotas has to be on.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000303 ASSERT(flags & (XFSMNT_UQUOTA | XFSMNT_PQUOTA | XFSMNT_GQUOTA));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
305 /*
306 * Initialize the flags in the mount structure. From this point
307 * onwards we look at m_qflags to figure out if quotas's ON/OFF, etc.
308 * Note that we enforce nothing if accounting is off.
309 * ie. XFSMNT_*QUOTA must be ON for XFSMNT_*QUOTAENF.
310 * It isn't necessary to take the quotaoff lock to do this; this is
311 * called from mount.
312 */
313 if (flags & XFSMNT_UQUOTA) {
314 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
315 if (flags & XFSMNT_UQUOTAENF)
316 mp->m_qflags |= XFS_UQUOTA_ENFD;
317 }
318 if (flags & XFSMNT_GQUOTA) {
319 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
320 if (flags & XFSMNT_GQUOTAENF)
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000321 mp->m_qflags |= XFS_OQUOTA_ENFD;
322 } else if (flags & XFSMNT_PQUOTA) {
323 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
324 if (flags & XFSMNT_PQUOTAENF)
325 mp->m_qflags |= XFS_OQUOTA_ENFD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 }
327}
328
329/*
330 * Just destroy the quotainfo structure.
331 */
332void
333xfs_qm_unmount_quotadestroy(
334 xfs_mount_t *mp)
335{
336 if (mp->m_quotainfo)
337 xfs_qm_destroy_quotainfo(mp);
338}
339
340
341/*
342 * This is called from xfs_mountfs to start quotas and initialize all
343 * necessary data structures like quotainfo. This is also responsible for
344 * running a quotacheck as necessary. We are guaranteed that the superblock
345 * is consistently read in at this point.
346 */
347int
348xfs_qm_mount_quotas(
349 xfs_mount_t *mp,
350 int mfsi_flags)
351{
352 unsigned long s;
353 int error = 0;
354 uint sbf;
355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
357 /*
358 * If quotas on realtime volumes is not supported, we disable
359 * quotas immediately.
360 */
361 if (mp->m_sb.sb_rextents) {
362 cmn_err(CE_NOTE,
363 "Cannot turn on quotas for realtime filesystem %s",
364 mp->m_fsname);
365 mp->m_qflags = 0;
366 goto write_changes;
367 }
368
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
Nathan Scott155ffd02005-09-02 16:43:48 +1000370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 /*
372 * Allocate the quotainfo structure inside the mount struct, and
373 * create quotainode(s), and change/rev superblock if necessary.
374 */
375 if ((error = xfs_qm_init_quotainfo(mp))) {
376 /*
377 * We must turn off quotas.
378 */
379 ASSERT(mp->m_quotainfo == NULL);
380 mp->m_qflags = 0;
381 goto write_changes;
382 }
383 /*
384 * If any of the quotas are not consistent, do a quotacheck.
385 */
386 if (XFS_QM_NEED_QUOTACHECK(mp) &&
387 !(mfsi_flags & XFS_MFSI_NO_QUOTACHECK)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 if ((error = xfs_qm_quotacheck(mp))) {
389 /* Quotacheck has failed and quotas have
390 * been disabled.
391 */
392 return XFS_ERROR(error);
393 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 }
Donald Douwsma646d5bd2007-05-08 13:49:09 +1000395 /*
396 * If one type of quotas is off, then it will lose its
397 * quotachecked status, since we won't be doing accounting for
398 * that type anymore.
399 */
400 if (!XFS_IS_UQUOTA_ON(mp)) {
401 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
402 }
403 if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp))) {
404 mp->m_qflags &= ~XFS_OQUOTA_CHKD;
405 }
Nathan Scott155ffd02005-09-02 16:43:48 +1000406
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 write_changes:
408 /*
409 * We actually don't have to acquire the SB_LOCK at all.
410 * This can only be called from mount, and that's single threaded. XXX
411 */
412 s = XFS_SB_LOCK(mp);
413 sbf = mp->m_sb.sb_qflags;
414 mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
415 XFS_SB_UNLOCK(mp, s);
416
417 if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
418 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
419 /*
420 * We could only have been turning quotas off.
421 * We aren't in very good shape actually because
422 * the incore structures are convinced that quotas are
423 * off, but the on disk superblock doesn't know that !
424 */
425 ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
426 xfs_fs_cmn_err(CE_ALERT, mp,
427 "XFS mount_quotas: Superblock update failed!");
428 }
429 }
430
431 if (error) {
432 xfs_fs_cmn_err(CE_WARN, mp,
433 "Failed to initialize disk quotas.");
434 }
435 return XFS_ERROR(error);
436}
437
438/*
439 * Called from the vfsops layer.
440 */
441int
442xfs_qm_unmount_quotas(
443 xfs_mount_t *mp)
444{
445 xfs_inode_t *uqp, *gqp;
446 int error = 0;
447
448 /*
449 * Release the dquots that root inode, et al might be holding,
450 * before we flush quotas and blow away the quotainfo structure.
451 */
452 ASSERT(mp->m_rootip);
453 xfs_qm_dqdetach(mp->m_rootip);
454 if (mp->m_rbmip)
455 xfs_qm_dqdetach(mp->m_rbmip);
456 if (mp->m_rsumip)
457 xfs_qm_dqdetach(mp->m_rsumip);
458
459 /*
460 * Flush out the quota inodes.
461 */
462 uqp = gqp = NULL;
463 if (mp->m_quotainfo) {
464 if ((uqp = mp->m_quotainfo->qi_uquotaip) != NULL) {
465 xfs_ilock(uqp, XFS_ILOCK_EXCL);
466 xfs_iflock(uqp);
467 error = xfs_iflush(uqp, XFS_IFLUSH_SYNC);
468 xfs_iunlock(uqp, XFS_ILOCK_EXCL);
469 if (unlikely(error == EFSCORRUPTED)) {
470 XFS_ERROR_REPORT("xfs_qm_unmount_quotas(1)",
471 XFS_ERRLEVEL_LOW, mp);
472 goto out;
473 }
474 }
475 if ((gqp = mp->m_quotainfo->qi_gquotaip) != NULL) {
476 xfs_ilock(gqp, XFS_ILOCK_EXCL);
477 xfs_iflock(gqp);
478 error = xfs_iflush(gqp, XFS_IFLUSH_SYNC);
479 xfs_iunlock(gqp, XFS_ILOCK_EXCL);
480 if (unlikely(error == EFSCORRUPTED)) {
481 XFS_ERROR_REPORT("xfs_qm_unmount_quotas(2)",
482 XFS_ERRLEVEL_LOW, mp);
483 goto out;
484 }
485 }
486 }
487 if (uqp) {
488 XFS_PURGE_INODE(uqp);
489 mp->m_quotainfo->qi_uquotaip = NULL;
490 }
491 if (gqp) {
492 XFS_PURGE_INODE(gqp);
493 mp->m_quotainfo->qi_gquotaip = NULL;
494 }
495out:
496 return XFS_ERROR(error);
497}
498
499/*
500 * Flush all dquots of the given file system to disk. The dquots are
501 * _not_ purged from memory here, just their data written to disk.
502 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000503STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504xfs_qm_dqflush_all(
505 xfs_mount_t *mp,
506 int flags)
507{
508 int recl;
509 xfs_dquot_t *dqp;
510 int niters;
511 int error;
512
513 if (mp->m_quotainfo == NULL)
Jesper Juhl014c2542006-01-15 02:37:08 +0100514 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 niters = 0;
516again:
517 xfs_qm_mplist_lock(mp);
518 FOREACH_DQUOT_IN_MP(dqp, mp) {
519 xfs_dqlock(dqp);
520 if (! XFS_DQ_IS_DIRTY(dqp)) {
521 xfs_dqunlock(dqp);
522 continue;
523 }
524 xfs_dqtrace_entry(dqp, "FLUSHALL: DQDIRTY");
525 /* XXX a sentinel would be better */
526 recl = XFS_QI_MPLRECLAIMS(mp);
527 if (! xfs_qm_dqflock_nowait(dqp)) {
528 /*
529 * If we can't grab the flush lock then check
530 * to see if the dquot has been flushed delayed
531 * write. If so, grab its buffer and send it
532 * out immediately. We'll be able to acquire
533 * the flush lock when the I/O completes.
534 */
535 xfs_qm_dqflock_pushbuf_wait(dqp);
536 }
537 /*
538 * Let go of the mplist lock. We don't want to hold it
539 * across a disk write.
540 */
541 xfs_qm_mplist_unlock(mp);
542 error = xfs_qm_dqflush(dqp, flags);
543 xfs_dqunlock(dqp);
544 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +0100545 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
547 xfs_qm_mplist_lock(mp);
548 if (recl != XFS_QI_MPLRECLAIMS(mp)) {
549 xfs_qm_mplist_unlock(mp);
550 /* XXX restart limit */
551 goto again;
552 }
553 }
554
555 xfs_qm_mplist_unlock(mp);
556 /* return ! busy */
Jesper Juhl014c2542006-01-15 02:37:08 +0100557 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558}
559/*
560 * Release the group dquot pointers the user dquots may be
561 * carrying around as a hint. mplist is locked on entry and exit.
562 */
563STATIC void
564xfs_qm_detach_gdquots(
565 xfs_mount_t *mp)
566{
567 xfs_dquot_t *dqp, *gdqp;
568 int nrecl;
569
570 again:
571 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
572 dqp = XFS_QI_MPLNEXT(mp);
573 while (dqp) {
574 xfs_dqlock(dqp);
575 if ((gdqp = dqp->q_gdquot)) {
576 xfs_dqlock(gdqp);
577 dqp->q_gdquot = NULL;
578 }
579 xfs_dqunlock(dqp);
580
581 if (gdqp) {
582 /*
583 * Can't hold the mplist lock across a dqput.
584 * XXXmust convert to marker based iterations here.
585 */
586 nrecl = XFS_QI_MPLRECLAIMS(mp);
587 xfs_qm_mplist_unlock(mp);
588 xfs_qm_dqput(gdqp);
589
590 xfs_qm_mplist_lock(mp);
591 if (nrecl != XFS_QI_MPLRECLAIMS(mp))
592 goto again;
593 }
594 dqp = dqp->MPL_NEXT;
595 }
596}
597
598/*
599 * Go through all the incore dquots of this file system and take them
600 * off the mplist and hashlist, if the dquot type matches the dqtype
601 * parameter. This is used when turning off quota accounting for
602 * users and/or groups, as well as when the filesystem is unmounting.
603 */
604STATIC int
605xfs_qm_dqpurge_int(
606 xfs_mount_t *mp,
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000607 uint flags) /* QUOTAOFF/UMOUNTING/UQUOTA/PQUOTA/GQUOTA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608{
609 xfs_dquot_t *dqp;
610 uint dqtype;
611 int nrecl;
612 xfs_dquot_t *nextdqp;
613 int nmisses;
614
615 if (mp->m_quotainfo == NULL)
Jesper Juhl014c2542006-01-15 02:37:08 +0100616 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
618 dqtype = (flags & XFS_QMOPT_UQUOTA) ? XFS_DQ_USER : 0;
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000619 dqtype |= (flags & XFS_QMOPT_PQUOTA) ? XFS_DQ_PROJ : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 dqtype |= (flags & XFS_QMOPT_GQUOTA) ? XFS_DQ_GROUP : 0;
621
622 xfs_qm_mplist_lock(mp);
623
624 /*
625 * In the first pass through all incore dquots of this filesystem,
626 * we release the group dquot pointers the user dquots may be
627 * carrying around as a hint. We need to do this irrespective of
628 * what's being turned off.
629 */
630 xfs_qm_detach_gdquots(mp);
631
632 again:
633 nmisses = 0;
634 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
635 /*
636 * Try to get rid of all of the unwanted dquots. The idea is to
637 * get them off mplist and hashlist, but leave them on freelist.
638 */
639 dqp = XFS_QI_MPLNEXT(mp);
640 while (dqp) {
641 /*
642 * It's OK to look at the type without taking dqlock here.
643 * We're holding the mplist lock here, and that's needed for
644 * a dqreclaim.
645 */
646 if ((dqp->dq_flags & dqtype) == 0) {
647 dqp = dqp->MPL_NEXT;
648 continue;
649 }
650
651 if (! xfs_qm_dqhashlock_nowait(dqp)) {
652 nrecl = XFS_QI_MPLRECLAIMS(mp);
653 xfs_qm_mplist_unlock(mp);
654 XFS_DQ_HASH_LOCK(dqp->q_hash);
655 xfs_qm_mplist_lock(mp);
656
657 /*
658 * XXXTheoretically, we can get into a very long
659 * ping pong game here.
660 * No one can be adding dquots to the mplist at
661 * this point, but somebody might be taking things off.
662 */
663 if (nrecl != XFS_QI_MPLRECLAIMS(mp)) {
664 XFS_DQ_HASH_UNLOCK(dqp->q_hash);
665 goto again;
666 }
667 }
668
669 /*
670 * Take the dquot off the mplist and hashlist. It may remain on
671 * freelist in INACTIVE state.
672 */
673 nextdqp = dqp->MPL_NEXT;
674 nmisses += xfs_qm_dqpurge(dqp, flags);
675 dqp = nextdqp;
676 }
677 xfs_qm_mplist_unlock(mp);
678 return nmisses;
679}
680
681int
682xfs_qm_dqpurge_all(
683 xfs_mount_t *mp,
684 uint flags)
685{
686 int ndquots;
687
688 /*
689 * Purge the dquot cache.
690 * None of the dquots should really be busy at this point.
691 */
692 if (mp->m_quotainfo) {
693 while ((ndquots = xfs_qm_dqpurge_int(mp, flags))) {
694 delay(ndquots * 10);
695 }
696 }
697 return 0;
698}
699
700STATIC int
701xfs_qm_dqattach_one(
702 xfs_inode_t *ip,
703 xfs_dqid_t id,
704 uint type,
705 uint doalloc,
706 uint dolock,
707 xfs_dquot_t *udqhint, /* hint */
708 xfs_dquot_t **IO_idqpp)
709{
710 xfs_dquot_t *dqp;
711 int error;
712
713 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
714 error = 0;
715 /*
716 * See if we already have it in the inode itself. IO_idqpp is
717 * &i_udquot or &i_gdquot. This made the code look weird, but
718 * made the logic a lot simpler.
719 */
720 if ((dqp = *IO_idqpp)) {
721 if (dolock)
722 xfs_dqlock(dqp);
723 xfs_dqtrace_entry(dqp, "DQATTACH: found in ip");
724 goto done;
725 }
726
727 /*
728 * udqhint is the i_udquot field in inode, and is non-NULL only
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000729 * when the type arg is group/project. Its purpose is to save a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside
731 * the user dquot.
732 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000733 ASSERT(!udqhint || type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 if (udqhint && !dolock)
735 xfs_dqlock(udqhint);
736
737 /*
738 * No need to take dqlock to look at the id.
739 * The ID can't change until it gets reclaimed, and it won't
740 * be reclaimed as long as we have a ref from inode and we hold
741 * the ilock.
742 */
743 if (udqhint &&
744 (dqp = udqhint->q_gdquot) &&
Christoph Hellwig1149d962005-11-02 15:01:12 +1100745 (be32_to_cpu(dqp->q_core.d_id) == id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 ASSERT(XFS_DQ_IS_LOCKED(udqhint));
747 xfs_dqlock(dqp);
748 XFS_DQHOLD(dqp);
749 ASSERT(*IO_idqpp == NULL);
750 *IO_idqpp = dqp;
751 if (!dolock) {
752 xfs_dqunlock(dqp);
753 xfs_dqunlock(udqhint);
754 }
755 goto done;
756 }
757 /*
758 * We can't hold a dquot lock when we call the dqget code.
759 * We'll deadlock in no time, because of (not conforming to)
760 * lock ordering - the inodelock comes before any dquot lock,
761 * and we may drop and reacquire the ilock in xfs_qm_dqget().
762 */
763 if (udqhint)
764 xfs_dqunlock(udqhint);
765 /*
766 * Find the dquot from somewhere. This bumps the
767 * reference count of dquot and returns it locked.
768 * This can return ENOENT if dquot didn't exist on
769 * disk and we didn't ask it to allocate;
770 * ESRCH if quotas got turned off suddenly.
771 */
772 if ((error = xfs_qm_dqget(ip->i_mount, ip, id, type,
773 doalloc|XFS_QMOPT_DOWARN, &dqp))) {
774 if (udqhint && dolock)
775 xfs_dqlock(udqhint);
776 goto done;
777 }
778
779 xfs_dqtrace_entry(dqp, "DQATTACH: found by dqget");
780 /*
781 * dqget may have dropped and re-acquired the ilock, but it guarantees
782 * that the dquot returned is the one that should go in the inode.
783 */
784 *IO_idqpp = dqp;
785 ASSERT(dqp);
786 ASSERT(XFS_DQ_IS_LOCKED(dqp));
787 if (! dolock) {
788 xfs_dqunlock(dqp);
789 goto done;
790 }
791 if (! udqhint)
792 goto done;
793
794 ASSERT(udqhint);
795 ASSERT(dolock);
796 ASSERT(XFS_DQ_IS_LOCKED(dqp));
797 if (! xfs_qm_dqlock_nowait(udqhint)) {
798 xfs_dqunlock(dqp);
799 xfs_dqlock(udqhint);
800 xfs_dqlock(dqp);
801 }
802 done:
803#ifdef QUOTADEBUG
804 if (udqhint) {
805 if (dolock)
806 ASSERT(XFS_DQ_IS_LOCKED(udqhint));
807 }
808 if (! error) {
809 if (dolock)
810 ASSERT(XFS_DQ_IS_LOCKED(dqp));
811 }
812#endif
Jesper Juhl014c2542006-01-15 02:37:08 +0100813 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814}
815
816
817/*
818 * Given a udquot and gdquot, attach a ptr to the group dquot in the
819 * udquot as a hint for future lookups. The idea sounds simple, but the
820 * execution isn't, because the udquot might have a group dquot attached
Nathan Scottc41564b2006-03-29 08:55:14 +1000821 * already and getting rid of that gets us into lock ordering constraints.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 * The process is complicated more by the fact that the dquots may or may not
823 * be locked on entry.
824 */
825STATIC void
826xfs_qm_dqattach_grouphint(
827 xfs_dquot_t *udq,
828 xfs_dquot_t *gdq,
829 uint locked)
830{
831 xfs_dquot_t *tmp;
832
833#ifdef QUOTADEBUG
834 if (locked) {
835 ASSERT(XFS_DQ_IS_LOCKED(udq));
836 ASSERT(XFS_DQ_IS_LOCKED(gdq));
837 }
838#endif
839 if (! locked)
840 xfs_dqlock(udq);
841
842 if ((tmp = udq->q_gdquot)) {
843 if (tmp == gdq) {
844 if (! locked)
845 xfs_dqunlock(udq);
846 return;
847 }
848
849 udq->q_gdquot = NULL;
850 /*
851 * We can't keep any dqlocks when calling dqrele,
852 * because the freelist lock comes before dqlocks.
853 */
854 xfs_dqunlock(udq);
855 if (locked)
856 xfs_dqunlock(gdq);
857 /*
858 * we took a hard reference once upon a time in dqget,
859 * so give it back when the udquot no longer points at it
860 * dqput() does the unlocking of the dquot.
861 */
862 xfs_qm_dqrele(tmp);
863
864 xfs_dqlock(udq);
865 xfs_dqlock(gdq);
866
867 } else {
868 ASSERT(XFS_DQ_IS_LOCKED(udq));
869 if (! locked) {
870 xfs_dqlock(gdq);
871 }
872 }
873
874 ASSERT(XFS_DQ_IS_LOCKED(udq));
875 ASSERT(XFS_DQ_IS_LOCKED(gdq));
876 /*
877 * Somebody could have attached a gdquot here,
878 * when we dropped the uqlock. If so, just do nothing.
879 */
880 if (udq->q_gdquot == NULL) {
881 XFS_DQHOLD(gdq);
882 udq->q_gdquot = gdq;
883 }
884 if (! locked) {
885 xfs_dqunlock(gdq);
886 xfs_dqunlock(udq);
887 }
888}
889
890
891/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000892 * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
893 * into account.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed.
895 * If XFS_QMOPT_DQLOCK, the dquot(s) will be returned locked. This option pretty
896 * much made this code a complete mess, but it has been pretty useful.
897 * If XFS_QMOPT_ILOCKED, then inode sent is already locked EXCL.
898 * Inode may get unlocked and relocked in here, and the caller must deal with
899 * the consequences.
900 */
901int
902xfs_qm_dqattach(
903 xfs_inode_t *ip,
904 uint flags)
905{
906 xfs_mount_t *mp = ip->i_mount;
907 uint nquotas = 0;
908 int error = 0;
909
910 if ((! XFS_IS_QUOTA_ON(mp)) ||
911 (! XFS_NOT_DQATTACHED(mp, ip)) ||
912 (ip->i_ino == mp->m_sb.sb_uquotino) ||
913 (ip->i_ino == mp->m_sb.sb_gquotino))
Jesper Juhl014c2542006-01-15 02:37:08 +0100914 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915
916 ASSERT((flags & XFS_QMOPT_ILOCKED) == 0 ||
917 XFS_ISLOCKED_INODE_EXCL(ip));
918
919 if (! (flags & XFS_QMOPT_ILOCKED))
920 xfs_ilock(ip, XFS_ILOCK_EXCL);
921
922 if (XFS_IS_UQUOTA_ON(mp)) {
923 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
924 flags & XFS_QMOPT_DQALLOC,
925 flags & XFS_QMOPT_DQLOCK,
926 NULL, &ip->i_udquot);
927 if (error)
928 goto done;
929 nquotas++;
930 }
931 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000932 if (XFS_IS_OQUOTA_ON(mp)) {
933 error = XFS_IS_GQUOTA_ON(mp) ?
934 xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
935 flags & XFS_QMOPT_DQALLOC,
936 flags & XFS_QMOPT_DQLOCK,
937 ip->i_udquot, &ip->i_gdquot) :
938 xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQ_PROJ,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 flags & XFS_QMOPT_DQALLOC,
940 flags & XFS_QMOPT_DQLOCK,
941 ip->i_udquot, &ip->i_gdquot);
942 /*
943 * Don't worry about the udquot that we may have
944 * attached above. It'll get detached, if not already.
945 */
946 if (error)
947 goto done;
948 nquotas++;
949 }
950
951 /*
952 * Attach this group quota to the user quota as a hint.
953 * This WON'T, in general, result in a thrash.
954 */
955 if (nquotas == 2) {
956 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
957 ASSERT(ip->i_udquot);
958 ASSERT(ip->i_gdquot);
959
960 /*
961 * We may or may not have the i_udquot locked at this point,
962 * but this check is OK since we don't depend on the i_gdquot to
963 * be accurate 100% all the time. It is just a hint, and this
964 * will succeed in general.
965 */
966 if (ip->i_udquot->q_gdquot == ip->i_gdquot)
967 goto done;
968 /*
969 * Attach i_gdquot to the gdquot hint inside the i_udquot.
970 */
971 xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot,
972 flags & XFS_QMOPT_DQLOCK);
973 }
974
975 done:
976
977#ifdef QUOTADEBUG
978 if (! error) {
979 if (ip->i_udquot) {
980 if (flags & XFS_QMOPT_DQLOCK)
981 ASSERT(XFS_DQ_IS_LOCKED(ip->i_udquot));
982 }
983 if (ip->i_gdquot) {
984 if (flags & XFS_QMOPT_DQLOCK)
985 ASSERT(XFS_DQ_IS_LOCKED(ip->i_gdquot));
986 }
987 if (XFS_IS_UQUOTA_ON(mp))
988 ASSERT(ip->i_udquot);
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000989 if (XFS_IS_OQUOTA_ON(mp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 ASSERT(ip->i_gdquot);
991 }
992#endif
993
994 if (! (flags & XFS_QMOPT_ILOCKED))
995 xfs_iunlock(ip, XFS_ILOCK_EXCL);
996
997#ifdef QUOTADEBUG
998 else
999 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
1000#endif
Jesper Juhl014c2542006-01-15 02:37:08 +01001001 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002}
1003
1004/*
1005 * Release dquots (and their references) if any.
1006 * The inode should be locked EXCL except when this's called by
1007 * xfs_ireclaim.
1008 */
1009void
1010xfs_qm_dqdetach(
1011 xfs_inode_t *ip)
1012{
1013 if (!(ip->i_udquot || ip->i_gdquot))
1014 return;
1015
1016 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
1017 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 if (ip->i_udquot) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001019 xfs_dqtrace_entry_ino(ip->i_udquot, "DQDETTACH", ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 xfs_qm_dqrele(ip->i_udquot);
1021 ip->i_udquot = NULL;
1022 }
1023 if (ip->i_gdquot) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001024 xfs_dqtrace_entry_ino(ip->i_gdquot, "DQDETTACH", ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 xfs_qm_dqrele(ip->i_gdquot);
1026 ip->i_gdquot = NULL;
1027 }
1028}
1029
1030/*
1031 * This is called by VFS_SYNC and flags arg determines the caller,
1032 * and its motives, as done in xfs_sync.
1033 *
1034 * vfs_sync: SYNC_FSDATA|SYNC_ATTR|SYNC_BDFLUSH 0x31
1035 * syscall sync: SYNC_FSDATA|SYNC_ATTR|SYNC_DELWRI 0x25
1036 * umountroot : SYNC_WAIT | SYNC_CLOSE | SYNC_ATTR | SYNC_FSDATA
1037 */
1038
1039int
1040xfs_qm_sync(
1041 xfs_mount_t *mp,
1042 short flags)
1043{
1044 int recl, restarts;
1045 xfs_dquot_t *dqp;
1046 uint flush_flags;
1047 boolean_t nowait;
1048 int error;
1049
1050 restarts = 0;
1051 /*
1052 * We won't block unless we are asked to.
1053 */
1054 nowait = (boolean_t)(flags & SYNC_BDFLUSH || (flags & SYNC_WAIT) == 0);
1055
1056 again:
1057 xfs_qm_mplist_lock(mp);
1058 /*
1059 * dqpurge_all() also takes the mplist lock and iterate thru all dquots
1060 * in quotaoff. However, if the QUOTA_ACTIVE bits are not cleared
1061 * when we have the mplist lock, we know that dquots will be consistent
1062 * as long as we have it locked.
1063 */
1064 if (! XFS_IS_QUOTA_ON(mp)) {
1065 xfs_qm_mplist_unlock(mp);
Jesper Juhl014c2542006-01-15 02:37:08 +01001066 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 }
1068 FOREACH_DQUOT_IN_MP(dqp, mp) {
1069 /*
1070 * If this is vfs_sync calling, then skip the dquots that
1071 * don't 'seem' to be dirty. ie. don't acquire dqlock.
1072 * This is very similar to what xfs_sync does with inodes.
1073 */
1074 if (flags & SYNC_BDFLUSH) {
1075 if (! XFS_DQ_IS_DIRTY(dqp))
1076 continue;
1077 }
1078
1079 if (nowait) {
1080 /*
1081 * Try to acquire the dquot lock. We are NOT out of
1082 * lock order, but we just don't want to wait for this
1083 * lock, unless somebody wanted us to.
1084 */
1085 if (! xfs_qm_dqlock_nowait(dqp))
1086 continue;
1087 } else {
1088 xfs_dqlock(dqp);
1089 }
1090
1091 /*
1092 * Now, find out for sure if this dquot is dirty or not.
1093 */
1094 if (! XFS_DQ_IS_DIRTY(dqp)) {
1095 xfs_dqunlock(dqp);
1096 continue;
1097 }
1098
1099 /* XXX a sentinel would be better */
1100 recl = XFS_QI_MPLRECLAIMS(mp);
1101 if (! xfs_qm_dqflock_nowait(dqp)) {
1102 if (nowait) {
1103 xfs_dqunlock(dqp);
1104 continue;
1105 }
1106 /*
1107 * If we can't grab the flush lock then if the caller
Nathan Scottc41564b2006-03-29 08:55:14 +10001108 * really wanted us to give this our best shot, so
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 * see if we can give a push to the buffer before we wait
1110 * on the flush lock. At this point, we know that
Nathan Scottc41564b2006-03-29 08:55:14 +10001111 * even though the dquot is being flushed,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 * it has (new) dirty data.
1113 */
1114 xfs_qm_dqflock_pushbuf_wait(dqp);
1115 }
1116 /*
1117 * Let go of the mplist lock. We don't want to hold it
1118 * across a disk write
1119 */
1120 flush_flags = (nowait) ? XFS_QMOPT_DELWRI : XFS_QMOPT_SYNC;
1121 xfs_qm_mplist_unlock(mp);
1122 xfs_dqtrace_entry(dqp, "XQM_SYNC: DQFLUSH");
1123 error = xfs_qm_dqflush(dqp, flush_flags);
1124 xfs_dqunlock(dqp);
1125 if (error && XFS_FORCED_SHUTDOWN(mp))
Jesper Juhl014c2542006-01-15 02:37:08 +01001126 return 0; /* Need to prevent umount failure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 else if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01001128 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
1130 xfs_qm_mplist_lock(mp);
1131 if (recl != XFS_QI_MPLRECLAIMS(mp)) {
1132 if (++restarts >= XFS_QM_SYNC_MAX_RESTARTS)
1133 break;
1134
1135 xfs_qm_mplist_unlock(mp);
1136 goto again;
1137 }
1138 }
1139
1140 xfs_qm_mplist_unlock(mp);
Jesper Juhl014c2542006-01-15 02:37:08 +01001141 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142}
1143
1144
1145/*
1146 * This initializes all the quota information that's kept in the
1147 * mount structure
1148 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10001149STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150xfs_qm_init_quotainfo(
1151 xfs_mount_t *mp)
1152{
1153 xfs_quotainfo_t *qinf;
1154 int error;
1155 xfs_dquot_t *dqp;
1156
1157 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1158
1159 /*
1160 * Tell XQM that we exist as soon as possible.
1161 */
1162 if ((error = xfs_qm_hold_quotafs_ref(mp))) {
Jesper Juhl014c2542006-01-15 02:37:08 +01001163 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 }
1165
1166 qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
1167
1168 /*
1169 * See if quotainodes are setup, and if not, allocate them,
1170 * and change the superblock accordingly.
1171 */
1172 if ((error = xfs_qm_init_quotainos(mp))) {
1173 kmem_free(qinf, sizeof(xfs_quotainfo_t));
1174 mp->m_quotainfo = NULL;
Jesper Juhl014c2542006-01-15 02:37:08 +01001175 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 }
1177
1178 spinlock_init(&qinf->qi_pinlock, "xfs_qinf_pin");
1179 xfs_qm_list_init(&qinf->qi_dqlist, "mpdqlist", 0);
1180 qinf->qi_dqreclaims = 0;
1181
1182 /* mutex used to serialize quotaoffs */
Jes Sorensen794ee1b2006-01-09 15:59:21 -08001183 mutex_init(&qinf->qi_quotaofflock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184
1185 /* Precalc some constants */
1186 qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1187 ASSERT(qinf->qi_dqchunklen);
1188 qinf->qi_dqperchunk = BBTOB(qinf->qi_dqchunklen);
1189 do_div(qinf->qi_dqperchunk, sizeof(xfs_dqblk_t));
1190
1191 mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
1192
1193 /*
1194 * We try to get the limits from the superuser's limits fields.
1195 * This is quite hacky, but it is standard quota practice.
1196 * We look at the USR dquot with id == 0 first, but if user quotas
1197 * are not enabled we goto the GRP dquot with id == 0.
1198 * We don't really care to keep separate default limits for user
1199 * and group quotas, at least not at this point.
1200 */
1201 error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)0,
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001202 XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
1203 (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
1204 XFS_DQ_PROJ),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 XFS_QMOPT_DQSUSER|XFS_QMOPT_DOWARN,
1206 &dqp);
1207 if (! error) {
1208 xfs_disk_dquot_t *ddqp = &dqp->q_core;
1209
1210 /*
1211 * The warnings and timers set the grace period given to
1212 * a user or group before he or she can not perform any
1213 * more writing. If it is zero, a default is used.
1214 */
Christoph Hellwig1149d962005-11-02 15:01:12 +11001215 qinf->qi_btimelimit = ddqp->d_btimer ?
1216 be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;
1217 qinf->qi_itimelimit = ddqp->d_itimer ?
1218 be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;
1219 qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?
1220 be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;
1221 qinf->qi_bwarnlimit = ddqp->d_bwarns ?
1222 be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;
1223 qinf->qi_iwarnlimit = ddqp->d_iwarns ?
1224 be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
1225 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
1226 be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
1227 qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
1228 qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
1229 qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
1230 qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
1231 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
1232 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233
1234 /*
1235 * We sent the XFS_QMOPT_DQSUSER flag to dqget because
1236 * we don't want this dquot cached. We haven't done a
1237 * quotacheck yet, and quotacheck doesn't like incore dquots.
1238 */
1239 xfs_qm_dqdestroy(dqp);
1240 } else {
1241 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
1242 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
1243 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
1244 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
1245 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
Nathan Scott06d10dd2005-06-21 15:48:47 +10001246 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 }
1248
Jesper Juhl014c2542006-01-15 02:37:08 +01001249 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250}
1251
1252
1253/*
1254 * Gets called when unmounting a filesystem or when all quotas get
1255 * turned off.
1256 * This purges the quota inodes, destroys locks and frees itself.
1257 */
1258void
1259xfs_qm_destroy_quotainfo(
1260 xfs_mount_t *mp)
1261{
1262 xfs_quotainfo_t *qi;
1263
1264 qi = mp->m_quotainfo;
1265 ASSERT(qi != NULL);
1266 ASSERT(xfs_Gqm != NULL);
1267
1268 /*
1269 * Release the reference that XQM kept, so that we know
1270 * when the XQM structure should be freed. We cannot assume
1271 * that xfs_Gqm is non-null after this point.
1272 */
1273 xfs_qm_rele_quotafs_ref(mp);
1274
1275 spinlock_destroy(&qi->qi_pinlock);
1276 xfs_qm_list_destroy(&qi->qi_dqlist);
1277
1278 if (qi->qi_uquotaip) {
1279 XFS_PURGE_INODE(qi->qi_uquotaip);
1280 qi->qi_uquotaip = NULL; /* paranoia */
1281 }
1282 if (qi->qi_gquotaip) {
1283 XFS_PURGE_INODE(qi->qi_gquotaip);
1284 qi->qi_gquotaip = NULL;
1285 }
1286 mutex_destroy(&qi->qi_quotaofflock);
1287 kmem_free(qi, sizeof(xfs_quotainfo_t));
1288 mp->m_quotainfo = NULL;
1289}
1290
1291
1292
1293/* ------------------- PRIVATE STATIC FUNCTIONS ----------------------- */
1294
1295/* ARGSUSED */
1296STATIC void
1297xfs_qm_list_init(
1298 xfs_dqlist_t *list,
1299 char *str,
1300 int n)
1301{
Jes Sorensen794ee1b2006-01-09 15:59:21 -08001302 mutex_init(&list->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 list->qh_next = NULL;
1304 list->qh_version = 0;
1305 list->qh_nelems = 0;
1306}
1307
1308STATIC void
1309xfs_qm_list_destroy(
1310 xfs_dqlist_t *list)
1311{
1312 mutex_destroy(&(list->qh_lock));
1313}
1314
1315
1316/*
1317 * Stripped down version of dqattach. This doesn't attach, or even look at the
1318 * dquots attached to the inode. The rationale is that there won't be any
1319 * attached at the time this is called from quotacheck.
1320 */
1321STATIC int
1322xfs_qm_dqget_noattach(
1323 xfs_inode_t *ip,
1324 xfs_dquot_t **O_udqpp,
1325 xfs_dquot_t **O_gdqpp)
1326{
1327 int error;
1328 xfs_mount_t *mp;
1329 xfs_dquot_t *udqp, *gdqp;
1330
1331 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
1332 mp = ip->i_mount;
1333 udqp = NULL;
1334 gdqp = NULL;
1335
1336 if (XFS_IS_UQUOTA_ON(mp)) {
1337 ASSERT(ip->i_udquot == NULL);
1338 /*
1339 * We want the dquot allocated if it doesn't exist.
1340 */
1341 if ((error = xfs_qm_dqget(mp, ip, ip->i_d.di_uid, XFS_DQ_USER,
1342 XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN,
1343 &udqp))) {
1344 /*
1345 * Shouldn't be able to turn off quotas here.
1346 */
1347 ASSERT(error != ESRCH);
1348 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01001349 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 }
1351 ASSERT(udqp);
1352 }
1353
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001354 if (XFS_IS_OQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 ASSERT(ip->i_gdquot == NULL);
1356 if (udqp)
1357 xfs_dqunlock(udqp);
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001358 error = XFS_IS_GQUOTA_ON(mp) ?
1359 xfs_qm_dqget(mp, ip,
1360 ip->i_d.di_gid, XFS_DQ_GROUP,
1361 XFS_QMOPT_DQALLOC|XFS_QMOPT_DOWARN,
1362 &gdqp) :
1363 xfs_qm_dqget(mp, ip,
1364 ip->i_d.di_projid, XFS_DQ_PROJ,
1365 XFS_QMOPT_DQALLOC|XFS_QMOPT_DOWARN,
1366 &gdqp);
1367 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 if (udqp)
1369 xfs_qm_dqrele(udqp);
1370 ASSERT(error != ESRCH);
1371 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01001372 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 }
1374 ASSERT(gdqp);
1375
1376 /* Reacquire the locks in the right order */
1377 if (udqp) {
1378 if (! xfs_qm_dqlock_nowait(udqp)) {
1379 xfs_dqunlock(gdqp);
1380 xfs_dqlock(udqp);
1381 xfs_dqlock(gdqp);
1382 }
1383 }
1384 }
1385
1386 *O_udqpp = udqp;
1387 *O_gdqpp = gdqp;
1388
1389#ifdef QUOTADEBUG
1390 if (udqp) ASSERT(XFS_DQ_IS_LOCKED(udqp));
1391 if (gdqp) ASSERT(XFS_DQ_IS_LOCKED(gdqp));
1392#endif
Jesper Juhl014c2542006-01-15 02:37:08 +01001393 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394}
1395
1396/*
1397 * Create an inode and return with a reference already taken, but unlocked
1398 * This is how we create quota inodes
1399 */
1400STATIC int
1401xfs_qm_qino_alloc(
1402 xfs_mount_t *mp,
1403 xfs_inode_t **ip,
1404 __int64_t sbfields,
1405 uint flags)
1406{
1407 xfs_trans_t *tp;
1408 int error;
Nathan Scott061f7202006-01-11 15:27:50 +11001409 unsigned long s;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 int committed;
1411
Nathan Scott061f7202006-01-11 15:27:50 +11001412 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 if ((error = xfs_trans_reserve(tp,
1414 XFS_QM_QINOCREATE_SPACE_RES(mp),
1415 XFS_CREATE_LOG_RES(mp), 0,
1416 XFS_TRANS_PERM_LOG_RES,
1417 XFS_CREATE_LOG_COUNT))) {
1418 xfs_trans_cancel(tp, 0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001419 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421
David Chinnerb11f94d2007-07-11 11:09:33 +10001422 if ((error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0,
Nathan Scottdae81d42006-02-28 12:30:13 +11001423 &xfs_zerocr, 0, 1, ip, &committed))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
1425 XFS_TRANS_ABORT);
Jesper Juhl014c2542006-01-15 02:37:08 +01001426 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 }
1428
1429 /*
1430 * Keep an extra reference to this quota inode. This inode is
1431 * locked exclusively and joined to the transaction already.
1432 */
1433 ASSERT(XFS_ISLOCKED_INODE_EXCL(*ip));
1434 VN_HOLD(XFS_ITOV((*ip)));
1435
1436 /*
1437 * Make the changes in the superblock, and log those too.
1438 * sbfields arg may contain fields other than *QUOTINO;
1439 * VERSIONNUM for example.
1440 */
1441 s = XFS_SB_LOCK(mp);
1442 if (flags & XFS_QMOPT_SBVERSION) {
1443#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
1444 unsigned oldv = mp->m_sb.sb_versionnum;
1445#endif
1446 ASSERT(!XFS_SB_VERSION_HASQUOTA(&mp->m_sb));
1447 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1448 XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
1449 (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1450 XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
1451
1452 XFS_SB_VERSION_ADDQUOTA(&mp->m_sb);
1453 mp->m_sb.sb_uquotino = NULLFSINO;
1454 mp->m_sb.sb_gquotino = NULLFSINO;
1455
1456 /* qflags will get updated _after_ quotacheck */
1457 mp->m_sb.sb_qflags = 0;
1458#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
1459 cmn_err(CE_NOTE,
1460 "Old superblock version %x, converting to %x.",
1461 oldv, mp->m_sb.sb_versionnum);
1462#endif
1463 }
1464 if (flags & XFS_QMOPT_UQUOTA)
1465 mp->m_sb.sb_uquotino = (*ip)->i_ino;
1466 else
1467 mp->m_sb.sb_gquotino = (*ip)->i_ino;
1468 XFS_SB_UNLOCK(mp, s);
1469 xfs_mod_sb(tp, sbfields);
1470
Eric Sandeen1c72bf92007-05-08 13:48:42 +10001471 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 xfs_fs_cmn_err(CE_ALERT, mp, "XFS qino_alloc failed!");
Jesper Juhl014c2542006-01-15 02:37:08 +01001473 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001475 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476}
1477
1478
1479STATIC int
1480xfs_qm_reset_dqcounts(
1481 xfs_mount_t *mp,
1482 xfs_buf_t *bp,
1483 xfs_dqid_t id,
1484 uint type)
1485{
1486 xfs_disk_dquot_t *ddq;
1487 int j;
1488
1489 xfs_buftrace("RESET DQUOTS", bp);
1490 /*
1491 * Reset all counters and timers. They'll be
1492 * started afresh by xfs_qm_quotacheck.
1493 */
1494#ifdef DEBUG
1495 j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1496 do_div(j, sizeof(xfs_dqblk_t));
1497 ASSERT(XFS_QM_DQPERBLK(mp) == j);
1498#endif
1499 ddq = (xfs_disk_dquot_t *)XFS_BUF_PTR(bp);
1500 for (j = 0; j < XFS_QM_DQPERBLK(mp); j++) {
1501 /*
1502 * Do a sanity check, and if needed, repair the dqblk. Don't
1503 * output any warnings because it's perfectly possible to
Nathan Scottc41564b2006-03-29 08:55:14 +10001504 * find uninitialised dquot blks. See comment in xfs_qm_dqcheck.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 */
1506 (void) xfs_qm_dqcheck(ddq, id+j, type, XFS_QMOPT_DQREPAIR,
1507 "xfs_quotacheck");
Christoph Hellwig1149d962005-11-02 15:01:12 +11001508 ddq->d_bcount = 0;
1509 ddq->d_icount = 0;
1510 ddq->d_rtbcount = 0;
1511 ddq->d_btimer = 0;
1512 ddq->d_itimer = 0;
1513 ddq->d_rtbtimer = 0;
1514 ddq->d_bwarns = 0;
1515 ddq->d_iwarns = 0;
1516 ddq->d_rtbwarns = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);
1518 }
1519
Jesper Juhl014c2542006-01-15 02:37:08 +01001520 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521}
1522
1523STATIC int
1524xfs_qm_dqiter_bufs(
1525 xfs_mount_t *mp,
1526 xfs_dqid_t firstid,
1527 xfs_fsblock_t bno,
1528 xfs_filblks_t blkcnt,
1529 uint flags)
1530{
1531 xfs_buf_t *bp;
1532 int error;
1533 int notcommitted;
1534 int incr;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001535 int type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536
1537 ASSERT(blkcnt > 0);
1538 notcommitted = 0;
1539 incr = (blkcnt > XFS_QM_MAX_DQCLUSTER_LOGSZ) ?
1540 XFS_QM_MAX_DQCLUSTER_LOGSZ : blkcnt;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001541 type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
1542 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 error = 0;
1544
1545 /*
1546 * Blkcnt arg can be a very big number, and might even be
1547 * larger than the log itself. So, we have to break it up into
1548 * manageable-sized transactions.
1549 * Note that we don't start a permanent transaction here; we might
1550 * not be able to get a log reservation for the whole thing up front,
1551 * and we don't really care to either, because we just discard
1552 * everything if we were to crash in the middle of this loop.
1553 */
1554 while (blkcnt--) {
1555 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1556 XFS_FSB_TO_DADDR(mp, bno),
1557 (int)XFS_QI_DQCHUNKLEN(mp), 0, &bp);
1558 if (error)
1559 break;
1560
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001561 (void) xfs_qm_reset_dqcounts(mp, bp, firstid, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 xfs_bdwrite(mp, bp);
1563 /*
1564 * goto the next block.
1565 */
1566 bno++;
1567 firstid += XFS_QM_DQPERBLK(mp);
1568 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001569 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570}
1571
1572/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001573 * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 * caller supplied function for every chunk of dquots that we find.
1575 */
1576STATIC int
1577xfs_qm_dqiterate(
1578 xfs_mount_t *mp,
1579 xfs_inode_t *qip,
1580 uint flags)
1581{
1582 xfs_bmbt_irec_t *map;
1583 int i, nmaps; /* number of map entries */
1584 int error; /* return value */
1585 xfs_fileoff_t lblkno;
1586 xfs_filblks_t maxlblkcnt;
1587 xfs_dqid_t firstid;
1588 xfs_fsblock_t rablkno;
1589 xfs_filblks_t rablkcnt;
1590
1591 error = 0;
1592 /*
Nathan Scottc41564b2006-03-29 08:55:14 +10001593 * This looks racy, but we can't keep an inode lock across a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 * trans_reserve. But, this gets called during quotacheck, and that
1595 * happens only at mount time which is single threaded.
1596 */
1597 if (qip->i_d.di_nblocks == 0)
Jesper Juhl014c2542006-01-15 02:37:08 +01001598 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599
1600 map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
1601
1602 lblkno = 0;
1603 maxlblkcnt = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
1604 do {
1605 nmaps = XFS_DQITER_MAP_SIZE;
1606 /*
1607 * We aren't changing the inode itself. Just changing
1608 * some of its data. No new blocks are added here, and
1609 * the inode is never added to the transaction.
1610 */
1611 xfs_ilock(qip, XFS_ILOCK_SHARED);
1612 error = xfs_bmapi(NULL, qip, lblkno,
1613 maxlblkcnt - lblkno,
1614 XFS_BMAPI_METADATA,
1615 NULL,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10001616 0, map, &nmaps, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1618 if (error)
1619 break;
1620
1621 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
1622 for (i = 0; i < nmaps; i++) {
1623 ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
1624 ASSERT(map[i].br_blockcount);
1625
1626
1627 lblkno += map[i].br_blockcount;
1628
1629 if (map[i].br_startblock == HOLESTARTBLOCK)
1630 continue;
1631
1632 firstid = (xfs_dqid_t) map[i].br_startoff *
1633 XFS_QM_DQPERBLK(mp);
1634 /*
1635 * Do a read-ahead on the next extent.
1636 */
1637 if ((i+1 < nmaps) &&
1638 (map[i+1].br_startblock != HOLESTARTBLOCK)) {
1639 rablkcnt = map[i+1].br_blockcount;
1640 rablkno = map[i+1].br_startblock;
1641 while (rablkcnt--) {
1642 xfs_baread(mp->m_ddev_targp,
1643 XFS_FSB_TO_DADDR(mp, rablkno),
1644 (int)XFS_QI_DQCHUNKLEN(mp));
1645 rablkno++;
1646 }
1647 }
1648 /*
1649 * Iterate thru all the blks in the extent and
1650 * reset the counters of all the dquots inside them.
1651 */
1652 if ((error = xfs_qm_dqiter_bufs(mp,
1653 firstid,
1654 map[i].br_startblock,
1655 map[i].br_blockcount,
1656 flags))) {
1657 break;
1658 }
1659 }
1660
1661 if (error)
1662 break;
1663 } while (nmaps > 0);
1664
1665 kmem_free(map, XFS_DQITER_MAP_SIZE * sizeof(*map));
1666
Jesper Juhl014c2542006-01-15 02:37:08 +01001667 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668}
1669
1670/*
1671 * Called by dqusage_adjust in doing a quotacheck.
1672 * Given the inode, and a dquot (either USR or GRP, doesn't matter),
1673 * this updates its incore copy as well as the buffer copy. This is
1674 * so that once the quotacheck is done, we can just log all the buffers,
1675 * as opposed to logging numerous updates to individual dquots.
1676 */
1677STATIC void
1678xfs_qm_quotacheck_dqadjust(
1679 xfs_dquot_t *dqp,
1680 xfs_qcnt_t nblks,
1681 xfs_qcnt_t rtblks)
1682{
1683 ASSERT(XFS_DQ_IS_LOCKED(dqp));
1684 xfs_dqtrace_entry(dqp, "QCHECK DQADJUST");
1685 /*
1686 * Adjust the inode count and the block count to reflect this inode's
1687 * resource usage.
1688 */
Christoph Hellwig1149d962005-11-02 15:01:12 +11001689 be64_add(&dqp->q_core.d_icount, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 dqp->q_res_icount++;
1691 if (nblks) {
Christoph Hellwig1149d962005-11-02 15:01:12 +11001692 be64_add(&dqp->q_core.d_bcount, nblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 dqp->q_res_bcount += nblks;
1694 }
1695 if (rtblks) {
Christoph Hellwig1149d962005-11-02 15:01:12 +11001696 be64_add(&dqp->q_core.d_rtbcount, rtblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 dqp->q_res_rtbcount += rtblks;
1698 }
1699
1700 /*
1701 * Set default limits, adjust timers (since we changed usages)
1702 */
1703 if (! XFS_IS_SUSER_DQUOT(dqp)) {
1704 xfs_qm_adjust_dqlimits(dqp->q_mount, &dqp->q_core);
1705 xfs_qm_adjust_dqtimers(dqp->q_mount, &dqp->q_core);
1706 }
1707
1708 dqp->dq_flags |= XFS_DQ_DIRTY;
1709}
1710
1711STATIC int
1712xfs_qm_get_rtblks(
1713 xfs_inode_t *ip,
1714 xfs_qcnt_t *O_rtblks)
1715{
1716 xfs_filblks_t rtblks; /* total rt blks */
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11001717 xfs_extnum_t idx; /* extent record index */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 xfs_ifork_t *ifp; /* inode fork pointer */
1719 xfs_extnum_t nextents; /* number of extent entries */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 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);
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10001730 for (idx = 0; idx < nextents; idx++)
1731 rtblks += xfs_bmbt_get_blockcount(xfs_iext_get_ext(ifp, idx));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 *O_rtblks = (xfs_qcnt_t)rtblks;
Jesper Juhl014c2542006-01-15 02:37:08 +01001733 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734}
1735
1736/*
1737 * callback routine supplied to bulkstat(). Given an inumber, find its
1738 * dquots and update them to account for resources taken by that inode.
1739 */
1740/* ARGSUSED */
1741STATIC int
1742xfs_qm_dqusage_adjust(
1743 xfs_mount_t *mp, /* mount point for filesystem */
1744 xfs_ino_t ino, /* inode number to get data for */
1745 void __user *buffer, /* not used */
1746 int ubsize, /* not used */
1747 void *private_data, /* not used */
1748 xfs_daddr_t bno, /* starting block of inode cluster */
1749 int *ubused, /* not used */
1750 void *dip, /* on-disk inode pointer (not used) */
1751 int *res) /* result code value */
1752{
1753 xfs_inode_t *ip;
1754 xfs_dquot_t *udqp, *gdqp;
1755 xfs_qcnt_t nblks, rtblks;
1756 int error;
1757
1758 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1759
1760 /*
1761 * rootino must have its resources accounted for, not so with the quota
1762 * inodes.
1763 */
1764 if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1765 *res = BULKSTAT_RV_NOTHING;
1766 return XFS_ERROR(EINVAL);
1767 }
1768
1769 /*
1770 * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget
1771 * interface expects the inode to be exclusively locked because that's
1772 * the case in all other instances. It's OK that we do this because
1773 * quotacheck is done only at mount time.
1774 */
1775 if ((error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip, bno))) {
1776 *res = BULKSTAT_RV_NOTHING;
Jesper Juhl014c2542006-01-15 02:37:08 +01001777 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 }
1779
1780 if (ip->i_d.di_mode == 0) {
1781 xfs_iput_new(ip, XFS_ILOCK_EXCL);
1782 *res = BULKSTAT_RV_NOTHING;
1783 return XFS_ERROR(ENOENT);
1784 }
1785
1786 /*
1787 * Obtain the locked dquots. In case of an error (eg. allocation
1788 * fails for ENOSPC), we return the negative of the error number
1789 * to bulkstat, so that it can get propagated to quotacheck() and
1790 * making us disable quotas for the file system.
1791 */
1792 if ((error = xfs_qm_dqget_noattach(ip, &udqp, &gdqp))) {
1793 xfs_iput(ip, XFS_ILOCK_EXCL);
1794 *res = BULKSTAT_RV_GIVEUP;
Jesper Juhl014c2542006-01-15 02:37:08 +01001795 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 }
1797
1798 rtblks = 0;
1799 if (! XFS_IS_REALTIME_INODE(ip)) {
1800 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks;
1801 } else {
1802 /*
1803 * Walk thru the extent list and count the realtime blocks.
1804 */
1805 if ((error = xfs_qm_get_rtblks(ip, &rtblks))) {
1806 xfs_iput(ip, XFS_ILOCK_EXCL);
1807 if (udqp)
1808 xfs_qm_dqput(udqp);
1809 if (gdqp)
1810 xfs_qm_dqput(gdqp);
1811 *res = BULKSTAT_RV_GIVEUP;
Jesper Juhl014c2542006-01-15 02:37:08 +01001812 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 }
1814 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
1815 }
1816 ASSERT(ip->i_delayed_blks == 0);
1817
1818 /*
1819 * We can't release the inode while holding its dquot locks.
1820 * The inode can go into inactive and might try to acquire the dquotlocks.
1821 * So, just unlock here and do a vn_rele at the end.
1822 */
1823 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1824
1825 /*
1826 * Add the (disk blocks and inode) resources occupied by this
1827 * inode to its dquots. We do this adjustment in the incore dquot,
1828 * and also copy the changes to its buffer.
1829 * We don't care about putting these changes in a transaction
1830 * envelope because if we crash in the middle of a 'quotacheck'
1831 * we have to start from the beginning anyway.
1832 * Once we're done, we'll log all the dquot bufs.
1833 *
Nathan Scottc41564b2006-03-29 08:55:14 +10001834 * The *QUOTA_ON checks below may look pretty racy, but quotachecks
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 * and quotaoffs don't race. (Quotachecks happen at mount time only).
1836 */
1837 if (XFS_IS_UQUOTA_ON(mp)) {
1838 ASSERT(udqp);
1839 xfs_qm_quotacheck_dqadjust(udqp, nblks, rtblks);
1840 xfs_qm_dqput(udqp);
1841 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001842 if (XFS_IS_OQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 ASSERT(gdqp);
1844 xfs_qm_quotacheck_dqadjust(gdqp, nblks, rtblks);
1845 xfs_qm_dqput(gdqp);
1846 }
1847 /*
1848 * Now release the inode. This will send it to 'inactive', and
1849 * possibly even free blocks.
1850 */
1851 VN_RELE(XFS_ITOV(ip));
1852
1853 /*
1854 * Goto next inode.
1855 */
1856 *res = BULKSTAT_RV_DIDONE;
Jesper Juhl014c2542006-01-15 02:37:08 +01001857 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858}
1859
1860/*
1861 * Walk thru all the filesystem inodes and construct a consistent view
1862 * of the disk quota world. If the quotacheck fails, disable quotas.
1863 */
1864int
1865xfs_qm_quotacheck(
1866 xfs_mount_t *mp)
1867{
1868 int done, count, error;
1869 xfs_ino_t lastino;
1870 size_t structsz;
1871 xfs_inode_t *uip, *gip;
1872 uint flags;
1873
1874 count = INT_MAX;
1875 structsz = 1;
1876 lastino = 0;
1877 flags = 0;
1878
1879 ASSERT(XFS_QI_UQIP(mp) || XFS_QI_GQIP(mp));
1880 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1881
1882 /*
1883 * There should be no cached dquots. The (simplistic) quotacheck
1884 * algorithm doesn't like that.
1885 */
1886 ASSERT(XFS_QI_MPLNDQUOTS(mp) == 0);
1887
1888 cmn_err(CE_NOTE, "XFS quotacheck %s: Please wait.", mp->m_fsname);
1889
1890 /*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001891 * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 * their counters to zero. We need a clean slate.
1893 * We don't log our changes till later.
1894 */
1895 if ((uip = XFS_QI_UQIP(mp))) {
1896 if ((error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA)))
1897 goto error_return;
1898 flags |= XFS_UQUOTA_CHKD;
1899 }
1900
1901 if ((gip = XFS_QI_GQIP(mp))) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001902 if ((error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
1903 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 goto error_return;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001905 flags |= XFS_OQUOTA_CHKD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 }
1907
1908 do {
1909 /*
1910 * Iterate thru all the inodes in the file system,
1911 * adjusting the corresponding dquot counters in core.
1912 */
1913 if ((error = xfs_bulkstat(mp, &lastino, &count,
1914 xfs_qm_dqusage_adjust, NULL,
Nathan Scott9c488762006-06-09 15:29:22 +10001915 structsz, NULL, BULKSTAT_FG_IGET, &done)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 break;
1917
1918 } while (! done);
1919
1920 /*
1921 * We can get this error if we couldn't do a dquot allocation inside
1922 * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
1923 * dirty dquots that might be cached, we just want to get rid of them
1924 * and turn quotaoff. The dquots won't be attached to any of the inodes
1925 * at this point (because we intentionally didn't in dqget_noattach).
1926 */
1927 if (error) {
Nathan Scottee2a4f72006-01-11 15:33:36 +11001928 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL | XFS_QMOPT_QUOTAOFF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 goto error_return;
1930 }
1931 /*
1932 * We've made all the changes that we need to make incore.
1933 * Now flush_them down to disk buffers.
1934 */
1935 xfs_qm_dqflush_all(mp, XFS_QMOPT_DELWRI);
1936
1937 /*
1938 * We didn't log anything, because if we crashed, we'll have to
1939 * start the quotacheck from scratch anyway. However, we must make
1940 * sure that our dquot changes are secure before we put the
1941 * quotacheck'd stamp on the superblock. So, here we do a synchronous
1942 * flush.
1943 */
1944 XFS_bflush(mp->m_ddev_targp);
1945
1946 /*
1947 * If one type of quotas is off, then it will lose its
1948 * quotachecked status, since we won't be doing accounting for
1949 * that type anymore.
1950 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001951 mp->m_qflags &= ~(XFS_OQUOTA_CHKD | XFS_UQUOTA_CHKD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 mp->m_qflags |= flags;
1953
1954 XQM_LIST_PRINT(&(XFS_QI_MPL_LIST(mp)), MPL_NEXT, "++++ Mp list +++");
1955
1956 error_return:
1957 if (error) {
1958 cmn_err(CE_WARN, "XFS quotacheck %s: Unsuccessful (Error %d): "
1959 "Disabling quotas.",
1960 mp->m_fsname, error);
1961 /*
1962 * We must turn off quotas.
1963 */
1964 ASSERT(mp->m_quotainfo != NULL);
1965 ASSERT(xfs_Gqm != NULL);
1966 xfs_qm_destroy_quotainfo(mp);
Tim Shimmin4cd4a032005-09-05 08:24:10 +10001967 (void)xfs_mount_reset_sbqflags(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 } else {
1969 cmn_err(CE_NOTE, "XFS quotacheck %s: Done.", mp->m_fsname);
1970 }
1971 return (error);
1972}
1973
1974/*
1975 * This is called after the superblock has been read in and we're ready to
1976 * iget the quota inodes.
1977 */
1978STATIC int
1979xfs_qm_init_quotainos(
1980 xfs_mount_t *mp)
1981{
1982 xfs_inode_t *uip, *gip;
1983 int error;
1984 __int64_t sbflags;
1985 uint flags;
1986
1987 ASSERT(mp->m_quotainfo);
1988 uip = gip = NULL;
1989 sbflags = 0;
1990 flags = 0;
1991
1992 /*
1993 * Get the uquota and gquota inodes
1994 */
1995 if (XFS_SB_VERSION_HASQUOTA(&mp->m_sb)) {
1996 if (XFS_IS_UQUOTA_ON(mp) &&
1997 mp->m_sb.sb_uquotino != NULLFSINO) {
1998 ASSERT(mp->m_sb.sb_uquotino > 0);
1999 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
2000 0, 0, &uip, 0)))
2001 return XFS_ERROR(error);
2002 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002003 if (XFS_IS_OQUOTA_ON(mp) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 mp->m_sb.sb_gquotino != NULLFSINO) {
2005 ASSERT(mp->m_sb.sb_gquotino > 0);
2006 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
2007 0, 0, &gip, 0))) {
2008 if (uip)
2009 VN_RELE(XFS_ITOV(uip));
2010 return XFS_ERROR(error);
2011 }
2012 }
2013 } else {
2014 flags |= XFS_QMOPT_SBVERSION;
2015 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
2016 XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
2017 }
2018
2019 /*
2020 * Create the two inodes, if they don't exist already. The changes
2021 * made above will get added to a transaction and logged in one of
2022 * the qino_alloc calls below. If the device is readonly,
2023 * temporarily switch to read-write to do this.
2024 */
2025 if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
2026 if ((error = xfs_qm_qino_alloc(mp, &uip,
2027 sbflags | XFS_SB_UQUOTINO,
2028 flags | XFS_QMOPT_UQUOTA)))
2029 return XFS_ERROR(error);
2030
2031 flags &= ~XFS_QMOPT_SBVERSION;
2032 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002033 if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) {
2034 flags |= (XFS_IS_GQUOTA_ON(mp) ?
2035 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
2036 error = xfs_qm_qino_alloc(mp, &gip,
2037 sbflags | XFS_SB_GQUOTINO, flags);
2038 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 if (uip)
2040 VN_RELE(XFS_ITOV(uip));
2041
2042 return XFS_ERROR(error);
2043 }
2044 }
2045
2046 XFS_QI_UQIP(mp) = uip;
2047 XFS_QI_GQIP(mp) = gip;
2048
Jesper Juhl014c2542006-01-15 02:37:08 +01002049 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050}
2051
2052
2053/*
2054 * Traverse the freelist of dquots and attempt to reclaim a maximum of
2055 * 'howmany' dquots. This operation races with dqlookup(), and attempts to
2056 * favor the lookup function ...
2057 * XXXsup merge this with qm_reclaim_one().
2058 */
2059STATIC int
2060xfs_qm_shake_freelist(
2061 int howmany)
2062{
2063 int nreclaimed;
2064 xfs_dqhash_t *hash;
2065 xfs_dquot_t *dqp, *nextdqp;
2066 int restarts;
2067 int nflushes;
2068
2069 if (howmany <= 0)
Jesper Juhl014c2542006-01-15 02:37:08 +01002070 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071
2072 nreclaimed = 0;
2073 restarts = 0;
2074 nflushes = 0;
2075
2076#ifdef QUOTADEBUG
2077 cmn_err(CE_DEBUG, "Shake free 0x%x", howmany);
2078#endif
2079 /* lock order is : hashchainlock, freelistlock, mplistlock */
2080 tryagain:
2081 xfs_qm_freelist_lock(xfs_Gqm);
2082
2083 for (dqp = xfs_Gqm->qm_dqfreelist.qh_next;
2084 ((dqp != (xfs_dquot_t *) &xfs_Gqm->qm_dqfreelist) &&
2085 nreclaimed < howmany); ) {
2086 xfs_dqlock(dqp);
2087
2088 /*
2089 * We are racing with dqlookup here. Naturally we don't
2090 * want to reclaim a dquot that lookup wants.
2091 */
2092 if (dqp->dq_flags & XFS_DQ_WANT) {
2093 xfs_dqunlock(dqp);
2094 xfs_qm_freelist_unlock(xfs_Gqm);
2095 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
Jesper Juhl014c2542006-01-15 02:37:08 +01002096 return nreclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 XQM_STATS_INC(xqmstats.xs_qm_dqwants);
2098 goto tryagain;
2099 }
2100
2101 /*
2102 * If the dquot is inactive, we are assured that it is
2103 * not on the mplist or the hashlist, and that makes our
2104 * life easier.
2105 */
2106 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
2107 ASSERT(dqp->q_mount == NULL);
2108 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
2109 ASSERT(dqp->HL_PREVP == NULL);
2110 ASSERT(dqp->MPL_PREVP == NULL);
2111 XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
2112 nextdqp = dqp->dq_flnext;
2113 goto off_freelist;
2114 }
2115
2116 ASSERT(dqp->MPL_PREVP);
2117 /*
2118 * Try to grab the flush lock. If this dquot is in the process of
2119 * getting flushed to disk, we don't want to reclaim it.
2120 */
2121 if (! xfs_qm_dqflock_nowait(dqp)) {
2122 xfs_dqunlock(dqp);
2123 dqp = dqp->dq_flnext;
2124 continue;
2125 }
2126
2127 /*
2128 * We have the flush lock so we know that this is not in the
2129 * process of being flushed. So, if this is dirty, flush it
2130 * DELWRI so that we don't get a freelist infested with
2131 * dirty dquots.
2132 */
2133 if (XFS_DQ_IS_DIRTY(dqp)) {
2134 xfs_dqtrace_entry(dqp, "DQSHAKE: DQDIRTY");
2135 /*
2136 * We flush it delayed write, so don't bother
2137 * releasing the mplock.
2138 */
2139 (void) xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
2140 xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
2141 dqp = dqp->dq_flnext;
2142 continue;
2143 }
2144 /*
2145 * We're trying to get the hashlock out of order. This races
2146 * with dqlookup; so, we giveup and goto the next dquot if
2147 * we couldn't get the hashlock. This way, we won't starve
2148 * a dqlookup process that holds the hashlock that is
2149 * waiting for the freelist lock.
2150 */
2151 if (! xfs_qm_dqhashlock_nowait(dqp)) {
2152 xfs_dqfunlock(dqp);
2153 xfs_dqunlock(dqp);
2154 dqp = dqp->dq_flnext;
2155 continue;
2156 }
2157 /*
2158 * This races with dquot allocation code as well as dqflush_all
2159 * and reclaim code. So, if we failed to grab the mplist lock,
2160 * giveup everything and start over.
2161 */
2162 hash = dqp->q_hash;
2163 ASSERT(hash);
2164 if (! xfs_qm_mplist_nowait(dqp->q_mount)) {
2165 /* XXX put a sentinel so that we can come back here */
2166 xfs_dqfunlock(dqp);
2167 xfs_dqunlock(dqp);
2168 XFS_DQ_HASH_UNLOCK(hash);
2169 xfs_qm_freelist_unlock(xfs_Gqm);
2170 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
Jesper Juhl014c2542006-01-15 02:37:08 +01002171 return nreclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 goto tryagain;
2173 }
2174 xfs_dqtrace_entry(dqp, "DQSHAKE: UNLINKING");
2175#ifdef QUOTADEBUG
2176 cmn_err(CE_DEBUG, "Shake 0x%p, ID 0x%x\n",
Christoph Hellwig1149d962005-11-02 15:01:12 +11002177 dqp, be32_to_cpu(dqp->q_core.d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178#endif
2179 ASSERT(dqp->q_nrefs == 0);
2180 nextdqp = dqp->dq_flnext;
2181 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(dqp->q_mount)), dqp);
2182 XQM_HASHLIST_REMOVE(hash, dqp);
2183 xfs_dqfunlock(dqp);
2184 xfs_qm_mplist_unlock(dqp->q_mount);
2185 XFS_DQ_HASH_UNLOCK(hash);
2186
2187 off_freelist:
2188 XQM_FREELIST_REMOVE(dqp);
2189 xfs_dqunlock(dqp);
2190 nreclaimed++;
2191 XQM_STATS_INC(xqmstats.xs_qm_dqshake_reclaims);
2192 xfs_qm_dqdestroy(dqp);
2193 dqp = nextdqp;
2194 }
2195 xfs_qm_freelist_unlock(xfs_Gqm);
Jesper Juhl014c2542006-01-15 02:37:08 +01002196 return nreclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197}
2198
2199
2200/*
2201 * The kmem_shake interface is invoked when memory is running low.
2202 */
2203/* ARGSUSED */
2204STATIC int
Al Viro51bfb752005-12-15 09:17:24 +00002205xfs_qm_shake(int nr_to_scan, gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206{
2207 int ndqused, nfree, n;
2208
2209 if (!kmem_shake_allow(gfp_mask))
Jesper Juhl014c2542006-01-15 02:37:08 +01002210 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211 if (!xfs_Gqm)
Jesper Juhl014c2542006-01-15 02:37:08 +01002212 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213
2214 nfree = xfs_Gqm->qm_dqfreelist.qh_nelems; /* free dquots */
2215 /* incore dquots in all f/s's */
2216 ndqused = atomic_read(&xfs_Gqm->qm_totaldquots) - nfree;
2217
2218 ASSERT(ndqused >= 0);
2219
2220 if (nfree <= ndqused && nfree < ndquot)
Jesper Juhl014c2542006-01-15 02:37:08 +01002221 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222
2223 ndqused *= xfs_Gqm->qm_dqfree_ratio; /* target # of free dquots */
2224 n = nfree - ndqused - ndquot; /* # over target */
2225
2226 return xfs_qm_shake_freelist(MAX(nfree, n));
2227}
2228
2229
2230/*
2231 * Just pop the least recently used dquot off the freelist and
2232 * recycle it. The returned dquot is locked.
2233 */
2234STATIC xfs_dquot_t *
2235xfs_qm_dqreclaim_one(void)
2236{
2237 xfs_dquot_t *dqpout;
2238 xfs_dquot_t *dqp;
2239 int restarts;
2240 int nflushes;
2241
2242 restarts = 0;
2243 dqpout = NULL;
2244 nflushes = 0;
2245
2246 /* lockorder: hashchainlock, freelistlock, mplistlock, dqlock, dqflock */
2247 startagain:
2248 xfs_qm_freelist_lock(xfs_Gqm);
2249
2250 FOREACH_DQUOT_IN_FREELIST(dqp, &(xfs_Gqm->qm_dqfreelist)) {
2251 xfs_dqlock(dqp);
2252
2253 /*
2254 * We are racing with dqlookup here. Naturally we don't
2255 * want to reclaim a dquot that lookup wants. We release the
2256 * freelist lock and start over, so that lookup will grab
2257 * both the dquot and the freelistlock.
2258 */
2259 if (dqp->dq_flags & XFS_DQ_WANT) {
2260 ASSERT(! (dqp->dq_flags & XFS_DQ_INACTIVE));
2261 xfs_dqtrace_entry(dqp, "DQRECLAIM: DQWANT");
2262 xfs_dqunlock(dqp);
2263 xfs_qm_freelist_unlock(xfs_Gqm);
2264 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
Jesper Juhl014c2542006-01-15 02:37:08 +01002265 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 XQM_STATS_INC(xqmstats.xs_qm_dqwants);
2267 goto startagain;
2268 }
2269
2270 /*
2271 * If the dquot is inactive, we are assured that it is
2272 * not on the mplist or the hashlist, and that makes our
2273 * life easier.
2274 */
2275 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
2276 ASSERT(dqp->q_mount == NULL);
2277 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
2278 ASSERT(dqp->HL_PREVP == NULL);
2279 ASSERT(dqp->MPL_PREVP == NULL);
2280 XQM_FREELIST_REMOVE(dqp);
2281 xfs_dqunlock(dqp);
2282 dqpout = dqp;
2283 XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
2284 break;
2285 }
2286
2287 ASSERT(dqp->q_hash);
2288 ASSERT(dqp->MPL_PREVP);
2289
2290 /*
2291 * Try to grab the flush lock. If this dquot is in the process of
2292 * getting flushed to disk, we don't want to reclaim it.
2293 */
2294 if (! xfs_qm_dqflock_nowait(dqp)) {
2295 xfs_dqunlock(dqp);
2296 continue;
2297 }
2298
2299 /*
2300 * We have the flush lock so we know that this is not in the
2301 * process of being flushed. So, if this is dirty, flush it
2302 * DELWRI so that we don't get a freelist infested with
2303 * dirty dquots.
2304 */
2305 if (XFS_DQ_IS_DIRTY(dqp)) {
2306 xfs_dqtrace_entry(dqp, "DQRECLAIM: DQDIRTY");
2307 /*
2308 * We flush it delayed write, so don't bother
2309 * releasing the freelist lock.
2310 */
2311 (void) xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
2312 xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
2313 continue;
2314 }
2315
2316 if (! xfs_qm_mplist_nowait(dqp->q_mount)) {
2317 xfs_dqfunlock(dqp);
2318 xfs_dqunlock(dqp);
2319 continue;
2320 }
2321
2322 if (! xfs_qm_dqhashlock_nowait(dqp))
2323 goto mplistunlock;
2324
2325 ASSERT(dqp->q_nrefs == 0);
2326 xfs_dqtrace_entry(dqp, "DQRECLAIM: UNLINKING");
2327 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(dqp->q_mount)), dqp);
2328 XQM_HASHLIST_REMOVE(dqp->q_hash, dqp);
2329 XQM_FREELIST_REMOVE(dqp);
2330 dqpout = dqp;
2331 XFS_DQ_HASH_UNLOCK(dqp->q_hash);
2332 mplistunlock:
2333 xfs_qm_mplist_unlock(dqp->q_mount);
2334 xfs_dqfunlock(dqp);
2335 xfs_dqunlock(dqp);
2336 if (dqpout)
2337 break;
2338 }
2339
2340 xfs_qm_freelist_unlock(xfs_Gqm);
Jesper Juhl014c2542006-01-15 02:37:08 +01002341 return dqpout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342}
2343
2344
2345/*------------------------------------------------------------------*/
2346
2347/*
2348 * Return a new incore dquot. Depending on the number of
2349 * dquots in the system, we either allocate a new one on the kernel heap,
2350 * or reclaim a free one.
2351 * Return value is B_TRUE if we allocated a new dquot, B_FALSE if we managed
2352 * to reclaim an existing one from the freelist.
2353 */
2354boolean_t
2355xfs_qm_dqalloc_incore(
2356 xfs_dquot_t **O_dqpp)
2357{
2358 xfs_dquot_t *dqp;
2359
2360 /*
2361 * Check against high water mark to see if we want to pop
2362 * a nincompoop dquot off the freelist.
2363 */
2364 if (atomic_read(&xfs_Gqm->qm_totaldquots) >= ndquot) {
2365 /*
2366 * Try to recycle a dquot from the freelist.
2367 */
2368 if ((dqp = xfs_qm_dqreclaim_one())) {
2369 XQM_STATS_INC(xqmstats.xs_qm_dqreclaims);
2370 /*
2371 * Just zero the core here. The rest will get
2372 * reinitialized by caller. XXX we shouldn't even
2373 * do this zero ...
2374 */
2375 memset(&dqp->q_core, 0, sizeof(dqp->q_core));
2376 *O_dqpp = dqp;
Jesper Juhl014c2542006-01-15 02:37:08 +01002377 return B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378 }
2379 XQM_STATS_INC(xqmstats.xs_qm_dqreclaim_misses);
2380 }
2381
2382 /*
2383 * Allocate a brand new dquot on the kernel heap and return it
2384 * to the caller to initialize.
2385 */
2386 ASSERT(xfs_Gqm->qm_dqzone != NULL);
2387 *O_dqpp = kmem_zone_zalloc(xfs_Gqm->qm_dqzone, KM_SLEEP);
2388 atomic_inc(&xfs_Gqm->qm_totaldquots);
2389
Jesper Juhl014c2542006-01-15 02:37:08 +01002390 return B_TRUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391}
2392
2393
2394/*
2395 * Start a transaction and write the incore superblock changes to
2396 * disk. flags parameter indicates which fields have changed.
2397 */
2398int
2399xfs_qm_write_sb_changes(
2400 xfs_mount_t *mp,
2401 __int64_t flags)
2402{
2403 xfs_trans_t *tp;
2404 int error;
2405
2406#ifdef QUOTADEBUG
2407 cmn_err(CE_NOTE, "Writing superblock quota changes :%s", mp->m_fsname);
2408#endif
2409 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
2410 if ((error = xfs_trans_reserve(tp, 0,
2411 mp->m_sb.sb_sectsize + 128, 0,
2412 0,
2413 XFS_DEFAULT_LOG_COUNT))) {
2414 xfs_trans_cancel(tp, 0);
Jesper Juhl014c2542006-01-15 02:37:08 +01002415 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416 }
2417
2418 xfs_mod_sb(tp, flags);
Eric Sandeen1c72bf92007-05-08 13:48:42 +10002419 (void) xfs_trans_commit(tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420
Jesper Juhl014c2542006-01-15 02:37:08 +01002421 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422}
2423
2424
2425/* --------------- utility functions for vnodeops ---------------- */
2426
2427
2428/*
2429 * Given an inode, a uid and gid (from cred_t) make sure that we have
2430 * allocated relevant dquot(s) on disk, and that we won't exceed inode
2431 * quotas by creating this file.
2432 * This also attaches dquot(s) to the given inode after locking it,
2433 * and returns the dquots corresponding to the uid and/or gid.
2434 *
2435 * in : inode (unlocked)
2436 * out : udquot, gdquot with references taken and unlocked
2437 */
2438int
2439xfs_qm_vop_dqalloc(
2440 xfs_mount_t *mp,
2441 xfs_inode_t *ip,
2442 uid_t uid,
2443 gid_t gid,
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002444 prid_t prid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 uint flags,
2446 xfs_dquot_t **O_udqpp,
2447 xfs_dquot_t **O_gdqpp)
2448{
2449 int error;
2450 xfs_dquot_t *uq, *gq;
2451 uint lockflags;
2452
2453 if (!XFS_IS_QUOTA_ON(mp))
2454 return 0;
2455
2456 lockflags = XFS_ILOCK_EXCL;
2457 xfs_ilock(ip, lockflags);
2458
2459 if ((flags & XFS_QMOPT_INHERIT) &&
2460 XFS_INHERIT_GID(ip, XFS_MTOVFS(mp)))
2461 gid = ip->i_d.di_gid;
2462
2463 /*
2464 * Attach the dquot(s) to this inode, doing a dquot allocation
2465 * if necessary. The dquot(s) will not be locked.
2466 */
2467 if (XFS_NOT_DQATTACHED(mp, ip)) {
2468 if ((error = xfs_qm_dqattach(ip, XFS_QMOPT_DQALLOC |
2469 XFS_QMOPT_ILOCKED))) {
2470 xfs_iunlock(ip, lockflags);
Jesper Juhl014c2542006-01-15 02:37:08 +01002471 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472 }
2473 }
2474
2475 uq = gq = NULL;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002476 if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 if (ip->i_d.di_uid != uid) {
2478 /*
2479 * What we need is the dquot that has this uid, and
2480 * if we send the inode to dqget, the uid of the inode
2481 * takes priority over what's sent in the uid argument.
2482 * We must unlock inode here before calling dqget if
2483 * we're not sending the inode, because otherwise
2484 * we'll deadlock by doing trans_reserve while
2485 * holding ilock.
2486 */
2487 xfs_iunlock(ip, lockflags);
2488 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
2489 XFS_DQ_USER,
2490 XFS_QMOPT_DQALLOC |
2491 XFS_QMOPT_DOWARN,
2492 &uq))) {
2493 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01002494 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495 }
2496 /*
2497 * Get the ilock in the right order.
2498 */
2499 xfs_dqunlock(uq);
2500 lockflags = XFS_ILOCK_SHARED;
2501 xfs_ilock(ip, lockflags);
2502 } else {
2503 /*
2504 * Take an extra reference, because we'll return
2505 * this to caller
2506 */
2507 ASSERT(ip->i_udquot);
2508 uq = ip->i_udquot;
2509 xfs_dqlock(uq);
2510 XFS_DQHOLD(uq);
2511 xfs_dqunlock(uq);
2512 }
2513 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002514 if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 if (ip->i_d.di_gid != gid) {
2516 xfs_iunlock(ip, lockflags);
2517 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
2518 XFS_DQ_GROUP,
2519 XFS_QMOPT_DQALLOC |
2520 XFS_QMOPT_DOWARN,
2521 &gq))) {
2522 if (uq)
2523 xfs_qm_dqrele(uq);
2524 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01002525 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526 }
2527 xfs_dqunlock(gq);
2528 lockflags = XFS_ILOCK_SHARED;
2529 xfs_ilock(ip, lockflags);
2530 } else {
2531 ASSERT(ip->i_gdquot);
2532 gq = ip->i_gdquot;
2533 xfs_dqlock(gq);
2534 XFS_DQHOLD(gq);
2535 xfs_dqunlock(gq);
2536 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002537 } else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
2538 if (ip->i_d.di_projid != prid) {
2539 xfs_iunlock(ip, lockflags);
2540 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
2541 XFS_DQ_PROJ,
2542 XFS_QMOPT_DQALLOC |
2543 XFS_QMOPT_DOWARN,
2544 &gq))) {
2545 if (uq)
2546 xfs_qm_dqrele(uq);
2547 ASSERT(error != ENOENT);
2548 return (error);
2549 }
2550 xfs_dqunlock(gq);
2551 lockflags = XFS_ILOCK_SHARED;
2552 xfs_ilock(ip, lockflags);
2553 } else {
2554 ASSERT(ip->i_gdquot);
2555 gq = ip->i_gdquot;
2556 xfs_dqlock(gq);
2557 XFS_DQHOLD(gq);
2558 xfs_dqunlock(gq);
2559 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560 }
2561 if (uq)
2562 xfs_dqtrace_entry_ino(uq, "DQALLOC", ip);
2563
2564 xfs_iunlock(ip, lockflags);
2565 if (O_udqpp)
2566 *O_udqpp = uq;
2567 else if (uq)
2568 xfs_qm_dqrele(uq);
2569 if (O_gdqpp)
2570 *O_gdqpp = gq;
2571 else if (gq)
2572 xfs_qm_dqrele(gq);
Jesper Juhl014c2542006-01-15 02:37:08 +01002573 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574}
2575
2576/*
2577 * Actually transfer ownership, and do dquot modifications.
2578 * These were already reserved.
2579 */
2580xfs_dquot_t *
2581xfs_qm_vop_chown(
2582 xfs_trans_t *tp,
2583 xfs_inode_t *ip,
2584 xfs_dquot_t **IO_olddq,
2585 xfs_dquot_t *newdq)
2586{
2587 xfs_dquot_t *prevdq;
Nathan Scott06d10dd2005-06-21 15:48:47 +10002588 uint bfield = XFS_IS_REALTIME_INODE(ip) ?
2589 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
2590
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
2592 ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
2593
2594 /* old dquot */
2595 prevdq = *IO_olddq;
2596 ASSERT(prevdq);
2597 ASSERT(prevdq != newdq);
2598
Nathan Scott06d10dd2005-06-21 15:48:47 +10002599 xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
2600 xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601
2602 /* the sparkling new dquot */
Nathan Scott06d10dd2005-06-21 15:48:47 +10002603 xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
2604 xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605
2606 /*
2607 * Take an extra reference, because the inode
2608 * is going to keep this dquot pointer even
2609 * after the trans_commit.
2610 */
2611 xfs_dqlock(newdq);
2612 XFS_DQHOLD(newdq);
2613 xfs_dqunlock(newdq);
2614 *IO_olddq = newdq;
2615
Jesper Juhl014c2542006-01-15 02:37:08 +01002616 return prevdq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617}
2618
2619/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002620 * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
Linus Torvalds1da177e2005-04-16 15:20:36 -07002621 */
2622int
2623xfs_qm_vop_chown_reserve(
2624 xfs_trans_t *tp,
2625 xfs_inode_t *ip,
2626 xfs_dquot_t *udqp,
2627 xfs_dquot_t *gdqp,
2628 uint flags)
2629{
2630 int error;
2631 xfs_mount_t *mp;
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002632 uint delblks, blkflags, prjflags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002633 xfs_dquot_t *unresudq, *unresgdq, *delblksudq, *delblksgdq;
2634
2635 ASSERT(XFS_ISLOCKED_INODE(ip));
2636 mp = ip->i_mount;
2637 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2638
2639 delblks = ip->i_delayed_blks;
2640 delblksudq = delblksgdq = unresudq = unresgdq = NULL;
Nathan Scott06d10dd2005-06-21 15:48:47 +10002641 blkflags = XFS_IS_REALTIME_INODE(ip) ?
2642 XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643
2644 if (XFS_IS_UQUOTA_ON(mp) && udqp &&
Christoph Hellwig1149d962005-11-02 15:01:12 +11002645 ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646 delblksudq = udqp;
2647 /*
2648 * If there are delayed allocation blocks, then we have to
2649 * unreserve those from the old dquot, and add them to the
2650 * new dquot.
2651 */
2652 if (delblks) {
2653 ASSERT(ip->i_udquot);
2654 unresudq = ip->i_udquot;
2655 }
2656 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002657 if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002658 if (XFS_IS_PQUOTA_ON(ip->i_mount) &&
2659 ip->i_d.di_projid != be32_to_cpu(gdqp->q_core.d_id))
2660 prjflags = XFS_QMOPT_ENOSPC;
2661
2662 if (prjflags ||
2663 (XFS_IS_GQUOTA_ON(ip->i_mount) &&
2664 ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002665 delblksgdq = gdqp;
2666 if (delblks) {
2667 ASSERT(ip->i_gdquot);
2668 unresgdq = ip->i_gdquot;
2669 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002670 }
2671 }
2672
2673 if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
2674 delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002675 flags | blkflags | prjflags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002676 return (error);
2677
2678 /*
2679 * Do the delayed blks reservations/unreservations now. Since, these
2680 * are done without the help of a transaction, if a reservation fails
2681 * its previous reservations won't be automatically undone by trans
2682 * code. So, we have to do it manually here.
2683 */
2684 if (delblks) {
2685 /*
2686 * Do the reservations first. Unreservation can't fail.
2687 */
2688 ASSERT(delblksudq || delblksgdq);
2689 ASSERT(unresudq || unresgdq);
2690 if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2691 delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002692 flags | blkflags | prjflags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002693 return (error);
2694 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2695 unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
Nathan Scott06d10dd2005-06-21 15:48:47 +10002696 blkflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697 }
2698
2699 return (0);
2700}
2701
2702int
2703xfs_qm_vop_rename_dqattach(
2704 xfs_inode_t **i_tab)
2705{
2706 xfs_inode_t *ip;
2707 int i;
2708 int error;
2709
2710 ip = i_tab[0];
2711
2712 if (! XFS_IS_QUOTA_ON(ip->i_mount))
Jesper Juhl014c2542006-01-15 02:37:08 +01002713 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002714
2715 if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
2716 error = xfs_qm_dqattach(ip, 0);
2717 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01002718 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719 }
2720 for (i = 1; (i < 4 && i_tab[i]); i++) {
2721 /*
2722 * Watch out for duplicate entries in the table.
2723 */
2724 if ((ip = i_tab[i]) != i_tab[i-1]) {
2725 if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
2726 error = xfs_qm_dqattach(ip, 0);
2727 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01002728 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729 }
2730 }
2731 }
Jesper Juhl014c2542006-01-15 02:37:08 +01002732 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733}
2734
2735void
2736xfs_qm_vop_dqattach_and_dqmod_newinode(
2737 xfs_trans_t *tp,
2738 xfs_inode_t *ip,
2739 xfs_dquot_t *udqp,
2740 xfs_dquot_t *gdqp)
2741{
2742 if (!XFS_IS_QUOTA_ON(tp->t_mountp))
2743 return;
2744
2745 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
2746 ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp));
2747
2748 if (udqp) {
2749 xfs_dqlock(udqp);
2750 XFS_DQHOLD(udqp);
2751 xfs_dqunlock(udqp);
2752 ASSERT(ip->i_udquot == NULL);
2753 ip->i_udquot = udqp;
Nathan Scottee2a4f72006-01-11 15:33:36 +11002754 ASSERT(XFS_IS_UQUOTA_ON(tp->t_mountp));
Christoph Hellwig1149d962005-11-02 15:01:12 +11002755 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
2757 }
2758 if (gdqp) {
2759 xfs_dqlock(gdqp);
2760 XFS_DQHOLD(gdqp);
2761 xfs_dqunlock(gdqp);
2762 ASSERT(ip->i_gdquot == NULL);
2763 ip->i_gdquot = gdqp;
Nathan Scottee2a4f72006-01-11 15:33:36 +11002764 ASSERT(XFS_IS_OQUOTA_ON(tp->t_mountp));
2765 ASSERT((XFS_IS_GQUOTA_ON(tp->t_mountp) ?
2766 ip->i_d.di_gid : ip->i_d.di_projid) ==
2767 be32_to_cpu(gdqp->q_core.d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
2769 }
2770}
2771
2772/* ------------- list stuff -----------------*/
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002773STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774xfs_qm_freelist_init(xfs_frlist_t *ql)
2775{
2776 ql->qh_next = ql->qh_prev = (xfs_dquot_t *) ql;
Jes Sorensen794ee1b2006-01-09 15:59:21 -08002777 mutex_init(&ql->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778 ql->qh_version = 0;
2779 ql->qh_nelems = 0;
2780}
2781
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002782STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783xfs_qm_freelist_destroy(xfs_frlist_t *ql)
2784{
2785 xfs_dquot_t *dqp, *nextdqp;
2786
Jes Sorensen794ee1b2006-01-09 15:59:21 -08002787 mutex_lock(&ql->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002788 for (dqp = ql->qh_next;
2789 dqp != (xfs_dquot_t *)ql; ) {
2790 xfs_dqlock(dqp);
2791 nextdqp = dqp->dq_flnext;
2792#ifdef QUOTADEBUG
2793 cmn_err(CE_DEBUG, "FREELIST destroy 0x%p", dqp);
2794#endif
2795 XQM_FREELIST_REMOVE(dqp);
2796 xfs_dqunlock(dqp);
2797 xfs_qm_dqdestroy(dqp);
2798 dqp = nextdqp;
2799 }
Nathan Scott20722a92006-03-14 13:19:08 +11002800 mutex_unlock(&ql->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801 mutex_destroy(&ql->qh_lock);
2802
2803 ASSERT(ql->qh_nelems == 0);
2804}
2805
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002806STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807xfs_qm_freelist_insert(xfs_frlist_t *ql, xfs_dquot_t *dq)
2808{
2809 dq->dq_flnext = ql->qh_next;
2810 dq->dq_flprev = (xfs_dquot_t *)ql;
2811 ql->qh_next = dq;
2812 dq->dq_flnext->dq_flprev = dq;
2813 xfs_Gqm->qm_dqfreelist.qh_nelems++;
2814 xfs_Gqm->qm_dqfreelist.qh_version++;
2815}
2816
2817void
2818xfs_qm_freelist_unlink(xfs_dquot_t *dq)
2819{
2820 xfs_dquot_t *next = dq->dq_flnext;
2821 xfs_dquot_t *prev = dq->dq_flprev;
2822
2823 next->dq_flprev = prev;
2824 prev->dq_flnext = next;
2825 dq->dq_flnext = dq->dq_flprev = dq;
2826 xfs_Gqm->qm_dqfreelist.qh_nelems--;
2827 xfs_Gqm->qm_dqfreelist.qh_version++;
2828}
2829
2830void
2831xfs_qm_freelist_append(xfs_frlist_t *ql, xfs_dquot_t *dq)
2832{
2833 xfs_qm_freelist_insert((xfs_frlist_t *)ql->qh_prev, dq);
2834}
2835
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002836STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837xfs_qm_dqhashlock_nowait(
2838 xfs_dquot_t *dqp)
2839{
2840 int locked;
2841
2842 locked = mutex_trylock(&((dqp)->q_hash->qh_lock));
Jesper Juhl014c2542006-01-15 02:37:08 +01002843 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844}
2845
2846int
2847xfs_qm_freelist_lock_nowait(
2848 xfs_qm_t *xqm)
2849{
2850 int locked;
2851
2852 locked = mutex_trylock(&(xqm->qm_dqfreelist.qh_lock));
Jesper Juhl014c2542006-01-15 02:37:08 +01002853 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854}
2855
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002856STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002857xfs_qm_mplist_nowait(
2858 xfs_mount_t *mp)
2859{
2860 int locked;
2861
2862 ASSERT(mp->m_quotainfo);
2863 locked = mutex_trylock(&(XFS_QI_MPLLOCK(mp)));
Jesper Juhl014c2542006-01-15 02:37:08 +01002864 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002865}