1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
55
56
57
58
59mutex_t xfs_Gqm_lock;
60struct xfs_qm *xfs_Gqm;
61uint ndquot;
62
63kmem_zone_t *qm_dqzone;
64kmem_zone_t *qm_dqtrxzone;
65
66static cred_t xfs_zerocr;
67
68STATIC void xfs_qm_list_init(xfs_dqlist_t *, char *, int);
69STATIC void xfs_qm_list_destroy(xfs_dqlist_t *);
70
71STATIC void xfs_qm_freelist_init(xfs_frlist_t *);
72STATIC void xfs_qm_freelist_destroy(xfs_frlist_t *);
73STATIC int xfs_qm_mplist_nowait(xfs_mount_t *);
74STATIC int xfs_qm_dqhashlock_nowait(xfs_dquot_t *);
75
76STATIC int xfs_qm_init_quotainos(xfs_mount_t *);
77STATIC int xfs_qm_init_quotainfo(xfs_mount_t *);
78STATIC int xfs_qm_shake(int, gfp_t);
79
80static struct shrinker xfs_qm_shaker = {
81 .shrink = xfs_qm_shake,
82 .seeks = DEFAULT_SEEKS,
83};
84
85#ifdef DEBUG
86extern mutex_t qcheck_lock;
87#endif
88
89#ifdef QUOTADEBUG
90#define XQM_LIST_PRINT(l, NXT, title) \
91{ \
92 xfs_dquot_t *dqp; int i = 0; \
93 cmn_err(CE_DEBUG, "%s (#%d)", title, (int) (l)->qh_nelems); \
94 for (dqp = (l)->qh_next; dqp != NULL; dqp = dqp->NXT) { \
95 cmn_err(CE_DEBUG, " %d. \"%d (%s)\" " \
96 "bcnt = %d, icnt = %d, refs = %d", \
97 ++i, (int) be32_to_cpu(dqp->q_core.d_id), \
98 DQFLAGTO_TYPESTR(dqp), \
99 (int) be64_to_cpu(dqp->q_core.d_bcount), \
100 (int) be64_to_cpu(dqp->q_core.d_icount), \
101 (int) dqp->q_nrefs); } \
102}
103#else
104#define XQM_LIST_PRINT(l, NXT, title) do { } while (0)
105#endif
106
107
108
109
110
111STATIC struct xfs_qm *
112xfs_Gqm_init(void)
113{
114 xfs_dqhash_t *udqhash, *gdqhash;
115 xfs_qm_t *xqm;
116 size_t hsize;
117 uint i;
118
119
120
121
122 udqhash = kmem_zalloc_greedy(&hsize,
123 XFS_QM_HASHSIZE_LOW * sizeof(xfs_dqhash_t),
124 XFS_QM_HASHSIZE_HIGH * sizeof(xfs_dqhash_t),
125 KM_SLEEP | KM_MAYFAIL | KM_LARGE);
126 gdqhash = kmem_zalloc(hsize, KM_SLEEP | KM_LARGE);
127 hsize /= sizeof(xfs_dqhash_t);
128 ndquot = hsize << 8;
129
130 xqm = kmem_zalloc(sizeof(xfs_qm_t), KM_SLEEP);
131 xqm->qm_dqhashmask = hsize - 1;
132 xqm->qm_usr_dqhtable = udqhash;
133 xqm->qm_grp_dqhtable = gdqhash;
134 ASSERT(xqm->qm_usr_dqhtable != NULL);
135 ASSERT(xqm->qm_grp_dqhtable != NULL);
136
137 for (i = 0; i < hsize; i++) {
138 xfs_qm_list_init(&(xqm->qm_usr_dqhtable[i]), "uxdqh", i);
139 xfs_qm_list_init(&(xqm->qm_grp_dqhtable[i]), "gxdqh", i);
140 }
141
142
143
144
145 xfs_qm_freelist_init(&(xqm->qm_dqfreelist));
146
147
148
149
150 if (!qm_dqzone) {
151 xqm->qm_dqzone = kmem_zone_init(sizeof(xfs_dquot_t),
152 "xfs_dquots");
153 qm_dqzone = xqm->qm_dqzone;
154 } else
155 xqm->qm_dqzone = qm_dqzone;
156
157 register_shrinker(&xfs_qm_shaker);
158
159
160
161
162 if (!qm_dqtrxzone) {
163 xqm->qm_dqtrxzone = kmem_zone_init(sizeof(xfs_dquot_acct_t),
164 "xfs_dqtrx");
165 qm_dqtrxzone = xqm->qm_dqtrxzone;
166 } else
167 xqm->qm_dqtrxzone = qm_dqtrxzone;
168
169 atomic_set(&xqm->qm_totaldquots, 0);
170 xqm->qm_dqfree_ratio = XFS_QM_DQFREE_RATIO;
171 xqm->qm_nrefs = 0;
172#ifdef DEBUG
173 mutex_init(&qcheck_lock);
174#endif
175 return xqm;
176}
177
178
179
180
181STATIC void
182xfs_qm_destroy(
183 struct xfs_qm *xqm)
184{
185 int hsize, i;
186
187 ASSERT(xqm != NULL);
188 ASSERT(xqm->qm_nrefs == 0);
189 unregister_shrinker(&xfs_qm_shaker);
190 hsize = xqm->qm_dqhashmask + 1;
191 for (i = 0; i < hsize; i++) {
192 xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));
193 xfs_qm_list_destroy(&(xqm->qm_grp_dqhtable[i]));
194 }
195 kmem_free(xqm->qm_usr_dqhtable);
196 kmem_free(xqm->qm_grp_dqhtable);
197 xqm->qm_usr_dqhtable = NULL;
198 xqm->qm_grp_dqhtable = NULL;
199 xqm->qm_dqhashmask = 0;
200 xfs_qm_freelist_destroy(&(xqm->qm_dqfreelist));
201#ifdef DEBUG
202 mutex_destroy(&qcheck_lock);
203#endif
204 kmem_free(xqm);
205}
206
207
208
209
210
211
212
213
214STATIC int
215xfs_qm_hold_quotafs_ref(
216 struct xfs_mount *mp)
217{
218
219
220
221
222
223 XFS_QM_LOCK(xfs_Gqm);
224
225 if (xfs_Gqm == NULL)
226 xfs_Gqm = xfs_Gqm_init();
227
228
229
230
231
232 XFS_QM_HOLD(xfs_Gqm);
233 XFS_QM_UNLOCK(xfs_Gqm);
234
235 return 0;
236}
237
238
239
240
241
242
243
244STATIC void
245xfs_qm_rele_quotafs_ref(
246 struct xfs_mount *mp)
247{
248 xfs_dquot_t *dqp, *nextdqp;
249
250 ASSERT(xfs_Gqm);
251 ASSERT(xfs_Gqm->qm_nrefs > 0);
252
253
254
255
256 xfs_qm_freelist_lock(xfs_Gqm);
257
258 for (dqp = xfs_Gqm->qm_dqfreelist.qh_next;
259 dqp != (xfs_dquot_t *)&(xfs_Gqm->qm_dqfreelist); ) {
260 xfs_dqlock(dqp);
261 nextdqp = dqp->dq_flnext;
262 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
263 ASSERT(dqp->q_mount == NULL);
264 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
265 ASSERT(dqp->HL_PREVP == NULL);
266 ASSERT(dqp->MPL_PREVP == NULL);
267 XQM_FREELIST_REMOVE(dqp);
268 xfs_dqunlock(dqp);
269 xfs_qm_dqdestroy(dqp);
270 } else {
271 xfs_dqunlock(dqp);
272 }
273 dqp = nextdqp;
274 }
275 xfs_qm_freelist_unlock(xfs_Gqm);
276
277
278
279
280
281 XFS_QM_LOCK(xfs_Gqm);
282 XFS_QM_RELE(xfs_Gqm);
283 if (xfs_Gqm->qm_nrefs == 0) {
284 xfs_qm_destroy(xfs_Gqm);
285 xfs_Gqm = NULL;
286 }
287 XFS_QM_UNLOCK(xfs_Gqm);
288}
289
290
291
292
293void
294xfs_qm_unmount_quotadestroy(
295 xfs_mount_t *mp)
296{
297 if (mp->m_quotainfo)
298 xfs_qm_destroy_quotainfo(mp);
299}
300
301
302
303
304
305
306
307
308
309
310
311void
312xfs_qm_mount_quotas(
313 xfs_mount_t *mp)
314{
315 int error = 0;
316 uint sbf;
317
318
319
320
321
322 if (mp->m_sb.sb_rextents) {
323 cmn_err(CE_NOTE,
324 "Cannot turn on quotas for realtime filesystem %s",
325 mp->m_fsname);
326 mp->m_qflags = 0;
327 goto write_changes;
328 }
329
330 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
331
332
333
334
335
336 error = xfs_qm_init_quotainfo(mp);
337 if (error) {
338
339
340
341 ASSERT(mp->m_quotainfo == NULL);
342 mp->m_qflags = 0;
343 goto write_changes;
344 }
345
346
347
348 if (XFS_QM_NEED_QUOTACHECK(mp)) {
349 error = xfs_qm_quotacheck(mp);
350 if (error) {
351
352 return;
353 }
354 }
355
356
357
358
359
360 if (!XFS_IS_UQUOTA_ON(mp))
361 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
362 if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp)))
363 mp->m_qflags &= ~XFS_OQUOTA_CHKD;
364
365 write_changes:
366
367
368
369
370 spin_lock(&mp->m_sb_lock);
371 sbf = mp->m_sb.sb_qflags;
372 mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
373 spin_unlock(&mp->m_sb_lock);
374
375 if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
376 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
377
378
379
380
381
382
383 ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
384 xfs_fs_cmn_err(CE_ALERT, mp,
385 "XFS mount_quotas: Superblock update failed!");
386 }
387 }
388
389 if (error) {
390 xfs_fs_cmn_err(CE_WARN, mp,
391 "Failed to initialize disk quotas.");
392 }
393 return;
394}
395
396
397
398
399int
400xfs_qm_unmount_quotas(
401 xfs_mount_t *mp)
402{
403 xfs_inode_t *uqp, *gqp;
404 int error = 0;
405
406
407
408
409
410 ASSERT(mp->m_rootip);
411 xfs_qm_dqdetach(mp->m_rootip);
412 if (mp->m_rbmip)
413 xfs_qm_dqdetach(mp->m_rbmip);
414 if (mp->m_rsumip)
415 xfs_qm_dqdetach(mp->m_rsumip);
416
417
418
419
420 uqp = gqp = NULL;
421 if (mp->m_quotainfo) {
422 if ((uqp = mp->m_quotainfo->qi_uquotaip) != NULL) {
423 xfs_ilock(uqp, XFS_ILOCK_EXCL);
424 xfs_iflock(uqp);
425 error = xfs_iflush(uqp, XFS_IFLUSH_SYNC);
426 xfs_iunlock(uqp, XFS_ILOCK_EXCL);
427 if (unlikely(error == EFSCORRUPTED)) {
428 XFS_ERROR_REPORT("xfs_qm_unmount_quotas(1)",
429 XFS_ERRLEVEL_LOW, mp);
430 goto out;
431 }
432 }
433 if ((gqp = mp->m_quotainfo->qi_gquotaip) != NULL) {
434 xfs_ilock(gqp, XFS_ILOCK_EXCL);
435 xfs_iflock(gqp);
436 error = xfs_iflush(gqp, XFS_IFLUSH_SYNC);
437 xfs_iunlock(gqp, XFS_ILOCK_EXCL);
438 if (unlikely(error == EFSCORRUPTED)) {
439 XFS_ERROR_REPORT("xfs_qm_unmount_quotas(2)",
440 XFS_ERRLEVEL_LOW, mp);
441 goto out;
442 }
443 }
444 }
445 if (uqp) {
446 IRELE(uqp);
447 mp->m_quotainfo->qi_uquotaip = NULL;
448 }
449 if (gqp) {
450 IRELE(gqp);
451 mp->m_quotainfo->qi_gquotaip = NULL;
452 }
453out:
454 return XFS_ERROR(error);
455}
456
457
458
459
460
461STATIC int
462xfs_qm_dqflush_all(
463 xfs_mount_t *mp,
464 int flags)
465{
466 int recl;
467 xfs_dquot_t *dqp;
468 int niters;
469 int error;
470
471 if (mp->m_quotainfo == NULL)
472 return 0;
473 niters = 0;
474again:
475 xfs_qm_mplist_lock(mp);
476 FOREACH_DQUOT_IN_MP(dqp, mp) {
477 xfs_dqlock(dqp);
478 if (! XFS_DQ_IS_DIRTY(dqp)) {
479 xfs_dqunlock(dqp);
480 continue;
481 }
482 xfs_dqtrace_entry(dqp, "FLUSHALL: DQDIRTY");
483
484 recl = XFS_QI_MPLRECLAIMS(mp);
485 if (!xfs_dqflock_nowait(dqp)) {
486
487
488
489
490
491
492
493 xfs_qm_dqflock_pushbuf_wait(dqp);
494 }
495
496
497
498
499 xfs_qm_mplist_unlock(mp);
500 error = xfs_qm_dqflush(dqp, flags);
501 xfs_dqunlock(dqp);
502 if (error)
503 return error;
504
505 xfs_qm_mplist_lock(mp);
506 if (recl != XFS_QI_MPLRECLAIMS(mp)) {
507 xfs_qm_mplist_unlock(mp);
508
509 goto again;
510 }
511 }
512
513 xfs_qm_mplist_unlock(mp);
514
515 return 0;
516}
517
518
519
520
521STATIC void
522xfs_qm_detach_gdquots(
523 xfs_mount_t *mp)
524{
525 xfs_dquot_t *dqp, *gdqp;
526 int nrecl;
527
528 again:
529 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
530 dqp = XFS_QI_MPLNEXT(mp);
531 while (dqp) {
532 xfs_dqlock(dqp);
533 if ((gdqp = dqp->q_gdquot)) {
534 xfs_dqlock(gdqp);
535 dqp->q_gdquot = NULL;
536 }
537 xfs_dqunlock(dqp);
538
539 if (gdqp) {
540
541
542
543
544 nrecl = XFS_QI_MPLRECLAIMS(mp);
545 xfs_qm_mplist_unlock(mp);
546 xfs_qm_dqput(gdqp);
547
548 xfs_qm_mplist_lock(mp);
549 if (nrecl != XFS_QI_MPLRECLAIMS(mp))
550 goto again;
551 }
552 dqp = dqp->MPL_NEXT;
553 }
554}
555
556
557
558
559
560
561
562STATIC int
563xfs_qm_dqpurge_int(
564 xfs_mount_t *mp,
565 uint flags)
566{
567 xfs_dquot_t *dqp;
568 uint dqtype;
569 int nrecl;
570 xfs_dquot_t *nextdqp;
571 int nmisses;
572
573 if (mp->m_quotainfo == NULL)
574 return 0;
575
576 dqtype = (flags & XFS_QMOPT_UQUOTA) ? XFS_DQ_USER : 0;
577 dqtype |= (flags & XFS_QMOPT_PQUOTA) ? XFS_DQ_PROJ : 0;
578 dqtype |= (flags & XFS_QMOPT_GQUOTA) ? XFS_DQ_GROUP : 0;
579
580 xfs_qm_mplist_lock(mp);
581
582
583
584
585
586
587
588 xfs_qm_detach_gdquots(mp);
589
590 again:
591 nmisses = 0;
592 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
593
594
595
596
597 dqp = XFS_QI_MPLNEXT(mp);
598 while (dqp) {
599
600
601
602
603
604 if ((dqp->dq_flags & dqtype) == 0) {
605 dqp = dqp->MPL_NEXT;
606 continue;
607 }
608
609 if (! xfs_qm_dqhashlock_nowait(dqp)) {
610 nrecl = XFS_QI_MPLRECLAIMS(mp);
611 xfs_qm_mplist_unlock(mp);
612 XFS_DQ_HASH_LOCK(dqp->q_hash);
613 xfs_qm_mplist_lock(mp);
614
615
616
617
618
619
620
621 if (nrecl != XFS_QI_MPLRECLAIMS(mp)) {
622 XFS_DQ_HASH_UNLOCK(dqp->q_hash);
623 goto again;
624 }
625 }
626
627
628
629
630
631 nextdqp = dqp->MPL_NEXT;
632 nmisses += xfs_qm_dqpurge(dqp);
633 dqp = nextdqp;
634 }
635 xfs_qm_mplist_unlock(mp);
636 return nmisses;
637}
638
639int
640xfs_qm_dqpurge_all(
641 xfs_mount_t *mp,
642 uint flags)
643{
644 int ndquots;
645
646
647
648
649
650 if (mp->m_quotainfo) {
651 while ((ndquots = xfs_qm_dqpurge_int(mp, flags))) {
652 delay(ndquots * 10);
653 }
654 }
655 return 0;
656}
657
658STATIC int
659xfs_qm_dqattach_one(
660 xfs_inode_t *ip,
661 xfs_dqid_t id,
662 uint type,
663 uint doalloc,
664 uint dolock,
665 xfs_dquot_t *udqhint,
666 xfs_dquot_t **IO_idqpp)
667{
668 xfs_dquot_t *dqp;
669 int error;
670
671 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
672 error = 0;
673
674
675
676
677
678 if ((dqp = *IO_idqpp)) {
679 if (dolock)
680 xfs_dqlock(dqp);
681 xfs_dqtrace_entry(dqp, "DQATTACH: found in ip");
682 goto done;
683 }
684
685
686
687
688
689
690
691 ASSERT(!udqhint || type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
692 if (udqhint && !dolock)
693 xfs_dqlock(udqhint);
694
695
696
697
698
699
700
701 if (udqhint &&
702 (dqp = udqhint->q_gdquot) &&
703 (be32_to_cpu(dqp->q_core.d_id) == id)) {
704 ASSERT(XFS_DQ_IS_LOCKED(udqhint));
705 xfs_dqlock(dqp);
706 XFS_DQHOLD(dqp);
707 ASSERT(*IO_idqpp == NULL);
708 *IO_idqpp = dqp;
709 if (!dolock) {
710 xfs_dqunlock(dqp);
711 xfs_dqunlock(udqhint);
712 }
713 goto done;
714 }
715
716
717
718
719
720
721 if (udqhint)
722 xfs_dqunlock(udqhint);
723
724
725
726
727
728
729
730 if ((error = xfs_qm_dqget(ip->i_mount, ip, id, type,
731 doalloc|XFS_QMOPT_DOWARN, &dqp))) {
732 if (udqhint && dolock)
733 xfs_dqlock(udqhint);
734 goto done;
735 }
736
737 xfs_dqtrace_entry(dqp, "DQATTACH: found by dqget");
738
739
740
741
742 *IO_idqpp = dqp;
743 ASSERT(dqp);
744 ASSERT(XFS_DQ_IS_LOCKED(dqp));
745 if (! dolock) {
746 xfs_dqunlock(dqp);
747 goto done;
748 }
749 if (! udqhint)
750 goto done;
751
752 ASSERT(udqhint);
753 ASSERT(dolock);
754 ASSERT(XFS_DQ_IS_LOCKED(dqp));
755 if (! xfs_qm_dqlock_nowait(udqhint)) {
756 xfs_dqunlock(dqp);
757 xfs_dqlock(udqhint);
758 xfs_dqlock(dqp);
759 }
760 done:
761#ifdef QUOTADEBUG
762 if (udqhint) {
763 if (dolock)
764 ASSERT(XFS_DQ_IS_LOCKED(udqhint));
765 }
766 if (! error) {
767 if (dolock)
768 ASSERT(XFS_DQ_IS_LOCKED(dqp));
769 }
770#endif
771 return error;
772}
773
774
775
776
777
778
779
780
781
782
783STATIC void
784xfs_qm_dqattach_grouphint(
785 xfs_dquot_t *udq,
786 xfs_dquot_t *gdq,
787 uint locked)
788{
789 xfs_dquot_t *tmp;
790
791#ifdef QUOTADEBUG
792 if (locked) {
793 ASSERT(XFS_DQ_IS_LOCKED(udq));
794 ASSERT(XFS_DQ_IS_LOCKED(gdq));
795 }
796#endif
797 if (! locked)
798 xfs_dqlock(udq);
799
800 if ((tmp = udq->q_gdquot)) {
801 if (tmp == gdq) {
802 if (! locked)
803 xfs_dqunlock(udq);
804 return;
805 }
806
807 udq->q_gdquot = NULL;
808
809
810
811
812 xfs_dqunlock(udq);
813 if (locked)
814 xfs_dqunlock(gdq);
815
816
817
818
819
820 xfs_qm_dqrele(tmp);
821
822 xfs_dqlock(udq);
823 xfs_dqlock(gdq);
824
825 } else {
826 ASSERT(XFS_DQ_IS_LOCKED(udq));
827 if (! locked) {
828 xfs_dqlock(gdq);
829 }
830 }
831
832 ASSERT(XFS_DQ_IS_LOCKED(udq));
833 ASSERT(XFS_DQ_IS_LOCKED(gdq));
834
835
836
837
838 if (udq->q_gdquot == NULL) {
839 XFS_DQHOLD(gdq);
840 udq->q_gdquot = gdq;
841 }
842 if (! locked) {
843 xfs_dqunlock(gdq);
844 xfs_dqunlock(udq);
845 }
846}
847
848
849
850
851
852
853
854
855
856
857
858
859int
860xfs_qm_dqattach(
861 xfs_inode_t *ip,
862 uint flags)
863{
864 xfs_mount_t *mp = ip->i_mount;
865 uint nquotas = 0;
866 int error = 0;
867
868 if ((! XFS_IS_QUOTA_ON(mp)) ||
869 (! XFS_NOT_DQATTACHED(mp, ip)) ||
870 (ip->i_ino == mp->m_sb.sb_uquotino) ||
871 (ip->i_ino == mp->m_sb.sb_gquotino))
872 return 0;
873
874 ASSERT((flags & XFS_QMOPT_ILOCKED) == 0 ||
875 xfs_isilocked(ip, XFS_ILOCK_EXCL));
876
877 if (! (flags & XFS_QMOPT_ILOCKED))
878 xfs_ilock(ip, XFS_ILOCK_EXCL);
879
880 if (XFS_IS_UQUOTA_ON(mp)) {
881 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
882 flags & XFS_QMOPT_DQALLOC,
883 flags & XFS_QMOPT_DQLOCK,
884 NULL, &ip->i_udquot);
885 if (error)
886 goto done;
887 nquotas++;
888 }
889
890 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
891 if (XFS_IS_OQUOTA_ON(mp)) {
892 error = XFS_IS_GQUOTA_ON(mp) ?
893 xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
894 flags & XFS_QMOPT_DQALLOC,
895 flags & XFS_QMOPT_DQLOCK,
896 ip->i_udquot, &ip->i_gdquot) :
897 xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQ_PROJ,
898 flags & XFS_QMOPT_DQALLOC,
899 flags & XFS_QMOPT_DQLOCK,
900 ip->i_udquot, &ip->i_gdquot);
901
902
903
904
905 if (error)
906 goto done;
907 nquotas++;
908 }
909
910
911
912
913
914 if (nquotas == 2) {
915 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
916 ASSERT(ip->i_udquot);
917 ASSERT(ip->i_gdquot);
918
919
920
921
922
923
924
925 if (ip->i_udquot->q_gdquot == ip->i_gdquot)
926 goto done;
927
928
929
930 xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot,
931 flags & XFS_QMOPT_DQLOCK);
932 }
933
934 done:
935
936#ifdef QUOTADEBUG
937 if (! error) {
938 if (ip->i_udquot) {
939 if (flags & XFS_QMOPT_DQLOCK)
940 ASSERT(XFS_DQ_IS_LOCKED(ip->i_udquot));
941 }
942 if (ip->i_gdquot) {
943 if (flags & XFS_QMOPT_DQLOCK)
944 ASSERT(XFS_DQ_IS_LOCKED(ip->i_gdquot));
945 }
946 if (XFS_IS_UQUOTA_ON(mp))
947 ASSERT(ip->i_udquot);
948 if (XFS_IS_OQUOTA_ON(mp))
949 ASSERT(ip->i_gdquot);
950 }
951#endif
952
953 if (! (flags & XFS_QMOPT_ILOCKED))
954 xfs_iunlock(ip, XFS_ILOCK_EXCL);
955
956#ifdef QUOTADEBUG
957 else
958 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
959#endif
960 return error;
961}
962
963
964
965
966
967
968void
969xfs_qm_dqdetach(
970 xfs_inode_t *ip)
971{
972 if (!(ip->i_udquot || ip->i_gdquot))
973 return;
974
975 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
976 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
977 if (ip->i_udquot) {
978 xfs_dqtrace_entry_ino(ip->i_udquot, "DQDETTACH", ip);
979 xfs_qm_dqrele(ip->i_udquot);
980 ip->i_udquot = NULL;
981 }
982 if (ip->i_gdquot) {
983 xfs_dqtrace_entry_ino(ip->i_gdquot, "DQDETTACH", ip);
984 xfs_qm_dqrele(ip->i_gdquot);
985 ip->i_gdquot = NULL;
986 }
987}
988
989
990
991
992
993
994
995
996
997
998int
999xfs_qm_sync(
1000 xfs_mount_t *mp,
1001 int flags)
1002{
1003 int recl, restarts;
1004 xfs_dquot_t *dqp;
1005 uint flush_flags;
1006 boolean_t nowait;
1007 int error;
1008
1009 if (! XFS_IS_QUOTA_ON(mp))
1010 return 0;
1011
1012 restarts = 0;
1013
1014
1015
1016 nowait = (boolean_t)(flags & SYNC_BDFLUSH || (flags & SYNC_WAIT) == 0);
1017
1018 again:
1019 xfs_qm_mplist_lock(mp);
1020
1021
1022
1023
1024
1025
1026 if (! XFS_IS_QUOTA_ON(mp)) {
1027 xfs_qm_mplist_unlock(mp);
1028 return 0;
1029 }
1030 FOREACH_DQUOT_IN_MP(dqp, mp) {
1031
1032
1033
1034
1035
1036 if (flags & SYNC_BDFLUSH) {
1037 if (! XFS_DQ_IS_DIRTY(dqp))
1038 continue;
1039 }
1040
1041 if (nowait) {
1042
1043
1044
1045
1046
1047 if (! xfs_qm_dqlock_nowait(dqp))
1048 continue;
1049 } else {
1050 xfs_dqlock(dqp);
1051 }
1052
1053
1054
1055
1056 if (! XFS_DQ_IS_DIRTY(dqp)) {
1057 xfs_dqunlock(dqp);
1058 continue;
1059 }
1060
1061
1062 recl = XFS_QI_MPLRECLAIMS(mp);
1063 if (!xfs_dqflock_nowait(dqp)) {
1064 if (nowait) {
1065 xfs_dqunlock(dqp);
1066 continue;
1067 }
1068
1069
1070
1071
1072
1073
1074
1075
1076 xfs_qm_dqflock_pushbuf_wait(dqp);
1077 }
1078
1079
1080
1081
1082 flush_flags = (nowait) ? XFS_QMOPT_DELWRI : XFS_QMOPT_SYNC;
1083 xfs_qm_mplist_unlock(mp);
1084 xfs_dqtrace_entry(dqp, "XQM_SYNC: DQFLUSH");
1085 error = xfs_qm_dqflush(dqp, flush_flags);
1086 xfs_dqunlock(dqp);
1087 if (error && XFS_FORCED_SHUTDOWN(mp))
1088 return 0;
1089 else if (error)
1090 return error;
1091
1092 xfs_qm_mplist_lock(mp);
1093 if (recl != XFS_QI_MPLRECLAIMS(mp)) {
1094 if (++restarts >= XFS_QM_SYNC_MAX_RESTARTS)
1095 break;
1096
1097 xfs_qm_mplist_unlock(mp);
1098 goto again;
1099 }
1100 }
1101
1102 xfs_qm_mplist_unlock(mp);
1103 return 0;
1104}
1105
1106
1107
1108
1109
1110
1111STATIC int
1112xfs_qm_init_quotainfo(
1113 xfs_mount_t *mp)
1114{
1115 xfs_quotainfo_t *qinf;
1116 int error;
1117 xfs_dquot_t *dqp;
1118
1119 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1120
1121
1122
1123
1124 if ((error = xfs_qm_hold_quotafs_ref(mp))) {
1125 return error;
1126 }
1127
1128 qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
1129
1130
1131
1132
1133
1134 if ((error = xfs_qm_init_quotainos(mp))) {
1135 kmem_free(qinf);
1136 mp->m_quotainfo = NULL;
1137 return error;
1138 }
1139
1140 spin_lock_init(&qinf->qi_pinlock);
1141 xfs_qm_list_init(&qinf->qi_dqlist, "mpdqlist", 0);
1142 qinf->qi_dqreclaims = 0;
1143
1144
1145 mutex_init(&qinf->qi_quotaofflock);
1146
1147
1148 qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1149 ASSERT(qinf->qi_dqchunklen);
1150 qinf->qi_dqperchunk = BBTOB(qinf->qi_dqchunklen);
1151 do_div(qinf->qi_dqperchunk, sizeof(xfs_dqblk_t));
1152
1153 mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163 error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)0,
1164 XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
1165 (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
1166 XFS_DQ_PROJ),
1167 XFS_QMOPT_DQSUSER|XFS_QMOPT_DOWARN,
1168 &dqp);
1169 if (! error) {
1170 xfs_disk_dquot_t *ddqp = &dqp->q_core;
1171
1172
1173
1174
1175
1176
1177 qinf->qi_btimelimit = ddqp->d_btimer ?
1178 be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;
1179 qinf->qi_itimelimit = ddqp->d_itimer ?
1180 be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;
1181 qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?
1182 be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;
1183 qinf->qi_bwarnlimit = ddqp->d_bwarns ?
1184 be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;
1185 qinf->qi_iwarnlimit = ddqp->d_iwarns ?
1186 be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
1187 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
1188 be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
1189 qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
1190 qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
1191 qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
1192 qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
1193 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
1194 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
1195
1196
1197
1198
1199
1200
1201 xfs_qm_dqdestroy(dqp);
1202 } else {
1203 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
1204 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
1205 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
1206 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
1207 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
1208 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
1209 }
1210
1211 return 0;
1212}
1213
1214
1215
1216
1217
1218
1219
1220void
1221xfs_qm_destroy_quotainfo(
1222 xfs_mount_t *mp)
1223{
1224 xfs_quotainfo_t *qi;
1225
1226 qi = mp->m_quotainfo;
1227 ASSERT(qi != NULL);
1228 ASSERT(xfs_Gqm != NULL);
1229
1230
1231
1232
1233
1234
1235 xfs_qm_rele_quotafs_ref(mp);
1236
1237 spinlock_destroy(&qi->qi_pinlock);
1238 xfs_qm_list_destroy(&qi->qi_dqlist);
1239
1240 if (qi->qi_uquotaip) {
1241 IRELE(qi->qi_uquotaip);
1242 qi->qi_uquotaip = NULL;
1243 }
1244 if (qi->qi_gquotaip) {
1245 IRELE(qi->qi_gquotaip);
1246 qi->qi_gquotaip = NULL;
1247 }
1248 mutex_destroy(&qi->qi_quotaofflock);
1249 kmem_free(qi);
1250 mp->m_quotainfo = NULL;
1251}
1252
1253
1254
1255
1256
1257
1258STATIC void
1259xfs_qm_list_init(
1260 xfs_dqlist_t *list,
1261 char *str,
1262 int n)
1263{
1264 mutex_init(&list->qh_lock);
1265 list->qh_next = NULL;
1266 list->qh_version = 0;
1267 list->qh_nelems = 0;
1268}
1269
1270STATIC void
1271xfs_qm_list_destroy(
1272 xfs_dqlist_t *list)
1273{
1274 mutex_destroy(&(list->qh_lock));
1275}
1276
1277
1278
1279
1280
1281
1282
1283STATIC int
1284xfs_qm_dqget_noattach(
1285 xfs_inode_t *ip,
1286 xfs_dquot_t **O_udqpp,
1287 xfs_dquot_t **O_gdqpp)
1288{
1289 int error;
1290 xfs_mount_t *mp;
1291 xfs_dquot_t *udqp, *gdqp;
1292
1293 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1294 mp = ip->i_mount;
1295 udqp = NULL;
1296 gdqp = NULL;
1297
1298 if (XFS_IS_UQUOTA_ON(mp)) {
1299 ASSERT(ip->i_udquot == NULL);
1300
1301
1302
1303 if ((error = xfs_qm_dqget(mp, ip, ip->i_d.di_uid, XFS_DQ_USER,
1304 XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN,
1305 &udqp))) {
1306
1307
1308
1309 ASSERT(error != ESRCH);
1310 ASSERT(error != ENOENT);
1311 return error;
1312 }
1313 ASSERT(udqp);
1314 }
1315
1316 if (XFS_IS_OQUOTA_ON(mp)) {
1317 ASSERT(ip->i_gdquot == NULL);
1318 if (udqp)
1319 xfs_dqunlock(udqp);
1320 error = XFS_IS_GQUOTA_ON(mp) ?
1321 xfs_qm_dqget(mp, ip,
1322 ip->i_d.di_gid, XFS_DQ_GROUP,
1323 XFS_QMOPT_DQALLOC|XFS_QMOPT_DOWARN,
1324 &gdqp) :
1325 xfs_qm_dqget(mp, ip,
1326 ip->i_d.di_projid, XFS_DQ_PROJ,
1327 XFS_QMOPT_DQALLOC|XFS_QMOPT_DOWARN,
1328 &gdqp);
1329 if (error) {
1330 if (udqp)
1331 xfs_qm_dqrele(udqp);
1332 ASSERT(error != ESRCH);
1333 ASSERT(error != ENOENT);
1334 return error;
1335 }
1336 ASSERT(gdqp);
1337
1338
1339 if (udqp) {
1340 if (! xfs_qm_dqlock_nowait(udqp)) {
1341 xfs_dqunlock(gdqp);
1342 xfs_dqlock(udqp);
1343 xfs_dqlock(gdqp);
1344 }
1345 }
1346 }
1347
1348 *O_udqpp = udqp;
1349 *O_gdqpp = gdqp;
1350
1351#ifdef QUOTADEBUG
1352 if (udqp) ASSERT(XFS_DQ_IS_LOCKED(udqp));
1353 if (gdqp) ASSERT(XFS_DQ_IS_LOCKED(gdqp));
1354#endif
1355 return 0;
1356}
1357
1358
1359
1360
1361
1362STATIC int
1363xfs_qm_qino_alloc(
1364 xfs_mount_t *mp,
1365 xfs_inode_t **ip,
1366 __int64_t sbfields,
1367 uint flags)
1368{
1369 xfs_trans_t *tp;
1370 int error;
1371 int committed;
1372
1373 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
1374 if ((error = xfs_trans_reserve(tp,
1375 XFS_QM_QINOCREATE_SPACE_RES(mp),
1376 XFS_CREATE_LOG_RES(mp), 0,
1377 XFS_TRANS_PERM_LOG_RES,
1378 XFS_CREATE_LOG_COUNT))) {
1379 xfs_trans_cancel(tp, 0);
1380 return error;
1381 }
1382
1383 if ((error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0,
1384 &xfs_zerocr, 0, 1, ip, &committed))) {
1385 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
1386 XFS_TRANS_ABORT);
1387 return error;
1388 }
1389
1390
1391
1392
1393
1394 ASSERT(xfs_isilocked(*ip, XFS_ILOCK_EXCL));
1395 IHOLD(*ip);
1396
1397
1398
1399
1400
1401
1402 spin_lock(&mp->m_sb_lock);
1403 if (flags & XFS_QMOPT_SBVERSION) {
1404#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
1405 unsigned oldv = mp->m_sb.sb_versionnum;
1406#endif
1407 ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
1408 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1409 XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
1410 (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1411 XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
1412
1413 xfs_sb_version_addquota(&mp->m_sb);
1414 mp->m_sb.sb_uquotino = NULLFSINO;
1415 mp->m_sb.sb_gquotino = NULLFSINO;
1416
1417
1418 mp->m_sb.sb_qflags = 0;
1419#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
1420 cmn_err(CE_NOTE,
1421 "Old superblock version %x, converting to %x.",
1422 oldv, mp->m_sb.sb_versionnum);
1423#endif
1424 }
1425 if (flags & XFS_QMOPT_UQUOTA)
1426 mp->m_sb.sb_uquotino = (*ip)->i_ino;
1427 else
1428 mp->m_sb.sb_gquotino = (*ip)->i_ino;
1429 spin_unlock(&mp->m_sb_lock);
1430 xfs_mod_sb(tp, sbfields);
1431
1432 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) {
1433 xfs_fs_cmn_err(CE_ALERT, mp, "XFS qino_alloc failed!");
1434 return error;
1435 }
1436 return 0;
1437}
1438
1439
1440STATIC void
1441xfs_qm_reset_dqcounts(
1442 xfs_mount_t *mp,
1443 xfs_buf_t *bp,
1444 xfs_dqid_t id,
1445 uint type)
1446{
1447 xfs_disk_dquot_t *ddq;
1448 int j;
1449
1450 xfs_buftrace("RESET DQUOTS", bp);
1451
1452
1453
1454
1455#ifdef DEBUG
1456 j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1457 do_div(j, sizeof(xfs_dqblk_t));
1458 ASSERT(XFS_QM_DQPERBLK(mp) == j);
1459#endif
1460 ddq = (xfs_disk_dquot_t *)XFS_BUF_PTR(bp);
1461 for (j = 0; j < XFS_QM_DQPERBLK(mp); j++) {
1462
1463
1464
1465
1466
1467 (void) xfs_qm_dqcheck(ddq, id+j, type, XFS_QMOPT_DQREPAIR,
1468 "xfs_quotacheck");
1469 ddq->d_bcount = 0;
1470 ddq->d_icount = 0;
1471 ddq->d_rtbcount = 0;
1472 ddq->d_btimer = 0;
1473 ddq->d_itimer = 0;
1474 ddq->d_rtbtimer = 0;
1475 ddq->d_bwarns = 0;
1476 ddq->d_iwarns = 0;
1477 ddq->d_rtbwarns = 0;
1478 ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);
1479 }
1480}
1481
1482STATIC int
1483xfs_qm_dqiter_bufs(
1484 xfs_mount_t *mp,
1485 xfs_dqid_t firstid,
1486 xfs_fsblock_t bno,
1487 xfs_filblks_t blkcnt,
1488 uint flags)
1489{
1490 xfs_buf_t *bp;
1491 int error;
1492 int notcommitted;
1493 int incr;
1494 int type;
1495
1496 ASSERT(blkcnt > 0);
1497 notcommitted = 0;
1498 incr = (blkcnt > XFS_QM_MAX_DQCLUSTER_LOGSZ) ?
1499 XFS_QM_MAX_DQCLUSTER_LOGSZ : blkcnt;
1500 type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
1501 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
1502 error = 0;
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513 while (blkcnt--) {
1514 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1515 XFS_FSB_TO_DADDR(mp, bno),
1516 (int)XFS_QI_DQCHUNKLEN(mp), 0, &bp);
1517 if (error)
1518 break;
1519
1520 xfs_qm_reset_dqcounts(mp, bp, firstid, type);
1521 xfs_bdwrite(mp, bp);
1522
1523
1524
1525 bno++;
1526 firstid += XFS_QM_DQPERBLK(mp);
1527 }
1528 return error;
1529}
1530
1531
1532
1533
1534
1535STATIC int
1536xfs_qm_dqiterate(
1537 xfs_mount_t *mp,
1538 xfs_inode_t *qip,
1539 uint flags)
1540{
1541 xfs_bmbt_irec_t *map;
1542 int i, nmaps;
1543 int error;
1544 xfs_fileoff_t lblkno;
1545 xfs_filblks_t maxlblkcnt;
1546 xfs_dqid_t firstid;
1547 xfs_fsblock_t rablkno;
1548 xfs_filblks_t rablkcnt;
1549
1550 error = 0;
1551
1552
1553
1554
1555
1556 if (qip->i_d.di_nblocks == 0)
1557 return 0;
1558
1559 map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
1560
1561 lblkno = 0;
1562 maxlblkcnt = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
1563 do {
1564 nmaps = XFS_DQITER_MAP_SIZE;
1565
1566
1567
1568
1569
1570 xfs_ilock(qip, XFS_ILOCK_SHARED);
1571 error = xfs_bmapi(NULL, qip, lblkno,
1572 maxlblkcnt - lblkno,
1573 XFS_BMAPI_METADATA,
1574 NULL,
1575 0, map, &nmaps, NULL, NULL);
1576 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1577 if (error)
1578 break;
1579
1580 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
1581 for (i = 0; i < nmaps; i++) {
1582 ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
1583 ASSERT(map[i].br_blockcount);
1584
1585
1586 lblkno += map[i].br_blockcount;
1587
1588 if (map[i].br_startblock == HOLESTARTBLOCK)
1589 continue;
1590
1591 firstid = (xfs_dqid_t) map[i].br_startoff *
1592 XFS_QM_DQPERBLK(mp);
1593
1594
1595
1596 if ((i+1 < nmaps) &&
1597 (map[i+1].br_startblock != HOLESTARTBLOCK)) {
1598 rablkcnt = map[i+1].br_blockcount;
1599 rablkno = map[i+1].br_startblock;
1600 while (rablkcnt--) {
1601 xfs_baread(mp->m_ddev_targp,
1602 XFS_FSB_TO_DADDR(mp, rablkno),
1603 (int)XFS_QI_DQCHUNKLEN(mp));
1604 rablkno++;
1605 }
1606 }
1607
1608
1609
1610
1611 if ((error = xfs_qm_dqiter_bufs(mp,
1612 firstid,
1613 map[i].br_startblock,
1614 map[i].br_blockcount,
1615 flags))) {
1616 break;
1617 }
1618 }
1619
1620 if (error)
1621 break;
1622 } while (nmaps > 0);
1623
1624 kmem_free(map);
1625
1626 return error;
1627}
1628
1629
1630
1631
1632
1633
1634
1635
1636STATIC void
1637xfs_qm_quotacheck_dqadjust(
1638 xfs_dquot_t *dqp,
1639 xfs_qcnt_t nblks,
1640 xfs_qcnt_t rtblks)
1641{
1642 ASSERT(XFS_DQ_IS_LOCKED(dqp));
1643 xfs_dqtrace_entry(dqp, "QCHECK DQADJUST");
1644
1645
1646
1647
1648 be64_add_cpu(&dqp->q_core.d_icount, 1);
1649 dqp->q_res_icount++;
1650 if (nblks) {
1651 be64_add_cpu(&dqp->q_core.d_bcount, nblks);
1652 dqp->q_res_bcount += nblks;
1653 }
1654 if (rtblks) {
1655 be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
1656 dqp->q_res_rtbcount += rtblks;
1657 }
1658
1659
1660
1661
1662 if (! XFS_IS_SUSER_DQUOT(dqp)) {
1663 xfs_qm_adjust_dqlimits(dqp->q_mount, &dqp->q_core);
1664 xfs_qm_adjust_dqtimers(dqp->q_mount, &dqp->q_core);
1665 }
1666
1667 dqp->dq_flags |= XFS_DQ_DIRTY;
1668}
1669
1670STATIC int
1671xfs_qm_get_rtblks(
1672 xfs_inode_t *ip,
1673 xfs_qcnt_t *O_rtblks)
1674{
1675 xfs_filblks_t rtblks;
1676 xfs_extnum_t idx;
1677 xfs_ifork_t *ifp;
1678 xfs_extnum_t nextents;
1679 int error;
1680
1681 ASSERT(XFS_IS_REALTIME_INODE(ip));
1682 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1683 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1684 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
1685 return error;
1686 }
1687 rtblks = 0;
1688 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
1689 for (idx = 0; idx < nextents; idx++)
1690 rtblks += xfs_bmbt_get_blockcount(xfs_iext_get_ext(ifp, idx));
1691 *O_rtblks = (xfs_qcnt_t)rtblks;
1692 return 0;
1693}
1694
1695
1696
1697
1698
1699
1700STATIC int
1701xfs_qm_dqusage_adjust(
1702 xfs_mount_t *mp,
1703 xfs_ino_t ino,
1704 void __user *buffer,
1705 int ubsize,
1706 void *private_data,
1707 xfs_daddr_t bno,
1708 int *ubused,
1709 void *dip,
1710 int *res)
1711{
1712 xfs_inode_t *ip;
1713 xfs_dquot_t *udqp, *gdqp;
1714 xfs_qcnt_t nblks, rtblks;
1715 int error;
1716
1717 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1718
1719
1720
1721
1722
1723 if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1724 *res = BULKSTAT_RV_NOTHING;
1725 return XFS_ERROR(EINVAL);
1726 }
1727
1728
1729
1730
1731
1732
1733
1734 if ((error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip, bno))) {
1735 *res = BULKSTAT_RV_NOTHING;
1736 return error;
1737 }
1738
1739
1740
1741
1742
1743
1744
1745 if ((error = xfs_qm_dqget_noattach(ip, &udqp, &gdqp))) {
1746 xfs_iput(ip, XFS_ILOCK_EXCL);
1747 *res = BULKSTAT_RV_GIVEUP;
1748 return error;
1749 }
1750
1751 rtblks = 0;
1752 if (! XFS_IS_REALTIME_INODE(ip)) {
1753 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks;
1754 } else {
1755
1756
1757
1758 if ((error = xfs_qm_get_rtblks(ip, &rtblks))) {
1759 xfs_iput(ip, XFS_ILOCK_EXCL);
1760 if (udqp)
1761 xfs_qm_dqput(udqp);
1762 if (gdqp)
1763 xfs_qm_dqput(gdqp);
1764 *res = BULKSTAT_RV_GIVEUP;
1765 return error;
1766 }
1767 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
1768 }
1769 ASSERT(ip->i_delayed_blks == 0);
1770
1771
1772
1773
1774
1775
1776 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790 if (XFS_IS_UQUOTA_ON(mp)) {
1791 ASSERT(udqp);
1792 xfs_qm_quotacheck_dqadjust(udqp, nblks, rtblks);
1793 xfs_qm_dqput(udqp);
1794 }
1795 if (XFS_IS_OQUOTA_ON(mp)) {
1796 ASSERT(gdqp);
1797 xfs_qm_quotacheck_dqadjust(gdqp, nblks, rtblks);
1798 xfs_qm_dqput(gdqp);
1799 }
1800
1801
1802
1803
1804 IRELE(ip);
1805
1806
1807
1808
1809 *res = BULKSTAT_RV_DIDONE;
1810 return 0;
1811}
1812
1813
1814
1815
1816
1817int
1818xfs_qm_quotacheck(
1819 xfs_mount_t *mp)
1820{
1821 int done, count, error;
1822 xfs_ino_t lastino;
1823 size_t structsz;
1824 xfs_inode_t *uip, *gip;
1825 uint flags;
1826
1827 count = INT_MAX;
1828 structsz = 1;
1829 lastino = 0;
1830 flags = 0;
1831
1832 ASSERT(XFS_QI_UQIP(mp) || XFS_QI_GQIP(mp));
1833 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1834
1835
1836
1837
1838
1839 ASSERT(XFS_QI_MPLNDQUOTS(mp) == 0);
1840
1841 cmn_err(CE_NOTE, "XFS quotacheck %s: Please wait.", mp->m_fsname);
1842
1843
1844
1845
1846
1847
1848 if ((uip = XFS_QI_UQIP(mp))) {
1849 if ((error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA)))
1850 goto error_return;
1851 flags |= XFS_UQUOTA_CHKD;
1852 }
1853
1854 if ((gip = XFS_QI_GQIP(mp))) {
1855 if ((error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
1856 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA)))
1857 goto error_return;
1858 flags |= XFS_OQUOTA_CHKD;
1859 }
1860
1861 do {
1862
1863
1864
1865
1866 if ((error = xfs_bulkstat(mp, &lastino, &count,
1867 xfs_qm_dqusage_adjust, NULL,
1868 structsz, NULL, BULKSTAT_FG_IGET, &done)))
1869 break;
1870
1871 } while (! done);
1872
1873
1874
1875
1876
1877
1878 if (!error)
1879 error = xfs_qm_dqflush_all(mp, XFS_QMOPT_DELWRI);
1880
1881
1882
1883
1884
1885
1886
1887
1888 if (error) {
1889 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL | XFS_QMOPT_QUOTAOFF);
1890 goto error_return;
1891 }
1892
1893
1894
1895
1896
1897
1898
1899
1900 XFS_bflush(mp->m_ddev_targp);
1901
1902
1903
1904
1905
1906
1907 mp->m_qflags &= ~(XFS_OQUOTA_CHKD | XFS_UQUOTA_CHKD);
1908 mp->m_qflags |= flags;
1909
1910 XQM_LIST_PRINT(&(XFS_QI_MPL_LIST(mp)), MPL_NEXT, "++++ Mp list +++");
1911
1912 error_return:
1913 if (error) {
1914 cmn_err(CE_WARN, "XFS quotacheck %s: Unsuccessful (Error %d): "
1915 "Disabling quotas.",
1916 mp->m_fsname, error);
1917
1918
1919
1920 ASSERT(mp->m_quotainfo != NULL);
1921 ASSERT(xfs_Gqm != NULL);
1922 xfs_qm_destroy_quotainfo(mp);
1923 if (xfs_mount_reset_sbqflags(mp)) {
1924 cmn_err(CE_WARN, "XFS quotacheck %s: "
1925 "Failed to reset quota flags.", mp->m_fsname);
1926 }
1927 } else {
1928 cmn_err(CE_NOTE, "XFS quotacheck %s: Done.", mp->m_fsname);
1929 }
1930 return (error);
1931}
1932
1933
1934
1935
1936
1937STATIC int
1938xfs_qm_init_quotainos(
1939 xfs_mount_t *mp)
1940{
1941 xfs_inode_t *uip, *gip;
1942 int error;
1943 __int64_t sbflags;
1944 uint flags;
1945
1946 ASSERT(mp->m_quotainfo);
1947 uip = gip = NULL;
1948 sbflags = 0;
1949 flags = 0;
1950
1951
1952
1953
1954 if (xfs_sb_version_hasquota(&mp->m_sb)) {
1955 if (XFS_IS_UQUOTA_ON(mp) &&
1956 mp->m_sb.sb_uquotino != NULLFSINO) {
1957 ASSERT(mp->m_sb.sb_uquotino > 0);
1958 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
1959 0, 0, &uip, 0)))
1960 return XFS_ERROR(error);
1961 }
1962 if (XFS_IS_OQUOTA_ON(mp) &&
1963 mp->m_sb.sb_gquotino != NULLFSINO) {
1964 ASSERT(mp->m_sb.sb_gquotino > 0);
1965 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
1966 0, 0, &gip, 0))) {
1967 if (uip)
1968 IRELE(uip);
1969 return XFS_ERROR(error);
1970 }
1971 }
1972 } else {
1973 flags |= XFS_QMOPT_SBVERSION;
1974 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1975 XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
1976 }
1977
1978
1979
1980
1981
1982
1983
1984 if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
1985 if ((error = xfs_qm_qino_alloc(mp, &uip,
1986 sbflags | XFS_SB_UQUOTINO,
1987 flags | XFS_QMOPT_UQUOTA)))
1988 return XFS_ERROR(error);
1989
1990 flags &= ~XFS_QMOPT_SBVERSION;
1991 }
1992 if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) {
1993 flags |= (XFS_IS_GQUOTA_ON(mp) ?
1994 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
1995 error = xfs_qm_qino_alloc(mp, &gip,
1996 sbflags | XFS_SB_GQUOTINO, flags);
1997 if (error) {
1998 if (uip)
1999 IRELE(uip);
2000
2001 return XFS_ERROR(error);
2002 }
2003 }
2004
2005 XFS_QI_UQIP(mp) = uip;
2006 XFS_QI_GQIP(mp) = gip;
2007
2008 return 0;
2009}
2010
2011
2012
2013
2014
2015
2016
2017
2018STATIC int
2019xfs_qm_shake_freelist(
2020 int howmany)
2021{
2022 int nreclaimed;
2023 xfs_dqhash_t *hash;
2024 xfs_dquot_t *dqp, *nextdqp;
2025 int restarts;
2026 int nflushes;
2027
2028 if (howmany <= 0)
2029 return 0;
2030
2031 nreclaimed = 0;
2032 restarts = 0;
2033 nflushes = 0;
2034
2035#ifdef QUOTADEBUG
2036 cmn_err(CE_DEBUG, "Shake free 0x%x", howmany);
2037#endif
2038
2039 tryagain:
2040 xfs_qm_freelist_lock(xfs_Gqm);
2041
2042 for (dqp = xfs_Gqm->qm_dqfreelist.qh_next;
2043 ((dqp != (xfs_dquot_t *) &xfs_Gqm->qm_dqfreelist) &&
2044 nreclaimed < howmany); ) {
2045 xfs_dqlock(dqp);
2046
2047
2048
2049
2050
2051 if (dqp->dq_flags & XFS_DQ_WANT) {
2052 xfs_dqunlock(dqp);
2053 xfs_qm_freelist_unlock(xfs_Gqm);
2054 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
2055 return nreclaimed;
2056 XQM_STATS_INC(xqmstats.xs_qm_dqwants);
2057 goto tryagain;
2058 }
2059
2060
2061
2062
2063
2064
2065 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
2066 ASSERT(dqp->q_mount == NULL);
2067 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
2068 ASSERT(dqp->HL_PREVP == NULL);
2069 ASSERT(dqp->MPL_PREVP == NULL);
2070 XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
2071 nextdqp = dqp->dq_flnext;
2072 goto off_freelist;
2073 }
2074
2075 ASSERT(dqp->MPL_PREVP);
2076
2077
2078
2079
2080 if (!xfs_dqflock_nowait(dqp)) {
2081 xfs_dqunlock(dqp);
2082 dqp = dqp->dq_flnext;
2083 continue;
2084 }
2085
2086
2087
2088
2089
2090
2091
2092 if (XFS_DQ_IS_DIRTY(dqp)) {
2093 int error;
2094 xfs_dqtrace_entry(dqp, "DQSHAKE: DQDIRTY");
2095
2096
2097
2098
2099 error = xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
2100 if (error) {
2101 xfs_fs_cmn_err(CE_WARN, dqp->q_mount,
2102 "xfs_qm_dqflush_all: dquot %p flush failed", dqp);
2103 }
2104 xfs_dqunlock(dqp);
2105 dqp = dqp->dq_flnext;
2106 continue;
2107 }
2108
2109
2110
2111
2112
2113
2114
2115 if (! xfs_qm_dqhashlock_nowait(dqp)) {
2116 xfs_dqfunlock(dqp);
2117 xfs_dqunlock(dqp);
2118 dqp = dqp->dq_flnext;
2119 continue;
2120 }
2121
2122
2123
2124
2125
2126 hash = dqp->q_hash;
2127 ASSERT(hash);
2128 if (! xfs_qm_mplist_nowait(dqp->q_mount)) {
2129
2130 xfs_dqfunlock(dqp);
2131 xfs_dqunlock(dqp);
2132 XFS_DQ_HASH_UNLOCK(hash);
2133 xfs_qm_freelist_unlock(xfs_Gqm);
2134 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
2135 return nreclaimed;
2136 goto tryagain;
2137 }
2138 xfs_dqtrace_entry(dqp, "DQSHAKE: UNLINKING");
2139#ifdef QUOTADEBUG
2140 cmn_err(CE_DEBUG, "Shake 0x%p, ID 0x%x\n",
2141 dqp, be32_to_cpu(dqp->q_core.d_id));
2142#endif
2143 ASSERT(dqp->q_nrefs == 0);
2144 nextdqp = dqp->dq_flnext;
2145 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(dqp->q_mount)), dqp);
2146 XQM_HASHLIST_REMOVE(hash, dqp);
2147 xfs_dqfunlock(dqp);
2148 xfs_qm_mplist_unlock(dqp->q_mount);
2149 XFS_DQ_HASH_UNLOCK(hash);
2150
2151 off_freelist:
2152 XQM_FREELIST_REMOVE(dqp);
2153 xfs_dqunlock(dqp);
2154 nreclaimed++;
2155 XQM_STATS_INC(xqmstats.xs_qm_dqshake_reclaims);
2156 xfs_qm_dqdestroy(dqp);
2157 dqp = nextdqp;
2158 }
2159 xfs_qm_freelist_unlock(xfs_Gqm);
2160 return nreclaimed;
2161}
2162
2163
2164
2165
2166
2167
2168STATIC int
2169xfs_qm_shake(int nr_to_scan, gfp_t gfp_mask)
2170{
2171 int ndqused, nfree, n;
2172
2173 if (!kmem_shake_allow(gfp_mask))
2174 return 0;
2175 if (!xfs_Gqm)
2176 return 0;
2177
2178 nfree = xfs_Gqm->qm_dqfreelist.qh_nelems;
2179
2180 ndqused = atomic_read(&xfs_Gqm->qm_totaldquots) - nfree;
2181
2182 ASSERT(ndqused >= 0);
2183
2184 if (nfree <= ndqused && nfree < ndquot)
2185 return 0;
2186
2187 ndqused *= xfs_Gqm->qm_dqfree_ratio;
2188 n = nfree - ndqused - ndquot;
2189
2190 return xfs_qm_shake_freelist(MAX(nfree, n));
2191}
2192
2193
2194
2195
2196
2197
2198STATIC xfs_dquot_t *
2199xfs_qm_dqreclaim_one(void)
2200{
2201 xfs_dquot_t *dqpout;
2202 xfs_dquot_t *dqp;
2203 int restarts;
2204 int nflushes;
2205
2206 restarts = 0;
2207 dqpout = NULL;
2208 nflushes = 0;
2209
2210
2211 startagain:
2212 xfs_qm_freelist_lock(xfs_Gqm);
2213
2214 FOREACH_DQUOT_IN_FREELIST(dqp, &(xfs_Gqm->qm_dqfreelist)) {
2215 xfs_dqlock(dqp);
2216
2217
2218
2219
2220
2221
2222
2223 if (dqp->dq_flags & XFS_DQ_WANT) {
2224 ASSERT(! (dqp->dq_flags & XFS_DQ_INACTIVE));
2225 xfs_dqtrace_entry(dqp, "DQRECLAIM: DQWANT");
2226 xfs_dqunlock(dqp);
2227 xfs_qm_freelist_unlock(xfs_Gqm);
2228 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
2229 return NULL;
2230 XQM_STATS_INC(xqmstats.xs_qm_dqwants);
2231 goto startagain;
2232 }
2233
2234
2235
2236
2237
2238
2239 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
2240 ASSERT(dqp->q_mount == NULL);
2241 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
2242 ASSERT(dqp->HL_PREVP == NULL);
2243 ASSERT(dqp->MPL_PREVP == NULL);
2244 XQM_FREELIST_REMOVE(dqp);
2245 xfs_dqunlock(dqp);
2246 dqpout = dqp;
2247 XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
2248 break;
2249 }
2250
2251 ASSERT(dqp->q_hash);
2252 ASSERT(dqp->MPL_PREVP);
2253
2254
2255
2256
2257
2258 if (!xfs_dqflock_nowait(dqp)) {
2259 xfs_dqunlock(dqp);
2260 continue;
2261 }
2262
2263
2264
2265
2266
2267
2268
2269 if (XFS_DQ_IS_DIRTY(dqp)) {
2270 int error;
2271 xfs_dqtrace_entry(dqp, "DQRECLAIM: DQDIRTY");
2272
2273
2274
2275
2276 error = xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
2277 if (error) {
2278 xfs_fs_cmn_err(CE_WARN, dqp->q_mount,
2279 "xfs_qm_dqreclaim: dquot %p flush failed", dqp);
2280 }
2281 xfs_dqunlock(dqp);
2282 continue;
2283 }
2284
2285 if (! xfs_qm_mplist_nowait(dqp->q_mount)) {
2286 xfs_dqfunlock(dqp);
2287 xfs_dqunlock(dqp);
2288 continue;
2289 }
2290
2291 if (! xfs_qm_dqhashlock_nowait(dqp))
2292 goto mplistunlock;
2293
2294 ASSERT(dqp->q_nrefs == 0);
2295 xfs_dqtrace_entry(dqp, "DQRECLAIM: UNLINKING");
2296 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(dqp->q_mount)), dqp);
2297 XQM_HASHLIST_REMOVE(dqp->q_hash, dqp);
2298 XQM_FREELIST_REMOVE(dqp);
2299 dqpout = dqp;
2300 XFS_DQ_HASH_UNLOCK(dqp->q_hash);
2301 mplistunlock:
2302 xfs_qm_mplist_unlock(dqp->q_mount);
2303 xfs_dqfunlock(dqp);
2304 xfs_dqunlock(dqp);
2305 if (dqpout)
2306 break;
2307 }
2308
2309 xfs_qm_freelist_unlock(xfs_Gqm);
2310 return dqpout;
2311}
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323boolean_t
2324xfs_qm_dqalloc_incore(
2325 xfs_dquot_t **O_dqpp)
2326{
2327 xfs_dquot_t *dqp;
2328
2329
2330
2331
2332
2333 if (atomic_read(&xfs_Gqm->qm_totaldquots) >= ndquot) {
2334
2335
2336
2337 if ((dqp = xfs_qm_dqreclaim_one())) {
2338 XQM_STATS_INC(xqmstats.xs_qm_dqreclaims);
2339
2340
2341
2342
2343
2344 memset(&dqp->q_core, 0, sizeof(dqp->q_core));
2345 *O_dqpp = dqp;
2346 return B_FALSE;
2347 }
2348 XQM_STATS_INC(xqmstats.xs_qm_dqreclaim_misses);
2349 }
2350
2351
2352
2353
2354
2355 ASSERT(xfs_Gqm->qm_dqzone != NULL);
2356 *O_dqpp = kmem_zone_zalloc(xfs_Gqm->qm_dqzone, KM_SLEEP);
2357 atomic_inc(&xfs_Gqm->qm_totaldquots);
2358
2359 return B_TRUE;
2360}
2361
2362
2363
2364
2365
2366
2367int
2368xfs_qm_write_sb_changes(
2369 xfs_mount_t *mp,
2370 __int64_t flags)
2371{
2372 xfs_trans_t *tp;
2373 int error;
2374
2375#ifdef QUOTADEBUG
2376 cmn_err(CE_NOTE, "Writing superblock quota changes :%s", mp->m_fsname);
2377#endif
2378 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
2379 if ((error = xfs_trans_reserve(tp, 0,
2380 mp->m_sb.sb_sectsize + 128, 0,
2381 0,
2382 XFS_DEFAULT_LOG_COUNT))) {
2383 xfs_trans_cancel(tp, 0);
2384 return error;
2385 }
2386
2387 xfs_mod_sb(tp, flags);
2388 error = xfs_trans_commit(tp, 0);
2389
2390 return error;
2391}
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407int
2408xfs_qm_vop_dqalloc(
2409 xfs_mount_t *mp,
2410 xfs_inode_t *ip,
2411 uid_t uid,
2412 gid_t gid,
2413 prid_t prid,
2414 uint flags,
2415 xfs_dquot_t **O_udqpp,
2416 xfs_dquot_t **O_gdqpp)
2417{
2418 int error;
2419 xfs_dquot_t *uq, *gq;
2420 uint lockflags;
2421
2422 if (!XFS_IS_QUOTA_ON(mp))
2423 return 0;
2424
2425 lockflags = XFS_ILOCK_EXCL;
2426 xfs_ilock(ip, lockflags);
2427
2428 if ((flags & XFS_QMOPT_INHERIT) && XFS_INHERIT_GID(ip))
2429 gid = ip->i_d.di_gid;
2430
2431
2432
2433
2434
2435 if (XFS_NOT_DQATTACHED(mp, ip)) {
2436 if ((error = xfs_qm_dqattach(ip, XFS_QMOPT_DQALLOC |
2437 XFS_QMOPT_ILOCKED))) {
2438 xfs_iunlock(ip, lockflags);
2439 return error;
2440 }
2441 }
2442
2443 uq = gq = NULL;
2444 if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
2445 if (ip->i_d.di_uid != uid) {
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455 xfs_iunlock(ip, lockflags);
2456 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
2457 XFS_DQ_USER,
2458 XFS_QMOPT_DQALLOC |
2459 XFS_QMOPT_DOWARN,
2460 &uq))) {
2461 ASSERT(error != ENOENT);
2462 return error;
2463 }
2464
2465
2466
2467 xfs_dqunlock(uq);
2468 lockflags = XFS_ILOCK_SHARED;
2469 xfs_ilock(ip, lockflags);
2470 } else {
2471
2472
2473
2474
2475 ASSERT(ip->i_udquot);
2476 uq = ip->i_udquot;
2477 xfs_dqlock(uq);
2478 XFS_DQHOLD(uq);
2479 xfs_dqunlock(uq);
2480 }
2481 }
2482 if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
2483 if (ip->i_d.di_gid != gid) {
2484 xfs_iunlock(ip, lockflags);
2485 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
2486 XFS_DQ_GROUP,
2487 XFS_QMOPT_DQALLOC |
2488 XFS_QMOPT_DOWARN,
2489 &gq))) {
2490 if (uq)
2491 xfs_qm_dqrele(uq);
2492 ASSERT(error != ENOENT);
2493 return error;
2494 }
2495 xfs_dqunlock(gq);
2496 lockflags = XFS_ILOCK_SHARED;
2497 xfs_ilock(ip, lockflags);
2498 } else {
2499 ASSERT(ip->i_gdquot);
2500 gq = ip->i_gdquot;
2501 xfs_dqlock(gq);
2502 XFS_DQHOLD(gq);
2503 xfs_dqunlock(gq);
2504 }
2505 } else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
2506 if (ip->i_d.di_projid != prid) {
2507 xfs_iunlock(ip, lockflags);
2508 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
2509 XFS_DQ_PROJ,
2510 XFS_QMOPT_DQALLOC |
2511 XFS_QMOPT_DOWARN,
2512 &gq))) {
2513 if (uq)
2514 xfs_qm_dqrele(uq);
2515 ASSERT(error != ENOENT);
2516 return (error);
2517 }
2518 xfs_dqunlock(gq);
2519 lockflags = XFS_ILOCK_SHARED;
2520 xfs_ilock(ip, lockflags);
2521 } else {
2522 ASSERT(ip->i_gdquot);
2523 gq = ip->i_gdquot;
2524 xfs_dqlock(gq);
2525 XFS_DQHOLD(gq);
2526 xfs_dqunlock(gq);
2527 }
2528 }
2529 if (uq)
2530 xfs_dqtrace_entry_ino(uq, "DQALLOC", ip);
2531
2532 xfs_iunlock(ip, lockflags);
2533 if (O_udqpp)
2534 *O_udqpp = uq;
2535 else if (uq)
2536 xfs_qm_dqrele(uq);
2537 if (O_gdqpp)
2538 *O_gdqpp = gq;
2539 else if (gq)
2540 xfs_qm_dqrele(gq);
2541 return 0;
2542}
2543
2544
2545
2546
2547
2548xfs_dquot_t *
2549xfs_qm_vop_chown(
2550 xfs_trans_t *tp,
2551 xfs_inode_t *ip,
2552 xfs_dquot_t **IO_olddq,
2553 xfs_dquot_t *newdq)
2554{
2555 xfs_dquot_t *prevdq;
2556 uint bfield = XFS_IS_REALTIME_INODE(ip) ?
2557 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
2558
2559 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
2560 ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
2561
2562
2563 prevdq = *IO_olddq;
2564 ASSERT(prevdq);
2565 ASSERT(prevdq != newdq);
2566
2567 xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
2568 xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
2569
2570
2571 xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
2572 xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
2573
2574
2575
2576
2577
2578
2579 xfs_dqlock(newdq);
2580 XFS_DQHOLD(newdq);
2581 xfs_dqunlock(newdq);
2582 *IO_olddq = newdq;
2583
2584 return prevdq;
2585}
2586
2587
2588
2589
2590int
2591xfs_qm_vop_chown_reserve(
2592 xfs_trans_t *tp,
2593 xfs_inode_t *ip,
2594 xfs_dquot_t *udqp,
2595 xfs_dquot_t *gdqp,
2596 uint flags)
2597{
2598 int error;
2599 xfs_mount_t *mp;
2600 uint delblks, blkflags, prjflags = 0;
2601 xfs_dquot_t *unresudq, *unresgdq, *delblksudq, *delblksgdq;
2602
2603 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
2604 mp = ip->i_mount;
2605 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2606
2607 delblks = ip->i_delayed_blks;
2608 delblksudq = delblksgdq = unresudq = unresgdq = NULL;
2609 blkflags = XFS_IS_REALTIME_INODE(ip) ?
2610 XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
2611
2612 if (XFS_IS_UQUOTA_ON(mp) && udqp &&
2613 ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
2614 delblksudq = udqp;
2615
2616
2617
2618
2619
2620 if (delblks) {
2621 ASSERT(ip->i_udquot);
2622 unresudq = ip->i_udquot;
2623 }
2624 }
2625 if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
2626 if (XFS_IS_PQUOTA_ON(ip->i_mount) &&
2627 ip->i_d.di_projid != be32_to_cpu(gdqp->q_core.d_id))
2628 prjflags = XFS_QMOPT_ENOSPC;
2629
2630 if (prjflags ||
2631 (XFS_IS_GQUOTA_ON(ip->i_mount) &&
2632 ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
2633 delblksgdq = gdqp;
2634 if (delblks) {
2635 ASSERT(ip->i_gdquot);
2636 unresgdq = ip->i_gdquot;
2637 }
2638 }
2639 }
2640
2641 if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
2642 delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
2643 flags | blkflags | prjflags)))
2644 return (error);
2645
2646
2647
2648
2649
2650
2651
2652 if (delblks) {
2653
2654
2655
2656 ASSERT(delblksudq || delblksgdq);
2657 ASSERT(unresudq || unresgdq);
2658 if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2659 delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
2660 flags | blkflags | prjflags)))
2661 return (error);
2662 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2663 unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
2664 blkflags);
2665 }
2666
2667 return (0);
2668}
2669
2670int
2671xfs_qm_vop_rename_dqattach(
2672 xfs_inode_t **i_tab)
2673{
2674 xfs_inode_t *ip;
2675 int i;
2676 int error;
2677
2678 ip = i_tab[0];
2679
2680 if (! XFS_IS_QUOTA_ON(ip->i_mount))
2681 return 0;
2682
2683 if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
2684 error = xfs_qm_dqattach(ip, 0);
2685 if (error)
2686 return error;
2687 }
2688 for (i = 1; (i < 4 && i_tab[i]); i++) {
2689
2690
2691
2692 if ((ip = i_tab[i]) != i_tab[i-1]) {
2693 if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
2694 error = xfs_qm_dqattach(ip, 0);
2695 if (error)
2696 return error;
2697 }
2698 }
2699 }
2700 return 0;
2701}
2702
2703void
2704xfs_qm_vop_dqattach_and_dqmod_newinode(
2705 xfs_trans_t *tp,
2706 xfs_inode_t *ip,
2707 xfs_dquot_t *udqp,
2708 xfs_dquot_t *gdqp)
2709{
2710 if (!XFS_IS_QUOTA_ON(tp->t_mountp))
2711 return;
2712
2713 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
2714 ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp));
2715
2716 if (udqp) {
2717 xfs_dqlock(udqp);
2718 XFS_DQHOLD(udqp);
2719 xfs_dqunlock(udqp);
2720 ASSERT(ip->i_udquot == NULL);
2721 ip->i_udquot = udqp;
2722 ASSERT(XFS_IS_UQUOTA_ON(tp->t_mountp));
2723 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
2724 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
2725 }
2726 if (gdqp) {
2727 xfs_dqlock(gdqp);
2728 XFS_DQHOLD(gdqp);
2729 xfs_dqunlock(gdqp);
2730 ASSERT(ip->i_gdquot == NULL);
2731 ip->i_gdquot = gdqp;
2732 ASSERT(XFS_IS_OQUOTA_ON(tp->t_mountp));
2733 ASSERT((XFS_IS_GQUOTA_ON(tp->t_mountp) ?
2734 ip->i_d.di_gid : ip->i_d.di_projid) ==
2735 be32_to_cpu(gdqp->q_core.d_id));
2736 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
2737 }
2738}
2739
2740
2741STATIC void
2742xfs_qm_freelist_init(xfs_frlist_t *ql)
2743{
2744 ql->qh_next = ql->qh_prev = (xfs_dquot_t *) ql;
2745 mutex_init(&ql->qh_lock);
2746 ql->qh_version = 0;
2747 ql->qh_nelems = 0;
2748}
2749
2750STATIC void
2751xfs_qm_freelist_destroy(xfs_frlist_t *ql)
2752{
2753 xfs_dquot_t *dqp, *nextdqp;
2754
2755 mutex_lock(&ql->qh_lock);
2756 for (dqp = ql->qh_next;
2757 dqp != (xfs_dquot_t *)ql; ) {
2758 xfs_dqlock(dqp);
2759 nextdqp = dqp->dq_flnext;
2760#ifdef QUOTADEBUG
2761 cmn_err(CE_DEBUG, "FREELIST destroy 0x%p", dqp);
2762#endif
2763 XQM_FREELIST_REMOVE(dqp);
2764 xfs_dqunlock(dqp);
2765 xfs_qm_dqdestroy(dqp);
2766 dqp = nextdqp;
2767 }
2768 mutex_unlock(&ql->qh_lock);
2769 mutex_destroy(&ql->qh_lock);
2770
2771 ASSERT(ql->qh_nelems == 0);
2772}
2773
2774STATIC void
2775xfs_qm_freelist_insert(xfs_frlist_t *ql, xfs_dquot_t *dq)
2776{
2777 dq->dq_flnext = ql->qh_next;
2778 dq->dq_flprev = (xfs_dquot_t *)ql;
2779 ql->qh_next = dq;
2780 dq->dq_flnext->dq_flprev = dq;
2781 xfs_Gqm->qm_dqfreelist.qh_nelems++;
2782 xfs_Gqm->qm_dqfreelist.qh_version++;
2783}
2784
2785void
2786xfs_qm_freelist_unlink(xfs_dquot_t *dq)
2787{
2788 xfs_dquot_t *next = dq->dq_flnext;
2789 xfs_dquot_t *prev = dq->dq_flprev;
2790
2791 next->dq_flprev = prev;
2792 prev->dq_flnext = next;
2793 dq->dq_flnext = dq->dq_flprev = dq;
2794 xfs_Gqm->qm_dqfreelist.qh_nelems--;
2795 xfs_Gqm->qm_dqfreelist.qh_version++;
2796}
2797
2798void
2799xfs_qm_freelist_append(xfs_frlist_t *ql, xfs_dquot_t *dq)
2800{
2801 xfs_qm_freelist_insert((xfs_frlist_t *)ql->qh_prev, dq);
2802}
2803
2804STATIC int
2805xfs_qm_dqhashlock_nowait(
2806 xfs_dquot_t *dqp)
2807{
2808 int locked;
2809
2810 locked = mutex_trylock(&((dqp)->q_hash->qh_lock));
2811 return locked;
2812}
2813
2814int
2815xfs_qm_freelist_lock_nowait(
2816 xfs_qm_t *xqm)
2817{
2818 int locked;
2819
2820 locked = mutex_trylock(&(xqm->qm_dqfreelist.qh_lock));
2821 return locked;
2822}
2823
2824STATIC int
2825xfs_qm_mplist_nowait(
2826 xfs_mount_t *mp)
2827{
2828 int locked;
2829
2830 ASSERT(mp->m_quotainfo);
2831 locked = mutex_trylock(&(XFS_QI_MPLLOCK(mp)));
2832 return locked;
2833}