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