[XFS] Merge fixes into realtime quota code, since one/two reported, still
[linux-2.6] / fs / xfs / quota / xfs_qm.c
1 /*
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  */
79 mutex_t xfs_Gqm_lock;
80 struct xfs_qm   *xfs_Gqm;
81
82 kmem_zone_t     *qm_dqzone;
83 kmem_zone_t     *qm_dqtrxzone;
84 STATIC kmem_shaker_t    xfs_qm_shaker;
85
86 STATIC void     xfs_qm_list_init(xfs_dqlist_t *, char *, int);
87 STATIC void     xfs_qm_list_destroy(xfs_dqlist_t *);
88
89 STATIC void     xfs_qm_freelist_init(xfs_frlist_t *);
90 STATIC void     xfs_qm_freelist_destroy(xfs_frlist_t *);
91 STATIC int      xfs_qm_mplist_nowait(xfs_mount_t *);
92 STATIC int      xfs_qm_dqhashlock_nowait(xfs_dquot_t *);
93
94 STATIC int      xfs_qm_init_quotainos(xfs_mount_t *);
95 STATIC int      xfs_qm_init_quotainfo(xfs_mount_t *);
96 STATIC int      xfs_qm_shake(int, unsigned int);
97
98 #ifdef DEBUG
99 extern 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  */
124 STATIC struct xfs_qm *
125 xfs_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  */
193 STATIC void
194 xfs_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 */
226 STATIC int
227 xfs_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 */
256 STATIC void
257 xfs_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  */
307 void
308 xfs_qm_mount_quotainit(
309         xfs_mount_t     *mp,
310         uint            flags)
311 {
312         /*
313          * User, projects or group quotas has to be on.
314          */
315         ASSERT(flags & (XFSMNT_UQUOTA | XFSMNT_PQUOTA | XFSMNT_GQUOTA));
316
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)
333                         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;
338         }
339 }
340
341 /*
342  * Just destroy the quotainfo structure.
343  */
344 void
345 xfs_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  */
359 int
360 xfs_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
370          * mount without -o uquota/pquota/gquota options, revoke the
371          * quotachecked license, and bail out.
372          */
373         if (! XFS_IS_QUOTA_ON(mp) &&
374             (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT)) {
375                 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  */
460 int
461 xfs_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         }
514 out:
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  */
522 STATIC int
523 xfs_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;
535 again:
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  */
582 STATIC void
583 xfs_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  */
623 STATIC int
624 xfs_qm_dqpurge_int(
625         xfs_mount_t     *mp,
626         uint            flags) /* QUOTAOFF/UMOUNTING/UQUOTA/PQUOTA/GQUOTA */
627 {
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;
638         dqtype |= (flags & XFS_QMOPT_PQUOTA) ? XFS_DQ_PROJ : 0;
639         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
700 int
701 xfs_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
719 STATIC int
720 xfs_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
748          * when the type arg is group/project. Its purpose is to save a
749          * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside
750          * the user dquot.
751          */
752         ASSERT(!udqhint || type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
753         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  */
844 STATIC void
845 xfs_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 /*
911  * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
912  * into account.
913  * 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  */
920 int
921 xfs_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));
951         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,
958                                                 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);
1008                 if (XFS_IS_OQUOTA_ON(mp))
1009                         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  */
1028 void
1029 xfs_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);
1037         if (ip->i_udquot) {
1038                 xfs_dqtrace_entry_ino(ip->i_udquot, "DQDETTACH", ip);
1039                 xfs_qm_dqrele(ip->i_udquot);
1040                 ip->i_udquot = NULL;
1041         }
1042         if (ip->i_gdquot) {
1043                 xfs_dqtrace_entry_ino(ip->i_gdquot, "DQDETTACH", ip);
1044                 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
1058 int
1059 xfs_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  */
1168 STATIC int
1169 xfs_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,
1221                              XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER : 
1222                              (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
1223                                 XFS_DQ_PROJ),
1224                              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;
1254                 qinf->qi_rtbwarnlimit =
1255                                 INT_GET(ddqp->d_rtbwarns, ARCH_CONVERT) ?
1256                                 INT_GET(ddqp->d_rtbwarns, ARCH_CONVERT) :
1257                                 XFS_QM_RTBWARNLIMIT;
1258                 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;
1283                 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
1284         }
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  */
1295 void
1296 xfs_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 */
1333 STATIC void
1334 xfs_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
1345 STATIC void
1346 xfs_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  */
1358 STATIC int
1359 xfs_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
1391         if (XFS_IS_OQUOTA_ON(mp)) {
1392                 ASSERT(ip->i_gdquot == NULL);
1393                 if (udqp)
1394                         xfs_dqunlock(udqp);
1395                 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) {
1405                         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  */
1437 STATIC int
1438 xfs_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
1519 STATIC int
1520 xfs_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);
1553                 INT_SET(ddq->d_bwarns, ARCH_CONVERT, 0UL);
1554                 INT_SET(ddq->d_iwarns, ARCH_CONVERT, 0UL);
1555                 ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);
1556         }
1557
1558         return (0);
1559 }
1560
1561 STATIC int
1562 xfs_qm_dqiter_bufs(
1563         xfs_mount_t     *mp,
1564         xfs_dqid_t      firstid,
1565         xfs_fsblock_t   bno,
1566         xfs_filblks_t   blkcnt,
1567         uint            flags)
1568 {
1569         xfs_buf_t       *bp;
1570         int             error;
1571         int             notcommitted;
1572         int             incr;
1573         int             type;
1574
1575         ASSERT(blkcnt > 0);
1576         notcommitted = 0;
1577         incr = (blkcnt > XFS_QM_MAX_DQCLUSTER_LOGSZ) ?
1578                 XFS_QM_MAX_DQCLUSTER_LOGSZ : blkcnt;
1579         type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
1580                 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
1581         error = 0;
1582
1583         /*
1584          * Blkcnt arg can be a very big number, and might even be
1585          * larger than the log itself. So, we have to break it up into
1586          * manageable-sized transactions.
1587          * Note that we don't start a permanent transaction here; we might
1588          * not be able to get a log reservation for the whole thing up front,
1589          * and we don't really care to either, because we just discard
1590          * everything if we were to crash in the middle of this loop.
1591          */
1592         while (blkcnt--) {
1593                 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1594                               XFS_FSB_TO_DADDR(mp, bno),
1595                               (int)XFS_QI_DQCHUNKLEN(mp), 0, &bp);
1596                 if (error)
1597                         break;
1598
1599                 (void) xfs_qm_reset_dqcounts(mp, bp, firstid, type);
1600                 xfs_bdwrite(mp, bp);
1601                 /*
1602                  * goto the next block.
1603                  */
1604                 bno++;
1605                 firstid += XFS_QM_DQPERBLK(mp);
1606         }
1607         return (error);
1608 }
1609
1610 /*
1611  * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a
1612  * caller supplied function for every chunk of dquots that we find.
1613  */
1614 STATIC int
1615 xfs_qm_dqiterate(
1616         xfs_mount_t     *mp,
1617         xfs_inode_t     *qip,
1618         uint            flags)
1619 {
1620         xfs_bmbt_irec_t         *map;
1621         int                     i, nmaps;       /* number of map entries */
1622         int                     error;          /* return value */
1623         xfs_fileoff_t           lblkno;
1624         xfs_filblks_t           maxlblkcnt;
1625         xfs_dqid_t              firstid;
1626         xfs_fsblock_t           rablkno;
1627         xfs_filblks_t           rablkcnt;
1628
1629         error = 0;
1630         /*
1631          * This looks racey, but we can't keep an inode lock across a
1632          * trans_reserve. But, this gets called during quotacheck, and that
1633          * happens only at mount time which is single threaded.
1634          */
1635         if (qip->i_d.di_nblocks == 0)
1636                 return (0);
1637
1638         map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
1639
1640         lblkno = 0;
1641         maxlblkcnt = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
1642         do {
1643                 nmaps = XFS_DQITER_MAP_SIZE;
1644                 /*
1645                  * We aren't changing the inode itself. Just changing
1646                  * some of its data. No new blocks are added here, and
1647                  * the inode is never added to the transaction.
1648                  */
1649                 xfs_ilock(qip, XFS_ILOCK_SHARED);
1650                 error = xfs_bmapi(NULL, qip, lblkno,
1651                                   maxlblkcnt - lblkno,
1652                                   XFS_BMAPI_METADATA,
1653                                   NULL,
1654                                   0, map, &nmaps, NULL);
1655                 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1656                 if (error)
1657                         break;
1658
1659                 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
1660                 for (i = 0; i < nmaps; i++) {
1661                         ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
1662                         ASSERT(map[i].br_blockcount);
1663
1664
1665                         lblkno += map[i].br_blockcount;
1666
1667                         if (map[i].br_startblock == HOLESTARTBLOCK)
1668                                 continue;
1669
1670                         firstid = (xfs_dqid_t) map[i].br_startoff *
1671                                 XFS_QM_DQPERBLK(mp);
1672                         /*
1673                          * Do a read-ahead on the next extent.
1674                          */
1675                         if ((i+1 < nmaps) &&
1676                             (map[i+1].br_startblock != HOLESTARTBLOCK)) {
1677                                 rablkcnt =  map[i+1].br_blockcount;
1678                                 rablkno = map[i+1].br_startblock;
1679                                 while (rablkcnt--) {
1680                                         xfs_baread(mp->m_ddev_targp,
1681                                                XFS_FSB_TO_DADDR(mp, rablkno),
1682                                                (int)XFS_QI_DQCHUNKLEN(mp));
1683                                         rablkno++;
1684                                 }
1685                         }
1686                         /*
1687                          * Iterate thru all the blks in the extent and
1688                          * reset the counters of all the dquots inside them.
1689                          */
1690                         if ((error = xfs_qm_dqiter_bufs(mp,
1691                                                        firstid,
1692                                                        map[i].br_startblock,
1693                                                        map[i].br_blockcount,
1694                                                        flags))) {
1695                                 break;
1696                         }
1697                 }
1698
1699                 if (error)
1700                         break;
1701         } while (nmaps > 0);
1702
1703         kmem_free(map, XFS_DQITER_MAP_SIZE * sizeof(*map));
1704
1705         return (error);
1706 }
1707
1708 /*
1709  * Called by dqusage_adjust in doing a quotacheck.
1710  * Given the inode, and a dquot (either USR or GRP, doesn't matter),
1711  * this updates its incore copy as well as the buffer copy. This is
1712  * so that once the quotacheck is done, we can just log all the buffers,
1713  * as opposed to logging numerous updates to individual dquots.
1714  */
1715 STATIC void
1716 xfs_qm_quotacheck_dqadjust(
1717         xfs_dquot_t             *dqp,
1718         xfs_qcnt_t              nblks,
1719         xfs_qcnt_t              rtblks)
1720 {
1721         ASSERT(XFS_DQ_IS_LOCKED(dqp));
1722         xfs_dqtrace_entry(dqp, "QCHECK DQADJUST");
1723         /*
1724          * Adjust the inode count and the block count to reflect this inode's
1725          * resource usage.
1726          */
1727         INT_MOD(dqp->q_core.d_icount, ARCH_CONVERT, +1);
1728         dqp->q_res_icount++;
1729         if (nblks) {
1730                 INT_MOD(dqp->q_core.d_bcount, ARCH_CONVERT, nblks);
1731                 dqp->q_res_bcount += nblks;
1732         }
1733         if (rtblks) {
1734                 INT_MOD(dqp->q_core.d_rtbcount, ARCH_CONVERT, rtblks);
1735                 dqp->q_res_rtbcount += rtblks;
1736         }
1737
1738         /*
1739          * Set default limits, adjust timers (since we changed usages)
1740          */
1741         if (! XFS_IS_SUSER_DQUOT(dqp)) {
1742                 xfs_qm_adjust_dqlimits(dqp->q_mount, &dqp->q_core);
1743                 xfs_qm_adjust_dqtimers(dqp->q_mount, &dqp->q_core);
1744         }
1745
1746         dqp->dq_flags |= XFS_DQ_DIRTY;
1747 }
1748
1749 STATIC int
1750 xfs_qm_get_rtblks(
1751         xfs_inode_t     *ip,
1752         xfs_qcnt_t      *O_rtblks)
1753 {
1754         xfs_filblks_t   rtblks;                 /* total rt blks */
1755         xfs_ifork_t     *ifp;                   /* inode fork pointer */
1756         xfs_extnum_t    nextents;               /* number of extent entries */
1757         xfs_bmbt_rec_t  *base;                  /* base of extent array */
1758         xfs_bmbt_rec_t  *ep;                    /* pointer to an extent entry */
1759         int             error;
1760
1761         ASSERT(XFS_IS_REALTIME_INODE(ip));
1762         ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1763         if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1764                 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
1765                         return (error);
1766         }
1767         rtblks = 0;
1768         nextents = ifp->if_bytes / sizeof(xfs_bmbt_rec_t);
1769         base = &ifp->if_u1.if_extents[0];
1770         for (ep = base; ep < &base[nextents]; ep++)
1771                 rtblks += xfs_bmbt_get_blockcount(ep);
1772         *O_rtblks = (xfs_qcnt_t)rtblks;
1773         return (0);
1774 }
1775
1776 /*
1777  * callback routine supplied to bulkstat(). Given an inumber, find its
1778  * dquots and update them to account for resources taken by that inode.
1779  */
1780 /* ARGSUSED */
1781 STATIC int
1782 xfs_qm_dqusage_adjust(
1783         xfs_mount_t     *mp,            /* mount point for filesystem */
1784         xfs_ino_t       ino,            /* inode number to get data for */
1785         void            __user *buffer, /* not used */
1786         int             ubsize,         /* not used */
1787         void            *private_data,  /* not used */
1788         xfs_daddr_t     bno,            /* starting block of inode cluster */
1789         int             *ubused,        /* not used */
1790         void            *dip,           /* on-disk inode pointer (not used) */
1791         int             *res)           /* result code value */
1792 {
1793         xfs_inode_t     *ip;
1794         xfs_dquot_t     *udqp, *gdqp;
1795         xfs_qcnt_t      nblks, rtblks;
1796         int             error;
1797
1798         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1799
1800         /*
1801          * rootino must have its resources accounted for, not so with the quota
1802          * inodes.
1803          */
1804         if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1805                 *res = BULKSTAT_RV_NOTHING;
1806                 return XFS_ERROR(EINVAL);
1807         }
1808
1809         /*
1810          * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget
1811          * interface expects the inode to be exclusively locked because that's
1812          * the case in all other instances. It's OK that we do this because
1813          * quotacheck is done only at mount time.
1814          */
1815         if ((error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip, bno))) {
1816                 *res = BULKSTAT_RV_NOTHING;
1817                 return (error);
1818         }
1819
1820         if (ip->i_d.di_mode == 0) {
1821                 xfs_iput_new(ip, XFS_ILOCK_EXCL);
1822                 *res = BULKSTAT_RV_NOTHING;
1823                 return XFS_ERROR(ENOENT);
1824         }
1825
1826         /*
1827          * Obtain the locked dquots. In case of an error (eg. allocation
1828          * fails for ENOSPC), we return the negative of the error number
1829          * to bulkstat, so that it can get propagated to quotacheck() and
1830          * making us disable quotas for the file system.
1831          */
1832         if ((error = xfs_qm_dqget_noattach(ip, &udqp, &gdqp))) {
1833                 xfs_iput(ip, XFS_ILOCK_EXCL);
1834                 *res = BULKSTAT_RV_GIVEUP;
1835                 return (error);
1836         }
1837
1838         rtblks = 0;
1839         if (! XFS_IS_REALTIME_INODE(ip)) {
1840                 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks;
1841         } else {
1842                 /*
1843                  * Walk thru the extent list and count the realtime blocks.
1844                  */
1845                 if ((error = xfs_qm_get_rtblks(ip, &rtblks))) {
1846                         xfs_iput(ip, XFS_ILOCK_EXCL);
1847                         if (udqp)
1848                                 xfs_qm_dqput(udqp);
1849                         if (gdqp)
1850                                 xfs_qm_dqput(gdqp);
1851                         *res = BULKSTAT_RV_GIVEUP;
1852                         return (error);
1853                 }
1854                 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
1855         }
1856         ASSERT(ip->i_delayed_blks == 0);
1857
1858         /*
1859          * We can't release the inode while holding its dquot locks.
1860          * The inode can go into inactive and might try to acquire the dquotlocks.
1861          * So, just unlock here and do a vn_rele at the end.
1862          */
1863         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1864
1865         /*
1866          * Add the (disk blocks and inode) resources occupied by this
1867          * inode to its dquots. We do this adjustment in the incore dquot,
1868          * and also copy the changes to its buffer.
1869          * We don't care about putting these changes in a transaction
1870          * envelope because if we crash in the middle of a 'quotacheck'
1871          * we have to start from the beginning anyway.
1872          * Once we're done, we'll log all the dquot bufs.
1873          *
1874          * The *QUOTA_ON checks below may look pretty racey, but quotachecks
1875          * and quotaoffs don't race. (Quotachecks happen at mount time only).
1876          */
1877         if (XFS_IS_UQUOTA_ON(mp)) {
1878                 ASSERT(udqp);
1879                 xfs_qm_quotacheck_dqadjust(udqp, nblks, rtblks);
1880                 xfs_qm_dqput(udqp);
1881         }
1882         if (XFS_IS_OQUOTA_ON(mp)) {
1883                 ASSERT(gdqp);
1884                 xfs_qm_quotacheck_dqadjust(gdqp, nblks, rtblks);
1885                 xfs_qm_dqput(gdqp);
1886         }
1887         /*
1888          * Now release the inode. This will send it to 'inactive', and
1889          * possibly even free blocks.
1890          */
1891         VN_RELE(XFS_ITOV(ip));
1892
1893         /*
1894          * Goto next inode.
1895          */
1896         *res = BULKSTAT_RV_DIDONE;
1897         return (0);
1898 }
1899
1900 /*
1901  * Walk thru all the filesystem inodes and construct a consistent view
1902  * of the disk quota world. If the quotacheck fails, disable quotas.
1903  */
1904 int
1905 xfs_qm_quotacheck(
1906         xfs_mount_t     *mp)
1907 {
1908         int             done, count, error;
1909         xfs_ino_t       lastino;
1910         size_t          structsz;
1911         xfs_inode_t     *uip, *gip;
1912         uint            flags;
1913
1914         count = INT_MAX;
1915         structsz = 1;
1916         lastino = 0;
1917         flags = 0;
1918
1919         ASSERT(XFS_QI_UQIP(mp) || XFS_QI_GQIP(mp));
1920         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1921
1922         /*
1923          * There should be no cached dquots. The (simplistic) quotacheck
1924          * algorithm doesn't like that.
1925          */
1926         ASSERT(XFS_QI_MPLNDQUOTS(mp) == 0);
1927
1928         cmn_err(CE_NOTE, "XFS quotacheck %s: Please wait.", mp->m_fsname);
1929
1930         /*
1931          * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
1932          * their counters to zero. We need a clean slate.
1933          * We don't log our changes till later.
1934          */
1935         if ((uip = XFS_QI_UQIP(mp))) {
1936                 if ((error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA)))
1937                         goto error_return;
1938                 flags |= XFS_UQUOTA_CHKD;
1939         }
1940
1941         if ((gip = XFS_QI_GQIP(mp))) {
1942                 if ((error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
1943                                         XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA)))
1944                         goto error_return;
1945                 flags |= XFS_OQUOTA_CHKD;
1946         }
1947
1948         do {
1949                 /*
1950                  * Iterate thru all the inodes in the file system,
1951                  * adjusting the corresponding dquot counters in core.
1952                  */
1953                 if ((error = xfs_bulkstat(mp, &lastino, &count,
1954                                      xfs_qm_dqusage_adjust, NULL,
1955                                      structsz, NULL,
1956                                      BULKSTAT_FG_IGET|BULKSTAT_FG_VFSLOCKED,
1957                                      &done)))
1958                         break;
1959
1960         } while (! done);
1961
1962         /*
1963          * We can get this error if we couldn't do a dquot allocation inside
1964          * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
1965          * dirty dquots that might be cached, we just want to get rid of them
1966          * and turn quotaoff. The dquots won't be attached to any of the inodes
1967          * at this point (because we intentionally didn't in dqget_noattach).
1968          */
1969         if (error) {
1970                 xfs_qm_dqpurge_all(mp,
1971                                    XFS_QMOPT_UQUOTA|XFS_QMOPT_GQUOTA|
1972                                    XFS_QMOPT_PQUOTA|XFS_QMOPT_QUOTAOFF);
1973                 goto error_return;
1974         }
1975         /*
1976          * We've made all the changes that we need to make incore.
1977          * Now flush_them down to disk buffers.
1978          */
1979         xfs_qm_dqflush_all(mp, XFS_QMOPT_DELWRI);
1980
1981         /*
1982          * We didn't log anything, because if we crashed, we'll have to
1983          * start the quotacheck from scratch anyway. However, we must make
1984          * sure that our dquot changes are secure before we put the
1985          * quotacheck'd stamp on the superblock. So, here we do a synchronous
1986          * flush.
1987          */
1988         XFS_bflush(mp->m_ddev_targp);
1989
1990         /*
1991          * If one type of quotas is off, then it will lose its
1992          * quotachecked status, since we won't be doing accounting for
1993          * that type anymore.
1994          */
1995         mp->m_qflags &= ~(XFS_OQUOTA_CHKD | XFS_UQUOTA_CHKD);
1996         mp->m_qflags |= flags;
1997
1998         XQM_LIST_PRINT(&(XFS_QI_MPL_LIST(mp)), MPL_NEXT, "++++ Mp list +++");
1999
2000  error_return:
2001         if (error) {
2002                 cmn_err(CE_WARN, "XFS quotacheck %s: Unsuccessful (Error %d): "
2003                         "Disabling quotas.",
2004                         mp->m_fsname, error);
2005                 /*
2006                  * We must turn off quotas.
2007                  */
2008                 ASSERT(mp->m_quotainfo != NULL);
2009                 ASSERT(xfs_Gqm != NULL);
2010                 xfs_qm_destroy_quotainfo(mp);
2011                 xfs_mount_reset_sbqflags(mp);
2012         } else {
2013                 cmn_err(CE_NOTE, "XFS quotacheck %s: Done.", mp->m_fsname);
2014         }
2015         return (error);
2016 }
2017
2018 /*
2019  * This is called after the superblock has been read in and we're ready to
2020  * iget the quota inodes.
2021  */
2022 STATIC int
2023 xfs_qm_init_quotainos(
2024         xfs_mount_t     *mp)
2025 {
2026         xfs_inode_t     *uip, *gip;
2027         int             error;
2028         __int64_t       sbflags;
2029         uint            flags;
2030
2031         ASSERT(mp->m_quotainfo);
2032         uip = gip = NULL;
2033         sbflags = 0;
2034         flags = 0;
2035
2036         /*
2037          * Get the uquota and gquota inodes
2038          */
2039         if (XFS_SB_VERSION_HASQUOTA(&mp->m_sb)) {
2040                 if (XFS_IS_UQUOTA_ON(mp) &&
2041                     mp->m_sb.sb_uquotino != NULLFSINO) {
2042                         ASSERT(mp->m_sb.sb_uquotino > 0);
2043                         if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
2044                                              0, 0, &uip, 0)))
2045                                 return XFS_ERROR(error);
2046                 }
2047                 if (XFS_IS_OQUOTA_ON(mp) &&
2048                     mp->m_sb.sb_gquotino != NULLFSINO) {
2049                         ASSERT(mp->m_sb.sb_gquotino > 0);
2050                         if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
2051                                              0, 0, &gip, 0))) {
2052                                 if (uip)
2053                                         VN_RELE(XFS_ITOV(uip));
2054                                 return XFS_ERROR(error);
2055                         }
2056                 }
2057         } else {
2058                 flags |= XFS_QMOPT_SBVERSION;
2059                 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
2060                             XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
2061         }
2062
2063         /*
2064          * Create the two inodes, if they don't exist already. The changes
2065          * made above will get added to a transaction and logged in one of
2066          * the qino_alloc calls below.  If the device is readonly,
2067          * temporarily switch to read-write to do this.
2068          */
2069         if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
2070                 if ((error = xfs_qm_qino_alloc(mp, &uip,
2071                                               sbflags | XFS_SB_UQUOTINO,
2072                                               flags | XFS_QMOPT_UQUOTA)))
2073                         return XFS_ERROR(error);
2074
2075                 flags &= ~XFS_QMOPT_SBVERSION;
2076         }
2077         if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) {
2078                 flags |= (XFS_IS_GQUOTA_ON(mp) ?
2079                                 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
2080                 error = xfs_qm_qino_alloc(mp, &gip,
2081                                           sbflags | XFS_SB_GQUOTINO, flags);
2082                 if (error) {
2083                         if (uip)
2084                                 VN_RELE(XFS_ITOV(uip));
2085
2086                         return XFS_ERROR(error);
2087                 }
2088         }
2089
2090         XFS_QI_UQIP(mp) = uip;
2091         XFS_QI_GQIP(mp) = gip;
2092
2093         return (0);
2094 }
2095
2096
2097 /*
2098  * Traverse the freelist of dquots and attempt to reclaim a maximum of
2099  * 'howmany' dquots. This operation races with dqlookup(), and attempts to
2100  * favor the lookup function ...
2101  * XXXsup merge this with qm_reclaim_one().
2102  */
2103 STATIC int
2104 xfs_qm_shake_freelist(
2105         int howmany)
2106 {
2107         int             nreclaimed;
2108         xfs_dqhash_t    *hash;
2109         xfs_dquot_t     *dqp, *nextdqp;
2110         int             restarts;
2111         int             nflushes;
2112
2113         if (howmany <= 0)
2114                 return (0);
2115
2116         nreclaimed = 0;
2117         restarts = 0;
2118         nflushes = 0;
2119
2120 #ifdef QUOTADEBUG
2121         cmn_err(CE_DEBUG, "Shake free 0x%x", howmany);
2122 #endif
2123         /* lock order is : hashchainlock, freelistlock, mplistlock */
2124  tryagain:
2125         xfs_qm_freelist_lock(xfs_Gqm);
2126
2127         for (dqp = xfs_Gqm->qm_dqfreelist.qh_next;
2128              ((dqp != (xfs_dquot_t *) &xfs_Gqm->qm_dqfreelist) &&
2129               nreclaimed < howmany); ) {
2130                 xfs_dqlock(dqp);
2131
2132                 /*
2133                  * We are racing with dqlookup here. Naturally we don't
2134                  * want to reclaim a dquot that lookup wants.
2135                  */
2136                 if (dqp->dq_flags & XFS_DQ_WANT) {
2137                         xfs_dqunlock(dqp);
2138                         xfs_qm_freelist_unlock(xfs_Gqm);
2139                         if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
2140                                 return (nreclaimed);
2141                         XQM_STATS_INC(xqmstats.xs_qm_dqwants);
2142                         goto tryagain;
2143                 }
2144
2145                 /*
2146                  * If the dquot is inactive, we are assured that it is
2147                  * not on the mplist or the hashlist, and that makes our
2148                  * life easier.
2149                  */
2150                 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
2151                         ASSERT(dqp->q_mount == NULL);
2152                         ASSERT(! XFS_DQ_IS_DIRTY(dqp));
2153                         ASSERT(dqp->HL_PREVP == NULL);
2154                         ASSERT(dqp->MPL_PREVP == NULL);
2155                         XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
2156                         nextdqp = dqp->dq_flnext;
2157                         goto off_freelist;
2158                 }
2159
2160                 ASSERT(dqp->MPL_PREVP);
2161                 /*
2162                  * Try to grab the flush lock. If this dquot is in the process of
2163                  * getting flushed to disk, we don't want to reclaim it.
2164                  */
2165                 if (! xfs_qm_dqflock_nowait(dqp)) {
2166                         xfs_dqunlock(dqp);
2167                         dqp = dqp->dq_flnext;
2168                         continue;
2169                 }
2170
2171                 /*
2172                  * We have the flush lock so we know that this is not in the
2173                  * process of being flushed. So, if this is dirty, flush it
2174                  * DELWRI so that we don't get a freelist infested with
2175                  * dirty dquots.
2176                  */
2177                 if (XFS_DQ_IS_DIRTY(dqp)) {
2178                         xfs_dqtrace_entry(dqp, "DQSHAKE: DQDIRTY");
2179                         /*
2180                          * We flush it delayed write, so don't bother
2181                          * releasing the mplock.
2182                          */
2183                         (void) xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
2184                         xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
2185                         dqp = dqp->dq_flnext;
2186                         continue;
2187                 }
2188                 /*
2189                  * We're trying to get the hashlock out of order. This races
2190                  * with dqlookup; so, we giveup and goto the next dquot if
2191                  * we couldn't get the hashlock. This way, we won't starve
2192                  * a dqlookup process that holds the hashlock that is
2193                  * waiting for the freelist lock.
2194                  */
2195                 if (! xfs_qm_dqhashlock_nowait(dqp)) {
2196                         xfs_dqfunlock(dqp);
2197                         xfs_dqunlock(dqp);
2198                         dqp = dqp->dq_flnext;
2199                         continue;
2200                 }
2201                 /*
2202                  * This races with dquot allocation code as well as dqflush_all
2203                  * and reclaim code. So, if we failed to grab the mplist lock,
2204                  * giveup everything and start over.
2205                  */
2206                 hash = dqp->q_hash;
2207                 ASSERT(hash);
2208                 if (! xfs_qm_mplist_nowait(dqp->q_mount)) {
2209                         /* XXX put a sentinel so that we can come back here */
2210                         xfs_dqfunlock(dqp);
2211                         xfs_dqunlock(dqp);
2212                         XFS_DQ_HASH_UNLOCK(hash);
2213                         xfs_qm_freelist_unlock(xfs_Gqm);
2214                         if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
2215                                 return (nreclaimed);
2216                         goto tryagain;
2217                 }
2218                 xfs_dqtrace_entry(dqp, "DQSHAKE: UNLINKING");
2219 #ifdef QUOTADEBUG
2220                 cmn_err(CE_DEBUG, "Shake 0x%p, ID 0x%x\n",
2221                         dqp, INT_GET(dqp->q_core.d_id, ARCH_CONVERT));
2222 #endif
2223                 ASSERT(dqp->q_nrefs == 0);
2224                 nextdqp = dqp->dq_flnext;
2225                 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(dqp->q_mount)), dqp);
2226                 XQM_HASHLIST_REMOVE(hash, dqp);
2227                 xfs_dqfunlock(dqp);
2228                 xfs_qm_mplist_unlock(dqp->q_mount);
2229                 XFS_DQ_HASH_UNLOCK(hash);
2230
2231  off_freelist:
2232                 XQM_FREELIST_REMOVE(dqp);
2233                 xfs_dqunlock(dqp);
2234                 nreclaimed++;
2235                 XQM_STATS_INC(xqmstats.xs_qm_dqshake_reclaims);
2236                 xfs_qm_dqdestroy(dqp);
2237                 dqp = nextdqp;
2238         }
2239         xfs_qm_freelist_unlock(xfs_Gqm);
2240         return (nreclaimed);
2241 }
2242
2243
2244 /*
2245  * The kmem_shake interface is invoked when memory is running low.
2246  */
2247 /* ARGSUSED */
2248 STATIC int
2249 xfs_qm_shake(int nr_to_scan, unsigned int gfp_mask)
2250 {
2251         int     ndqused, nfree, n;
2252
2253         if (!kmem_shake_allow(gfp_mask))
2254                 return (0);
2255         if (!xfs_Gqm)
2256                 return (0);
2257
2258         nfree = xfs_Gqm->qm_dqfreelist.qh_nelems; /* free dquots */
2259         /* incore dquots in all f/s's */
2260         ndqused = atomic_read(&xfs_Gqm->qm_totaldquots) - nfree;
2261
2262         ASSERT(ndqused >= 0);
2263
2264         if (nfree <= ndqused && nfree < ndquot)
2265                 return (0);
2266
2267         ndqused *= xfs_Gqm->qm_dqfree_ratio;    /* target # of free dquots */
2268         n = nfree - ndqused - ndquot;           /* # over target */
2269
2270         return xfs_qm_shake_freelist(MAX(nfree, n));
2271 }
2272
2273
2274 /*
2275  * Just pop the least recently used dquot off the freelist and
2276  * recycle it. The returned dquot is locked.
2277  */
2278 STATIC xfs_dquot_t *
2279 xfs_qm_dqreclaim_one(void)
2280 {
2281         xfs_dquot_t     *dqpout;
2282         xfs_dquot_t     *dqp;
2283         int             restarts;
2284         int             nflushes;
2285
2286         restarts = 0;
2287         dqpout = NULL;
2288         nflushes = 0;
2289
2290         /* lockorder: hashchainlock, freelistlock, mplistlock, dqlock, dqflock */
2291  startagain:
2292         xfs_qm_freelist_lock(xfs_Gqm);
2293
2294         FOREACH_DQUOT_IN_FREELIST(dqp, &(xfs_Gqm->qm_dqfreelist)) {
2295                 xfs_dqlock(dqp);
2296
2297                 /*
2298                  * We are racing with dqlookup here. Naturally we don't
2299                  * want to reclaim a dquot that lookup wants. We release the
2300                  * freelist lock and start over, so that lookup will grab
2301                  * both the dquot and the freelistlock.
2302                  */
2303                 if (dqp->dq_flags & XFS_DQ_WANT) {
2304                         ASSERT(! (dqp->dq_flags & XFS_DQ_INACTIVE));
2305                         xfs_dqtrace_entry(dqp, "DQRECLAIM: DQWANT");
2306                         xfs_dqunlock(dqp);
2307                         xfs_qm_freelist_unlock(xfs_Gqm);
2308                         if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
2309                                 return (NULL);
2310                         XQM_STATS_INC(xqmstats.xs_qm_dqwants);
2311                         goto startagain;
2312                 }
2313
2314                 /*
2315                  * If the dquot is inactive, we are assured that it is
2316                  * not on the mplist or the hashlist, and that makes our
2317                  * life easier.
2318                  */
2319                 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
2320                         ASSERT(dqp->q_mount == NULL);
2321                         ASSERT(! XFS_DQ_IS_DIRTY(dqp));
2322                         ASSERT(dqp->HL_PREVP == NULL);
2323                         ASSERT(dqp->MPL_PREVP == NULL);
2324                         XQM_FREELIST_REMOVE(dqp);
2325                         xfs_dqunlock(dqp);
2326                         dqpout = dqp;
2327                         XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
2328                         break;
2329                 }
2330
2331                 ASSERT(dqp->q_hash);
2332                 ASSERT(dqp->MPL_PREVP);
2333
2334                 /*
2335                  * Try to grab the flush lock. If this dquot is in the process of
2336                  * getting flushed to disk, we don't want to reclaim it.
2337                  */
2338                 if (! xfs_qm_dqflock_nowait(dqp)) {
2339                         xfs_dqunlock(dqp);
2340                         continue;
2341                 }
2342
2343                 /*
2344                  * We have the flush lock so we know that this is not in the
2345                  * process of being flushed. So, if this is dirty, flush it
2346                  * DELWRI so that we don't get a freelist infested with
2347                  * dirty dquots.
2348                  */
2349                 if (XFS_DQ_IS_DIRTY(dqp)) {
2350                         xfs_dqtrace_entry(dqp, "DQRECLAIM: DQDIRTY");
2351                         /*
2352                          * We flush it delayed write, so don't bother
2353                          * releasing the freelist lock.
2354                          */
2355                         (void) xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
2356                         xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
2357                         continue;
2358                 }
2359
2360                 if (! xfs_qm_mplist_nowait(dqp->q_mount)) {
2361                         xfs_dqfunlock(dqp);
2362                         xfs_dqunlock(dqp);
2363                         continue;
2364                 }
2365
2366                 if (! xfs_qm_dqhashlock_nowait(dqp))
2367                         goto mplistunlock;
2368
2369                 ASSERT(dqp->q_nrefs == 0);
2370                 xfs_dqtrace_entry(dqp, "DQRECLAIM: UNLINKING");
2371                 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(dqp->q_mount)), dqp);
2372                 XQM_HASHLIST_REMOVE(dqp->q_hash, dqp);
2373                 XQM_FREELIST_REMOVE(dqp);
2374                 dqpout = dqp;
2375                 XFS_DQ_HASH_UNLOCK(dqp->q_hash);
2376  mplistunlock:
2377                 xfs_qm_mplist_unlock(dqp->q_mount);
2378                 xfs_dqfunlock(dqp);
2379                 xfs_dqunlock(dqp);
2380                 if (dqpout)
2381                         break;
2382         }
2383
2384         xfs_qm_freelist_unlock(xfs_Gqm);
2385         return (dqpout);
2386 }
2387
2388
2389 /*------------------------------------------------------------------*/
2390
2391 /*
2392  * Return a new incore dquot. Depending on the number of
2393  * dquots in the system, we either allocate a new one on the kernel heap,
2394  * or reclaim a free one.
2395  * Return value is B_TRUE if we allocated a new dquot, B_FALSE if we managed
2396  * to reclaim an existing one from the freelist.
2397  */
2398 boolean_t
2399 xfs_qm_dqalloc_incore(
2400         xfs_dquot_t **O_dqpp)
2401 {
2402         xfs_dquot_t     *dqp;
2403
2404         /*
2405          * Check against high water mark to see if we want to pop
2406          * a nincompoop dquot off the freelist.
2407          */
2408         if (atomic_read(&xfs_Gqm->qm_totaldquots) >= ndquot) {
2409                 /*
2410                  * Try to recycle a dquot from the freelist.
2411                  */
2412                 if ((dqp = xfs_qm_dqreclaim_one())) {
2413                         XQM_STATS_INC(xqmstats.xs_qm_dqreclaims);
2414                         /*
2415                          * Just zero the core here. The rest will get
2416                          * reinitialized by caller. XXX we shouldn't even
2417                          * do this zero ...
2418                          */
2419                         memset(&dqp->q_core, 0, sizeof(dqp->q_core));
2420                         *O_dqpp = dqp;
2421                         return (B_FALSE);
2422                 }
2423                 XQM_STATS_INC(xqmstats.xs_qm_dqreclaim_misses);
2424         }
2425
2426         /*
2427          * Allocate a brand new dquot on the kernel heap and return it
2428          * to the caller to initialize.
2429          */
2430         ASSERT(xfs_Gqm->qm_dqzone != NULL);
2431         *O_dqpp = kmem_zone_zalloc(xfs_Gqm->qm_dqzone, KM_SLEEP);
2432         atomic_inc(&xfs_Gqm->qm_totaldquots);
2433
2434         return (B_TRUE);
2435 }
2436
2437
2438 /*
2439  * Start a transaction and write the incore superblock changes to
2440  * disk. flags parameter indicates which fields have changed.
2441  */
2442 int
2443 xfs_qm_write_sb_changes(
2444         xfs_mount_t     *mp,
2445         __int64_t       flags)
2446 {
2447         xfs_trans_t     *tp;
2448         int             error;
2449
2450 #ifdef QUOTADEBUG
2451         cmn_err(CE_NOTE, "Writing superblock quota changes :%s", mp->m_fsname);
2452 #endif
2453         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
2454         if ((error = xfs_trans_reserve(tp, 0,
2455                                       mp->m_sb.sb_sectsize + 128, 0,
2456                                       0,
2457                                       XFS_DEFAULT_LOG_COUNT))) {
2458                 xfs_trans_cancel(tp, 0);
2459                 return (error);
2460         }
2461
2462         xfs_mod_sb(tp, flags);
2463         (void) xfs_trans_commit(tp, 0, NULL);
2464
2465         return (0);
2466 }
2467
2468
2469 /* --------------- utility functions for vnodeops ---------------- */
2470
2471
2472 /*
2473  * Given an inode, a uid and gid (from cred_t) make sure that we have
2474  * allocated relevant dquot(s) on disk, and that we won't exceed inode
2475  * quotas by creating this file.
2476  * This also attaches dquot(s) to the given inode after locking it,
2477  * and returns the dquots corresponding to the uid and/or gid.
2478  *
2479  * in   : inode (unlocked)
2480  * out  : udquot, gdquot with references taken and unlocked
2481  */
2482 int
2483 xfs_qm_vop_dqalloc(
2484         xfs_mount_t     *mp,
2485         xfs_inode_t     *ip,
2486         uid_t           uid,
2487         gid_t           gid,
2488         prid_t          prid,
2489         uint            flags,
2490         xfs_dquot_t     **O_udqpp,
2491         xfs_dquot_t     **O_gdqpp)
2492 {
2493         int             error;
2494         xfs_dquot_t     *uq, *gq;
2495         uint            lockflags;
2496
2497         if (!XFS_IS_QUOTA_ON(mp))
2498                 return 0;
2499
2500         lockflags = XFS_ILOCK_EXCL;
2501         xfs_ilock(ip, lockflags);
2502
2503         if ((flags & XFS_QMOPT_INHERIT) &&
2504             XFS_INHERIT_GID(ip, XFS_MTOVFS(mp)))
2505                 gid = ip->i_d.di_gid;
2506
2507         /*
2508          * Attach the dquot(s) to this inode, doing a dquot allocation
2509          * if necessary. The dquot(s) will not be locked.
2510          */
2511         if (XFS_NOT_DQATTACHED(mp, ip)) {
2512                 if ((error = xfs_qm_dqattach(ip, XFS_QMOPT_DQALLOC |
2513                                             XFS_QMOPT_ILOCKED))) {
2514                         xfs_iunlock(ip, lockflags);
2515                         return (error);
2516                 }
2517         }
2518
2519         uq = gq = NULL;
2520         if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
2521                 if (ip->i_d.di_uid != uid) {
2522                         /*
2523                          * What we need is the dquot that has this uid, and
2524                          * if we send the inode to dqget, the uid of the inode
2525                          * takes priority over what's sent in the uid argument.
2526                          * We must unlock inode here before calling dqget if
2527                          * we're not sending the inode, because otherwise
2528                          * we'll deadlock by doing trans_reserve while
2529                          * holding ilock.
2530                          */
2531                         xfs_iunlock(ip, lockflags);
2532                         if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
2533                                                  XFS_DQ_USER,
2534                                                  XFS_QMOPT_DQALLOC |
2535                                                  XFS_QMOPT_DOWARN,
2536                                                  &uq))) {
2537                                 ASSERT(error != ENOENT);
2538                                 return (error);
2539                         }
2540                         /*
2541                          * Get the ilock in the right order.
2542                          */
2543                         xfs_dqunlock(uq);
2544                         lockflags = XFS_ILOCK_SHARED;
2545                         xfs_ilock(ip, lockflags);
2546                 } else {
2547                         /*
2548                          * Take an extra reference, because we'll return
2549                          * this to caller
2550                          */
2551                         ASSERT(ip->i_udquot);
2552                         uq = ip->i_udquot;
2553                         xfs_dqlock(uq);
2554                         XFS_DQHOLD(uq);
2555                         xfs_dqunlock(uq);
2556                 }
2557         }
2558         if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
2559                 if (ip->i_d.di_gid != gid) {
2560                         xfs_iunlock(ip, lockflags);
2561                         if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
2562                                                  XFS_DQ_GROUP,
2563                                                  XFS_QMOPT_DQALLOC |
2564                                                  XFS_QMOPT_DOWARN,
2565                                                  &gq))) {
2566                                 if (uq)
2567                                         xfs_qm_dqrele(uq);
2568                                 ASSERT(error != ENOENT);
2569                                 return (error);
2570                         }
2571                         xfs_dqunlock(gq);
2572                         lockflags = XFS_ILOCK_SHARED;
2573                         xfs_ilock(ip, lockflags);
2574                 } else {
2575                         ASSERT(ip->i_gdquot);
2576                         gq = ip->i_gdquot;
2577                         xfs_dqlock(gq);
2578                         XFS_DQHOLD(gq);
2579                         xfs_dqunlock(gq);
2580                 }
2581         } else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
2582                 if (ip->i_d.di_projid != prid) {
2583                         xfs_iunlock(ip, lockflags);
2584                         if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
2585                                                  XFS_DQ_PROJ,
2586                                                  XFS_QMOPT_DQALLOC |
2587                                                  XFS_QMOPT_DOWARN,
2588                                                  &gq))) {
2589                                 if (uq)
2590                                         xfs_qm_dqrele(uq);
2591                                 ASSERT(error != ENOENT);
2592                                 return (error);
2593                         }
2594                         xfs_dqunlock(gq);
2595                         lockflags = XFS_ILOCK_SHARED;
2596                         xfs_ilock(ip, lockflags);
2597                 } else {
2598                         ASSERT(ip->i_gdquot);
2599                         gq = ip->i_gdquot;
2600                         xfs_dqlock(gq);
2601                         XFS_DQHOLD(gq);
2602                         xfs_dqunlock(gq);
2603                 }
2604         }
2605         if (uq)
2606                 xfs_dqtrace_entry_ino(uq, "DQALLOC", ip);
2607
2608         xfs_iunlock(ip, lockflags);
2609         if (O_udqpp)
2610                 *O_udqpp = uq;
2611         else if (uq)
2612                 xfs_qm_dqrele(uq);
2613         if (O_gdqpp)
2614                 *O_gdqpp = gq;
2615         else if (gq)
2616                 xfs_qm_dqrele(gq);
2617         return (0);
2618 }
2619
2620 /*
2621  * Actually transfer ownership, and do dquot modifications.
2622  * These were already reserved.
2623  */
2624 xfs_dquot_t *
2625 xfs_qm_vop_chown(
2626         xfs_trans_t     *tp,
2627         xfs_inode_t     *ip,
2628         xfs_dquot_t     **IO_olddq,
2629         xfs_dquot_t     *newdq)
2630 {
2631         xfs_dquot_t     *prevdq;
2632         uint            bfield = XFS_IS_REALTIME_INODE(ip) ?
2633                                  XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
2634
2635         ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
2636         ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
2637
2638         /* old dquot */
2639         prevdq = *IO_olddq;
2640         ASSERT(prevdq);
2641         ASSERT(prevdq != newdq);
2642
2643         xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
2644         xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
2645
2646         /* the sparkling new dquot */
2647         xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
2648         xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
2649
2650         /*
2651          * Take an extra reference, because the inode
2652          * is going to keep this dquot pointer even
2653          * after the trans_commit.
2654          */
2655         xfs_dqlock(newdq);
2656         XFS_DQHOLD(newdq);
2657         xfs_dqunlock(newdq);
2658         *IO_olddq = newdq;
2659
2660         return (prevdq);
2661 }
2662
2663 /*
2664  * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
2665  */
2666 int
2667 xfs_qm_vop_chown_reserve(
2668         xfs_trans_t     *tp,
2669         xfs_inode_t     *ip,
2670         xfs_dquot_t     *udqp,
2671         xfs_dquot_t     *gdqp,
2672         uint            flags)
2673 {
2674         int             error;
2675         xfs_mount_t     *mp;
2676         uint            delblks, blkflags;
2677         xfs_dquot_t     *unresudq, *unresgdq, *delblksudq, *delblksgdq;
2678
2679         ASSERT(XFS_ISLOCKED_INODE(ip));
2680         mp = ip->i_mount;
2681         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2682
2683         delblks = ip->i_delayed_blks;
2684         delblksudq = delblksgdq = unresudq = unresgdq = NULL;
2685         blkflags = XFS_IS_REALTIME_INODE(ip) ?
2686                         XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
2687
2688         if (XFS_IS_UQUOTA_ON(mp) && udqp &&
2689             ip->i_d.di_uid != (uid_t)INT_GET(udqp->q_core.d_id, ARCH_CONVERT)) {
2690                 delblksudq = udqp;
2691                 /*
2692                  * If there are delayed allocation blocks, then we have to
2693                  * unreserve those from the old dquot, and add them to the
2694                  * new dquot.
2695                  */
2696                 if (delblks) {
2697                         ASSERT(ip->i_udquot);
2698                         unresudq = ip->i_udquot;
2699                 }
2700         }
2701         if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
2702                 if ((XFS_IS_GQUOTA_ON(ip->i_mount) && ip->i_d.di_gid !=
2703                                 INT_GET(gdqp->q_core.d_id, ARCH_CONVERT)) ||
2704                     (XFS_IS_PQUOTA_ON(ip->i_mount) && ip->i_d.di_projid !=
2705                                 INT_GET(gdqp->q_core.d_id, ARCH_CONVERT))) {
2706                         delblksgdq = gdqp;
2707                         if (delblks) {
2708                                 ASSERT(ip->i_gdquot);
2709                                 unresgdq = ip->i_gdquot;
2710                         }
2711                 }
2712         }
2713
2714         if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
2715                                 delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
2716                                 flags | blkflags)))
2717                 return (error);
2718
2719         /*
2720          * Do the delayed blks reservations/unreservations now. Since, these
2721          * are done without the help of a transaction, if a reservation fails
2722          * its previous reservations won't be automatically undone by trans
2723          * code. So, we have to do it manually here.
2724          */
2725         if (delblks) {
2726                 /*
2727                  * Do the reservations first. Unreservation can't fail.
2728                  */
2729                 ASSERT(delblksudq || delblksgdq);
2730                 ASSERT(unresudq || unresgdq);
2731                 if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2732                                 delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
2733                                 flags | blkflags)))
2734                         return (error);
2735                 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2736                                 unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
2737                                 blkflags);
2738         }
2739
2740         return (0);
2741 }
2742
2743 int
2744 xfs_qm_vop_rename_dqattach(
2745         xfs_inode_t     **i_tab)
2746 {
2747         xfs_inode_t     *ip;
2748         int             i;
2749         int             error;
2750
2751         ip = i_tab[0];
2752
2753         if (! XFS_IS_QUOTA_ON(ip->i_mount))
2754                 return (0);
2755
2756         if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
2757                 error = xfs_qm_dqattach(ip, 0);
2758                 if (error)
2759                         return (error);
2760         }
2761         for (i = 1; (i < 4 && i_tab[i]); i++) {
2762                 /*
2763                  * Watch out for duplicate entries in the table.
2764                  */
2765                 if ((ip = i_tab[i]) != i_tab[i-1]) {
2766                         if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
2767                                 error = xfs_qm_dqattach(ip, 0);
2768                                 if (error)
2769                                         return (error);
2770                         }
2771                 }
2772         }
2773         return (0);
2774 }
2775
2776 void
2777 xfs_qm_vop_dqattach_and_dqmod_newinode(
2778         xfs_trans_t     *tp,
2779         xfs_inode_t     *ip,
2780         xfs_dquot_t     *udqp,
2781         xfs_dquot_t     *gdqp)
2782 {
2783         if (!XFS_IS_QUOTA_ON(tp->t_mountp))
2784                 return;
2785
2786         ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
2787         ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp));
2788
2789         if (udqp) {
2790                 xfs_dqlock(udqp);
2791                 XFS_DQHOLD(udqp);
2792                 xfs_dqunlock(udqp);
2793                 ASSERT(ip->i_udquot == NULL);
2794                 ip->i_udquot = udqp;
2795                 ASSERT(ip->i_d.di_uid == INT_GET(udqp->q_core.d_id, ARCH_CONVERT));
2796                 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
2797         }
2798         if (gdqp) {
2799                 xfs_dqlock(gdqp);
2800                 XFS_DQHOLD(gdqp);
2801                 xfs_dqunlock(gdqp);
2802                 ASSERT(ip->i_gdquot == NULL);
2803                 ip->i_gdquot = gdqp;
2804                 ASSERT(ip->i_d.di_gid == INT_GET(gdqp->q_core.d_id, ARCH_CONVERT));
2805                 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
2806         }
2807 }
2808
2809 /* ------------- list stuff -----------------*/
2810 STATIC void
2811 xfs_qm_freelist_init(xfs_frlist_t *ql)
2812 {
2813         ql->qh_next = ql->qh_prev = (xfs_dquot_t *) ql;
2814         mutex_init(&ql->qh_lock, MUTEX_DEFAULT, "dqf");
2815         ql->qh_version = 0;
2816         ql->qh_nelems = 0;
2817 }
2818
2819 STATIC void
2820 xfs_qm_freelist_destroy(xfs_frlist_t *ql)
2821 {
2822         xfs_dquot_t     *dqp, *nextdqp;
2823
2824         mutex_lock(&ql->qh_lock, PINOD);
2825         for (dqp = ql->qh_next;
2826              dqp != (xfs_dquot_t *)ql; ) {
2827                 xfs_dqlock(dqp);
2828                 nextdqp = dqp->dq_flnext;
2829 #ifdef QUOTADEBUG
2830                 cmn_err(CE_DEBUG, "FREELIST destroy 0x%p", dqp);
2831 #endif
2832                 XQM_FREELIST_REMOVE(dqp);
2833                 xfs_dqunlock(dqp);
2834                 xfs_qm_dqdestroy(dqp);
2835                 dqp = nextdqp;
2836         }
2837         /*
2838          * Don't bother about unlocking.
2839          */
2840         mutex_destroy(&ql->qh_lock);
2841
2842         ASSERT(ql->qh_nelems == 0);
2843 }
2844
2845 STATIC void
2846 xfs_qm_freelist_insert(xfs_frlist_t *ql, xfs_dquot_t *dq)
2847 {
2848         dq->dq_flnext = ql->qh_next;
2849         dq->dq_flprev = (xfs_dquot_t *)ql;
2850         ql->qh_next = dq;
2851         dq->dq_flnext->dq_flprev = dq;
2852         xfs_Gqm->qm_dqfreelist.qh_nelems++;
2853         xfs_Gqm->qm_dqfreelist.qh_version++;
2854 }
2855
2856 void
2857 xfs_qm_freelist_unlink(xfs_dquot_t *dq)
2858 {
2859         xfs_dquot_t *next = dq->dq_flnext;
2860         xfs_dquot_t *prev = dq->dq_flprev;
2861
2862         next->dq_flprev = prev;
2863         prev->dq_flnext = next;
2864         dq->dq_flnext = dq->dq_flprev = dq;
2865         xfs_Gqm->qm_dqfreelist.qh_nelems--;
2866         xfs_Gqm->qm_dqfreelist.qh_version++;
2867 }
2868
2869 void
2870 xfs_qm_freelist_append(xfs_frlist_t *ql, xfs_dquot_t *dq)
2871 {
2872         xfs_qm_freelist_insert((xfs_frlist_t *)ql->qh_prev, dq);
2873 }
2874
2875 STATIC int
2876 xfs_qm_dqhashlock_nowait(
2877         xfs_dquot_t *dqp)
2878 {
2879         int locked;
2880
2881         locked = mutex_trylock(&((dqp)->q_hash->qh_lock));
2882         return (locked);
2883 }
2884
2885 int
2886 xfs_qm_freelist_lock_nowait(
2887         xfs_qm_t *xqm)
2888 {
2889         int locked;
2890
2891         locked = mutex_trylock(&(xqm->qm_dqfreelist.qh_lock));
2892         return (locked);
2893 }
2894
2895 STATIC int
2896 xfs_qm_mplist_nowait(
2897         xfs_mount_t     *mp)
2898 {
2899         int locked;
2900
2901         ASSERT(mp->m_quotainfo);
2902         locked = mutex_trylock(&(XFS_QI_MPLLOCK(mp)));
2903         return (locked);
2904 }