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