]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - fs/xfs/xfs_qm.c
Merge branch 'omap-fixes-warnings' of git://git.linaro.org/people/rmk/linux-arm
[~shefty/rdma-dev.git] / fs / xfs / 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_trans.h"
24 #include "xfs_sb.h"
25 #include "xfs_ag.h"
26 #include "xfs_alloc.h"
27 #include "xfs_quota.h"
28 #include "xfs_mount.h"
29 #include "xfs_bmap_btree.h"
30 #include "xfs_ialloc_btree.h"
31 #include "xfs_dinode.h"
32 #include "xfs_inode.h"
33 #include "xfs_ialloc.h"
34 #include "xfs_itable.h"
35 #include "xfs_rtalloc.h"
36 #include "xfs_error.h"
37 #include "xfs_bmap.h"
38 #include "xfs_attr.h"
39 #include "xfs_buf_item.h"
40 #include "xfs_trans_space.h"
41 #include "xfs_utils.h"
42 #include "xfs_qm.h"
43 #include "xfs_trace.h"
44
45 /*
46  * The global quota manager. There is only one of these for the entire
47  * system, _not_ one per file system. XQM keeps track of the overall
48  * quota functionality, including maintaining the freelist and hash
49  * tables of dquots.
50  */
51 struct mutex    xfs_Gqm_lock;
52 struct xfs_qm   *xfs_Gqm;
53 uint            ndquot;
54
55 kmem_zone_t     *qm_dqzone;
56 kmem_zone_t     *qm_dqtrxzone;
57
58 STATIC void     xfs_qm_list_init(xfs_dqlist_t *, char *, int);
59 STATIC void     xfs_qm_list_destroy(xfs_dqlist_t *);
60
61 STATIC int      xfs_qm_init_quotainos(xfs_mount_t *);
62 STATIC int      xfs_qm_init_quotainfo(xfs_mount_t *);
63 STATIC int      xfs_qm_shake(struct shrinker *, struct shrink_control *);
64
65 static struct shrinker xfs_qm_shaker = {
66         .shrink = xfs_qm_shake,
67         .seeks = DEFAULT_SEEKS,
68 };
69
70 /*
71  * Initialize the XQM structure.
72  * Note that there is not one quota manager per file system.
73  */
74 STATIC struct xfs_qm *
75 xfs_Gqm_init(void)
76 {
77         xfs_dqhash_t    *udqhash, *gdqhash;
78         xfs_qm_t        *xqm;
79         size_t          hsize;
80         uint            i;
81
82         /*
83          * Initialize the dquot hash tables.
84          */
85         udqhash = kmem_zalloc_greedy(&hsize,
86                                      XFS_QM_HASHSIZE_LOW * sizeof(xfs_dqhash_t),
87                                      XFS_QM_HASHSIZE_HIGH * sizeof(xfs_dqhash_t));
88         if (!udqhash)
89                 goto out;
90
91         gdqhash = kmem_zalloc_large(hsize);
92         if (!gdqhash)
93                 goto out_free_udqhash;
94
95         hsize /= sizeof(xfs_dqhash_t);
96         ndquot = hsize << 8;
97
98         xqm = kmem_zalloc(sizeof(xfs_qm_t), KM_SLEEP);
99         xqm->qm_dqhashmask = hsize - 1;
100         xqm->qm_usr_dqhtable = udqhash;
101         xqm->qm_grp_dqhtable = gdqhash;
102         ASSERT(xqm->qm_usr_dqhtable != NULL);
103         ASSERT(xqm->qm_grp_dqhtable != NULL);
104
105         for (i = 0; i < hsize; i++) {
106                 xfs_qm_list_init(&(xqm->qm_usr_dqhtable[i]), "uxdqh", i);
107                 xfs_qm_list_init(&(xqm->qm_grp_dqhtable[i]), "gxdqh", i);
108         }
109
110         /*
111          * Freelist of all dquots of all file systems
112          */
113         INIT_LIST_HEAD(&xqm->qm_dqfrlist);
114         xqm->qm_dqfrlist_cnt = 0;
115         mutex_init(&xqm->qm_dqfrlist_lock);
116
117         /*
118          * dquot zone. we register our own low-memory callback.
119          */
120         if (!qm_dqzone) {
121                 xqm->qm_dqzone = kmem_zone_init(sizeof(xfs_dquot_t),
122                                                 "xfs_dquots");
123                 qm_dqzone = xqm->qm_dqzone;
124         } else
125                 xqm->qm_dqzone = qm_dqzone;
126
127         register_shrinker(&xfs_qm_shaker);
128
129         /*
130          * The t_dqinfo portion of transactions.
131          */
132         if (!qm_dqtrxzone) {
133                 xqm->qm_dqtrxzone = kmem_zone_init(sizeof(xfs_dquot_acct_t),
134                                                    "xfs_dqtrx");
135                 qm_dqtrxzone = xqm->qm_dqtrxzone;
136         } else
137                 xqm->qm_dqtrxzone = qm_dqtrxzone;
138
139         atomic_set(&xqm->qm_totaldquots, 0);
140         xqm->qm_dqfree_ratio = XFS_QM_DQFREE_RATIO;
141         xqm->qm_nrefs = 0;
142         return xqm;
143
144  out_free_udqhash:
145         kmem_free_large(udqhash);
146  out:
147         return NULL;
148 }
149
150 /*
151  * Destroy the global quota manager when its reference count goes to zero.
152  */
153 STATIC void
154 xfs_qm_destroy(
155         struct xfs_qm   *xqm)
156 {
157         int             hsize, i;
158
159         ASSERT(xqm != NULL);
160         ASSERT(xqm->qm_nrefs == 0);
161
162         unregister_shrinker(&xfs_qm_shaker);
163
164         mutex_lock(&xqm->qm_dqfrlist_lock);
165         ASSERT(list_empty(&xqm->qm_dqfrlist));
166         mutex_unlock(&xqm->qm_dqfrlist_lock);
167
168         hsize = xqm->qm_dqhashmask + 1;
169         for (i = 0; i < hsize; i++) {
170                 xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));
171                 xfs_qm_list_destroy(&(xqm->qm_grp_dqhtable[i]));
172         }
173         kmem_free_large(xqm->qm_usr_dqhtable);
174         kmem_free_large(xqm->qm_grp_dqhtable);
175         xqm->qm_usr_dqhtable = NULL;
176         xqm->qm_grp_dqhtable = NULL;
177         xqm->qm_dqhashmask = 0;
178
179         kmem_free(xqm);
180 }
181
182 /*
183  * Called at mount time to let XQM know that another file system is
184  * starting quotas. This isn't crucial information as the individual mount
185  * structures are pretty independent, but it helps the XQM keep a
186  * global view of what's going on.
187  */
188 /* ARGSUSED */
189 STATIC int
190 xfs_qm_hold_quotafs_ref(
191         struct xfs_mount *mp)
192 {
193         /*
194          * Need to lock the xfs_Gqm structure for things like this. For example,
195          * the structure could disappear between the entry to this routine and
196          * a HOLD operation if not locked.
197          */
198         mutex_lock(&xfs_Gqm_lock);
199
200         if (!xfs_Gqm) {
201                 xfs_Gqm = xfs_Gqm_init();
202                 if (!xfs_Gqm) {
203                         mutex_unlock(&xfs_Gqm_lock);
204                         return ENOMEM;
205                 }
206         }
207
208         /*
209          * We can keep a list of all filesystems with quotas mounted for
210          * debugging and statistical purposes, but ...
211          * Just take a reference and get out.
212          */
213         xfs_Gqm->qm_nrefs++;
214         mutex_unlock(&xfs_Gqm_lock);
215
216         return 0;
217 }
218
219
220 /*
221  * Release the reference that a filesystem took at mount time,
222  * so that we know when we need to destroy the entire quota manager.
223  */
224 /* ARGSUSED */
225 STATIC void
226 xfs_qm_rele_quotafs_ref(
227         struct xfs_mount *mp)
228 {
229         ASSERT(xfs_Gqm);
230         ASSERT(xfs_Gqm->qm_nrefs > 0);
231
232         /*
233          * Destroy the entire XQM. If somebody mounts with quotaon, this'll
234          * be restarted.
235          */
236         mutex_lock(&xfs_Gqm_lock);
237         if (--xfs_Gqm->qm_nrefs == 0) {
238                 xfs_qm_destroy(xfs_Gqm);
239                 xfs_Gqm = NULL;
240         }
241         mutex_unlock(&xfs_Gqm_lock);
242 }
243
244 /*
245  * Just destroy the quotainfo structure.
246  */
247 void
248 xfs_qm_unmount(
249         struct xfs_mount        *mp)
250 {
251         if (mp->m_quotainfo) {
252                 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
253                 xfs_qm_destroy_quotainfo(mp);
254         }
255 }
256
257
258 /*
259  * This is called from xfs_mountfs to start quotas and initialize all
260  * necessary data structures like quotainfo.  This is also responsible for
261  * running a quotacheck as necessary.  We are guaranteed that the superblock
262  * is consistently read in at this point.
263  *
264  * If we fail here, the mount will continue with quota turned off. We don't
265  * need to inidicate success or failure at all.
266  */
267 void
268 xfs_qm_mount_quotas(
269         xfs_mount_t     *mp)
270 {
271         int             error = 0;
272         uint            sbf;
273
274         /*
275          * If quotas on realtime volumes is not supported, we disable
276          * quotas immediately.
277          */
278         if (mp->m_sb.sb_rextents) {
279                 xfs_notice(mp, "Cannot turn on quotas for realtime filesystem");
280                 mp->m_qflags = 0;
281                 goto write_changes;
282         }
283
284         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
285
286         /*
287          * Allocate the quotainfo structure inside the mount struct, and
288          * create quotainode(s), and change/rev superblock if necessary.
289          */
290         error = xfs_qm_init_quotainfo(mp);
291         if (error) {
292                 /*
293                  * We must turn off quotas.
294                  */
295                 ASSERT(mp->m_quotainfo == NULL);
296                 mp->m_qflags = 0;
297                 goto write_changes;
298         }
299         /*
300          * If any of the quotas are not consistent, do a quotacheck.
301          */
302         if (XFS_QM_NEED_QUOTACHECK(mp)) {
303                 error = xfs_qm_quotacheck(mp);
304                 if (error) {
305                         /* Quotacheck failed and disabled quotas. */
306                         return;
307                 }
308         }
309         /* 
310          * If one type of quotas is off, then it will lose its
311          * quotachecked status, since we won't be doing accounting for
312          * that type anymore.
313          */
314         if (!XFS_IS_UQUOTA_ON(mp))
315                 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
316         if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp)))
317                 mp->m_qflags &= ~XFS_OQUOTA_CHKD;
318
319  write_changes:
320         /*
321          * We actually don't have to acquire the m_sb_lock at all.
322          * This can only be called from mount, and that's single threaded. XXX
323          */
324         spin_lock(&mp->m_sb_lock);
325         sbf = mp->m_sb.sb_qflags;
326         mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
327         spin_unlock(&mp->m_sb_lock);
328
329         if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
330                 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
331                         /*
332                          * We could only have been turning quotas off.
333                          * We aren't in very good shape actually because
334                          * the incore structures are convinced that quotas are
335                          * off, but the on disk superblock doesn't know that !
336                          */
337                         ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
338                         xfs_alert(mp, "%s: Superblock update failed!",
339                                 __func__);
340                 }
341         }
342
343         if (error) {
344                 xfs_warn(mp, "Failed to initialize disk quotas.");
345                 return;
346         }
347 }
348
349 /*
350  * Called from the vfsops layer.
351  */
352 void
353 xfs_qm_unmount_quotas(
354         xfs_mount_t     *mp)
355 {
356         /*
357          * Release the dquots that root inode, et al might be holding,
358          * before we flush quotas and blow away the quotainfo structure.
359          */
360         ASSERT(mp->m_rootip);
361         xfs_qm_dqdetach(mp->m_rootip);
362         if (mp->m_rbmip)
363                 xfs_qm_dqdetach(mp->m_rbmip);
364         if (mp->m_rsumip)
365                 xfs_qm_dqdetach(mp->m_rsumip);
366
367         /*
368          * Release the quota inodes.
369          */
370         if (mp->m_quotainfo) {
371                 if (mp->m_quotainfo->qi_uquotaip) {
372                         IRELE(mp->m_quotainfo->qi_uquotaip);
373                         mp->m_quotainfo->qi_uquotaip = NULL;
374                 }
375                 if (mp->m_quotainfo->qi_gquotaip) {
376                         IRELE(mp->m_quotainfo->qi_gquotaip);
377                         mp->m_quotainfo->qi_gquotaip = NULL;
378                 }
379         }
380 }
381
382 /*
383  * Flush all dquots of the given file system to disk. The dquots are
384  * _not_ purged from memory here, just their data written to disk.
385  */
386 STATIC int
387 xfs_qm_dqflush_all(
388         struct xfs_mount        *mp)
389 {
390         struct xfs_quotainfo    *q = mp->m_quotainfo;
391         int                     recl;
392         struct xfs_dquot        *dqp;
393         int                     error;
394
395         if (!q)
396                 return 0;
397 again:
398         mutex_lock(&q->qi_dqlist_lock);
399         list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {
400                 xfs_dqlock(dqp);
401                 if ((dqp->dq_flags & XFS_DQ_FREEING) ||
402                     !XFS_DQ_IS_DIRTY(dqp)) {
403                         xfs_dqunlock(dqp);
404                         continue;
405                 }
406
407                 /* XXX a sentinel would be better */
408                 recl = q->qi_dqreclaims;
409                 if (!xfs_dqflock_nowait(dqp)) {
410                         /*
411                          * If we can't grab the flush lock then check
412                          * to see if the dquot has been flushed delayed
413                          * write.  If so, grab its buffer and send it
414                          * out immediately.  We'll be able to acquire
415                          * the flush lock when the I/O completes.
416                          */
417                         xfs_dqflock_pushbuf_wait(dqp);
418                 }
419                 /*
420                  * Let go of the mplist lock. We don't want to hold it
421                  * across a disk write.
422                  */
423                 mutex_unlock(&q->qi_dqlist_lock);
424                 error = xfs_qm_dqflush(dqp, 0);
425                 xfs_dqunlock(dqp);
426                 if (error)
427                         return error;
428
429                 mutex_lock(&q->qi_dqlist_lock);
430                 if (recl != q->qi_dqreclaims) {
431                         mutex_unlock(&q->qi_dqlist_lock);
432                         /* XXX restart limit */
433                         goto again;
434                 }
435         }
436
437         mutex_unlock(&q->qi_dqlist_lock);
438         /* return ! busy */
439         return 0;
440 }
441
442 /*
443  * Release the group dquot pointers the user dquots may be
444  * carrying around as a hint. mplist is locked on entry and exit.
445  */
446 STATIC void
447 xfs_qm_detach_gdquots(
448         struct xfs_mount        *mp)
449 {
450         struct xfs_quotainfo    *q = mp->m_quotainfo;
451         struct xfs_dquot        *dqp, *gdqp;
452
453  again:
454         ASSERT(mutex_is_locked(&q->qi_dqlist_lock));
455         list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {
456                 xfs_dqlock(dqp);
457                 if (dqp->dq_flags & XFS_DQ_FREEING) {
458                         xfs_dqunlock(dqp);
459                         mutex_unlock(&q->qi_dqlist_lock);
460                         delay(1);
461                         mutex_lock(&q->qi_dqlist_lock);
462                         goto again;
463                 }
464
465                 gdqp = dqp->q_gdquot;
466                 if (gdqp)
467                         dqp->q_gdquot = NULL;
468                 xfs_dqunlock(dqp);
469
470                 if (gdqp)
471                         xfs_qm_dqrele(gdqp);
472         }
473 }
474
475 /*
476  * Go through all the incore dquots of this file system and take them
477  * off the mplist and hashlist, if the dquot type matches the dqtype
478  * parameter. This is used when turning off quota accounting for
479  * users and/or groups, as well as when the filesystem is unmounting.
480  */
481 STATIC int
482 xfs_qm_dqpurge_int(
483         struct xfs_mount        *mp,
484         uint                    flags)
485 {
486         struct xfs_quotainfo    *q = mp->m_quotainfo;
487         struct xfs_dquot        *dqp, *n;
488         uint                    dqtype;
489         int                     nmisses = 0;
490         LIST_HEAD               (dispose_list);
491
492         if (!q)
493                 return 0;
494
495         dqtype = (flags & XFS_QMOPT_UQUOTA) ? XFS_DQ_USER : 0;
496         dqtype |= (flags & XFS_QMOPT_PQUOTA) ? XFS_DQ_PROJ : 0;
497         dqtype |= (flags & XFS_QMOPT_GQUOTA) ? XFS_DQ_GROUP : 0;
498
499         mutex_lock(&q->qi_dqlist_lock);
500
501         /*
502          * In the first pass through all incore dquots of this filesystem,
503          * we release the group dquot pointers the user dquots may be
504          * carrying around as a hint. We need to do this irrespective of
505          * what's being turned off.
506          */
507         xfs_qm_detach_gdquots(mp);
508
509         /*
510          * Try to get rid of all of the unwanted dquots.
511          */
512         list_for_each_entry_safe(dqp, n, &q->qi_dqlist, q_mplist) {
513                 xfs_dqlock(dqp);
514                 if ((dqp->dq_flags & dqtype) != 0 &&
515                     !(dqp->dq_flags & XFS_DQ_FREEING)) {
516                         if (dqp->q_nrefs == 0) {
517                                 dqp->dq_flags |= XFS_DQ_FREEING;
518                                 list_move_tail(&dqp->q_mplist, &dispose_list);
519                         } else
520                                 nmisses++;
521                 }
522                 xfs_dqunlock(dqp);
523         }
524         mutex_unlock(&q->qi_dqlist_lock);
525
526         list_for_each_entry_safe(dqp, n, &dispose_list, q_mplist)
527                 xfs_qm_dqpurge(dqp);
528
529         return nmisses;
530 }
531
532 int
533 xfs_qm_dqpurge_all(
534         xfs_mount_t     *mp,
535         uint            flags)
536 {
537         int             ndquots;
538
539         /*
540          * Purge the dquot cache.
541          * None of the dquots should really be busy at this point.
542          */
543         if (mp->m_quotainfo) {
544                 while ((ndquots = xfs_qm_dqpurge_int(mp, flags))) {
545                         delay(ndquots * 10);
546                 }
547         }
548         return 0;
549 }
550
551 STATIC int
552 xfs_qm_dqattach_one(
553         xfs_inode_t     *ip,
554         xfs_dqid_t      id,
555         uint            type,
556         uint            doalloc,
557         xfs_dquot_t     *udqhint, /* hint */
558         xfs_dquot_t     **IO_idqpp)
559 {
560         xfs_dquot_t     *dqp;
561         int             error;
562
563         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
564         error = 0;
565
566         /*
567          * See if we already have it in the inode itself. IO_idqpp is
568          * &i_udquot or &i_gdquot. This made the code look weird, but
569          * made the logic a lot simpler.
570          */
571         dqp = *IO_idqpp;
572         if (dqp) {
573                 trace_xfs_dqattach_found(dqp);
574                 return 0;
575         }
576
577         /*
578          * udqhint is the i_udquot field in inode, and is non-NULL only
579          * when the type arg is group/project. Its purpose is to save a
580          * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside
581          * the user dquot.
582          */
583         if (udqhint) {
584                 ASSERT(type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
585                 xfs_dqlock(udqhint);
586
587                 /*
588                  * No need to take dqlock to look at the id.
589                  *
590                  * The ID can't change until it gets reclaimed, and it won't
591                  * be reclaimed as long as we have a ref from inode and we
592                  * hold the ilock.
593                  */
594                 dqp = udqhint->q_gdquot;
595                 if (dqp && be32_to_cpu(dqp->q_core.d_id) == id) {
596                         ASSERT(*IO_idqpp == NULL);
597
598                         *IO_idqpp = xfs_qm_dqhold(dqp);
599                         xfs_dqunlock(udqhint);
600                         return 0;
601                 }
602
603                 /*
604                  * We can't hold a dquot lock when we call the dqget code.
605                  * We'll deadlock in no time, because of (not conforming to)
606                  * lock ordering - the inodelock comes before any dquot lock,
607                  * and we may drop and reacquire the ilock in xfs_qm_dqget().
608                  */
609                 xfs_dqunlock(udqhint);
610         }
611
612         /*
613          * Find the dquot from somewhere. This bumps the
614          * reference count of dquot and returns it locked.
615          * This can return ENOENT if dquot didn't exist on
616          * disk and we didn't ask it to allocate;
617          * ESRCH if quotas got turned off suddenly.
618          */
619         error = xfs_qm_dqget(ip->i_mount, ip, id, type,
620                              doalloc | XFS_QMOPT_DOWARN, &dqp);
621         if (error)
622                 return error;
623
624         trace_xfs_dqattach_get(dqp);
625
626         /*
627          * dqget may have dropped and re-acquired the ilock, but it guarantees
628          * that the dquot returned is the one that should go in the inode.
629          */
630         *IO_idqpp = dqp;
631         xfs_dqunlock(dqp);
632         return 0;
633 }
634
635
636 /*
637  * Given a udquot and gdquot, attach a ptr to the group dquot in the
638  * udquot as a hint for future lookups.
639  */
640 STATIC void
641 xfs_qm_dqattach_grouphint(
642         xfs_dquot_t     *udq,
643         xfs_dquot_t     *gdq)
644 {
645         xfs_dquot_t     *tmp;
646
647         xfs_dqlock(udq);
648
649         tmp = udq->q_gdquot;
650         if (tmp) {
651                 if (tmp == gdq)
652                         goto done;
653
654                 udq->q_gdquot = NULL;
655                 xfs_qm_dqrele(tmp);
656         }
657
658         udq->q_gdquot = xfs_qm_dqhold(gdq);
659 done:
660         xfs_dqunlock(udq);
661 }
662
663
664 /*
665  * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
666  * into account.
667  * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed.
668  * Inode may get unlocked and relocked in here, and the caller must deal with
669  * the consequences.
670  */
671 int
672 xfs_qm_dqattach_locked(
673         xfs_inode_t     *ip,
674         uint            flags)
675 {
676         xfs_mount_t     *mp = ip->i_mount;
677         uint            nquotas = 0;
678         int             error = 0;
679
680         if (!XFS_IS_QUOTA_RUNNING(mp) ||
681             !XFS_IS_QUOTA_ON(mp) ||
682             !XFS_NOT_DQATTACHED(mp, ip) ||
683             ip->i_ino == mp->m_sb.sb_uquotino ||
684             ip->i_ino == mp->m_sb.sb_gquotino)
685                 return 0;
686
687         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
688
689         if (XFS_IS_UQUOTA_ON(mp)) {
690                 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
691                                                 flags & XFS_QMOPT_DQALLOC,
692                                                 NULL, &ip->i_udquot);
693                 if (error)
694                         goto done;
695                 nquotas++;
696         }
697
698         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
699         if (XFS_IS_OQUOTA_ON(mp)) {
700                 error = XFS_IS_GQUOTA_ON(mp) ?
701                         xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
702                                                 flags & XFS_QMOPT_DQALLOC,
703                                                 ip->i_udquot, &ip->i_gdquot) :
704                         xfs_qm_dqattach_one(ip, xfs_get_projid(ip), XFS_DQ_PROJ,
705                                                 flags & XFS_QMOPT_DQALLOC,
706                                                 ip->i_udquot, &ip->i_gdquot);
707                 /*
708                  * Don't worry about the udquot that we may have
709                  * attached above. It'll get detached, if not already.
710                  */
711                 if (error)
712                         goto done;
713                 nquotas++;
714         }
715
716         /*
717          * Attach this group quota to the user quota as a hint.
718          * This WON'T, in general, result in a thrash.
719          */
720         if (nquotas == 2) {
721                 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
722                 ASSERT(ip->i_udquot);
723                 ASSERT(ip->i_gdquot);
724
725                 /*
726                  * We do not have i_udquot locked at this point, but this check
727                  * is OK since we don't depend on the i_gdquot to be accurate
728                  * 100% all the time. It is just a hint, and this will
729                  * succeed in general.
730                  */
731                 if (ip->i_udquot->q_gdquot != ip->i_gdquot)
732                         xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot);
733         }
734
735  done:
736 #ifdef DEBUG
737         if (!error) {
738                 if (XFS_IS_UQUOTA_ON(mp))
739                         ASSERT(ip->i_udquot);
740                 if (XFS_IS_OQUOTA_ON(mp))
741                         ASSERT(ip->i_gdquot);
742         }
743         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
744 #endif
745         return error;
746 }
747
748 int
749 xfs_qm_dqattach(
750         struct xfs_inode        *ip,
751         uint                    flags)
752 {
753         int                     error;
754
755         xfs_ilock(ip, XFS_ILOCK_EXCL);
756         error = xfs_qm_dqattach_locked(ip, flags);
757         xfs_iunlock(ip, XFS_ILOCK_EXCL);
758
759         return error;
760 }
761
762 /*
763  * Release dquots (and their references) if any.
764  * The inode should be locked EXCL except when this's called by
765  * xfs_ireclaim.
766  */
767 void
768 xfs_qm_dqdetach(
769         xfs_inode_t     *ip)
770 {
771         if (!(ip->i_udquot || ip->i_gdquot))
772                 return;
773
774         trace_xfs_dquot_dqdetach(ip);
775
776         ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
777         ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
778         if (ip->i_udquot) {
779                 xfs_qm_dqrele(ip->i_udquot);
780                 ip->i_udquot = NULL;
781         }
782         if (ip->i_gdquot) {
783                 xfs_qm_dqrele(ip->i_gdquot);
784                 ip->i_gdquot = NULL;
785         }
786 }
787
788 /*
789  * The hash chains and the mplist use the same xfs_dqhash structure as
790  * their list head, but we can take the mplist qh_lock and one of the
791  * hash qh_locks at the same time without any problem as they aren't
792  * related.
793  */
794 static struct lock_class_key xfs_quota_mplist_class;
795
796 /*
797  * This initializes all the quota information that's kept in the
798  * mount structure
799  */
800 STATIC int
801 xfs_qm_init_quotainfo(
802         xfs_mount_t     *mp)
803 {
804         xfs_quotainfo_t *qinf;
805         int             error;
806         xfs_dquot_t     *dqp;
807
808         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
809
810         /*
811          * Tell XQM that we exist as soon as possible.
812          */
813         if ((error = xfs_qm_hold_quotafs_ref(mp))) {
814                 return error;
815         }
816
817         qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
818
819         /*
820          * See if quotainodes are setup, and if not, allocate them,
821          * and change the superblock accordingly.
822          */
823         if ((error = xfs_qm_init_quotainos(mp))) {
824                 kmem_free(qinf);
825                 mp->m_quotainfo = NULL;
826                 return error;
827         }
828
829         INIT_LIST_HEAD(&qinf->qi_dqlist);
830         mutex_init(&qinf->qi_dqlist_lock);
831         lockdep_set_class(&qinf->qi_dqlist_lock, &xfs_quota_mplist_class);
832
833         qinf->qi_dqreclaims = 0;
834
835         /* mutex used to serialize quotaoffs */
836         mutex_init(&qinf->qi_quotaofflock);
837
838         /* Precalc some constants */
839         qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
840         ASSERT(qinf->qi_dqchunklen);
841         qinf->qi_dqperchunk = BBTOB(qinf->qi_dqchunklen);
842         do_div(qinf->qi_dqperchunk, sizeof(xfs_dqblk_t));
843
844         mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
845
846         /*
847          * We try to get the limits from the superuser's limits fields.
848          * This is quite hacky, but it is standard quota practice.
849          *
850          * We look at the USR dquot with id == 0 first, but if user quotas
851          * are not enabled we goto the GRP dquot with id == 0.
852          * We don't really care to keep separate default limits for user
853          * and group quotas, at least not at this point.
854          *
855          * Since we may not have done a quotacheck by this point, just read
856          * the dquot without attaching it to any hashtables or lists.
857          */
858         error = xfs_qm_dqread(mp, 0,
859                         XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
860                          (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
861                           XFS_DQ_PROJ),
862                         XFS_QMOPT_DOWARN, &dqp);
863         if (!error) {
864                 xfs_disk_dquot_t        *ddqp = &dqp->q_core;
865
866                 /*
867                  * The warnings and timers set the grace period given to
868                  * a user or group before he or she can not perform any
869                  * more writing. If it is zero, a default is used.
870                  */
871                 qinf->qi_btimelimit = ddqp->d_btimer ?
872                         be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;
873                 qinf->qi_itimelimit = ddqp->d_itimer ?
874                         be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;
875                 qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?
876                         be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;
877                 qinf->qi_bwarnlimit = ddqp->d_bwarns ?
878                         be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;
879                 qinf->qi_iwarnlimit = ddqp->d_iwarns ?
880                         be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
881                 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
882                         be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
883                 qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
884                 qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
885                 qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
886                 qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
887                 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
888                 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
889  
890                 xfs_qm_dqdestroy(dqp);
891         } else {
892                 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
893                 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
894                 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
895                 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
896                 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
897                 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
898         }
899
900         return 0;
901 }
902
903
904 /*
905  * Gets called when unmounting a filesystem or when all quotas get
906  * turned off.
907  * This purges the quota inodes, destroys locks and frees itself.
908  */
909 void
910 xfs_qm_destroy_quotainfo(
911         xfs_mount_t     *mp)
912 {
913         xfs_quotainfo_t *qi;
914
915         qi = mp->m_quotainfo;
916         ASSERT(qi != NULL);
917         ASSERT(xfs_Gqm != NULL);
918
919         /*
920          * Release the reference that XQM kept, so that we know
921          * when the XQM structure should be freed. We cannot assume
922          * that xfs_Gqm is non-null after this point.
923          */
924         xfs_qm_rele_quotafs_ref(mp);
925
926         ASSERT(list_empty(&qi->qi_dqlist));
927         mutex_destroy(&qi->qi_dqlist_lock);
928
929         if (qi->qi_uquotaip) {
930                 IRELE(qi->qi_uquotaip);
931                 qi->qi_uquotaip = NULL; /* paranoia */
932         }
933         if (qi->qi_gquotaip) {
934                 IRELE(qi->qi_gquotaip);
935                 qi->qi_gquotaip = NULL;
936         }
937         mutex_destroy(&qi->qi_quotaofflock);
938         kmem_free(qi);
939         mp->m_quotainfo = NULL;
940 }
941
942
943
944 /* ------------------- PRIVATE STATIC FUNCTIONS ----------------------- */
945
946 /* ARGSUSED */
947 STATIC void
948 xfs_qm_list_init(
949         xfs_dqlist_t    *list,
950         char            *str,
951         int             n)
952 {
953         mutex_init(&list->qh_lock);
954         INIT_LIST_HEAD(&list->qh_list);
955         list->qh_version = 0;
956         list->qh_nelems = 0;
957 }
958
959 STATIC void
960 xfs_qm_list_destroy(
961         xfs_dqlist_t    *list)
962 {
963         mutex_destroy(&(list->qh_lock));
964 }
965
966 /*
967  * Create an inode and return with a reference already taken, but unlocked
968  * This is how we create quota inodes
969  */
970 STATIC int
971 xfs_qm_qino_alloc(
972         xfs_mount_t     *mp,
973         xfs_inode_t     **ip,
974         __int64_t       sbfields,
975         uint            flags)
976 {
977         xfs_trans_t     *tp;
978         int             error;
979         int             committed;
980
981         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
982         if ((error = xfs_trans_reserve(tp,
983                                       XFS_QM_QINOCREATE_SPACE_RES(mp),
984                                       XFS_CREATE_LOG_RES(mp), 0,
985                                       XFS_TRANS_PERM_LOG_RES,
986                                       XFS_CREATE_LOG_COUNT))) {
987                 xfs_trans_cancel(tp, 0);
988                 return error;
989         }
990
991         error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0, 0, 1, ip, &committed);
992         if (error) {
993                 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
994                                  XFS_TRANS_ABORT);
995                 return error;
996         }
997
998         /*
999          * Make the changes in the superblock, and log those too.
1000          * sbfields arg may contain fields other than *QUOTINO;
1001          * VERSIONNUM for example.
1002          */
1003         spin_lock(&mp->m_sb_lock);
1004         if (flags & XFS_QMOPT_SBVERSION) {
1005                 ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
1006                 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1007                                    XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
1008                        (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1009                         XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
1010
1011                 xfs_sb_version_addquota(&mp->m_sb);
1012                 mp->m_sb.sb_uquotino = NULLFSINO;
1013                 mp->m_sb.sb_gquotino = NULLFSINO;
1014
1015                 /* qflags will get updated _after_ quotacheck */
1016                 mp->m_sb.sb_qflags = 0;
1017         }
1018         if (flags & XFS_QMOPT_UQUOTA)
1019                 mp->m_sb.sb_uquotino = (*ip)->i_ino;
1020         else
1021                 mp->m_sb.sb_gquotino = (*ip)->i_ino;
1022         spin_unlock(&mp->m_sb_lock);
1023         xfs_mod_sb(tp, sbfields);
1024
1025         if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) {
1026                 xfs_alert(mp, "%s failed (error %d)!", __func__, error);
1027                 return error;
1028         }
1029         return 0;
1030 }
1031
1032
1033 STATIC void
1034 xfs_qm_reset_dqcounts(
1035         xfs_mount_t     *mp,
1036         xfs_buf_t       *bp,
1037         xfs_dqid_t      id,
1038         uint            type)
1039 {
1040         xfs_disk_dquot_t        *ddq;
1041         int                     j;
1042
1043         trace_xfs_reset_dqcounts(bp, _RET_IP_);
1044
1045         /*
1046          * Reset all counters and timers. They'll be
1047          * started afresh by xfs_qm_quotacheck.
1048          */
1049 #ifdef DEBUG
1050         j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1051         do_div(j, sizeof(xfs_dqblk_t));
1052         ASSERT(mp->m_quotainfo->qi_dqperchunk == j);
1053 #endif
1054         ddq = bp->b_addr;
1055         for (j = 0; j < mp->m_quotainfo->qi_dqperchunk; j++) {
1056                 /*
1057                  * Do a sanity check, and if needed, repair the dqblk. Don't
1058                  * output any warnings because it's perfectly possible to
1059                  * find uninitialised dquot blks. See comment in xfs_qm_dqcheck.
1060                  */
1061                 (void) xfs_qm_dqcheck(mp, ddq, id+j, type, XFS_QMOPT_DQREPAIR,
1062                                       "xfs_quotacheck");
1063                 ddq->d_bcount = 0;
1064                 ddq->d_icount = 0;
1065                 ddq->d_rtbcount = 0;
1066                 ddq->d_btimer = 0;
1067                 ddq->d_itimer = 0;
1068                 ddq->d_rtbtimer = 0;
1069                 ddq->d_bwarns = 0;
1070                 ddq->d_iwarns = 0;
1071                 ddq->d_rtbwarns = 0;
1072                 ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);
1073         }
1074 }
1075
1076 STATIC int
1077 xfs_qm_dqiter_bufs(
1078         xfs_mount_t     *mp,
1079         xfs_dqid_t      firstid,
1080         xfs_fsblock_t   bno,
1081         xfs_filblks_t   blkcnt,
1082         uint            flags)
1083 {
1084         xfs_buf_t       *bp;
1085         int             error;
1086         int             type;
1087
1088         ASSERT(blkcnt > 0);
1089         type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
1090                 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
1091         error = 0;
1092
1093         /*
1094          * Blkcnt arg can be a very big number, and might even be
1095          * larger than the log itself. So, we have to break it up into
1096          * manageable-sized transactions.
1097          * Note that we don't start a permanent transaction here; we might
1098          * not be able to get a log reservation for the whole thing up front,
1099          * and we don't really care to either, because we just discard
1100          * everything if we were to crash in the middle of this loop.
1101          */
1102         while (blkcnt--) {
1103                 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1104                               XFS_FSB_TO_DADDR(mp, bno),
1105                               mp->m_quotainfo->qi_dqchunklen, 0, &bp);
1106                 if (error)
1107                         break;
1108
1109                 xfs_qm_reset_dqcounts(mp, bp, firstid, type);
1110                 xfs_buf_delwri_queue(bp);
1111                 xfs_buf_relse(bp);
1112                 /*
1113                  * goto the next block.
1114                  */
1115                 bno++;
1116                 firstid += mp->m_quotainfo->qi_dqperchunk;
1117         }
1118         return error;
1119 }
1120
1121 /*
1122  * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a
1123  * caller supplied function for every chunk of dquots that we find.
1124  */
1125 STATIC int
1126 xfs_qm_dqiterate(
1127         xfs_mount_t     *mp,
1128         xfs_inode_t     *qip,
1129         uint            flags)
1130 {
1131         xfs_bmbt_irec_t         *map;
1132         int                     i, nmaps;       /* number of map entries */
1133         int                     error;          /* return value */
1134         xfs_fileoff_t           lblkno;
1135         xfs_filblks_t           maxlblkcnt;
1136         xfs_dqid_t              firstid;
1137         xfs_fsblock_t           rablkno;
1138         xfs_filblks_t           rablkcnt;
1139
1140         error = 0;
1141         /*
1142          * This looks racy, but we can't keep an inode lock across a
1143          * trans_reserve. But, this gets called during quotacheck, and that
1144          * happens only at mount time which is single threaded.
1145          */
1146         if (qip->i_d.di_nblocks == 0)
1147                 return 0;
1148
1149         map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
1150
1151         lblkno = 0;
1152         maxlblkcnt = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
1153         do {
1154                 nmaps = XFS_DQITER_MAP_SIZE;
1155                 /*
1156                  * We aren't changing the inode itself. Just changing
1157                  * some of its data. No new blocks are added here, and
1158                  * the inode is never added to the transaction.
1159                  */
1160                 xfs_ilock(qip, XFS_ILOCK_SHARED);
1161                 error = xfs_bmapi_read(qip, lblkno, maxlblkcnt - lblkno,
1162                                        map, &nmaps, 0);
1163                 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1164                 if (error)
1165                         break;
1166
1167                 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
1168                 for (i = 0; i < nmaps; i++) {
1169                         ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
1170                         ASSERT(map[i].br_blockcount);
1171
1172
1173                         lblkno += map[i].br_blockcount;
1174
1175                         if (map[i].br_startblock == HOLESTARTBLOCK)
1176                                 continue;
1177
1178                         firstid = (xfs_dqid_t) map[i].br_startoff *
1179                                 mp->m_quotainfo->qi_dqperchunk;
1180                         /*
1181                          * Do a read-ahead on the next extent.
1182                          */
1183                         if ((i+1 < nmaps) &&
1184                             (map[i+1].br_startblock != HOLESTARTBLOCK)) {
1185                                 rablkcnt =  map[i+1].br_blockcount;
1186                                 rablkno = map[i+1].br_startblock;
1187                                 while (rablkcnt--) {
1188                                         xfs_buf_readahead(mp->m_ddev_targp,
1189                                                XFS_FSB_TO_DADDR(mp, rablkno),
1190                                                mp->m_quotainfo->qi_dqchunklen);
1191                                         rablkno++;
1192                                 }
1193                         }
1194                         /*
1195                          * Iterate thru all the blks in the extent and
1196                          * reset the counters of all the dquots inside them.
1197                          */
1198                         if ((error = xfs_qm_dqiter_bufs(mp,
1199                                                        firstid,
1200                                                        map[i].br_startblock,
1201                                                        map[i].br_blockcount,
1202                                                        flags))) {
1203                                 break;
1204                         }
1205                 }
1206
1207                 if (error)
1208                         break;
1209         } while (nmaps > 0);
1210
1211         kmem_free(map);
1212
1213         return error;
1214 }
1215
1216 /*
1217  * Called by dqusage_adjust in doing a quotacheck.
1218  *
1219  * Given the inode, and a dquot id this updates both the incore dqout as well
1220  * as the buffer copy. This is so that once the quotacheck is done, we can
1221  * just log all the buffers, as opposed to logging numerous updates to
1222  * individual dquots.
1223  */
1224 STATIC int
1225 xfs_qm_quotacheck_dqadjust(
1226         struct xfs_inode        *ip,
1227         xfs_dqid_t              id,
1228         uint                    type,
1229         xfs_qcnt_t              nblks,
1230         xfs_qcnt_t              rtblks)
1231 {
1232         struct xfs_mount        *mp = ip->i_mount;
1233         struct xfs_dquot        *dqp;
1234         int                     error;
1235
1236         error = xfs_qm_dqget(mp, ip, id, type,
1237                              XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN, &dqp);
1238         if (error) {
1239                 /*
1240                  * Shouldn't be able to turn off quotas here.
1241                  */
1242                 ASSERT(error != ESRCH);
1243                 ASSERT(error != ENOENT);
1244                 return error;
1245         }
1246
1247         trace_xfs_dqadjust(dqp);
1248
1249         /*
1250          * Adjust the inode count and the block count to reflect this inode's
1251          * resource usage.
1252          */
1253         be64_add_cpu(&dqp->q_core.d_icount, 1);
1254         dqp->q_res_icount++;
1255         if (nblks) {
1256                 be64_add_cpu(&dqp->q_core.d_bcount, nblks);
1257                 dqp->q_res_bcount += nblks;
1258         }
1259         if (rtblks) {
1260                 be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
1261                 dqp->q_res_rtbcount += rtblks;
1262         }
1263
1264         /*
1265          * Set default limits, adjust timers (since we changed usages)
1266          *
1267          * There are no timers for the default values set in the root dquot.
1268          */
1269         if (dqp->q_core.d_id) {
1270                 xfs_qm_adjust_dqlimits(mp, &dqp->q_core);
1271                 xfs_qm_adjust_dqtimers(mp, &dqp->q_core);
1272         }
1273
1274         dqp->dq_flags |= XFS_DQ_DIRTY;
1275         xfs_qm_dqput(dqp);
1276         return 0;
1277 }
1278
1279 STATIC int
1280 xfs_qm_get_rtblks(
1281         xfs_inode_t     *ip,
1282         xfs_qcnt_t      *O_rtblks)
1283 {
1284         xfs_filblks_t   rtblks;                 /* total rt blks */
1285         xfs_extnum_t    idx;                    /* extent record index */
1286         xfs_ifork_t     *ifp;                   /* inode fork pointer */
1287         xfs_extnum_t    nextents;               /* number of extent entries */
1288         int             error;
1289
1290         ASSERT(XFS_IS_REALTIME_INODE(ip));
1291         ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1292         if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1293                 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
1294                         return error;
1295         }
1296         rtblks = 0;
1297         nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
1298         for (idx = 0; idx < nextents; idx++)
1299                 rtblks += xfs_bmbt_get_blockcount(xfs_iext_get_ext(ifp, idx));
1300         *O_rtblks = (xfs_qcnt_t)rtblks;
1301         return 0;
1302 }
1303
1304 /*
1305  * callback routine supplied to bulkstat(). Given an inumber, find its
1306  * dquots and update them to account for resources taken by that inode.
1307  */
1308 /* ARGSUSED */
1309 STATIC int
1310 xfs_qm_dqusage_adjust(
1311         xfs_mount_t     *mp,            /* mount point for filesystem */
1312         xfs_ino_t       ino,            /* inode number to get data for */
1313         void            __user *buffer, /* not used */
1314         int             ubsize,         /* not used */
1315         int             *ubused,        /* not used */
1316         int             *res)           /* result code value */
1317 {
1318         xfs_inode_t     *ip;
1319         xfs_qcnt_t      nblks, rtblks = 0;
1320         int             error;
1321
1322         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1323
1324         /*
1325          * rootino must have its resources accounted for, not so with the quota
1326          * inodes.
1327          */
1328         if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1329                 *res = BULKSTAT_RV_NOTHING;
1330                 return XFS_ERROR(EINVAL);
1331         }
1332
1333         /*
1334          * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget
1335          * interface expects the inode to be exclusively locked because that's
1336          * the case in all other instances. It's OK that we do this because
1337          * quotacheck is done only at mount time.
1338          */
1339         error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip);
1340         if (error) {
1341                 *res = BULKSTAT_RV_NOTHING;
1342                 return error;
1343         }
1344
1345         ASSERT(ip->i_delayed_blks == 0);
1346
1347         if (XFS_IS_REALTIME_INODE(ip)) {
1348                 /*
1349                  * Walk thru the extent list and count the realtime blocks.
1350                  */
1351                 error = xfs_qm_get_rtblks(ip, &rtblks);
1352                 if (error)
1353                         goto error0;
1354         }
1355
1356         nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
1357
1358         /*
1359          * Add the (disk blocks and inode) resources occupied by this
1360          * inode to its dquots. We do this adjustment in the incore dquot,
1361          * and also copy the changes to its buffer.
1362          * We don't care about putting these changes in a transaction
1363          * envelope because if we crash in the middle of a 'quotacheck'
1364          * we have to start from the beginning anyway.
1365          * Once we're done, we'll log all the dquot bufs.
1366          *
1367          * The *QUOTA_ON checks below may look pretty racy, but quotachecks
1368          * and quotaoffs don't race. (Quotachecks happen at mount time only).
1369          */
1370         if (XFS_IS_UQUOTA_ON(mp)) {
1371                 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_uid,
1372                                                    XFS_DQ_USER, nblks, rtblks);
1373                 if (error)
1374                         goto error0;
1375         }
1376
1377         if (XFS_IS_GQUOTA_ON(mp)) {
1378                 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_gid,
1379                                                    XFS_DQ_GROUP, nblks, rtblks);
1380                 if (error)
1381                         goto error0;
1382         }
1383
1384         if (XFS_IS_PQUOTA_ON(mp)) {
1385                 error = xfs_qm_quotacheck_dqadjust(ip, xfs_get_projid(ip),
1386                                                    XFS_DQ_PROJ, nblks, rtblks);
1387                 if (error)
1388                         goto error0;
1389         }
1390
1391         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1392         IRELE(ip);
1393         *res = BULKSTAT_RV_DIDONE;
1394         return 0;
1395
1396 error0:
1397         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1398         IRELE(ip);
1399         *res = BULKSTAT_RV_GIVEUP;
1400         return error;
1401 }
1402
1403 /*
1404  * Walk thru all the filesystem inodes and construct a consistent view
1405  * of the disk quota world. If the quotacheck fails, disable quotas.
1406  */
1407 int
1408 xfs_qm_quotacheck(
1409         xfs_mount_t     *mp)
1410 {
1411         int             done, count, error;
1412         xfs_ino_t       lastino;
1413         size_t          structsz;
1414         xfs_inode_t     *uip, *gip;
1415         uint            flags;
1416
1417         count = INT_MAX;
1418         structsz = 1;
1419         lastino = 0;
1420         flags = 0;
1421
1422         ASSERT(mp->m_quotainfo->qi_uquotaip || mp->m_quotainfo->qi_gquotaip);
1423         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1424
1425         /*
1426          * There should be no cached dquots. The (simplistic) quotacheck
1427          * algorithm doesn't like that.
1428          */
1429         ASSERT(list_empty(&mp->m_quotainfo->qi_dqlist));
1430
1431         xfs_notice(mp, "Quotacheck needed: Please wait.");
1432
1433         /*
1434          * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
1435          * their counters to zero. We need a clean slate.
1436          * We don't log our changes till later.
1437          */
1438         uip = mp->m_quotainfo->qi_uquotaip;
1439         if (uip) {
1440                 error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA);
1441                 if (error)
1442                         goto error_return;
1443                 flags |= XFS_UQUOTA_CHKD;
1444         }
1445
1446         gip = mp->m_quotainfo->qi_gquotaip;
1447         if (gip) {
1448                 error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
1449                                         XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
1450                 if (error)
1451                         goto error_return;
1452                 flags |= XFS_OQUOTA_CHKD;
1453         }
1454
1455         do {
1456                 /*
1457                  * Iterate thru all the inodes in the file system,
1458                  * adjusting the corresponding dquot counters in core.
1459                  */
1460                 error = xfs_bulkstat(mp, &lastino, &count,
1461                                      xfs_qm_dqusage_adjust,
1462                                      structsz, NULL, &done);
1463                 if (error)
1464                         break;
1465
1466         } while (!done);
1467
1468         /*
1469          * We've made all the changes that we need to make incore.
1470          * Flush them down to disk buffers if everything was updated
1471          * successfully.
1472          */
1473         if (!error)
1474                 error = xfs_qm_dqflush_all(mp);
1475
1476         /*
1477          * We can get this error if we couldn't do a dquot allocation inside
1478          * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
1479          * dirty dquots that might be cached, we just want to get rid of them
1480          * and turn quotaoff. The dquots won't be attached to any of the inodes
1481          * at this point (because we intentionally didn't in dqget_noattach).
1482          */
1483         if (error) {
1484                 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
1485                 goto error_return;
1486         }
1487
1488         /*
1489          * We didn't log anything, because if we crashed, we'll have to
1490          * start the quotacheck from scratch anyway. However, we must make
1491          * sure that our dquot changes are secure before we put the
1492          * quotacheck'd stamp on the superblock. So, here we do a synchronous
1493          * flush.
1494          */
1495         xfs_flush_buftarg(mp->m_ddev_targp, 1);
1496
1497         /*
1498          * If one type of quotas is off, then it will lose its
1499          * quotachecked status, since we won't be doing accounting for
1500          * that type anymore.
1501          */
1502         mp->m_qflags &= ~(XFS_OQUOTA_CHKD | XFS_UQUOTA_CHKD);
1503         mp->m_qflags |= flags;
1504
1505  error_return:
1506         if (error) {
1507                 xfs_warn(mp,
1508         "Quotacheck: Unsuccessful (Error %d): Disabling quotas.",
1509                         error);
1510                 /*
1511                  * We must turn off quotas.
1512                  */
1513                 ASSERT(mp->m_quotainfo != NULL);
1514                 ASSERT(xfs_Gqm != NULL);
1515                 xfs_qm_destroy_quotainfo(mp);
1516                 if (xfs_mount_reset_sbqflags(mp)) {
1517                         xfs_warn(mp,
1518                                 "Quotacheck: Failed to reset quota flags.");
1519                 }
1520         } else
1521                 xfs_notice(mp, "Quotacheck: Done.");
1522         return (error);
1523 }
1524
1525 /*
1526  * This is called after the superblock has been read in and we're ready to
1527  * iget the quota inodes.
1528  */
1529 STATIC int
1530 xfs_qm_init_quotainos(
1531         xfs_mount_t     *mp)
1532 {
1533         xfs_inode_t     *uip, *gip;
1534         int             error;
1535         __int64_t       sbflags;
1536         uint            flags;
1537
1538         ASSERT(mp->m_quotainfo);
1539         uip = gip = NULL;
1540         sbflags = 0;
1541         flags = 0;
1542
1543         /*
1544          * Get the uquota and gquota inodes
1545          */
1546         if (xfs_sb_version_hasquota(&mp->m_sb)) {
1547                 if (XFS_IS_UQUOTA_ON(mp) &&
1548                     mp->m_sb.sb_uquotino != NULLFSINO) {
1549                         ASSERT(mp->m_sb.sb_uquotino > 0);
1550                         if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
1551                                              0, 0, &uip)))
1552                                 return XFS_ERROR(error);
1553                 }
1554                 if (XFS_IS_OQUOTA_ON(mp) &&
1555                     mp->m_sb.sb_gquotino != NULLFSINO) {
1556                         ASSERT(mp->m_sb.sb_gquotino > 0);
1557                         if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
1558                                              0, 0, &gip))) {
1559                                 if (uip)
1560                                         IRELE(uip);
1561                                 return XFS_ERROR(error);
1562                         }
1563                 }
1564         } else {
1565                 flags |= XFS_QMOPT_SBVERSION;
1566                 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1567                             XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
1568         }
1569
1570         /*
1571          * Create the two inodes, if they don't exist already. The changes
1572          * made above will get added to a transaction and logged in one of
1573          * the qino_alloc calls below.  If the device is readonly,
1574          * temporarily switch to read-write to do this.
1575          */
1576         if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
1577                 if ((error = xfs_qm_qino_alloc(mp, &uip,
1578                                               sbflags | XFS_SB_UQUOTINO,
1579                                               flags | XFS_QMOPT_UQUOTA)))
1580                         return XFS_ERROR(error);
1581
1582                 flags &= ~XFS_QMOPT_SBVERSION;
1583         }
1584         if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) {
1585                 flags |= (XFS_IS_GQUOTA_ON(mp) ?
1586                                 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
1587                 error = xfs_qm_qino_alloc(mp, &gip,
1588                                           sbflags | XFS_SB_GQUOTINO, flags);
1589                 if (error) {
1590                         if (uip)
1591                                 IRELE(uip);
1592
1593                         return XFS_ERROR(error);
1594                 }
1595         }
1596
1597         mp->m_quotainfo->qi_uquotaip = uip;
1598         mp->m_quotainfo->qi_gquotaip = gip;
1599
1600         return 0;
1601 }
1602
1603
1604
1605 /*
1606  * Pop the least recently used dquot off the freelist and recycle it.
1607  */
1608 STATIC struct xfs_dquot *
1609 xfs_qm_dqreclaim_one(void)
1610 {
1611         struct xfs_dquot        *dqp;
1612         int                     restarts = 0;
1613
1614         mutex_lock(&xfs_Gqm->qm_dqfrlist_lock);
1615 restart:
1616         list_for_each_entry(dqp, &xfs_Gqm->qm_dqfrlist, q_freelist) {
1617                 struct xfs_mount *mp = dqp->q_mount;
1618
1619                 if (!xfs_dqlock_nowait(dqp))
1620                         continue;
1621
1622                 /*
1623                  * This dquot has already been grabbed by dqlookup.
1624                  * Remove it from the freelist and try again.
1625                  */
1626                 if (dqp->q_nrefs) {
1627                         trace_xfs_dqreclaim_want(dqp);
1628                         XQM_STATS_INC(xqmstats.xs_qm_dqwants);
1629
1630                         list_del_init(&dqp->q_freelist);
1631                         xfs_Gqm->qm_dqfrlist_cnt--;
1632                         restarts++;
1633                         goto dqunlock;
1634                 }
1635
1636                 ASSERT(dqp->q_hash);
1637                 ASSERT(!list_empty(&dqp->q_mplist));
1638
1639                 /*
1640                  * Try to grab the flush lock. If this dquot is in the process
1641                  * of getting flushed to disk, we don't want to reclaim it.
1642                  */
1643                 if (!xfs_dqflock_nowait(dqp))
1644                         goto dqunlock;
1645
1646                 /*
1647                  * We have the flush lock so we know that this is not in the
1648                  * process of being flushed. So, if this is dirty, flush it
1649                  * DELWRI so that we don't get a freelist infested with
1650                  * dirty dquots.
1651                  */
1652                 if (XFS_DQ_IS_DIRTY(dqp)) {
1653                         int     error;
1654
1655                         trace_xfs_dqreclaim_dirty(dqp);
1656
1657                         /*
1658                          * We flush it delayed write, so don't bother
1659                          * releasing the freelist lock.
1660                          */
1661                         error = xfs_qm_dqflush(dqp, SYNC_TRYLOCK);
1662                         if (error) {
1663                                 xfs_warn(mp, "%s: dquot %p flush failed",
1664                                         __func__, dqp);
1665                         }
1666                         goto dqunlock;
1667                 }
1668                 xfs_dqfunlock(dqp);
1669
1670                 /*
1671                  * Prevent lookup now that we are going to reclaim the dquot.
1672                  * Once XFS_DQ_FREEING is set lookup won't touch the dquot,
1673                  * thus we can drop the lock now.
1674                  */
1675                 dqp->dq_flags |= XFS_DQ_FREEING;
1676                 xfs_dqunlock(dqp);
1677
1678                 mutex_lock(&dqp->q_hash->qh_lock);
1679                 list_del_init(&dqp->q_hashlist);
1680                 dqp->q_hash->qh_version++;
1681                 mutex_unlock(&dqp->q_hash->qh_lock);
1682
1683                 mutex_lock(&mp->m_quotainfo->qi_dqlist_lock);
1684                 list_del_init(&dqp->q_mplist);
1685                 mp->m_quotainfo->qi_dquots--;
1686                 mp->m_quotainfo->qi_dqreclaims++;
1687                 mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);
1688
1689                 ASSERT(dqp->q_nrefs == 0);
1690                 list_del_init(&dqp->q_freelist);
1691                 xfs_Gqm->qm_dqfrlist_cnt--;
1692
1693                 mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
1694                 return dqp;
1695 dqunlock:
1696                 xfs_dqunlock(dqp);
1697                 if (restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
1698                         break;
1699                 goto restart;
1700         }
1701
1702         mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
1703         return NULL;
1704 }
1705
1706 /*
1707  * Traverse the freelist of dquots and attempt to reclaim a maximum of
1708  * 'howmany' dquots. This operation races with dqlookup(), and attempts to
1709  * favor the lookup function ...
1710  */
1711 STATIC int
1712 xfs_qm_shake_freelist(
1713         int     howmany)
1714 {
1715         int             nreclaimed = 0;
1716         xfs_dquot_t     *dqp;
1717
1718         if (howmany <= 0)
1719                 return 0;
1720
1721         while (nreclaimed < howmany) {
1722                 dqp = xfs_qm_dqreclaim_one();
1723                 if (!dqp)
1724                         return nreclaimed;
1725                 xfs_qm_dqdestroy(dqp);
1726                 nreclaimed++;
1727         }
1728         return nreclaimed;
1729 }
1730
1731 /*
1732  * The kmem_shake interface is invoked when memory is running low.
1733  */
1734 /* ARGSUSED */
1735 STATIC int
1736 xfs_qm_shake(
1737         struct shrinker *shrink,
1738         struct shrink_control *sc)
1739 {
1740         int     ndqused, nfree, n;
1741         gfp_t gfp_mask = sc->gfp_mask;
1742
1743         if (!kmem_shake_allow(gfp_mask))
1744                 return 0;
1745         if (!xfs_Gqm)
1746                 return 0;
1747
1748         nfree = xfs_Gqm->qm_dqfrlist_cnt; /* free dquots */
1749         /* incore dquots in all f/s's */
1750         ndqused = atomic_read(&xfs_Gqm->qm_totaldquots) - nfree;
1751
1752         ASSERT(ndqused >= 0);
1753
1754         if (nfree <= ndqused && nfree < ndquot)
1755                 return 0;
1756
1757         ndqused *= xfs_Gqm->qm_dqfree_ratio;    /* target # of free dquots */
1758         n = nfree - ndqused - ndquot;           /* # over target */
1759
1760         return xfs_qm_shake_freelist(MAX(nfree, n));
1761 }
1762
1763
1764 /*------------------------------------------------------------------*/
1765
1766 /*
1767  * Return a new incore dquot. Depending on the number of
1768  * dquots in the system, we either allocate a new one on the kernel heap,
1769  * or reclaim a free one.
1770  * Return value is B_TRUE if we allocated a new dquot, B_FALSE if we managed
1771  * to reclaim an existing one from the freelist.
1772  */
1773 boolean_t
1774 xfs_qm_dqalloc_incore(
1775         xfs_dquot_t **O_dqpp)
1776 {
1777         xfs_dquot_t     *dqp;
1778
1779         /*
1780          * Check against high water mark to see if we want to pop
1781          * a nincompoop dquot off the freelist.
1782          */
1783         if (atomic_read(&xfs_Gqm->qm_totaldquots) >= ndquot) {
1784                 /*
1785                  * Try to recycle a dquot from the freelist.
1786                  */
1787                 if ((dqp = xfs_qm_dqreclaim_one())) {
1788                         XQM_STATS_INC(xqmstats.xs_qm_dqreclaims);
1789                         /*
1790                          * Just zero the core here. The rest will get
1791                          * reinitialized by caller. XXX we shouldn't even
1792                          * do this zero ...
1793                          */
1794                         memset(&dqp->q_core, 0, sizeof(dqp->q_core));
1795                         *O_dqpp = dqp;
1796                         return B_FALSE;
1797                 }
1798                 XQM_STATS_INC(xqmstats.xs_qm_dqreclaim_misses);
1799         }
1800
1801         /*
1802          * Allocate a brand new dquot on the kernel heap and return it
1803          * to the caller to initialize.
1804          */
1805         ASSERT(xfs_Gqm->qm_dqzone != NULL);
1806         *O_dqpp = kmem_zone_zalloc(xfs_Gqm->qm_dqzone, KM_SLEEP);
1807         atomic_inc(&xfs_Gqm->qm_totaldquots);
1808
1809         return B_TRUE;
1810 }
1811
1812
1813 /*
1814  * Start a transaction and write the incore superblock changes to
1815  * disk. flags parameter indicates which fields have changed.
1816  */
1817 int
1818 xfs_qm_write_sb_changes(
1819         xfs_mount_t     *mp,
1820         __int64_t       flags)
1821 {
1822         xfs_trans_t     *tp;
1823         int             error;
1824
1825         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
1826         if ((error = xfs_trans_reserve(tp, 0,
1827                                       mp->m_sb.sb_sectsize + 128, 0,
1828                                       0,
1829                                       XFS_DEFAULT_LOG_COUNT))) {
1830                 xfs_trans_cancel(tp, 0);
1831                 return error;
1832         }
1833
1834         xfs_mod_sb(tp, flags);
1835         error = xfs_trans_commit(tp, 0);
1836
1837         return error;
1838 }
1839
1840
1841 /* --------------- utility functions for vnodeops ---------------- */
1842
1843
1844 /*
1845  * Given an inode, a uid, gid and prid make sure that we have
1846  * allocated relevant dquot(s) on disk, and that we won't exceed inode
1847  * quotas by creating this file.
1848  * This also attaches dquot(s) to the given inode after locking it,
1849  * and returns the dquots corresponding to the uid and/or gid.
1850  *
1851  * in   : inode (unlocked)
1852  * out  : udquot, gdquot with references taken and unlocked
1853  */
1854 int
1855 xfs_qm_vop_dqalloc(
1856         struct xfs_inode        *ip,
1857         uid_t                   uid,
1858         gid_t                   gid,
1859         prid_t                  prid,
1860         uint                    flags,
1861         struct xfs_dquot        **O_udqpp,
1862         struct xfs_dquot        **O_gdqpp)
1863 {
1864         struct xfs_mount        *mp = ip->i_mount;
1865         struct xfs_dquot        *uq, *gq;
1866         int                     error;
1867         uint                    lockflags;
1868
1869         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
1870                 return 0;
1871
1872         lockflags = XFS_ILOCK_EXCL;
1873         xfs_ilock(ip, lockflags);
1874
1875         if ((flags & XFS_QMOPT_INHERIT) && XFS_INHERIT_GID(ip))
1876                 gid = ip->i_d.di_gid;
1877
1878         /*
1879          * Attach the dquot(s) to this inode, doing a dquot allocation
1880          * if necessary. The dquot(s) will not be locked.
1881          */
1882         if (XFS_NOT_DQATTACHED(mp, ip)) {
1883                 error = xfs_qm_dqattach_locked(ip, XFS_QMOPT_DQALLOC);
1884                 if (error) {
1885                         xfs_iunlock(ip, lockflags);
1886                         return error;
1887                 }
1888         }
1889
1890         uq = gq = NULL;
1891         if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
1892                 if (ip->i_d.di_uid != uid) {
1893                         /*
1894                          * What we need is the dquot that has this uid, and
1895                          * if we send the inode to dqget, the uid of the inode
1896                          * takes priority over what's sent in the uid argument.
1897                          * We must unlock inode here before calling dqget if
1898                          * we're not sending the inode, because otherwise
1899                          * we'll deadlock by doing trans_reserve while
1900                          * holding ilock.
1901                          */
1902                         xfs_iunlock(ip, lockflags);
1903                         if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
1904                                                  XFS_DQ_USER,
1905                                                  XFS_QMOPT_DQALLOC |
1906                                                  XFS_QMOPT_DOWARN,
1907                                                  &uq))) {
1908                                 ASSERT(error != ENOENT);
1909                                 return error;
1910                         }
1911                         /*
1912                          * Get the ilock in the right order.
1913                          */
1914                         xfs_dqunlock(uq);
1915                         lockflags = XFS_ILOCK_SHARED;
1916                         xfs_ilock(ip, lockflags);
1917                 } else {
1918                         /*
1919                          * Take an extra reference, because we'll return
1920                          * this to caller
1921                          */
1922                         ASSERT(ip->i_udquot);
1923                         uq = xfs_qm_dqhold(ip->i_udquot);
1924                 }
1925         }
1926         if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
1927                 if (ip->i_d.di_gid != gid) {
1928                         xfs_iunlock(ip, lockflags);
1929                         if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
1930                                                  XFS_DQ_GROUP,
1931                                                  XFS_QMOPT_DQALLOC |
1932                                                  XFS_QMOPT_DOWARN,
1933                                                  &gq))) {
1934                                 if (uq)
1935                                         xfs_qm_dqrele(uq);
1936                                 ASSERT(error != ENOENT);
1937                                 return error;
1938                         }
1939                         xfs_dqunlock(gq);
1940                         lockflags = XFS_ILOCK_SHARED;
1941                         xfs_ilock(ip, lockflags);
1942                 } else {
1943                         ASSERT(ip->i_gdquot);
1944                         gq = xfs_qm_dqhold(ip->i_gdquot);
1945                 }
1946         } else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
1947                 if (xfs_get_projid(ip) != prid) {
1948                         xfs_iunlock(ip, lockflags);
1949                         if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
1950                                                  XFS_DQ_PROJ,
1951                                                  XFS_QMOPT_DQALLOC |
1952                                                  XFS_QMOPT_DOWARN,
1953                                                  &gq))) {
1954                                 if (uq)
1955                                         xfs_qm_dqrele(uq);
1956                                 ASSERT(error != ENOENT);
1957                                 return (error);
1958                         }
1959                         xfs_dqunlock(gq);
1960                         lockflags = XFS_ILOCK_SHARED;
1961                         xfs_ilock(ip, lockflags);
1962                 } else {
1963                         ASSERT(ip->i_gdquot);
1964                         gq = xfs_qm_dqhold(ip->i_gdquot);
1965                 }
1966         }
1967         if (uq)
1968                 trace_xfs_dquot_dqalloc(ip);
1969
1970         xfs_iunlock(ip, lockflags);
1971         if (O_udqpp)
1972                 *O_udqpp = uq;
1973         else if (uq)
1974                 xfs_qm_dqrele(uq);
1975         if (O_gdqpp)
1976                 *O_gdqpp = gq;
1977         else if (gq)
1978                 xfs_qm_dqrele(gq);
1979         return 0;
1980 }
1981
1982 /*
1983  * Actually transfer ownership, and do dquot modifications.
1984  * These were already reserved.
1985  */
1986 xfs_dquot_t *
1987 xfs_qm_vop_chown(
1988         xfs_trans_t     *tp,
1989         xfs_inode_t     *ip,
1990         xfs_dquot_t     **IO_olddq,
1991         xfs_dquot_t     *newdq)
1992 {
1993         xfs_dquot_t     *prevdq;
1994         uint            bfield = XFS_IS_REALTIME_INODE(ip) ?
1995                                  XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
1996
1997
1998         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1999         ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
2000
2001         /* old dquot */
2002         prevdq = *IO_olddq;
2003         ASSERT(prevdq);
2004         ASSERT(prevdq != newdq);
2005
2006         xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
2007         xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
2008
2009         /* the sparkling new dquot */
2010         xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
2011         xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
2012
2013         /*
2014          * Take an extra reference, because the inode is going to keep
2015          * this dquot pointer even after the trans_commit.
2016          */
2017         *IO_olddq = xfs_qm_dqhold(newdq);
2018
2019         return prevdq;
2020 }
2021
2022 /*
2023  * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
2024  */
2025 int
2026 xfs_qm_vop_chown_reserve(
2027         xfs_trans_t     *tp,
2028         xfs_inode_t     *ip,
2029         xfs_dquot_t     *udqp,
2030         xfs_dquot_t     *gdqp,
2031         uint            flags)
2032 {
2033         xfs_mount_t     *mp = ip->i_mount;
2034         uint            delblks, blkflags, prjflags = 0;
2035         xfs_dquot_t     *unresudq, *unresgdq, *delblksudq, *delblksgdq;
2036         int             error;
2037
2038
2039         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
2040         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2041
2042         delblks = ip->i_delayed_blks;
2043         delblksudq = delblksgdq = unresudq = unresgdq = NULL;
2044         blkflags = XFS_IS_REALTIME_INODE(ip) ?
2045                         XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
2046
2047         if (XFS_IS_UQUOTA_ON(mp) && udqp &&
2048             ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
2049                 delblksudq = udqp;
2050                 /*
2051                  * If there are delayed allocation blocks, then we have to
2052                  * unreserve those from the old dquot, and add them to the
2053                  * new dquot.
2054                  */
2055                 if (delblks) {
2056                         ASSERT(ip->i_udquot);
2057                         unresudq = ip->i_udquot;
2058                 }
2059         }
2060         if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
2061                 if (XFS_IS_PQUOTA_ON(ip->i_mount) &&
2062                      xfs_get_projid(ip) != be32_to_cpu(gdqp->q_core.d_id))
2063                         prjflags = XFS_QMOPT_ENOSPC;
2064
2065                 if (prjflags ||
2066                     (XFS_IS_GQUOTA_ON(ip->i_mount) &&
2067                      ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
2068                         delblksgdq = gdqp;
2069                         if (delblks) {
2070                                 ASSERT(ip->i_gdquot);
2071                                 unresgdq = ip->i_gdquot;
2072                         }
2073                 }
2074         }
2075
2076         if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
2077                                 delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
2078                                 flags | blkflags | prjflags)))
2079                 return (error);
2080
2081         /*
2082          * Do the delayed blks reservations/unreservations now. Since, these
2083          * are done without the help of a transaction, if a reservation fails
2084          * its previous reservations won't be automatically undone by trans
2085          * code. So, we have to do it manually here.
2086          */
2087         if (delblks) {
2088                 /*
2089                  * Do the reservations first. Unreservation can't fail.
2090                  */
2091                 ASSERT(delblksudq || delblksgdq);
2092                 ASSERT(unresudq || unresgdq);
2093                 if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2094                                 delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
2095                                 flags | blkflags | prjflags)))
2096                         return (error);
2097                 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2098                                 unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
2099                                 blkflags);
2100         }
2101
2102         return (0);
2103 }
2104
2105 int
2106 xfs_qm_vop_rename_dqattach(
2107         struct xfs_inode        **i_tab)
2108 {
2109         struct xfs_mount        *mp = i_tab[0]->i_mount;
2110         int                     i;
2111
2112         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
2113                 return 0;
2114
2115         for (i = 0; (i < 4 && i_tab[i]); i++) {
2116                 struct xfs_inode        *ip = i_tab[i];
2117                 int                     error;
2118
2119                 /*
2120                  * Watch out for duplicate entries in the table.
2121                  */
2122                 if (i == 0 || ip != i_tab[i-1]) {
2123                         if (XFS_NOT_DQATTACHED(mp, ip)) {
2124                                 error = xfs_qm_dqattach(ip, 0);
2125                                 if (error)
2126                                         return error;
2127                         }
2128                 }
2129         }
2130         return 0;
2131 }
2132
2133 void
2134 xfs_qm_vop_create_dqattach(
2135         struct xfs_trans        *tp,
2136         struct xfs_inode        *ip,
2137         struct xfs_dquot        *udqp,
2138         struct xfs_dquot        *gdqp)
2139 {
2140         struct xfs_mount        *mp = tp->t_mountp;
2141
2142         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
2143                 return;
2144
2145         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
2146         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2147
2148         if (udqp) {
2149                 ASSERT(ip->i_udquot == NULL);
2150                 ASSERT(XFS_IS_UQUOTA_ON(mp));
2151                 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
2152
2153                 ip->i_udquot = xfs_qm_dqhold(udqp);
2154                 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
2155         }
2156         if (gdqp) {
2157                 ASSERT(ip->i_gdquot == NULL);
2158                 ASSERT(XFS_IS_OQUOTA_ON(mp));
2159                 ASSERT((XFS_IS_GQUOTA_ON(mp) ?
2160                         ip->i_d.di_gid : xfs_get_projid(ip)) ==
2161                                 be32_to_cpu(gdqp->q_core.d_id));
2162
2163                 ip->i_gdquot = xfs_qm_dqhold(gdqp);
2164                 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
2165         }
2166 }
2167