blob: f665ca8f9e960c93c65d0cc31c244fded5f3e73a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (c) 2000-2004 Silicon Graphics, Inc. All Rights Reserved.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of version 2 of the GNU General Public License as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it would be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 *
12 * Further, this software is distributed without any warranty that it is
13 * free of the rightful claim of any third person regarding infringement
14 * or the like. Any license provided herein, whether implied or
15 * otherwise, applies only to this software file. Patent licenses, if
16 * any, provided herein do not apply to combinations of this program with
17 * other software, or any other product whatsoever.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write the Free Software Foundation, Inc., 59
21 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
22 *
23 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24 * Mountain View, CA 94043, or:
25 *
26 * http://www.sgi.com
27 *
28 * For further information regarding this notice, see:
29 *
30 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
31 */
32
33#include "xfs.h"
34#include "xfs_fs.h"
35#include "xfs_inum.h"
36#include "xfs_log.h"
37#include "xfs_clnt.h"
38#include "xfs_trans.h"
39#include "xfs_sb.h"
40#include "xfs_ag.h"
41#include "xfs_dir.h"
42#include "xfs_dir2.h"
43#include "xfs_alloc.h"
44#include "xfs_dmapi.h"
45#include "xfs_quota.h"
46#include "xfs_mount.h"
47#include "xfs_alloc_btree.h"
48#include "xfs_bmap_btree.h"
49#include "xfs_ialloc_btree.h"
50#include "xfs_btree.h"
51#include "xfs_ialloc.h"
52#include "xfs_attr_sf.h"
53#include "xfs_dir_sf.h"
54#include "xfs_dir2_sf.h"
55#include "xfs_dinode.h"
56#include "xfs_inode.h"
57#include "xfs_bmap.h"
58#include "xfs_bit.h"
59#include "xfs_rtalloc.h"
60#include "xfs_error.h"
61#include "xfs_itable.h"
62#include "xfs_rw.h"
63#include "xfs_acl.h"
64#include "xfs_cap.h"
65#include "xfs_mac.h"
66#include "xfs_attr.h"
67#include "xfs_buf_item.h"
68#include "xfs_trans_space.h"
69#include "xfs_utils.h"
70
71#include "xfs_qm.h"
72
73/*
74 * The global quota manager. There is only one of these for the entire
75 * system, _not_ one per file system. XQM keeps track of the overall
76 * quota functionality, including maintaining the freelist and hash
77 * tables of dquots.
78 */
79mutex_t xfs_Gqm_lock;
80struct xfs_qm *xfs_Gqm;
81
82kmem_zone_t *qm_dqzone;
83kmem_zone_t *qm_dqtrxzone;
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100084STATIC kmem_shaker_t xfs_qm_shaker;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
86STATIC void xfs_qm_list_init(xfs_dqlist_t *, char *, int);
87STATIC void xfs_qm_list_destroy(xfs_dqlist_t *);
88
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100089STATIC void xfs_qm_freelist_init(xfs_frlist_t *);
90STATIC void xfs_qm_freelist_destroy(xfs_frlist_t *);
91STATIC int xfs_qm_mplist_nowait(xfs_mount_t *);
92STATIC int xfs_qm_dqhashlock_nowait(xfs_dquot_t *);
93
Linus Torvalds1da177e2005-04-16 15:20:36 -070094STATIC int xfs_qm_init_quotainos(xfs_mount_t *);
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100095STATIC int xfs_qm_init_quotainfo(xfs_mount_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096STATIC int xfs_qm_shake(int, unsigned int);
97
98#ifdef DEBUG
99extern mutex_t qcheck_lock;
100#endif
101
102#ifdef QUOTADEBUG
103#define XQM_LIST_PRINT(l, NXT, title) \
104{ \
105 xfs_dquot_t *dqp; int i = 0; \
106 cmn_err(CE_DEBUG, "%s (#%d)", title, (int) (l)->qh_nelems); \
107 for (dqp = (l)->qh_next; dqp != NULL; dqp = dqp->NXT) { \
108 cmn_err(CE_DEBUG, " %d. \"%d (%s)\" " \
109 "bcnt = %d, icnt = %d, refs = %d", \
110 ++i, (int) INT_GET(dqp->q_core.d_id, ARCH_CONVERT), \
111 DQFLAGTO_TYPESTR(dqp), \
112 (int) INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT), \
113 (int) INT_GET(dqp->q_core.d_icount, ARCH_CONVERT), \
114 (int) dqp->q_nrefs); } \
115}
116#else
117#define XQM_LIST_PRINT(l, NXT, title) do { } while (0)
118#endif
119
120/*
121 * Initialize the XQM structure.
122 * Note that there is not one quota manager per file system.
123 */
124STATIC struct xfs_qm *
125xfs_Gqm_init(void)
126{
127 xfs_qm_t *xqm;
128 int hsize, i;
129
130 xqm = kmem_zalloc(sizeof(xfs_qm_t), KM_SLEEP);
131 ASSERT(xqm);
132
133 /*
134 * Initialize the dquot hash tables.
135 */
136 hsize = (DQUOT_HASH_HEURISTIC < XFS_QM_NCSIZE_THRESHOLD) ?
137 XFS_QM_HASHSIZE_LOW : XFS_QM_HASHSIZE_HIGH;
138 xqm->qm_dqhashmask = hsize - 1;
139
140 xqm->qm_usr_dqhtable = (xfs_dqhash_t *)kmem_zalloc(hsize *
141 sizeof(xfs_dqhash_t),
142 KM_SLEEP);
143 xqm->qm_grp_dqhtable = (xfs_dqhash_t *)kmem_zalloc(hsize *
144 sizeof(xfs_dqhash_t),
145 KM_SLEEP);
146 ASSERT(xqm->qm_usr_dqhtable != NULL);
147 ASSERT(xqm->qm_grp_dqhtable != NULL);
148
149 for (i = 0; i < hsize; i++) {
150 xfs_qm_list_init(&(xqm->qm_usr_dqhtable[i]), "uxdqh", i);
151 xfs_qm_list_init(&(xqm->qm_grp_dqhtable[i]), "gxdqh", i);
152 }
153
154 /*
155 * Freelist of all dquots of all file systems
156 */
157 xfs_qm_freelist_init(&(xqm->qm_dqfreelist));
158
159 /*
160 * dquot zone. we register our own low-memory callback.
161 */
162 if (!qm_dqzone) {
163 xqm->qm_dqzone = kmem_zone_init(sizeof(xfs_dquot_t),
164 "xfs_dquots");
165 qm_dqzone = xqm->qm_dqzone;
166 } else
167 xqm->qm_dqzone = qm_dqzone;
168
169 xfs_qm_shaker = kmem_shake_register(xfs_qm_shake);
170
171 /*
172 * The t_dqinfo portion of transactions.
173 */
174 if (!qm_dqtrxzone) {
175 xqm->qm_dqtrxzone = kmem_zone_init(sizeof(xfs_dquot_acct_t),
176 "xfs_dqtrx");
177 qm_dqtrxzone = xqm->qm_dqtrxzone;
178 } else
179 xqm->qm_dqtrxzone = qm_dqtrxzone;
180
181 atomic_set(&xqm->qm_totaldquots, 0);
182 xqm->qm_dqfree_ratio = XFS_QM_DQFREE_RATIO;
183 xqm->qm_nrefs = 0;
184#ifdef DEBUG
185 mutex_init(&qcheck_lock, MUTEX_DEFAULT, "qchk");
186#endif
187 return xqm;
188}
189
190/*
191 * Destroy the global quota manager when its reference count goes to zero.
192 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000193STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194xfs_qm_destroy(
195 struct xfs_qm *xqm)
196{
197 int hsize, i;
198
199 ASSERT(xqm != NULL);
200 ASSERT(xqm->qm_nrefs == 0);
201 kmem_shake_deregister(xfs_qm_shaker);
202 hsize = xqm->qm_dqhashmask + 1;
203 for (i = 0; i < hsize; i++) {
204 xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));
205 xfs_qm_list_destroy(&(xqm->qm_grp_dqhtable[i]));
206 }
207 kmem_free(xqm->qm_usr_dqhtable, hsize * sizeof(xfs_dqhash_t));
208 kmem_free(xqm->qm_grp_dqhtable, hsize * sizeof(xfs_dqhash_t));
209 xqm->qm_usr_dqhtable = NULL;
210 xqm->qm_grp_dqhtable = NULL;
211 xqm->qm_dqhashmask = 0;
212 xfs_qm_freelist_destroy(&(xqm->qm_dqfreelist));
213#ifdef DEBUG
214 mutex_destroy(&qcheck_lock);
215#endif
216 kmem_free(xqm, sizeof(xfs_qm_t));
217}
218
219/*
220 * Called at mount time to let XQM know that another file system is
221 * starting quotas. This isn't crucial information as the individual mount
222 * structures are pretty independent, but it helps the XQM keep a
223 * global view of what's going on.
224 */
225/* ARGSUSED */
226STATIC int
227xfs_qm_hold_quotafs_ref(
228 struct xfs_mount *mp)
229{
230 /*
231 * Need to lock the xfs_Gqm structure for things like this. For example,
232 * the structure could disappear between the entry to this routine and
233 * a HOLD operation if not locked.
234 */
235 XFS_QM_LOCK(xfs_Gqm);
236
237 if (xfs_Gqm == NULL)
238 xfs_Gqm = xfs_Gqm_init();
239 /*
240 * We can keep a list of all filesystems with quotas mounted for
241 * debugging and statistical purposes, but ...
242 * Just take a reference and get out.
243 */
244 XFS_QM_HOLD(xfs_Gqm);
245 XFS_QM_UNLOCK(xfs_Gqm);
246
247 return 0;
248}
249
250
251/*
252 * Release the reference that a filesystem took at mount time,
253 * so that we know when we need to destroy the entire quota manager.
254 */
255/* ARGSUSED */
256STATIC void
257xfs_qm_rele_quotafs_ref(
258 struct xfs_mount *mp)
259{
260 xfs_dquot_t *dqp, *nextdqp;
261
262 ASSERT(xfs_Gqm);
263 ASSERT(xfs_Gqm->qm_nrefs > 0);
264
265 /*
266 * Go thru the freelist and destroy all inactive dquots.
267 */
268 xfs_qm_freelist_lock(xfs_Gqm);
269
270 for (dqp = xfs_Gqm->qm_dqfreelist.qh_next;
271 dqp != (xfs_dquot_t *)&(xfs_Gqm->qm_dqfreelist); ) {
272 xfs_dqlock(dqp);
273 nextdqp = dqp->dq_flnext;
274 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
275 ASSERT(dqp->q_mount == NULL);
276 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
277 ASSERT(dqp->HL_PREVP == NULL);
278 ASSERT(dqp->MPL_PREVP == NULL);
279 XQM_FREELIST_REMOVE(dqp);
280 xfs_dqunlock(dqp);
281 xfs_qm_dqdestroy(dqp);
282 } else {
283 xfs_dqunlock(dqp);
284 }
285 dqp = nextdqp;
286 }
287 xfs_qm_freelist_unlock(xfs_Gqm);
288
289 /*
290 * Destroy the entire XQM. If somebody mounts with quotaon, this'll
291 * be restarted.
292 */
293 XFS_QM_LOCK(xfs_Gqm);
294 XFS_QM_RELE(xfs_Gqm);
295 if (xfs_Gqm->qm_nrefs == 0) {
296 xfs_qm_destroy(xfs_Gqm);
297 xfs_Gqm = NULL;
298 }
299 XFS_QM_UNLOCK(xfs_Gqm);
300}
301
302/*
303 * This is called at mount time from xfs_mountfs to initialize the quotainfo
304 * structure and start the global quotamanager (xfs_Gqm) if it hasn't done
305 * so already. Note that the superblock has not been read in yet.
306 */
307void
308xfs_qm_mount_quotainit(
309 xfs_mount_t *mp,
310 uint flags)
311{
312 /*
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000313 * User, projects or group quotas has to be on.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000315 ASSERT(flags & (XFSMNT_UQUOTA | XFSMNT_PQUOTA | XFSMNT_GQUOTA));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
317 /*
318 * Initialize the flags in the mount structure. From this point
319 * onwards we look at m_qflags to figure out if quotas's ON/OFF, etc.
320 * Note that we enforce nothing if accounting is off.
321 * ie. XFSMNT_*QUOTA must be ON for XFSMNT_*QUOTAENF.
322 * It isn't necessary to take the quotaoff lock to do this; this is
323 * called from mount.
324 */
325 if (flags & XFSMNT_UQUOTA) {
326 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
327 if (flags & XFSMNT_UQUOTAENF)
328 mp->m_qflags |= XFS_UQUOTA_ENFD;
329 }
330 if (flags & XFSMNT_GQUOTA) {
331 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
332 if (flags & XFSMNT_GQUOTAENF)
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000333 mp->m_qflags |= XFS_OQUOTA_ENFD;
334 } else if (flags & XFSMNT_PQUOTA) {
335 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
336 if (flags & XFSMNT_PQUOTAENF)
337 mp->m_qflags |= XFS_OQUOTA_ENFD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 }
339}
340
341/*
342 * Just destroy the quotainfo structure.
343 */
344void
345xfs_qm_unmount_quotadestroy(
346 xfs_mount_t *mp)
347{
348 if (mp->m_quotainfo)
349 xfs_qm_destroy_quotainfo(mp);
350}
351
352
353/*
354 * This is called from xfs_mountfs to start quotas and initialize all
355 * necessary data structures like quotainfo. This is also responsible for
356 * running a quotacheck as necessary. We are guaranteed that the superblock
357 * is consistently read in at this point.
358 */
359int
360xfs_qm_mount_quotas(
361 xfs_mount_t *mp,
362 int mfsi_flags)
363{
364 unsigned long s;
365 int error = 0;
366 uint sbf;
367
368 /*
369 * If a file system had quotas running earlier, but decided to
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000370 * mount without -o uquota/pquota/gquota options, revoke the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 * quotachecked license, and bail out.
372 */
373 if (! XFS_IS_QUOTA_ON(mp) &&
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000374 (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 mp->m_qflags = 0;
376 goto write_changes;
377 }
378
379 /*
380 * If quotas on realtime volumes is not supported, we disable
381 * quotas immediately.
382 */
383 if (mp->m_sb.sb_rextents) {
384 cmn_err(CE_NOTE,
385 "Cannot turn on quotas for realtime filesystem %s",
386 mp->m_fsname);
387 mp->m_qflags = 0;
388 goto write_changes;
389 }
390
391#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
392 cmn_err(CE_NOTE, "Attempting to turn on disk quotas.");
393#endif
394
395 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
396 /*
397 * Allocate the quotainfo structure inside the mount struct, and
398 * create quotainode(s), and change/rev superblock if necessary.
399 */
400 if ((error = xfs_qm_init_quotainfo(mp))) {
401 /*
402 * We must turn off quotas.
403 */
404 ASSERT(mp->m_quotainfo == NULL);
405 mp->m_qflags = 0;
406 goto write_changes;
407 }
408 /*
409 * If any of the quotas are not consistent, do a quotacheck.
410 */
411 if (XFS_QM_NEED_QUOTACHECK(mp) &&
412 !(mfsi_flags & XFS_MFSI_NO_QUOTACHECK)) {
413#ifdef DEBUG
414 cmn_err(CE_NOTE, "Doing a quotacheck. Please wait.");
415#endif
416 if ((error = xfs_qm_quotacheck(mp))) {
417 /* Quotacheck has failed and quotas have
418 * been disabled.
419 */
420 return XFS_ERROR(error);
421 }
422#ifdef DEBUG
423 cmn_err(CE_NOTE, "Done quotacheck.");
424#endif
425 }
426 write_changes:
427 /*
428 * We actually don't have to acquire the SB_LOCK at all.
429 * This can only be called from mount, and that's single threaded. XXX
430 */
431 s = XFS_SB_LOCK(mp);
432 sbf = mp->m_sb.sb_qflags;
433 mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
434 XFS_SB_UNLOCK(mp, s);
435
436 if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
437 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
438 /*
439 * We could only have been turning quotas off.
440 * We aren't in very good shape actually because
441 * the incore structures are convinced that quotas are
442 * off, but the on disk superblock doesn't know that !
443 */
444 ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
445 xfs_fs_cmn_err(CE_ALERT, mp,
446 "XFS mount_quotas: Superblock update failed!");
447 }
448 }
449
450 if (error) {
451 xfs_fs_cmn_err(CE_WARN, mp,
452 "Failed to initialize disk quotas.");
453 }
454 return XFS_ERROR(error);
455}
456
457/*
458 * Called from the vfsops layer.
459 */
460int
461xfs_qm_unmount_quotas(
462 xfs_mount_t *mp)
463{
464 xfs_inode_t *uqp, *gqp;
465 int error = 0;
466
467 /*
468 * Release the dquots that root inode, et al might be holding,
469 * before we flush quotas and blow away the quotainfo structure.
470 */
471 ASSERT(mp->m_rootip);
472 xfs_qm_dqdetach(mp->m_rootip);
473 if (mp->m_rbmip)
474 xfs_qm_dqdetach(mp->m_rbmip);
475 if (mp->m_rsumip)
476 xfs_qm_dqdetach(mp->m_rsumip);
477
478 /*
479 * Flush out the quota inodes.
480 */
481 uqp = gqp = NULL;
482 if (mp->m_quotainfo) {
483 if ((uqp = mp->m_quotainfo->qi_uquotaip) != NULL) {
484 xfs_ilock(uqp, XFS_ILOCK_EXCL);
485 xfs_iflock(uqp);
486 error = xfs_iflush(uqp, XFS_IFLUSH_SYNC);
487 xfs_iunlock(uqp, XFS_ILOCK_EXCL);
488 if (unlikely(error == EFSCORRUPTED)) {
489 XFS_ERROR_REPORT("xfs_qm_unmount_quotas(1)",
490 XFS_ERRLEVEL_LOW, mp);
491 goto out;
492 }
493 }
494 if ((gqp = mp->m_quotainfo->qi_gquotaip) != NULL) {
495 xfs_ilock(gqp, XFS_ILOCK_EXCL);
496 xfs_iflock(gqp);
497 error = xfs_iflush(gqp, XFS_IFLUSH_SYNC);
498 xfs_iunlock(gqp, XFS_ILOCK_EXCL);
499 if (unlikely(error == EFSCORRUPTED)) {
500 XFS_ERROR_REPORT("xfs_qm_unmount_quotas(2)",
501 XFS_ERRLEVEL_LOW, mp);
502 goto out;
503 }
504 }
505 }
506 if (uqp) {
507 XFS_PURGE_INODE(uqp);
508 mp->m_quotainfo->qi_uquotaip = NULL;
509 }
510 if (gqp) {
511 XFS_PURGE_INODE(gqp);
512 mp->m_quotainfo->qi_gquotaip = NULL;
513 }
514out:
515 return XFS_ERROR(error);
516}
517
518/*
519 * Flush all dquots of the given file system to disk. The dquots are
520 * _not_ purged from memory here, just their data written to disk.
521 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000522STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523xfs_qm_dqflush_all(
524 xfs_mount_t *mp,
525 int flags)
526{
527 int recl;
528 xfs_dquot_t *dqp;
529 int niters;
530 int error;
531
532 if (mp->m_quotainfo == NULL)
533 return (0);
534 niters = 0;
535again:
536 xfs_qm_mplist_lock(mp);
537 FOREACH_DQUOT_IN_MP(dqp, mp) {
538 xfs_dqlock(dqp);
539 if (! XFS_DQ_IS_DIRTY(dqp)) {
540 xfs_dqunlock(dqp);
541 continue;
542 }
543 xfs_dqtrace_entry(dqp, "FLUSHALL: DQDIRTY");
544 /* XXX a sentinel would be better */
545 recl = XFS_QI_MPLRECLAIMS(mp);
546 if (! xfs_qm_dqflock_nowait(dqp)) {
547 /*
548 * If we can't grab the flush lock then check
549 * to see if the dquot has been flushed delayed
550 * write. If so, grab its buffer and send it
551 * out immediately. We'll be able to acquire
552 * the flush lock when the I/O completes.
553 */
554 xfs_qm_dqflock_pushbuf_wait(dqp);
555 }
556 /*
557 * Let go of the mplist lock. We don't want to hold it
558 * across a disk write.
559 */
560 xfs_qm_mplist_unlock(mp);
561 error = xfs_qm_dqflush(dqp, flags);
562 xfs_dqunlock(dqp);
563 if (error)
564 return (error);
565
566 xfs_qm_mplist_lock(mp);
567 if (recl != XFS_QI_MPLRECLAIMS(mp)) {
568 xfs_qm_mplist_unlock(mp);
569 /* XXX restart limit */
570 goto again;
571 }
572 }
573
574 xfs_qm_mplist_unlock(mp);
575 /* return ! busy */
576 return (0);
577}
578/*
579 * Release the group dquot pointers the user dquots may be
580 * carrying around as a hint. mplist is locked on entry and exit.
581 */
582STATIC void
583xfs_qm_detach_gdquots(
584 xfs_mount_t *mp)
585{
586 xfs_dquot_t *dqp, *gdqp;
587 int nrecl;
588
589 again:
590 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
591 dqp = XFS_QI_MPLNEXT(mp);
592 while (dqp) {
593 xfs_dqlock(dqp);
594 if ((gdqp = dqp->q_gdquot)) {
595 xfs_dqlock(gdqp);
596 dqp->q_gdquot = NULL;
597 }
598 xfs_dqunlock(dqp);
599
600 if (gdqp) {
601 /*
602 * Can't hold the mplist lock across a dqput.
603 * XXXmust convert to marker based iterations here.
604 */
605 nrecl = XFS_QI_MPLRECLAIMS(mp);
606 xfs_qm_mplist_unlock(mp);
607 xfs_qm_dqput(gdqp);
608
609 xfs_qm_mplist_lock(mp);
610 if (nrecl != XFS_QI_MPLRECLAIMS(mp))
611 goto again;
612 }
613 dqp = dqp->MPL_NEXT;
614 }
615}
616
617/*
618 * Go through all the incore dquots of this file system and take them
619 * off the mplist and hashlist, if the dquot type matches the dqtype
620 * parameter. This is used when turning off quota accounting for
621 * users and/or groups, as well as when the filesystem is unmounting.
622 */
623STATIC int
624xfs_qm_dqpurge_int(
625 xfs_mount_t *mp,
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000626 uint flags) /* QUOTAOFF/UMOUNTING/UQUOTA/PQUOTA/GQUOTA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627{
628 xfs_dquot_t *dqp;
629 uint dqtype;
630 int nrecl;
631 xfs_dquot_t *nextdqp;
632 int nmisses;
633
634 if (mp->m_quotainfo == NULL)
635 return (0);
636
637 dqtype = (flags & XFS_QMOPT_UQUOTA) ? XFS_DQ_USER : 0;
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000638 dqtype |= (flags & XFS_QMOPT_PQUOTA) ? XFS_DQ_PROJ : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 dqtype |= (flags & XFS_QMOPT_GQUOTA) ? XFS_DQ_GROUP : 0;
640
641 xfs_qm_mplist_lock(mp);
642
643 /*
644 * In the first pass through all incore dquots of this filesystem,
645 * we release the group dquot pointers the user dquots may be
646 * carrying around as a hint. We need to do this irrespective of
647 * what's being turned off.
648 */
649 xfs_qm_detach_gdquots(mp);
650
651 again:
652 nmisses = 0;
653 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
654 /*
655 * Try to get rid of all of the unwanted dquots. The idea is to
656 * get them off mplist and hashlist, but leave them on freelist.
657 */
658 dqp = XFS_QI_MPLNEXT(mp);
659 while (dqp) {
660 /*
661 * It's OK to look at the type without taking dqlock here.
662 * We're holding the mplist lock here, and that's needed for
663 * a dqreclaim.
664 */
665 if ((dqp->dq_flags & dqtype) == 0) {
666 dqp = dqp->MPL_NEXT;
667 continue;
668 }
669
670 if (! xfs_qm_dqhashlock_nowait(dqp)) {
671 nrecl = XFS_QI_MPLRECLAIMS(mp);
672 xfs_qm_mplist_unlock(mp);
673 XFS_DQ_HASH_LOCK(dqp->q_hash);
674 xfs_qm_mplist_lock(mp);
675
676 /*
677 * XXXTheoretically, we can get into a very long
678 * ping pong game here.
679 * No one can be adding dquots to the mplist at
680 * this point, but somebody might be taking things off.
681 */
682 if (nrecl != XFS_QI_MPLRECLAIMS(mp)) {
683 XFS_DQ_HASH_UNLOCK(dqp->q_hash);
684 goto again;
685 }
686 }
687
688 /*
689 * Take the dquot off the mplist and hashlist. It may remain on
690 * freelist in INACTIVE state.
691 */
692 nextdqp = dqp->MPL_NEXT;
693 nmisses += xfs_qm_dqpurge(dqp, flags);
694 dqp = nextdqp;
695 }
696 xfs_qm_mplist_unlock(mp);
697 return nmisses;
698}
699
700int
701xfs_qm_dqpurge_all(
702 xfs_mount_t *mp,
703 uint flags)
704{
705 int ndquots;
706
707 /*
708 * Purge the dquot cache.
709 * None of the dquots should really be busy at this point.
710 */
711 if (mp->m_quotainfo) {
712 while ((ndquots = xfs_qm_dqpurge_int(mp, flags))) {
713 delay(ndquots * 10);
714 }
715 }
716 return 0;
717}
718
719STATIC int
720xfs_qm_dqattach_one(
721 xfs_inode_t *ip,
722 xfs_dqid_t id,
723 uint type,
724 uint doalloc,
725 uint dolock,
726 xfs_dquot_t *udqhint, /* hint */
727 xfs_dquot_t **IO_idqpp)
728{
729 xfs_dquot_t *dqp;
730 int error;
731
732 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
733 error = 0;
734 /*
735 * See if we already have it in the inode itself. IO_idqpp is
736 * &i_udquot or &i_gdquot. This made the code look weird, but
737 * made the logic a lot simpler.
738 */
739 if ((dqp = *IO_idqpp)) {
740 if (dolock)
741 xfs_dqlock(dqp);
742 xfs_dqtrace_entry(dqp, "DQATTACH: found in ip");
743 goto done;
744 }
745
746 /*
747 * udqhint is the i_udquot field in inode, and is non-NULL only
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000748 * when the type arg is group/project. Its purpose is to save a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside
750 * the user dquot.
751 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000752 ASSERT(!udqhint || type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 if (udqhint && !dolock)
754 xfs_dqlock(udqhint);
755
756 /*
757 * No need to take dqlock to look at the id.
758 * The ID can't change until it gets reclaimed, and it won't
759 * be reclaimed as long as we have a ref from inode and we hold
760 * the ilock.
761 */
762 if (udqhint &&
763 (dqp = udqhint->q_gdquot) &&
764 (INT_GET(dqp->q_core.d_id, ARCH_CONVERT) == id)) {
765 ASSERT(XFS_DQ_IS_LOCKED(udqhint));
766 xfs_dqlock(dqp);
767 XFS_DQHOLD(dqp);
768 ASSERT(*IO_idqpp == NULL);
769 *IO_idqpp = dqp;
770 if (!dolock) {
771 xfs_dqunlock(dqp);
772 xfs_dqunlock(udqhint);
773 }
774 goto done;
775 }
776 /*
777 * We can't hold a dquot lock when we call the dqget code.
778 * We'll deadlock in no time, because of (not conforming to)
779 * lock ordering - the inodelock comes before any dquot lock,
780 * and we may drop and reacquire the ilock in xfs_qm_dqget().
781 */
782 if (udqhint)
783 xfs_dqunlock(udqhint);
784 /*
785 * Find the dquot from somewhere. This bumps the
786 * reference count of dquot and returns it locked.
787 * This can return ENOENT if dquot didn't exist on
788 * disk and we didn't ask it to allocate;
789 * ESRCH if quotas got turned off suddenly.
790 */
791 if ((error = xfs_qm_dqget(ip->i_mount, ip, id, type,
792 doalloc|XFS_QMOPT_DOWARN, &dqp))) {
793 if (udqhint && dolock)
794 xfs_dqlock(udqhint);
795 goto done;
796 }
797
798 xfs_dqtrace_entry(dqp, "DQATTACH: found by dqget");
799 /*
800 * dqget may have dropped and re-acquired the ilock, but it guarantees
801 * that the dquot returned is the one that should go in the inode.
802 */
803 *IO_idqpp = dqp;
804 ASSERT(dqp);
805 ASSERT(XFS_DQ_IS_LOCKED(dqp));
806 if (! dolock) {
807 xfs_dqunlock(dqp);
808 goto done;
809 }
810 if (! udqhint)
811 goto done;
812
813 ASSERT(udqhint);
814 ASSERT(dolock);
815 ASSERT(XFS_DQ_IS_LOCKED(dqp));
816 if (! xfs_qm_dqlock_nowait(udqhint)) {
817 xfs_dqunlock(dqp);
818 xfs_dqlock(udqhint);
819 xfs_dqlock(dqp);
820 }
821 done:
822#ifdef QUOTADEBUG
823 if (udqhint) {
824 if (dolock)
825 ASSERT(XFS_DQ_IS_LOCKED(udqhint));
826 }
827 if (! error) {
828 if (dolock)
829 ASSERT(XFS_DQ_IS_LOCKED(dqp));
830 }
831#endif
832 return (error);
833}
834
835
836/*
837 * Given a udquot and gdquot, attach a ptr to the group dquot in the
838 * udquot as a hint for future lookups. The idea sounds simple, but the
839 * execution isn't, because the udquot might have a group dquot attached
840 * already and getting rid of that gets us into lock ordering contraints.
841 * The process is complicated more by the fact that the dquots may or may not
842 * be locked on entry.
843 */
844STATIC void
845xfs_qm_dqattach_grouphint(
846 xfs_dquot_t *udq,
847 xfs_dquot_t *gdq,
848 uint locked)
849{
850 xfs_dquot_t *tmp;
851
852#ifdef QUOTADEBUG
853 if (locked) {
854 ASSERT(XFS_DQ_IS_LOCKED(udq));
855 ASSERT(XFS_DQ_IS_LOCKED(gdq));
856 }
857#endif
858 if (! locked)
859 xfs_dqlock(udq);
860
861 if ((tmp = udq->q_gdquot)) {
862 if (tmp == gdq) {
863 if (! locked)
864 xfs_dqunlock(udq);
865 return;
866 }
867
868 udq->q_gdquot = NULL;
869 /*
870 * We can't keep any dqlocks when calling dqrele,
871 * because the freelist lock comes before dqlocks.
872 */
873 xfs_dqunlock(udq);
874 if (locked)
875 xfs_dqunlock(gdq);
876 /*
877 * we took a hard reference once upon a time in dqget,
878 * so give it back when the udquot no longer points at it
879 * dqput() does the unlocking of the dquot.
880 */
881 xfs_qm_dqrele(tmp);
882
883 xfs_dqlock(udq);
884 xfs_dqlock(gdq);
885
886 } else {
887 ASSERT(XFS_DQ_IS_LOCKED(udq));
888 if (! locked) {
889 xfs_dqlock(gdq);
890 }
891 }
892
893 ASSERT(XFS_DQ_IS_LOCKED(udq));
894 ASSERT(XFS_DQ_IS_LOCKED(gdq));
895 /*
896 * Somebody could have attached a gdquot here,
897 * when we dropped the uqlock. If so, just do nothing.
898 */
899 if (udq->q_gdquot == NULL) {
900 XFS_DQHOLD(gdq);
901 udq->q_gdquot = gdq;
902 }
903 if (! locked) {
904 xfs_dqunlock(gdq);
905 xfs_dqunlock(udq);
906 }
907}
908
909
910/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000911 * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
912 * into account.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed.
914 * If XFS_QMOPT_DQLOCK, the dquot(s) will be returned locked. This option pretty
915 * much made this code a complete mess, but it has been pretty useful.
916 * If XFS_QMOPT_ILOCKED, then inode sent is already locked EXCL.
917 * Inode may get unlocked and relocked in here, and the caller must deal with
918 * the consequences.
919 */
920int
921xfs_qm_dqattach(
922 xfs_inode_t *ip,
923 uint flags)
924{
925 xfs_mount_t *mp = ip->i_mount;
926 uint nquotas = 0;
927 int error = 0;
928
929 if ((! XFS_IS_QUOTA_ON(mp)) ||
930 (! XFS_NOT_DQATTACHED(mp, ip)) ||
931 (ip->i_ino == mp->m_sb.sb_uquotino) ||
932 (ip->i_ino == mp->m_sb.sb_gquotino))
933 return (0);
934
935 ASSERT((flags & XFS_QMOPT_ILOCKED) == 0 ||
936 XFS_ISLOCKED_INODE_EXCL(ip));
937
938 if (! (flags & XFS_QMOPT_ILOCKED))
939 xfs_ilock(ip, XFS_ILOCK_EXCL);
940
941 if (XFS_IS_UQUOTA_ON(mp)) {
942 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
943 flags & XFS_QMOPT_DQALLOC,
944 flags & XFS_QMOPT_DQLOCK,
945 NULL, &ip->i_udquot);
946 if (error)
947 goto done;
948 nquotas++;
949 }
950 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000951 if (XFS_IS_OQUOTA_ON(mp)) {
952 error = XFS_IS_GQUOTA_ON(mp) ?
953 xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
954 flags & XFS_QMOPT_DQALLOC,
955 flags & XFS_QMOPT_DQLOCK,
956 ip->i_udquot, &ip->i_gdquot) :
957 xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQ_PROJ,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 flags & XFS_QMOPT_DQALLOC,
959 flags & XFS_QMOPT_DQLOCK,
960 ip->i_udquot, &ip->i_gdquot);
961 /*
962 * Don't worry about the udquot that we may have
963 * attached above. It'll get detached, if not already.
964 */
965 if (error)
966 goto done;
967 nquotas++;
968 }
969
970 /*
971 * Attach this group quota to the user quota as a hint.
972 * This WON'T, in general, result in a thrash.
973 */
974 if (nquotas == 2) {
975 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
976 ASSERT(ip->i_udquot);
977 ASSERT(ip->i_gdquot);
978
979 /*
980 * We may or may not have the i_udquot locked at this point,
981 * but this check is OK since we don't depend on the i_gdquot to
982 * be accurate 100% all the time. It is just a hint, and this
983 * will succeed in general.
984 */
985 if (ip->i_udquot->q_gdquot == ip->i_gdquot)
986 goto done;
987 /*
988 * Attach i_gdquot to the gdquot hint inside the i_udquot.
989 */
990 xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot,
991 flags & XFS_QMOPT_DQLOCK);
992 }
993
994 done:
995
996#ifdef QUOTADEBUG
997 if (! error) {
998 if (ip->i_udquot) {
999 if (flags & XFS_QMOPT_DQLOCK)
1000 ASSERT(XFS_DQ_IS_LOCKED(ip->i_udquot));
1001 }
1002 if (ip->i_gdquot) {
1003 if (flags & XFS_QMOPT_DQLOCK)
1004 ASSERT(XFS_DQ_IS_LOCKED(ip->i_gdquot));
1005 }
1006 if (XFS_IS_UQUOTA_ON(mp))
1007 ASSERT(ip->i_udquot);
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001008 if (XFS_IS_OQUOTA_ON(mp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 ASSERT(ip->i_gdquot);
1010 }
1011#endif
1012
1013 if (! (flags & XFS_QMOPT_ILOCKED))
1014 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1015
1016#ifdef QUOTADEBUG
1017 else
1018 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
1019#endif
1020 return (error);
1021}
1022
1023/*
1024 * Release dquots (and their references) if any.
1025 * The inode should be locked EXCL except when this's called by
1026 * xfs_ireclaim.
1027 */
1028void
1029xfs_qm_dqdetach(
1030 xfs_inode_t *ip)
1031{
1032 if (!(ip->i_udquot || ip->i_gdquot))
1033 return;
1034
1035 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
1036 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 if (ip->i_udquot) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001038 xfs_dqtrace_entry_ino(ip->i_udquot, "DQDETTACH", ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 xfs_qm_dqrele(ip->i_udquot);
1040 ip->i_udquot = NULL;
1041 }
1042 if (ip->i_gdquot) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001043 xfs_dqtrace_entry_ino(ip->i_gdquot, "DQDETTACH", ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 xfs_qm_dqrele(ip->i_gdquot);
1045 ip->i_gdquot = NULL;
1046 }
1047}
1048
1049/*
1050 * This is called by VFS_SYNC and flags arg determines the caller,
1051 * and its motives, as done in xfs_sync.
1052 *
1053 * vfs_sync: SYNC_FSDATA|SYNC_ATTR|SYNC_BDFLUSH 0x31
1054 * syscall sync: SYNC_FSDATA|SYNC_ATTR|SYNC_DELWRI 0x25
1055 * umountroot : SYNC_WAIT | SYNC_CLOSE | SYNC_ATTR | SYNC_FSDATA
1056 */
1057
1058int
1059xfs_qm_sync(
1060 xfs_mount_t *mp,
1061 short flags)
1062{
1063 int recl, restarts;
1064 xfs_dquot_t *dqp;
1065 uint flush_flags;
1066 boolean_t nowait;
1067 int error;
1068
1069 restarts = 0;
1070 /*
1071 * We won't block unless we are asked to.
1072 */
1073 nowait = (boolean_t)(flags & SYNC_BDFLUSH || (flags & SYNC_WAIT) == 0);
1074
1075 again:
1076 xfs_qm_mplist_lock(mp);
1077 /*
1078 * dqpurge_all() also takes the mplist lock and iterate thru all dquots
1079 * in quotaoff. However, if the QUOTA_ACTIVE bits are not cleared
1080 * when we have the mplist lock, we know that dquots will be consistent
1081 * as long as we have it locked.
1082 */
1083 if (! XFS_IS_QUOTA_ON(mp)) {
1084 xfs_qm_mplist_unlock(mp);
1085 return (0);
1086 }
1087 FOREACH_DQUOT_IN_MP(dqp, mp) {
1088 /*
1089 * If this is vfs_sync calling, then skip the dquots that
1090 * don't 'seem' to be dirty. ie. don't acquire dqlock.
1091 * This is very similar to what xfs_sync does with inodes.
1092 */
1093 if (flags & SYNC_BDFLUSH) {
1094 if (! XFS_DQ_IS_DIRTY(dqp))
1095 continue;
1096 }
1097
1098 if (nowait) {
1099 /*
1100 * Try to acquire the dquot lock. We are NOT out of
1101 * lock order, but we just don't want to wait for this
1102 * lock, unless somebody wanted us to.
1103 */
1104 if (! xfs_qm_dqlock_nowait(dqp))
1105 continue;
1106 } else {
1107 xfs_dqlock(dqp);
1108 }
1109
1110 /*
1111 * Now, find out for sure if this dquot is dirty or not.
1112 */
1113 if (! XFS_DQ_IS_DIRTY(dqp)) {
1114 xfs_dqunlock(dqp);
1115 continue;
1116 }
1117
1118 /* XXX a sentinel would be better */
1119 recl = XFS_QI_MPLRECLAIMS(mp);
1120 if (! xfs_qm_dqflock_nowait(dqp)) {
1121 if (nowait) {
1122 xfs_dqunlock(dqp);
1123 continue;
1124 }
1125 /*
1126 * If we can't grab the flush lock then if the caller
1127 * really wanted us to give this our best shot,
1128 * see if we can give a push to the buffer before we wait
1129 * on the flush lock. At this point, we know that
1130 * eventhough the dquot is being flushed,
1131 * it has (new) dirty data.
1132 */
1133 xfs_qm_dqflock_pushbuf_wait(dqp);
1134 }
1135 /*
1136 * Let go of the mplist lock. We don't want to hold it
1137 * across a disk write
1138 */
1139 flush_flags = (nowait) ? XFS_QMOPT_DELWRI : XFS_QMOPT_SYNC;
1140 xfs_qm_mplist_unlock(mp);
1141 xfs_dqtrace_entry(dqp, "XQM_SYNC: DQFLUSH");
1142 error = xfs_qm_dqflush(dqp, flush_flags);
1143 xfs_dqunlock(dqp);
1144 if (error && XFS_FORCED_SHUTDOWN(mp))
1145 return(0); /* Need to prevent umount failure */
1146 else if (error)
1147 return (error);
1148
1149 xfs_qm_mplist_lock(mp);
1150 if (recl != XFS_QI_MPLRECLAIMS(mp)) {
1151 if (++restarts >= XFS_QM_SYNC_MAX_RESTARTS)
1152 break;
1153
1154 xfs_qm_mplist_unlock(mp);
1155 goto again;
1156 }
1157 }
1158
1159 xfs_qm_mplist_unlock(mp);
1160 return (0);
1161}
1162
1163
1164/*
1165 * This initializes all the quota information that's kept in the
1166 * mount structure
1167 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10001168STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169xfs_qm_init_quotainfo(
1170 xfs_mount_t *mp)
1171{
1172 xfs_quotainfo_t *qinf;
1173 int error;
1174 xfs_dquot_t *dqp;
1175
1176 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1177
1178 /*
1179 * Tell XQM that we exist as soon as possible.
1180 */
1181 if ((error = xfs_qm_hold_quotafs_ref(mp))) {
1182 return (error);
1183 }
1184
1185 qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
1186
1187 /*
1188 * See if quotainodes are setup, and if not, allocate them,
1189 * and change the superblock accordingly.
1190 */
1191 if ((error = xfs_qm_init_quotainos(mp))) {
1192 kmem_free(qinf, sizeof(xfs_quotainfo_t));
1193 mp->m_quotainfo = NULL;
1194 return (error);
1195 }
1196
1197 spinlock_init(&qinf->qi_pinlock, "xfs_qinf_pin");
1198 xfs_qm_list_init(&qinf->qi_dqlist, "mpdqlist", 0);
1199 qinf->qi_dqreclaims = 0;
1200
1201 /* mutex used to serialize quotaoffs */
1202 mutex_init(&qinf->qi_quotaofflock, MUTEX_DEFAULT, "qoff");
1203
1204 /* Precalc some constants */
1205 qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1206 ASSERT(qinf->qi_dqchunklen);
1207 qinf->qi_dqperchunk = BBTOB(qinf->qi_dqchunklen);
1208 do_div(qinf->qi_dqperchunk, sizeof(xfs_dqblk_t));
1209
1210 mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
1211
1212 /*
1213 * We try to get the limits from the superuser's limits fields.
1214 * This is quite hacky, but it is standard quota practice.
1215 * We look at the USR dquot with id == 0 first, but if user quotas
1216 * are not enabled we goto the GRP dquot with id == 0.
1217 * We don't really care to keep separate default limits for user
1218 * and group quotas, at least not at this point.
1219 */
1220 error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)0,
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001221 XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
1222 (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
1223 XFS_DQ_PROJ),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 XFS_QMOPT_DQSUSER|XFS_QMOPT_DOWARN,
1225 &dqp);
1226 if (! error) {
1227 xfs_disk_dquot_t *ddqp = &dqp->q_core;
1228
1229 /*
1230 * The warnings and timers set the grace period given to
1231 * a user or group before he or she can not perform any
1232 * more writing. If it is zero, a default is used.
1233 */
1234 qinf->qi_btimelimit =
1235 INT_GET(ddqp->d_btimer, ARCH_CONVERT) ?
1236 INT_GET(ddqp->d_btimer, ARCH_CONVERT) :
1237 XFS_QM_BTIMELIMIT;
1238 qinf->qi_itimelimit =
1239 INT_GET(ddqp->d_itimer, ARCH_CONVERT) ?
1240 INT_GET(ddqp->d_itimer, ARCH_CONVERT) :
1241 XFS_QM_ITIMELIMIT;
1242 qinf->qi_rtbtimelimit =
1243 INT_GET(ddqp->d_rtbtimer, ARCH_CONVERT) ?
1244 INT_GET(ddqp->d_rtbtimer, ARCH_CONVERT) :
1245 XFS_QM_RTBTIMELIMIT;
1246 qinf->qi_bwarnlimit =
1247 INT_GET(ddqp->d_bwarns, ARCH_CONVERT) ?
1248 INT_GET(ddqp->d_bwarns, ARCH_CONVERT) :
1249 XFS_QM_BWARNLIMIT;
1250 qinf->qi_iwarnlimit =
1251 INT_GET(ddqp->d_iwarns, ARCH_CONVERT) ?
1252 INT_GET(ddqp->d_iwarns, ARCH_CONVERT) :
1253 XFS_QM_IWARNLIMIT;
Nathan Scott06d10dd2005-06-21 15:48:47 +10001254 qinf->qi_rtbwarnlimit =
1255 INT_GET(ddqp->d_rtbwarns, ARCH_CONVERT) ?
1256 INT_GET(ddqp->d_rtbwarns, ARCH_CONVERT) :
1257 XFS_QM_RTBWARNLIMIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 qinf->qi_bhardlimit =
1259 INT_GET(ddqp->d_blk_hardlimit, ARCH_CONVERT);
1260 qinf->qi_bsoftlimit =
1261 INT_GET(ddqp->d_blk_softlimit, ARCH_CONVERT);
1262 qinf->qi_ihardlimit =
1263 INT_GET(ddqp->d_ino_hardlimit, ARCH_CONVERT);
1264 qinf->qi_isoftlimit =
1265 INT_GET(ddqp->d_ino_softlimit, ARCH_CONVERT);
1266 qinf->qi_rtbhardlimit =
1267 INT_GET(ddqp->d_rtb_hardlimit, ARCH_CONVERT);
1268 qinf->qi_rtbsoftlimit =
1269 INT_GET(ddqp->d_rtb_softlimit, ARCH_CONVERT);
1270
1271 /*
1272 * We sent the XFS_QMOPT_DQSUSER flag to dqget because
1273 * we don't want this dquot cached. We haven't done a
1274 * quotacheck yet, and quotacheck doesn't like incore dquots.
1275 */
1276 xfs_qm_dqdestroy(dqp);
1277 } else {
1278 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
1279 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
1280 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
1281 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
1282 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
Nathan Scott06d10dd2005-06-21 15:48:47 +10001283 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 }
1285
1286 return (0);
1287}
1288
1289
1290/*
1291 * Gets called when unmounting a filesystem or when all quotas get
1292 * turned off.
1293 * This purges the quota inodes, destroys locks and frees itself.
1294 */
1295void
1296xfs_qm_destroy_quotainfo(
1297 xfs_mount_t *mp)
1298{
1299 xfs_quotainfo_t *qi;
1300
1301 qi = mp->m_quotainfo;
1302 ASSERT(qi != NULL);
1303 ASSERT(xfs_Gqm != NULL);
1304
1305 /*
1306 * Release the reference that XQM kept, so that we know
1307 * when the XQM structure should be freed. We cannot assume
1308 * that xfs_Gqm is non-null after this point.
1309 */
1310 xfs_qm_rele_quotafs_ref(mp);
1311
1312 spinlock_destroy(&qi->qi_pinlock);
1313 xfs_qm_list_destroy(&qi->qi_dqlist);
1314
1315 if (qi->qi_uquotaip) {
1316 XFS_PURGE_INODE(qi->qi_uquotaip);
1317 qi->qi_uquotaip = NULL; /* paranoia */
1318 }
1319 if (qi->qi_gquotaip) {
1320 XFS_PURGE_INODE(qi->qi_gquotaip);
1321 qi->qi_gquotaip = NULL;
1322 }
1323 mutex_destroy(&qi->qi_quotaofflock);
1324 kmem_free(qi, sizeof(xfs_quotainfo_t));
1325 mp->m_quotainfo = NULL;
1326}
1327
1328
1329
1330/* ------------------- PRIVATE STATIC FUNCTIONS ----------------------- */
1331
1332/* ARGSUSED */
1333STATIC void
1334xfs_qm_list_init(
1335 xfs_dqlist_t *list,
1336 char *str,
1337 int n)
1338{
1339 mutex_init(&list->qh_lock, MUTEX_DEFAULT, str);
1340 list->qh_next = NULL;
1341 list->qh_version = 0;
1342 list->qh_nelems = 0;
1343}
1344
1345STATIC void
1346xfs_qm_list_destroy(
1347 xfs_dqlist_t *list)
1348{
1349 mutex_destroy(&(list->qh_lock));
1350}
1351
1352
1353/*
1354 * Stripped down version of dqattach. This doesn't attach, or even look at the
1355 * dquots attached to the inode. The rationale is that there won't be any
1356 * attached at the time this is called from quotacheck.
1357 */
1358STATIC int
1359xfs_qm_dqget_noattach(
1360 xfs_inode_t *ip,
1361 xfs_dquot_t **O_udqpp,
1362 xfs_dquot_t **O_gdqpp)
1363{
1364 int error;
1365 xfs_mount_t *mp;
1366 xfs_dquot_t *udqp, *gdqp;
1367
1368 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
1369 mp = ip->i_mount;
1370 udqp = NULL;
1371 gdqp = NULL;
1372
1373 if (XFS_IS_UQUOTA_ON(mp)) {
1374 ASSERT(ip->i_udquot == NULL);
1375 /*
1376 * We want the dquot allocated if it doesn't exist.
1377 */
1378 if ((error = xfs_qm_dqget(mp, ip, ip->i_d.di_uid, XFS_DQ_USER,
1379 XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN,
1380 &udqp))) {
1381 /*
1382 * Shouldn't be able to turn off quotas here.
1383 */
1384 ASSERT(error != ESRCH);
1385 ASSERT(error != ENOENT);
1386 return (error);
1387 }
1388 ASSERT(udqp);
1389 }
1390
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001391 if (XFS_IS_OQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 ASSERT(ip->i_gdquot == NULL);
1393 if (udqp)
1394 xfs_dqunlock(udqp);
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001395 error = XFS_IS_GQUOTA_ON(mp) ?
1396 xfs_qm_dqget(mp, ip,
1397 ip->i_d.di_gid, XFS_DQ_GROUP,
1398 XFS_QMOPT_DQALLOC|XFS_QMOPT_DOWARN,
1399 &gdqp) :
1400 xfs_qm_dqget(mp, ip,
1401 ip->i_d.di_projid, XFS_DQ_PROJ,
1402 XFS_QMOPT_DQALLOC|XFS_QMOPT_DOWARN,
1403 &gdqp);
1404 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 if (udqp)
1406 xfs_qm_dqrele(udqp);
1407 ASSERT(error != ESRCH);
1408 ASSERT(error != ENOENT);
1409 return (error);
1410 }
1411 ASSERT(gdqp);
1412
1413 /* Reacquire the locks in the right order */
1414 if (udqp) {
1415 if (! xfs_qm_dqlock_nowait(udqp)) {
1416 xfs_dqunlock(gdqp);
1417 xfs_dqlock(udqp);
1418 xfs_dqlock(gdqp);
1419 }
1420 }
1421 }
1422
1423 *O_udqpp = udqp;
1424 *O_gdqpp = gdqp;
1425
1426#ifdef QUOTADEBUG
1427 if (udqp) ASSERT(XFS_DQ_IS_LOCKED(udqp));
1428 if (gdqp) ASSERT(XFS_DQ_IS_LOCKED(gdqp));
1429#endif
1430 return (0);
1431}
1432
1433/*
1434 * Create an inode and return with a reference already taken, but unlocked
1435 * This is how we create quota inodes
1436 */
1437STATIC int
1438xfs_qm_qino_alloc(
1439 xfs_mount_t *mp,
1440 xfs_inode_t **ip,
1441 __int64_t sbfields,
1442 uint flags)
1443{
1444 xfs_trans_t *tp;
1445 int error;
1446 unsigned long s;
1447 cred_t zerocr;
1448 int committed;
1449
1450 tp = xfs_trans_alloc(mp,XFS_TRANS_QM_QINOCREATE);
1451 if ((error = xfs_trans_reserve(tp,
1452 XFS_QM_QINOCREATE_SPACE_RES(mp),
1453 XFS_CREATE_LOG_RES(mp), 0,
1454 XFS_TRANS_PERM_LOG_RES,
1455 XFS_CREATE_LOG_COUNT))) {
1456 xfs_trans_cancel(tp, 0);
1457 return (error);
1458 }
1459 memset(&zerocr, 0, sizeof(zerocr));
1460
1461 if ((error = xfs_dir_ialloc(&tp, mp->m_rootip, S_IFREG, 1, 0,
1462 &zerocr, 0, 1, ip, &committed))) {
1463 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
1464 XFS_TRANS_ABORT);
1465 return (error);
1466 }
1467
1468 /*
1469 * Keep an extra reference to this quota inode. This inode is
1470 * locked exclusively and joined to the transaction already.
1471 */
1472 ASSERT(XFS_ISLOCKED_INODE_EXCL(*ip));
1473 VN_HOLD(XFS_ITOV((*ip)));
1474
1475 /*
1476 * Make the changes in the superblock, and log those too.
1477 * sbfields arg may contain fields other than *QUOTINO;
1478 * VERSIONNUM for example.
1479 */
1480 s = XFS_SB_LOCK(mp);
1481 if (flags & XFS_QMOPT_SBVERSION) {
1482#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
1483 unsigned oldv = mp->m_sb.sb_versionnum;
1484#endif
1485 ASSERT(!XFS_SB_VERSION_HASQUOTA(&mp->m_sb));
1486 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1487 XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
1488 (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1489 XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
1490
1491 XFS_SB_VERSION_ADDQUOTA(&mp->m_sb);
1492 mp->m_sb.sb_uquotino = NULLFSINO;
1493 mp->m_sb.sb_gquotino = NULLFSINO;
1494
1495 /* qflags will get updated _after_ quotacheck */
1496 mp->m_sb.sb_qflags = 0;
1497#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
1498 cmn_err(CE_NOTE,
1499 "Old superblock version %x, converting to %x.",
1500 oldv, mp->m_sb.sb_versionnum);
1501#endif
1502 }
1503 if (flags & XFS_QMOPT_UQUOTA)
1504 mp->m_sb.sb_uquotino = (*ip)->i_ino;
1505 else
1506 mp->m_sb.sb_gquotino = (*ip)->i_ino;
1507 XFS_SB_UNLOCK(mp, s);
1508 xfs_mod_sb(tp, sbfields);
1509
1510 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES,
1511 NULL))) {
1512 xfs_fs_cmn_err(CE_ALERT, mp, "XFS qino_alloc failed!");
1513 return (error);
1514 }
1515 return (0);
1516}
1517
1518
1519STATIC int
1520xfs_qm_reset_dqcounts(
1521 xfs_mount_t *mp,
1522 xfs_buf_t *bp,
1523 xfs_dqid_t id,
1524 uint type)
1525{
1526 xfs_disk_dquot_t *ddq;
1527 int j;
1528
1529 xfs_buftrace("RESET DQUOTS", bp);
1530 /*
1531 * Reset all counters and timers. They'll be
1532 * started afresh by xfs_qm_quotacheck.
1533 */
1534#ifdef DEBUG
1535 j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1536 do_div(j, sizeof(xfs_dqblk_t));
1537 ASSERT(XFS_QM_DQPERBLK(mp) == j);
1538#endif
1539 ddq = (xfs_disk_dquot_t *)XFS_BUF_PTR(bp);
1540 for (j = 0; j < XFS_QM_DQPERBLK(mp); j++) {
1541 /*
1542 * Do a sanity check, and if needed, repair the dqblk. Don't
1543 * output any warnings because it's perfectly possible to
1544 * find unitialized dquot blks. See comment in xfs_qm_dqcheck.
1545 */
1546 (void) xfs_qm_dqcheck(ddq, id+j, type, XFS_QMOPT_DQREPAIR,
1547 "xfs_quotacheck");
1548 INT_SET(ddq->d_bcount, ARCH_CONVERT, 0ULL);
1549 INT_SET(ddq->d_icount, ARCH_CONVERT, 0ULL);
1550 INT_SET(ddq->d_rtbcount, ARCH_CONVERT, 0ULL);
1551 INT_SET(ddq->d_btimer, ARCH_CONVERT, (time_t)0);
1552 INT_SET(ddq->d_itimer, ARCH_CONVERT, (time_t)0);
Nathan Scott754002b2005-06-21 15:49:06 +10001553 INT_SET(ddq->d_rtbtimer, ARCH_CONVERT, (time_t)0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 INT_SET(ddq->d_bwarns, ARCH_CONVERT, 0UL);
1555 INT_SET(ddq->d_iwarns, ARCH_CONVERT, 0UL);
Nathan Scott754002b2005-06-21 15:49:06 +10001556 INT_SET(ddq->d_rtbwarns, ARCH_CONVERT, 0UL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);
1558 }
1559
1560 return (0);
1561}
1562
1563STATIC int
1564xfs_qm_dqiter_bufs(
1565 xfs_mount_t *mp,
1566 xfs_dqid_t firstid,
1567 xfs_fsblock_t bno,
1568 xfs_filblks_t blkcnt,
1569 uint flags)
1570{
1571 xfs_buf_t *bp;
1572 int error;
1573 int notcommitted;
1574 int incr;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001575 int type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576
1577 ASSERT(blkcnt > 0);
1578 notcommitted = 0;
1579 incr = (blkcnt > XFS_QM_MAX_DQCLUSTER_LOGSZ) ?
1580 XFS_QM_MAX_DQCLUSTER_LOGSZ : blkcnt;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001581 type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
1582 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 error = 0;
1584
1585 /*
1586 * Blkcnt arg can be a very big number, and might even be
1587 * larger than the log itself. So, we have to break it up into
1588 * manageable-sized transactions.
1589 * Note that we don't start a permanent transaction here; we might
1590 * not be able to get a log reservation for the whole thing up front,
1591 * and we don't really care to either, because we just discard
1592 * everything if we were to crash in the middle of this loop.
1593 */
1594 while (blkcnt--) {
1595 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1596 XFS_FSB_TO_DADDR(mp, bno),
1597 (int)XFS_QI_DQCHUNKLEN(mp), 0, &bp);
1598 if (error)
1599 break;
1600
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001601 (void) xfs_qm_reset_dqcounts(mp, bp, firstid, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 xfs_bdwrite(mp, bp);
1603 /*
1604 * goto the next block.
1605 */
1606 bno++;
1607 firstid += XFS_QM_DQPERBLK(mp);
1608 }
1609 return (error);
1610}
1611
1612/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001613 * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 * caller supplied function for every chunk of dquots that we find.
1615 */
1616STATIC int
1617xfs_qm_dqiterate(
1618 xfs_mount_t *mp,
1619 xfs_inode_t *qip,
1620 uint flags)
1621{
1622 xfs_bmbt_irec_t *map;
1623 int i, nmaps; /* number of map entries */
1624 int error; /* return value */
1625 xfs_fileoff_t lblkno;
1626 xfs_filblks_t maxlblkcnt;
1627 xfs_dqid_t firstid;
1628 xfs_fsblock_t rablkno;
1629 xfs_filblks_t rablkcnt;
1630
1631 error = 0;
1632 /*
1633 * This looks racey, but we can't keep an inode lock across a
1634 * trans_reserve. But, this gets called during quotacheck, and that
1635 * happens only at mount time which is single threaded.
1636 */
1637 if (qip->i_d.di_nblocks == 0)
1638 return (0);
1639
1640 map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
1641
1642 lblkno = 0;
1643 maxlblkcnt = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
1644 do {
1645 nmaps = XFS_DQITER_MAP_SIZE;
1646 /*
1647 * We aren't changing the inode itself. Just changing
1648 * some of its data. No new blocks are added here, and
1649 * the inode is never added to the transaction.
1650 */
1651 xfs_ilock(qip, XFS_ILOCK_SHARED);
1652 error = xfs_bmapi(NULL, qip, lblkno,
1653 maxlblkcnt - lblkno,
1654 XFS_BMAPI_METADATA,
1655 NULL,
1656 0, map, &nmaps, NULL);
1657 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1658 if (error)
1659 break;
1660
1661 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
1662 for (i = 0; i < nmaps; i++) {
1663 ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
1664 ASSERT(map[i].br_blockcount);
1665
1666
1667 lblkno += map[i].br_blockcount;
1668
1669 if (map[i].br_startblock == HOLESTARTBLOCK)
1670 continue;
1671
1672 firstid = (xfs_dqid_t) map[i].br_startoff *
1673 XFS_QM_DQPERBLK(mp);
1674 /*
1675 * Do a read-ahead on the next extent.
1676 */
1677 if ((i+1 < nmaps) &&
1678 (map[i+1].br_startblock != HOLESTARTBLOCK)) {
1679 rablkcnt = map[i+1].br_blockcount;
1680 rablkno = map[i+1].br_startblock;
1681 while (rablkcnt--) {
1682 xfs_baread(mp->m_ddev_targp,
1683 XFS_FSB_TO_DADDR(mp, rablkno),
1684 (int)XFS_QI_DQCHUNKLEN(mp));
1685 rablkno++;
1686 }
1687 }
1688 /*
1689 * Iterate thru all the blks in the extent and
1690 * reset the counters of all the dquots inside them.
1691 */
1692 if ((error = xfs_qm_dqiter_bufs(mp,
1693 firstid,
1694 map[i].br_startblock,
1695 map[i].br_blockcount,
1696 flags))) {
1697 break;
1698 }
1699 }
1700
1701 if (error)
1702 break;
1703 } while (nmaps > 0);
1704
1705 kmem_free(map, XFS_DQITER_MAP_SIZE * sizeof(*map));
1706
1707 return (error);
1708}
1709
1710/*
1711 * Called by dqusage_adjust in doing a quotacheck.
1712 * Given the inode, and a dquot (either USR or GRP, doesn't matter),
1713 * this updates its incore copy as well as the buffer copy. This is
1714 * so that once the quotacheck is done, we can just log all the buffers,
1715 * as opposed to logging numerous updates to individual dquots.
1716 */
1717STATIC void
1718xfs_qm_quotacheck_dqadjust(
1719 xfs_dquot_t *dqp,
1720 xfs_qcnt_t nblks,
1721 xfs_qcnt_t rtblks)
1722{
1723 ASSERT(XFS_DQ_IS_LOCKED(dqp));
1724 xfs_dqtrace_entry(dqp, "QCHECK DQADJUST");
1725 /*
1726 * Adjust the inode count and the block count to reflect this inode's
1727 * resource usage.
1728 */
1729 INT_MOD(dqp->q_core.d_icount, ARCH_CONVERT, +1);
1730 dqp->q_res_icount++;
1731 if (nblks) {
1732 INT_MOD(dqp->q_core.d_bcount, ARCH_CONVERT, nblks);
1733 dqp->q_res_bcount += nblks;
1734 }
1735 if (rtblks) {
1736 INT_MOD(dqp->q_core.d_rtbcount, ARCH_CONVERT, rtblks);
1737 dqp->q_res_rtbcount += rtblks;
1738 }
1739
1740 /*
1741 * Set default limits, adjust timers (since we changed usages)
1742 */
1743 if (! XFS_IS_SUSER_DQUOT(dqp)) {
1744 xfs_qm_adjust_dqlimits(dqp->q_mount, &dqp->q_core);
1745 xfs_qm_adjust_dqtimers(dqp->q_mount, &dqp->q_core);
1746 }
1747
1748 dqp->dq_flags |= XFS_DQ_DIRTY;
1749}
1750
1751STATIC int
1752xfs_qm_get_rtblks(
1753 xfs_inode_t *ip,
1754 xfs_qcnt_t *O_rtblks)
1755{
1756 xfs_filblks_t rtblks; /* total rt blks */
1757 xfs_ifork_t *ifp; /* inode fork pointer */
1758 xfs_extnum_t nextents; /* number of extent entries */
1759 xfs_bmbt_rec_t *base; /* base of extent array */
1760 xfs_bmbt_rec_t *ep; /* pointer to an extent entry */
1761 int error;
1762
1763 ASSERT(XFS_IS_REALTIME_INODE(ip));
1764 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1765 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1766 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
1767 return (error);
1768 }
1769 rtblks = 0;
1770 nextents = ifp->if_bytes / sizeof(xfs_bmbt_rec_t);
1771 base = &ifp->if_u1.if_extents[0];
1772 for (ep = base; ep < &base[nextents]; ep++)
1773 rtblks += xfs_bmbt_get_blockcount(ep);
1774 *O_rtblks = (xfs_qcnt_t)rtblks;
1775 return (0);
1776}
1777
1778/*
1779 * callback routine supplied to bulkstat(). Given an inumber, find its
1780 * dquots and update them to account for resources taken by that inode.
1781 */
1782/* ARGSUSED */
1783STATIC int
1784xfs_qm_dqusage_adjust(
1785 xfs_mount_t *mp, /* mount point for filesystem */
1786 xfs_ino_t ino, /* inode number to get data for */
1787 void __user *buffer, /* not used */
1788 int ubsize, /* not used */
1789 void *private_data, /* not used */
1790 xfs_daddr_t bno, /* starting block of inode cluster */
1791 int *ubused, /* not used */
1792 void *dip, /* on-disk inode pointer (not used) */
1793 int *res) /* result code value */
1794{
1795 xfs_inode_t *ip;
1796 xfs_dquot_t *udqp, *gdqp;
1797 xfs_qcnt_t nblks, rtblks;
1798 int error;
1799
1800 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1801
1802 /*
1803 * rootino must have its resources accounted for, not so with the quota
1804 * inodes.
1805 */
1806 if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1807 *res = BULKSTAT_RV_NOTHING;
1808 return XFS_ERROR(EINVAL);
1809 }
1810
1811 /*
1812 * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget
1813 * interface expects the inode to be exclusively locked because that's
1814 * the case in all other instances. It's OK that we do this because
1815 * quotacheck is done only at mount time.
1816 */
1817 if ((error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip, bno))) {
1818 *res = BULKSTAT_RV_NOTHING;
1819 return (error);
1820 }
1821
1822 if (ip->i_d.di_mode == 0) {
1823 xfs_iput_new(ip, XFS_ILOCK_EXCL);
1824 *res = BULKSTAT_RV_NOTHING;
1825 return XFS_ERROR(ENOENT);
1826 }
1827
1828 /*
1829 * Obtain the locked dquots. In case of an error (eg. allocation
1830 * fails for ENOSPC), we return the negative of the error number
1831 * to bulkstat, so that it can get propagated to quotacheck() and
1832 * making us disable quotas for the file system.
1833 */
1834 if ((error = xfs_qm_dqget_noattach(ip, &udqp, &gdqp))) {
1835 xfs_iput(ip, XFS_ILOCK_EXCL);
1836 *res = BULKSTAT_RV_GIVEUP;
1837 return (error);
1838 }
1839
1840 rtblks = 0;
1841 if (! XFS_IS_REALTIME_INODE(ip)) {
1842 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks;
1843 } else {
1844 /*
1845 * Walk thru the extent list and count the realtime blocks.
1846 */
1847 if ((error = xfs_qm_get_rtblks(ip, &rtblks))) {
1848 xfs_iput(ip, XFS_ILOCK_EXCL);
1849 if (udqp)
1850 xfs_qm_dqput(udqp);
1851 if (gdqp)
1852 xfs_qm_dqput(gdqp);
1853 *res = BULKSTAT_RV_GIVEUP;
1854 return (error);
1855 }
1856 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
1857 }
1858 ASSERT(ip->i_delayed_blks == 0);
1859
1860 /*
1861 * We can't release the inode while holding its dquot locks.
1862 * The inode can go into inactive and might try to acquire the dquotlocks.
1863 * So, just unlock here and do a vn_rele at the end.
1864 */
1865 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1866
1867 /*
1868 * Add the (disk blocks and inode) resources occupied by this
1869 * inode to its dquots. We do this adjustment in the incore dquot,
1870 * and also copy the changes to its buffer.
1871 * We don't care about putting these changes in a transaction
1872 * envelope because if we crash in the middle of a 'quotacheck'
1873 * we have to start from the beginning anyway.
1874 * Once we're done, we'll log all the dquot bufs.
1875 *
1876 * The *QUOTA_ON checks below may look pretty racey, but quotachecks
1877 * and quotaoffs don't race. (Quotachecks happen at mount time only).
1878 */
1879 if (XFS_IS_UQUOTA_ON(mp)) {
1880 ASSERT(udqp);
1881 xfs_qm_quotacheck_dqadjust(udqp, nblks, rtblks);
1882 xfs_qm_dqput(udqp);
1883 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001884 if (XFS_IS_OQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 ASSERT(gdqp);
1886 xfs_qm_quotacheck_dqadjust(gdqp, nblks, rtblks);
1887 xfs_qm_dqput(gdqp);
1888 }
1889 /*
1890 * Now release the inode. This will send it to 'inactive', and
1891 * possibly even free blocks.
1892 */
1893 VN_RELE(XFS_ITOV(ip));
1894
1895 /*
1896 * Goto next inode.
1897 */
1898 *res = BULKSTAT_RV_DIDONE;
1899 return (0);
1900}
1901
1902/*
1903 * Walk thru all the filesystem inodes and construct a consistent view
1904 * of the disk quota world. If the quotacheck fails, disable quotas.
1905 */
1906int
1907xfs_qm_quotacheck(
1908 xfs_mount_t *mp)
1909{
1910 int done, count, error;
1911 xfs_ino_t lastino;
1912 size_t structsz;
1913 xfs_inode_t *uip, *gip;
1914 uint flags;
1915
1916 count = INT_MAX;
1917 structsz = 1;
1918 lastino = 0;
1919 flags = 0;
1920
1921 ASSERT(XFS_QI_UQIP(mp) || XFS_QI_GQIP(mp));
1922 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1923
1924 /*
1925 * There should be no cached dquots. The (simplistic) quotacheck
1926 * algorithm doesn't like that.
1927 */
1928 ASSERT(XFS_QI_MPLNDQUOTS(mp) == 0);
1929
1930 cmn_err(CE_NOTE, "XFS quotacheck %s: Please wait.", mp->m_fsname);
1931
1932 /*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001933 * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 * their counters to zero. We need a clean slate.
1935 * We don't log our changes till later.
1936 */
1937 if ((uip = XFS_QI_UQIP(mp))) {
1938 if ((error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA)))
1939 goto error_return;
1940 flags |= XFS_UQUOTA_CHKD;
1941 }
1942
1943 if ((gip = XFS_QI_GQIP(mp))) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001944 if ((error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
1945 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 goto error_return;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001947 flags |= XFS_OQUOTA_CHKD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 }
1949
1950 do {
1951 /*
1952 * Iterate thru all the inodes in the file system,
1953 * adjusting the corresponding dquot counters in core.
1954 */
1955 if ((error = xfs_bulkstat(mp, &lastino, &count,
1956 xfs_qm_dqusage_adjust, NULL,
1957 structsz, NULL,
1958 BULKSTAT_FG_IGET|BULKSTAT_FG_VFSLOCKED,
1959 &done)))
1960 break;
1961
1962 } while (! done);
1963
1964 /*
1965 * We can get this error if we couldn't do a dquot allocation inside
1966 * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
1967 * dirty dquots that might be cached, we just want to get rid of them
1968 * and turn quotaoff. The dquots won't be attached to any of the inodes
1969 * at this point (because we intentionally didn't in dqget_noattach).
1970 */
1971 if (error) {
1972 xfs_qm_dqpurge_all(mp,
1973 XFS_QMOPT_UQUOTA|XFS_QMOPT_GQUOTA|
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001974 XFS_QMOPT_PQUOTA|XFS_QMOPT_QUOTAOFF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 goto error_return;
1976 }
1977 /*
1978 * We've made all the changes that we need to make incore.
1979 * Now flush_them down to disk buffers.
1980 */
1981 xfs_qm_dqflush_all(mp, XFS_QMOPT_DELWRI);
1982
1983 /*
1984 * We didn't log anything, because if we crashed, we'll have to
1985 * start the quotacheck from scratch anyway. However, we must make
1986 * sure that our dquot changes are secure before we put the
1987 * quotacheck'd stamp on the superblock. So, here we do a synchronous
1988 * flush.
1989 */
1990 XFS_bflush(mp->m_ddev_targp);
1991
1992 /*
1993 * If one type of quotas is off, then it will lose its
1994 * quotachecked status, since we won't be doing accounting for
1995 * that type anymore.
1996 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001997 mp->m_qflags &= ~(XFS_OQUOTA_CHKD | XFS_UQUOTA_CHKD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 mp->m_qflags |= flags;
1999
2000 XQM_LIST_PRINT(&(XFS_QI_MPL_LIST(mp)), MPL_NEXT, "++++ Mp list +++");
2001
2002 error_return:
2003 if (error) {
2004 cmn_err(CE_WARN, "XFS quotacheck %s: Unsuccessful (Error %d): "
2005 "Disabling quotas.",
2006 mp->m_fsname, error);
2007 /*
2008 * We must turn off quotas.
2009 */
2010 ASSERT(mp->m_quotainfo != NULL);
2011 ASSERT(xfs_Gqm != NULL);
2012 xfs_qm_destroy_quotainfo(mp);
2013 xfs_mount_reset_sbqflags(mp);
2014 } else {
2015 cmn_err(CE_NOTE, "XFS quotacheck %s: Done.", mp->m_fsname);
2016 }
2017 return (error);
2018}
2019
2020/*
2021 * This is called after the superblock has been read in and we're ready to
2022 * iget the quota inodes.
2023 */
2024STATIC int
2025xfs_qm_init_quotainos(
2026 xfs_mount_t *mp)
2027{
2028 xfs_inode_t *uip, *gip;
2029 int error;
2030 __int64_t sbflags;
2031 uint flags;
2032
2033 ASSERT(mp->m_quotainfo);
2034 uip = gip = NULL;
2035 sbflags = 0;
2036 flags = 0;
2037
2038 /*
2039 * Get the uquota and gquota inodes
2040 */
2041 if (XFS_SB_VERSION_HASQUOTA(&mp->m_sb)) {
2042 if (XFS_IS_UQUOTA_ON(mp) &&
2043 mp->m_sb.sb_uquotino != NULLFSINO) {
2044 ASSERT(mp->m_sb.sb_uquotino > 0);
2045 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
2046 0, 0, &uip, 0)))
2047 return XFS_ERROR(error);
2048 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002049 if (XFS_IS_OQUOTA_ON(mp) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 mp->m_sb.sb_gquotino != NULLFSINO) {
2051 ASSERT(mp->m_sb.sb_gquotino > 0);
2052 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
2053 0, 0, &gip, 0))) {
2054 if (uip)
2055 VN_RELE(XFS_ITOV(uip));
2056 return XFS_ERROR(error);
2057 }
2058 }
2059 } else {
2060 flags |= XFS_QMOPT_SBVERSION;
2061 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
2062 XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
2063 }
2064
2065 /*
2066 * Create the two inodes, if they don't exist already. The changes
2067 * made above will get added to a transaction and logged in one of
2068 * the qino_alloc calls below. If the device is readonly,
2069 * temporarily switch to read-write to do this.
2070 */
2071 if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
2072 if ((error = xfs_qm_qino_alloc(mp, &uip,
2073 sbflags | XFS_SB_UQUOTINO,
2074 flags | XFS_QMOPT_UQUOTA)))
2075 return XFS_ERROR(error);
2076
2077 flags &= ~XFS_QMOPT_SBVERSION;
2078 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002079 if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) {
2080 flags |= (XFS_IS_GQUOTA_ON(mp) ?
2081 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
2082 error = xfs_qm_qino_alloc(mp, &gip,
2083 sbflags | XFS_SB_GQUOTINO, flags);
2084 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085 if (uip)
2086 VN_RELE(XFS_ITOV(uip));
2087
2088 return XFS_ERROR(error);
2089 }
2090 }
2091
2092 XFS_QI_UQIP(mp) = uip;
2093 XFS_QI_GQIP(mp) = gip;
2094
2095 return (0);
2096}
2097
2098
2099/*
2100 * Traverse the freelist of dquots and attempt to reclaim a maximum of
2101 * 'howmany' dquots. This operation races with dqlookup(), and attempts to
2102 * favor the lookup function ...
2103 * XXXsup merge this with qm_reclaim_one().
2104 */
2105STATIC int
2106xfs_qm_shake_freelist(
2107 int howmany)
2108{
2109 int nreclaimed;
2110 xfs_dqhash_t *hash;
2111 xfs_dquot_t *dqp, *nextdqp;
2112 int restarts;
2113 int nflushes;
2114
2115 if (howmany <= 0)
2116 return (0);
2117
2118 nreclaimed = 0;
2119 restarts = 0;
2120 nflushes = 0;
2121
2122#ifdef QUOTADEBUG
2123 cmn_err(CE_DEBUG, "Shake free 0x%x", howmany);
2124#endif
2125 /* lock order is : hashchainlock, freelistlock, mplistlock */
2126 tryagain:
2127 xfs_qm_freelist_lock(xfs_Gqm);
2128
2129 for (dqp = xfs_Gqm->qm_dqfreelist.qh_next;
2130 ((dqp != (xfs_dquot_t *) &xfs_Gqm->qm_dqfreelist) &&
2131 nreclaimed < howmany); ) {
2132 xfs_dqlock(dqp);
2133
2134 /*
2135 * We are racing with dqlookup here. Naturally we don't
2136 * want to reclaim a dquot that lookup wants.
2137 */
2138 if (dqp->dq_flags & XFS_DQ_WANT) {
2139 xfs_dqunlock(dqp);
2140 xfs_qm_freelist_unlock(xfs_Gqm);
2141 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
2142 return (nreclaimed);
2143 XQM_STATS_INC(xqmstats.xs_qm_dqwants);
2144 goto tryagain;
2145 }
2146
2147 /*
2148 * If the dquot is inactive, we are assured that it is
2149 * not on the mplist or the hashlist, and that makes our
2150 * life easier.
2151 */
2152 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
2153 ASSERT(dqp->q_mount == NULL);
2154 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
2155 ASSERT(dqp->HL_PREVP == NULL);
2156 ASSERT(dqp->MPL_PREVP == NULL);
2157 XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
2158 nextdqp = dqp->dq_flnext;
2159 goto off_freelist;
2160 }
2161
2162 ASSERT(dqp->MPL_PREVP);
2163 /*
2164 * Try to grab the flush lock. If this dquot is in the process of
2165 * getting flushed to disk, we don't want to reclaim it.
2166 */
2167 if (! xfs_qm_dqflock_nowait(dqp)) {
2168 xfs_dqunlock(dqp);
2169 dqp = dqp->dq_flnext;
2170 continue;
2171 }
2172
2173 /*
2174 * We have the flush lock so we know that this is not in the
2175 * process of being flushed. So, if this is dirty, flush it
2176 * DELWRI so that we don't get a freelist infested with
2177 * dirty dquots.
2178 */
2179 if (XFS_DQ_IS_DIRTY(dqp)) {
2180 xfs_dqtrace_entry(dqp, "DQSHAKE: DQDIRTY");
2181 /*
2182 * We flush it delayed write, so don't bother
2183 * releasing the mplock.
2184 */
2185 (void) xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
2186 xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
2187 dqp = dqp->dq_flnext;
2188 continue;
2189 }
2190 /*
2191 * We're trying to get the hashlock out of order. This races
2192 * with dqlookup; so, we giveup and goto the next dquot if
2193 * we couldn't get the hashlock. This way, we won't starve
2194 * a dqlookup process that holds the hashlock that is
2195 * waiting for the freelist lock.
2196 */
2197 if (! xfs_qm_dqhashlock_nowait(dqp)) {
2198 xfs_dqfunlock(dqp);
2199 xfs_dqunlock(dqp);
2200 dqp = dqp->dq_flnext;
2201 continue;
2202 }
2203 /*
2204 * This races with dquot allocation code as well as dqflush_all
2205 * and reclaim code. So, if we failed to grab the mplist lock,
2206 * giveup everything and start over.
2207 */
2208 hash = dqp->q_hash;
2209 ASSERT(hash);
2210 if (! xfs_qm_mplist_nowait(dqp->q_mount)) {
2211 /* XXX put a sentinel so that we can come back here */
2212 xfs_dqfunlock(dqp);
2213 xfs_dqunlock(dqp);
2214 XFS_DQ_HASH_UNLOCK(hash);
2215 xfs_qm_freelist_unlock(xfs_Gqm);
2216 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
2217 return (nreclaimed);
2218 goto tryagain;
2219 }
2220 xfs_dqtrace_entry(dqp, "DQSHAKE: UNLINKING");
2221#ifdef QUOTADEBUG
2222 cmn_err(CE_DEBUG, "Shake 0x%p, ID 0x%x\n",
2223 dqp, INT_GET(dqp->q_core.d_id, ARCH_CONVERT));
2224#endif
2225 ASSERT(dqp->q_nrefs == 0);
2226 nextdqp = dqp->dq_flnext;
2227 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(dqp->q_mount)), dqp);
2228 XQM_HASHLIST_REMOVE(hash, dqp);
2229 xfs_dqfunlock(dqp);
2230 xfs_qm_mplist_unlock(dqp->q_mount);
2231 XFS_DQ_HASH_UNLOCK(hash);
2232
2233 off_freelist:
2234 XQM_FREELIST_REMOVE(dqp);
2235 xfs_dqunlock(dqp);
2236 nreclaimed++;
2237 XQM_STATS_INC(xqmstats.xs_qm_dqshake_reclaims);
2238 xfs_qm_dqdestroy(dqp);
2239 dqp = nextdqp;
2240 }
2241 xfs_qm_freelist_unlock(xfs_Gqm);
2242 return (nreclaimed);
2243}
2244
2245
2246/*
2247 * The kmem_shake interface is invoked when memory is running low.
2248 */
2249/* ARGSUSED */
2250STATIC int
2251xfs_qm_shake(int nr_to_scan, unsigned int gfp_mask)
2252{
2253 int ndqused, nfree, n;
2254
2255 if (!kmem_shake_allow(gfp_mask))
2256 return (0);
2257 if (!xfs_Gqm)
2258 return (0);
2259
2260 nfree = xfs_Gqm->qm_dqfreelist.qh_nelems; /* free dquots */
2261 /* incore dquots in all f/s's */
2262 ndqused = atomic_read(&xfs_Gqm->qm_totaldquots) - nfree;
2263
2264 ASSERT(ndqused >= 0);
2265
2266 if (nfree <= ndqused && nfree < ndquot)
2267 return (0);
2268
2269 ndqused *= xfs_Gqm->qm_dqfree_ratio; /* target # of free dquots */
2270 n = nfree - ndqused - ndquot; /* # over target */
2271
2272 return xfs_qm_shake_freelist(MAX(nfree, n));
2273}
2274
2275
2276/*
2277 * Just pop the least recently used dquot off the freelist and
2278 * recycle it. The returned dquot is locked.
2279 */
2280STATIC xfs_dquot_t *
2281xfs_qm_dqreclaim_one(void)
2282{
2283 xfs_dquot_t *dqpout;
2284 xfs_dquot_t *dqp;
2285 int restarts;
2286 int nflushes;
2287
2288 restarts = 0;
2289 dqpout = NULL;
2290 nflushes = 0;
2291
2292 /* lockorder: hashchainlock, freelistlock, mplistlock, dqlock, dqflock */
2293 startagain:
2294 xfs_qm_freelist_lock(xfs_Gqm);
2295
2296 FOREACH_DQUOT_IN_FREELIST(dqp, &(xfs_Gqm->qm_dqfreelist)) {
2297 xfs_dqlock(dqp);
2298
2299 /*
2300 * We are racing with dqlookup here. Naturally we don't
2301 * want to reclaim a dquot that lookup wants. We release the
2302 * freelist lock and start over, so that lookup will grab
2303 * both the dquot and the freelistlock.
2304 */
2305 if (dqp->dq_flags & XFS_DQ_WANT) {
2306 ASSERT(! (dqp->dq_flags & XFS_DQ_INACTIVE));
2307 xfs_dqtrace_entry(dqp, "DQRECLAIM: DQWANT");
2308 xfs_dqunlock(dqp);
2309 xfs_qm_freelist_unlock(xfs_Gqm);
2310 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
2311 return (NULL);
2312 XQM_STATS_INC(xqmstats.xs_qm_dqwants);
2313 goto startagain;
2314 }
2315
2316 /*
2317 * If the dquot is inactive, we are assured that it is
2318 * not on the mplist or the hashlist, and that makes our
2319 * life easier.
2320 */
2321 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
2322 ASSERT(dqp->q_mount == NULL);
2323 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
2324 ASSERT(dqp->HL_PREVP == NULL);
2325 ASSERT(dqp->MPL_PREVP == NULL);
2326 XQM_FREELIST_REMOVE(dqp);
2327 xfs_dqunlock(dqp);
2328 dqpout = dqp;
2329 XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
2330 break;
2331 }
2332
2333 ASSERT(dqp->q_hash);
2334 ASSERT(dqp->MPL_PREVP);
2335
2336 /*
2337 * Try to grab the flush lock. If this dquot is in the process of
2338 * getting flushed to disk, we don't want to reclaim it.
2339 */
2340 if (! xfs_qm_dqflock_nowait(dqp)) {
2341 xfs_dqunlock(dqp);
2342 continue;
2343 }
2344
2345 /*
2346 * We have the flush lock so we know that this is not in the
2347 * process of being flushed. So, if this is dirty, flush it
2348 * DELWRI so that we don't get a freelist infested with
2349 * dirty dquots.
2350 */
2351 if (XFS_DQ_IS_DIRTY(dqp)) {
2352 xfs_dqtrace_entry(dqp, "DQRECLAIM: DQDIRTY");
2353 /*
2354 * We flush it delayed write, so don't bother
2355 * releasing the freelist lock.
2356 */
2357 (void) xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
2358 xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
2359 continue;
2360 }
2361
2362 if (! xfs_qm_mplist_nowait(dqp->q_mount)) {
2363 xfs_dqfunlock(dqp);
2364 xfs_dqunlock(dqp);
2365 continue;
2366 }
2367
2368 if (! xfs_qm_dqhashlock_nowait(dqp))
2369 goto mplistunlock;
2370
2371 ASSERT(dqp->q_nrefs == 0);
2372 xfs_dqtrace_entry(dqp, "DQRECLAIM: UNLINKING");
2373 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(dqp->q_mount)), dqp);
2374 XQM_HASHLIST_REMOVE(dqp->q_hash, dqp);
2375 XQM_FREELIST_REMOVE(dqp);
2376 dqpout = dqp;
2377 XFS_DQ_HASH_UNLOCK(dqp->q_hash);
2378 mplistunlock:
2379 xfs_qm_mplist_unlock(dqp->q_mount);
2380 xfs_dqfunlock(dqp);
2381 xfs_dqunlock(dqp);
2382 if (dqpout)
2383 break;
2384 }
2385
2386 xfs_qm_freelist_unlock(xfs_Gqm);
2387 return (dqpout);
2388}
2389
2390
2391/*------------------------------------------------------------------*/
2392
2393/*
2394 * Return a new incore dquot. Depending on the number of
2395 * dquots in the system, we either allocate a new one on the kernel heap,
2396 * or reclaim a free one.
2397 * Return value is B_TRUE if we allocated a new dquot, B_FALSE if we managed
2398 * to reclaim an existing one from the freelist.
2399 */
2400boolean_t
2401xfs_qm_dqalloc_incore(
2402 xfs_dquot_t **O_dqpp)
2403{
2404 xfs_dquot_t *dqp;
2405
2406 /*
2407 * Check against high water mark to see if we want to pop
2408 * a nincompoop dquot off the freelist.
2409 */
2410 if (atomic_read(&xfs_Gqm->qm_totaldquots) >= ndquot) {
2411 /*
2412 * Try to recycle a dquot from the freelist.
2413 */
2414 if ((dqp = xfs_qm_dqreclaim_one())) {
2415 XQM_STATS_INC(xqmstats.xs_qm_dqreclaims);
2416 /*
2417 * Just zero the core here. The rest will get
2418 * reinitialized by caller. XXX we shouldn't even
2419 * do this zero ...
2420 */
2421 memset(&dqp->q_core, 0, sizeof(dqp->q_core));
2422 *O_dqpp = dqp;
2423 return (B_FALSE);
2424 }
2425 XQM_STATS_INC(xqmstats.xs_qm_dqreclaim_misses);
2426 }
2427
2428 /*
2429 * Allocate a brand new dquot on the kernel heap and return it
2430 * to the caller to initialize.
2431 */
2432 ASSERT(xfs_Gqm->qm_dqzone != NULL);
2433 *O_dqpp = kmem_zone_zalloc(xfs_Gqm->qm_dqzone, KM_SLEEP);
2434 atomic_inc(&xfs_Gqm->qm_totaldquots);
2435
2436 return (B_TRUE);
2437}
2438
2439
2440/*
2441 * Start a transaction and write the incore superblock changes to
2442 * disk. flags parameter indicates which fields have changed.
2443 */
2444int
2445xfs_qm_write_sb_changes(
2446 xfs_mount_t *mp,
2447 __int64_t flags)
2448{
2449 xfs_trans_t *tp;
2450 int error;
2451
2452#ifdef QUOTADEBUG
2453 cmn_err(CE_NOTE, "Writing superblock quota changes :%s", mp->m_fsname);
2454#endif
2455 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
2456 if ((error = xfs_trans_reserve(tp, 0,
2457 mp->m_sb.sb_sectsize + 128, 0,
2458 0,
2459 XFS_DEFAULT_LOG_COUNT))) {
2460 xfs_trans_cancel(tp, 0);
2461 return (error);
2462 }
2463
2464 xfs_mod_sb(tp, flags);
2465 (void) xfs_trans_commit(tp, 0, NULL);
2466
2467 return (0);
2468}
2469
2470
2471/* --------------- utility functions for vnodeops ---------------- */
2472
2473
2474/*
2475 * Given an inode, a uid and gid (from cred_t) make sure that we have
2476 * allocated relevant dquot(s) on disk, and that we won't exceed inode
2477 * quotas by creating this file.
2478 * This also attaches dquot(s) to the given inode after locking it,
2479 * and returns the dquots corresponding to the uid and/or gid.
2480 *
2481 * in : inode (unlocked)
2482 * out : udquot, gdquot with references taken and unlocked
2483 */
2484int
2485xfs_qm_vop_dqalloc(
2486 xfs_mount_t *mp,
2487 xfs_inode_t *ip,
2488 uid_t uid,
2489 gid_t gid,
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002490 prid_t prid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 uint flags,
2492 xfs_dquot_t **O_udqpp,
2493 xfs_dquot_t **O_gdqpp)
2494{
2495 int error;
2496 xfs_dquot_t *uq, *gq;
2497 uint lockflags;
2498
2499 if (!XFS_IS_QUOTA_ON(mp))
2500 return 0;
2501
2502 lockflags = XFS_ILOCK_EXCL;
2503 xfs_ilock(ip, lockflags);
2504
2505 if ((flags & XFS_QMOPT_INHERIT) &&
2506 XFS_INHERIT_GID(ip, XFS_MTOVFS(mp)))
2507 gid = ip->i_d.di_gid;
2508
2509 /*
2510 * Attach the dquot(s) to this inode, doing a dquot allocation
2511 * if necessary. The dquot(s) will not be locked.
2512 */
2513 if (XFS_NOT_DQATTACHED(mp, ip)) {
2514 if ((error = xfs_qm_dqattach(ip, XFS_QMOPT_DQALLOC |
2515 XFS_QMOPT_ILOCKED))) {
2516 xfs_iunlock(ip, lockflags);
2517 return (error);
2518 }
2519 }
2520
2521 uq = gq = NULL;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002522 if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002523 if (ip->i_d.di_uid != uid) {
2524 /*
2525 * What we need is the dquot that has this uid, and
2526 * if we send the inode to dqget, the uid of the inode
2527 * takes priority over what's sent in the uid argument.
2528 * We must unlock inode here before calling dqget if
2529 * we're not sending the inode, because otherwise
2530 * we'll deadlock by doing trans_reserve while
2531 * holding ilock.
2532 */
2533 xfs_iunlock(ip, lockflags);
2534 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
2535 XFS_DQ_USER,
2536 XFS_QMOPT_DQALLOC |
2537 XFS_QMOPT_DOWARN,
2538 &uq))) {
2539 ASSERT(error != ENOENT);
2540 return (error);
2541 }
2542 /*
2543 * Get the ilock in the right order.
2544 */
2545 xfs_dqunlock(uq);
2546 lockflags = XFS_ILOCK_SHARED;
2547 xfs_ilock(ip, lockflags);
2548 } else {
2549 /*
2550 * Take an extra reference, because we'll return
2551 * this to caller
2552 */
2553 ASSERT(ip->i_udquot);
2554 uq = ip->i_udquot;
2555 xfs_dqlock(uq);
2556 XFS_DQHOLD(uq);
2557 xfs_dqunlock(uq);
2558 }
2559 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002560 if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561 if (ip->i_d.di_gid != gid) {
2562 xfs_iunlock(ip, lockflags);
2563 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
2564 XFS_DQ_GROUP,
2565 XFS_QMOPT_DQALLOC |
2566 XFS_QMOPT_DOWARN,
2567 &gq))) {
2568 if (uq)
2569 xfs_qm_dqrele(uq);
2570 ASSERT(error != ENOENT);
2571 return (error);
2572 }
2573 xfs_dqunlock(gq);
2574 lockflags = XFS_ILOCK_SHARED;
2575 xfs_ilock(ip, lockflags);
2576 } else {
2577 ASSERT(ip->i_gdquot);
2578 gq = ip->i_gdquot;
2579 xfs_dqlock(gq);
2580 XFS_DQHOLD(gq);
2581 xfs_dqunlock(gq);
2582 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002583 } else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
2584 if (ip->i_d.di_projid != prid) {
2585 xfs_iunlock(ip, lockflags);
2586 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
2587 XFS_DQ_PROJ,
2588 XFS_QMOPT_DQALLOC |
2589 XFS_QMOPT_DOWARN,
2590 &gq))) {
2591 if (uq)
2592 xfs_qm_dqrele(uq);
2593 ASSERT(error != ENOENT);
2594 return (error);
2595 }
2596 xfs_dqunlock(gq);
2597 lockflags = XFS_ILOCK_SHARED;
2598 xfs_ilock(ip, lockflags);
2599 } else {
2600 ASSERT(ip->i_gdquot);
2601 gq = ip->i_gdquot;
2602 xfs_dqlock(gq);
2603 XFS_DQHOLD(gq);
2604 xfs_dqunlock(gq);
2605 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606 }
2607 if (uq)
2608 xfs_dqtrace_entry_ino(uq, "DQALLOC", ip);
2609
2610 xfs_iunlock(ip, lockflags);
2611 if (O_udqpp)
2612 *O_udqpp = uq;
2613 else if (uq)
2614 xfs_qm_dqrele(uq);
2615 if (O_gdqpp)
2616 *O_gdqpp = gq;
2617 else if (gq)
2618 xfs_qm_dqrele(gq);
2619 return (0);
2620}
2621
2622/*
2623 * Actually transfer ownership, and do dquot modifications.
2624 * These were already reserved.
2625 */
2626xfs_dquot_t *
2627xfs_qm_vop_chown(
2628 xfs_trans_t *tp,
2629 xfs_inode_t *ip,
2630 xfs_dquot_t **IO_olddq,
2631 xfs_dquot_t *newdq)
2632{
2633 xfs_dquot_t *prevdq;
Nathan Scott06d10dd2005-06-21 15:48:47 +10002634 uint bfield = XFS_IS_REALTIME_INODE(ip) ?
2635 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
2636
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
2638 ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
2639
2640 /* old dquot */
2641 prevdq = *IO_olddq;
2642 ASSERT(prevdq);
2643 ASSERT(prevdq != newdq);
2644
Nathan Scott06d10dd2005-06-21 15:48:47 +10002645 xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
2646 xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647
2648 /* the sparkling new dquot */
Nathan Scott06d10dd2005-06-21 15:48:47 +10002649 xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
2650 xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002651
2652 /*
2653 * Take an extra reference, because the inode
2654 * is going to keep this dquot pointer even
2655 * after the trans_commit.
2656 */
2657 xfs_dqlock(newdq);
2658 XFS_DQHOLD(newdq);
2659 xfs_dqunlock(newdq);
2660 *IO_olddq = newdq;
2661
2662 return (prevdq);
2663}
2664
2665/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002666 * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 */
2668int
2669xfs_qm_vop_chown_reserve(
2670 xfs_trans_t *tp,
2671 xfs_inode_t *ip,
2672 xfs_dquot_t *udqp,
2673 xfs_dquot_t *gdqp,
2674 uint flags)
2675{
2676 int error;
2677 xfs_mount_t *mp;
Nathan Scott06d10dd2005-06-21 15:48:47 +10002678 uint delblks, blkflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679 xfs_dquot_t *unresudq, *unresgdq, *delblksudq, *delblksgdq;
2680
2681 ASSERT(XFS_ISLOCKED_INODE(ip));
2682 mp = ip->i_mount;
2683 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2684
2685 delblks = ip->i_delayed_blks;
2686 delblksudq = delblksgdq = unresudq = unresgdq = NULL;
Nathan Scott06d10dd2005-06-21 15:48:47 +10002687 blkflags = XFS_IS_REALTIME_INODE(ip) ?
2688 XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002689
2690 if (XFS_IS_UQUOTA_ON(mp) && udqp &&
2691 ip->i_d.di_uid != (uid_t)INT_GET(udqp->q_core.d_id, ARCH_CONVERT)) {
2692 delblksudq = udqp;
2693 /*
2694 * If there are delayed allocation blocks, then we have to
2695 * unreserve those from the old dquot, and add them to the
2696 * new dquot.
2697 */
2698 if (delblks) {
2699 ASSERT(ip->i_udquot);
2700 unresudq = ip->i_udquot;
2701 }
2702 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002703 if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
2704 if ((XFS_IS_GQUOTA_ON(ip->i_mount) && ip->i_d.di_gid !=
2705 INT_GET(gdqp->q_core.d_id, ARCH_CONVERT)) ||
2706 (XFS_IS_PQUOTA_ON(ip->i_mount) && ip->i_d.di_projid !=
2707 INT_GET(gdqp->q_core.d_id, ARCH_CONVERT))) {
2708 delblksgdq = gdqp;
2709 if (delblks) {
2710 ASSERT(ip->i_gdquot);
2711 unresgdq = ip->i_gdquot;
2712 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713 }
2714 }
2715
2716 if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
2717 delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
Nathan Scott06d10dd2005-06-21 15:48:47 +10002718 flags | blkflags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719 return (error);
2720
2721 /*
2722 * Do the delayed blks reservations/unreservations now. Since, these
2723 * are done without the help of a transaction, if a reservation fails
2724 * its previous reservations won't be automatically undone by trans
2725 * code. So, we have to do it manually here.
2726 */
2727 if (delblks) {
2728 /*
2729 * Do the reservations first. Unreservation can't fail.
2730 */
2731 ASSERT(delblksudq || delblksgdq);
2732 ASSERT(unresudq || unresgdq);
2733 if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2734 delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
Nathan Scott06d10dd2005-06-21 15:48:47 +10002735 flags | blkflags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736 return (error);
2737 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2738 unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
Nathan Scott06d10dd2005-06-21 15:48:47 +10002739 blkflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002740 }
2741
2742 return (0);
2743}
2744
2745int
2746xfs_qm_vop_rename_dqattach(
2747 xfs_inode_t **i_tab)
2748{
2749 xfs_inode_t *ip;
2750 int i;
2751 int error;
2752
2753 ip = i_tab[0];
2754
2755 if (! XFS_IS_QUOTA_ON(ip->i_mount))
2756 return (0);
2757
2758 if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
2759 error = xfs_qm_dqattach(ip, 0);
2760 if (error)
2761 return (error);
2762 }
2763 for (i = 1; (i < 4 && i_tab[i]); i++) {
2764 /*
2765 * Watch out for duplicate entries in the table.
2766 */
2767 if ((ip = i_tab[i]) != i_tab[i-1]) {
2768 if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
2769 error = xfs_qm_dqattach(ip, 0);
2770 if (error)
2771 return (error);
2772 }
2773 }
2774 }
2775 return (0);
2776}
2777
2778void
2779xfs_qm_vop_dqattach_and_dqmod_newinode(
2780 xfs_trans_t *tp,
2781 xfs_inode_t *ip,
2782 xfs_dquot_t *udqp,
2783 xfs_dquot_t *gdqp)
2784{
2785 if (!XFS_IS_QUOTA_ON(tp->t_mountp))
2786 return;
2787
2788 ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
2789 ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp));
2790
2791 if (udqp) {
2792 xfs_dqlock(udqp);
2793 XFS_DQHOLD(udqp);
2794 xfs_dqunlock(udqp);
2795 ASSERT(ip->i_udquot == NULL);
2796 ip->i_udquot = udqp;
2797 ASSERT(ip->i_d.di_uid == INT_GET(udqp->q_core.d_id, ARCH_CONVERT));
2798 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
2799 }
2800 if (gdqp) {
2801 xfs_dqlock(gdqp);
2802 XFS_DQHOLD(gdqp);
2803 xfs_dqunlock(gdqp);
2804 ASSERT(ip->i_gdquot == NULL);
2805 ip->i_gdquot = gdqp;
2806 ASSERT(ip->i_d.di_gid == INT_GET(gdqp->q_core.d_id, ARCH_CONVERT));
2807 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
2808 }
2809}
2810
2811/* ------------- list stuff -----------------*/
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002812STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813xfs_qm_freelist_init(xfs_frlist_t *ql)
2814{
2815 ql->qh_next = ql->qh_prev = (xfs_dquot_t *) ql;
2816 mutex_init(&ql->qh_lock, MUTEX_DEFAULT, "dqf");
2817 ql->qh_version = 0;
2818 ql->qh_nelems = 0;
2819}
2820
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002821STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822xfs_qm_freelist_destroy(xfs_frlist_t *ql)
2823{
2824 xfs_dquot_t *dqp, *nextdqp;
2825
2826 mutex_lock(&ql->qh_lock, PINOD);
2827 for (dqp = ql->qh_next;
2828 dqp != (xfs_dquot_t *)ql; ) {
2829 xfs_dqlock(dqp);
2830 nextdqp = dqp->dq_flnext;
2831#ifdef QUOTADEBUG
2832 cmn_err(CE_DEBUG, "FREELIST destroy 0x%p", dqp);
2833#endif
2834 XQM_FREELIST_REMOVE(dqp);
2835 xfs_dqunlock(dqp);
2836 xfs_qm_dqdestroy(dqp);
2837 dqp = nextdqp;
2838 }
2839 /*
2840 * Don't bother about unlocking.
2841 */
2842 mutex_destroy(&ql->qh_lock);
2843
2844 ASSERT(ql->qh_nelems == 0);
2845}
2846
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002847STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848xfs_qm_freelist_insert(xfs_frlist_t *ql, xfs_dquot_t *dq)
2849{
2850 dq->dq_flnext = ql->qh_next;
2851 dq->dq_flprev = (xfs_dquot_t *)ql;
2852 ql->qh_next = dq;
2853 dq->dq_flnext->dq_flprev = dq;
2854 xfs_Gqm->qm_dqfreelist.qh_nelems++;
2855 xfs_Gqm->qm_dqfreelist.qh_version++;
2856}
2857
2858void
2859xfs_qm_freelist_unlink(xfs_dquot_t *dq)
2860{
2861 xfs_dquot_t *next = dq->dq_flnext;
2862 xfs_dquot_t *prev = dq->dq_flprev;
2863
2864 next->dq_flprev = prev;
2865 prev->dq_flnext = next;
2866 dq->dq_flnext = dq->dq_flprev = dq;
2867 xfs_Gqm->qm_dqfreelist.qh_nelems--;
2868 xfs_Gqm->qm_dqfreelist.qh_version++;
2869}
2870
2871void
2872xfs_qm_freelist_append(xfs_frlist_t *ql, xfs_dquot_t *dq)
2873{
2874 xfs_qm_freelist_insert((xfs_frlist_t *)ql->qh_prev, dq);
2875}
2876
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002877STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878xfs_qm_dqhashlock_nowait(
2879 xfs_dquot_t *dqp)
2880{
2881 int locked;
2882
2883 locked = mutex_trylock(&((dqp)->q_hash->qh_lock));
2884 return (locked);
2885}
2886
2887int
2888xfs_qm_freelist_lock_nowait(
2889 xfs_qm_t *xqm)
2890{
2891 int locked;
2892
2893 locked = mutex_trylock(&(xqm->qm_dqfreelist.qh_lock));
2894 return (locked);
2895}
2896
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002897STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898xfs_qm_mplist_nowait(
2899 xfs_mount_t *mp)
2900{
2901 int locked;
2902
2903 ASSERT(mp->m_quotainfo);
2904 locked = mutex_trylock(&(XFS_QI_MPLLOCK(mp)));
2905 return (locked);
2906}