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_format.h"
21#include "xfs_bit.h"
22#include "xfs_log.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_qm.h"
42#include "xfs_trace.h"
43#include "xfs_icache.h"
44#include "xfs_cksum.h"
45
46
47
48
49
50
51
52STATIC int xfs_qm_init_quotainos(xfs_mount_t *);
53STATIC int xfs_qm_init_quotainfo(xfs_mount_t *);
54
55
56STATIC void xfs_qm_dqfree_one(struct xfs_dquot *dqp);
57
58
59
60
61
62
63
64#define XFS_DQ_LOOKUP_BATCH 32
65
66STATIC int
67xfs_qm_dquot_walk(
68 struct xfs_mount *mp,
69 int type,
70 int (*execute)(struct xfs_dquot *dqp, void *data),
71 void *data)
72{
73 struct xfs_quotainfo *qi = mp->m_quotainfo;
74 struct radix_tree_root *tree = xfs_dquot_tree(qi, type);
75 uint32_t next_index;
76 int last_error = 0;
77 int skipped;
78 int nr_found;
79
80restart:
81 skipped = 0;
82 next_index = 0;
83 nr_found = 0;
84
85 while (1) {
86 struct xfs_dquot *batch[XFS_DQ_LOOKUP_BATCH];
87 int error = 0;
88 int i;
89
90 mutex_lock(&qi->qi_tree_lock);
91 nr_found = radix_tree_gang_lookup(tree, (void **)batch,
92 next_index, XFS_DQ_LOOKUP_BATCH);
93 if (!nr_found) {
94 mutex_unlock(&qi->qi_tree_lock);
95 break;
96 }
97
98 for (i = 0; i < nr_found; i++) {
99 struct xfs_dquot *dqp = batch[i];
100
101 next_index = be32_to_cpu(dqp->q_core.d_id) + 1;
102
103 error = execute(batch[i], data);
104 if (error == EAGAIN) {
105 skipped++;
106 continue;
107 }
108 if (error && last_error != EFSCORRUPTED)
109 last_error = error;
110 }
111
112 mutex_unlock(&qi->qi_tree_lock);
113
114
115 if (last_error == EFSCORRUPTED) {
116 skipped = 0;
117 break;
118 }
119 }
120
121 if (skipped) {
122 delay(1);
123 goto restart;
124 }
125
126 return last_error;
127}
128
129
130
131
132
133STATIC int
134xfs_qm_dqpurge(
135 struct xfs_dquot *dqp,
136 void *data)
137{
138 struct xfs_mount *mp = dqp->q_mount;
139 struct xfs_quotainfo *qi = mp->m_quotainfo;
140 struct xfs_dquot *gdqp = NULL;
141 struct xfs_dquot *pdqp = NULL;
142
143 xfs_dqlock(dqp);
144 if ((dqp->dq_flags & XFS_DQ_FREEING) || dqp->q_nrefs != 0) {
145 xfs_dqunlock(dqp);
146 return EAGAIN;
147 }
148
149
150
151
152 gdqp = dqp->q_gdquot;
153 if (gdqp) {
154 xfs_dqlock(gdqp);
155 dqp->q_gdquot = NULL;
156 }
157
158 pdqp = dqp->q_pdquot;
159 if (pdqp) {
160 xfs_dqlock(pdqp);
161 dqp->q_pdquot = NULL;
162 }
163
164 dqp->dq_flags |= XFS_DQ_FREEING;
165
166 xfs_dqflock(dqp);
167
168
169
170
171
172
173 if (XFS_DQ_IS_DIRTY(dqp)) {
174 struct xfs_buf *bp = NULL;
175 int error;
176
177
178
179
180
181 error = xfs_qm_dqflush(dqp, &bp);
182 if (error) {
183 xfs_warn(mp, "%s: dquot %p flush failed",
184 __func__, dqp);
185 } else {
186 error = xfs_bwrite(bp);
187 xfs_buf_relse(bp);
188 }
189 xfs_dqflock(dqp);
190 }
191
192 ASSERT(atomic_read(&dqp->q_pincount) == 0);
193 ASSERT(XFS_FORCED_SHUTDOWN(mp) ||
194 !(dqp->q_logitem.qli_item.li_flags & XFS_LI_IN_AIL));
195
196 xfs_dqfunlock(dqp);
197 xfs_dqunlock(dqp);
198
199 radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
200 be32_to_cpu(dqp->q_core.d_id));
201 qi->qi_dquots--;
202
203
204
205
206
207 ASSERT(!list_empty(&dqp->q_lru));
208 list_lru_del(&qi->qi_lru, &dqp->q_lru);
209 XFS_STATS_DEC(xs_qm_dquot_unused);
210
211 xfs_qm_dqdestroy(dqp);
212
213 if (gdqp)
214 xfs_qm_dqput(gdqp);
215 if (pdqp)
216 xfs_qm_dqput(pdqp);
217 return 0;
218}
219
220
221
222
223void
224xfs_qm_dqpurge_all(
225 struct xfs_mount *mp,
226 uint flags)
227{
228 if (flags & XFS_QMOPT_UQUOTA)
229 xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_dqpurge, NULL);
230 if (flags & XFS_QMOPT_GQUOTA)
231 xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_dqpurge, NULL);
232 if (flags & XFS_QMOPT_PQUOTA)
233 xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_dqpurge, NULL);
234}
235
236
237
238
239void
240xfs_qm_unmount(
241 struct xfs_mount *mp)
242{
243 if (mp->m_quotainfo) {
244 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
245 xfs_qm_destroy_quotainfo(mp);
246 }
247}
248
249
250
251
252
253
254
255
256
257
258
259void
260xfs_qm_mount_quotas(
261 xfs_mount_t *mp)
262{
263 int error = 0;
264 uint sbf;
265
266
267
268
269
270 if (mp->m_sb.sb_rextents) {
271 xfs_notice(mp, "Cannot turn on quotas for realtime filesystem");
272 mp->m_qflags = 0;
273 goto write_changes;
274 }
275
276 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
277
278
279
280
281
282 error = xfs_qm_init_quotainfo(mp);
283 if (error) {
284
285
286
287 ASSERT(mp->m_quotainfo == NULL);
288 mp->m_qflags = 0;
289 goto write_changes;
290 }
291
292
293
294 if (XFS_QM_NEED_QUOTACHECK(mp)) {
295 error = xfs_qm_quotacheck(mp);
296 if (error) {
297
298 return;
299 }
300 }
301
302
303
304
305
306 if (!XFS_IS_UQUOTA_ON(mp))
307 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
308 if (!XFS_IS_GQUOTA_ON(mp))
309 mp->m_qflags &= ~XFS_GQUOTA_CHKD;
310 if (!XFS_IS_PQUOTA_ON(mp))
311 mp->m_qflags &= ~XFS_PQUOTA_CHKD;
312
313 write_changes:
314
315
316
317
318 spin_lock(&mp->m_sb_lock);
319 sbf = mp->m_sb.sb_qflags;
320 mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
321 spin_unlock(&mp->m_sb_lock);
322
323 if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
324 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
325
326
327
328
329
330
331 ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
332 xfs_alert(mp, "%s: Superblock update failed!",
333 __func__);
334 }
335 }
336
337 if (error) {
338 xfs_warn(mp, "Failed to initialize disk quotas.");
339 return;
340 }
341}
342
343
344
345
346void
347xfs_qm_unmount_quotas(
348 xfs_mount_t *mp)
349{
350
351
352
353
354 ASSERT(mp->m_rootip);
355 xfs_qm_dqdetach(mp->m_rootip);
356 if (mp->m_rbmip)
357 xfs_qm_dqdetach(mp->m_rbmip);
358 if (mp->m_rsumip)
359 xfs_qm_dqdetach(mp->m_rsumip);
360
361
362
363
364 if (mp->m_quotainfo) {
365 if (mp->m_quotainfo->qi_uquotaip) {
366 IRELE(mp->m_quotainfo->qi_uquotaip);
367 mp->m_quotainfo->qi_uquotaip = NULL;
368 }
369 if (mp->m_quotainfo->qi_gquotaip) {
370 IRELE(mp->m_quotainfo->qi_gquotaip);
371 mp->m_quotainfo->qi_gquotaip = NULL;
372 }
373 if (mp->m_quotainfo->qi_pquotaip) {
374 IRELE(mp->m_quotainfo->qi_pquotaip);
375 mp->m_quotainfo->qi_pquotaip = NULL;
376 }
377 }
378}
379
380STATIC int
381xfs_qm_dqattach_one(
382 xfs_inode_t *ip,
383 xfs_dqid_t id,
384 uint type,
385 uint doalloc,
386 xfs_dquot_t *udqhint,
387 xfs_dquot_t **IO_idqpp)
388{
389 xfs_dquot_t *dqp;
390 int error;
391
392 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
393 error = 0;
394
395
396
397
398
399
400 dqp = *IO_idqpp;
401 if (dqp) {
402 trace_xfs_dqattach_found(dqp);
403 return 0;
404 }
405
406
407
408
409
410
411
412 if (udqhint) {
413 ASSERT(type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
414 xfs_dqlock(udqhint);
415
416
417
418
419
420
421
422
423 if (type == XFS_DQ_GROUP)
424 dqp = udqhint->q_gdquot;
425 else
426 dqp = udqhint->q_pdquot;
427 if (dqp && be32_to_cpu(dqp->q_core.d_id) == id) {
428 ASSERT(*IO_idqpp == NULL);
429
430 *IO_idqpp = xfs_qm_dqhold(dqp);
431 xfs_dqunlock(udqhint);
432 return 0;
433 }
434
435
436
437
438
439
440
441 xfs_dqunlock(udqhint);
442 }
443
444
445
446
447
448
449
450
451 error = xfs_qm_dqget(ip->i_mount, ip, id, type,
452 doalloc | XFS_QMOPT_DOWARN, &dqp);
453 if (error)
454 return error;
455
456 trace_xfs_dqattach_get(dqp);
457
458
459
460
461
462 *IO_idqpp = dqp;
463 xfs_dqunlock(dqp);
464 return 0;
465}
466
467
468
469
470
471
472STATIC void
473xfs_qm_dqattach_hint(
474 struct xfs_inode *ip,
475 int type)
476{
477 struct xfs_dquot **dqhintp;
478 struct xfs_dquot *dqp;
479 struct xfs_dquot *udq = ip->i_udquot;
480
481 ASSERT(type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
482
483 xfs_dqlock(udq);
484
485 if (type == XFS_DQ_GROUP) {
486 dqp = ip->i_gdquot;
487 dqhintp = &udq->q_gdquot;
488 } else {
489 dqp = ip->i_pdquot;
490 dqhintp = &udq->q_pdquot;
491 }
492
493 if (*dqhintp) {
494 struct xfs_dquot *tmp;
495
496 if (*dqhintp == dqp)
497 goto done;
498
499 tmp = *dqhintp;
500 *dqhintp = NULL;
501 xfs_qm_dqrele(tmp);
502 }
503
504 *dqhintp = xfs_qm_dqhold(dqp);
505done:
506 xfs_dqunlock(udq);
507}
508
509static bool
510xfs_qm_need_dqattach(
511 struct xfs_inode *ip)
512{
513 struct xfs_mount *mp = ip->i_mount;
514
515 if (!XFS_IS_QUOTA_RUNNING(mp))
516 return false;
517 if (!XFS_IS_QUOTA_ON(mp))
518 return false;
519 if (!XFS_NOT_DQATTACHED(mp, ip))
520 return false;
521 if (xfs_is_quota_inode(&mp->m_sb, ip->i_ino))
522 return false;
523 return true;
524}
525
526
527
528
529
530
531
532
533int
534xfs_qm_dqattach_locked(
535 xfs_inode_t *ip,
536 uint flags)
537{
538 xfs_mount_t *mp = ip->i_mount;
539 uint nquotas = 0;
540 int error = 0;
541
542 if (!xfs_qm_need_dqattach(ip))
543 return 0;
544
545 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
546
547 if (XFS_IS_UQUOTA_ON(mp)) {
548 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
549 flags & XFS_QMOPT_DQALLOC,
550 NULL, &ip->i_udquot);
551 if (error)
552 goto done;
553 nquotas++;
554 }
555
556 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
557 if (XFS_IS_GQUOTA_ON(mp)) {
558 error = xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
559 flags & XFS_QMOPT_DQALLOC,
560 ip->i_udquot, &ip->i_gdquot);
561
562
563
564
565 if (error)
566 goto done;
567 nquotas++;
568 }
569
570 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
571 if (XFS_IS_PQUOTA_ON(mp)) {
572 error = xfs_qm_dqattach_one(ip, xfs_get_projid(ip), XFS_DQ_PROJ,
573 flags & XFS_QMOPT_DQALLOC,
574 ip->i_udquot, &ip->i_pdquot);
575
576
577
578
579 if (error)
580 goto done;
581 nquotas++;
582 }
583
584
585
586
587
588 if (nquotas > 1 && ip->i_udquot) {
589 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
590 ASSERT(ip->i_gdquot || !XFS_IS_GQUOTA_ON(mp));
591 ASSERT(ip->i_pdquot || !XFS_IS_PQUOTA_ON(mp));
592
593
594
595
596
597
598
599 if (ip->i_udquot->q_gdquot != ip->i_gdquot)
600 xfs_qm_dqattach_hint(ip, XFS_DQ_GROUP);
601
602 if (ip->i_udquot->q_pdquot != ip->i_pdquot)
603 xfs_qm_dqattach_hint(ip, XFS_DQ_PROJ);
604 }
605
606 done:
607#ifdef DEBUG
608 if (!error) {
609 if (XFS_IS_UQUOTA_ON(mp))
610 ASSERT(ip->i_udquot);
611 if (XFS_IS_GQUOTA_ON(mp))
612 ASSERT(ip->i_gdquot);
613 if (XFS_IS_PQUOTA_ON(mp))
614 ASSERT(ip->i_pdquot);
615 }
616 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
617#endif
618 return error;
619}
620
621int
622xfs_qm_dqattach(
623 struct xfs_inode *ip,
624 uint flags)
625{
626 int error;
627
628 if (!xfs_qm_need_dqattach(ip))
629 return 0;
630
631 xfs_ilock(ip, XFS_ILOCK_EXCL);
632 error = xfs_qm_dqattach_locked(ip, flags);
633 xfs_iunlock(ip, XFS_ILOCK_EXCL);
634
635 return error;
636}
637
638
639
640
641
642
643void
644xfs_qm_dqdetach(
645 xfs_inode_t *ip)
646{
647 if (!(ip->i_udquot || ip->i_gdquot || ip->i_pdquot))
648 return;
649
650 trace_xfs_dquot_dqdetach(ip);
651
652 ASSERT(!xfs_is_quota_inode(&ip->i_mount->m_sb, ip->i_ino));
653 if (ip->i_udquot) {
654 xfs_qm_dqrele(ip->i_udquot);
655 ip->i_udquot = NULL;
656 }
657 if (ip->i_gdquot) {
658 xfs_qm_dqrele(ip->i_gdquot);
659 ip->i_gdquot = NULL;
660 }
661 if (ip->i_pdquot) {
662 xfs_qm_dqrele(ip->i_pdquot);
663 ip->i_pdquot = NULL;
664 }
665}
666
667int
668xfs_qm_calc_dquots_per_chunk(
669 struct xfs_mount *mp,
670 unsigned int nbblks)
671{
672 unsigned int ndquots;
673
674 ASSERT(nbblks > 0);
675 ndquots = BBTOB(nbblks);
676 do_div(ndquots, sizeof(xfs_dqblk_t));
677
678 return ndquots;
679}
680
681struct xfs_qm_isolate {
682 struct list_head buffers;
683 struct list_head dispose;
684};
685
686static enum lru_status
687xfs_qm_dquot_isolate(
688 struct list_head *item,
689 spinlock_t *lru_lock,
690 void *arg)
691{
692 struct xfs_dquot *dqp = container_of(item,
693 struct xfs_dquot, q_lru);
694 struct xfs_qm_isolate *isol = arg;
695
696 if (!xfs_dqlock_nowait(dqp))
697 goto out_miss_busy;
698
699
700
701
702
703 if (dqp->q_nrefs) {
704 xfs_dqunlock(dqp);
705 XFS_STATS_INC(xs_qm_dqwants);
706
707 trace_xfs_dqreclaim_want(dqp);
708 list_del_init(&dqp->q_lru);
709 XFS_STATS_DEC(xs_qm_dquot_unused);
710 return LRU_REMOVED;
711 }
712
713
714
715
716
717
718 if (!xfs_dqflock_nowait(dqp)) {
719 xfs_dqunlock(dqp);
720 goto out_miss_busy;
721 }
722
723 if (XFS_DQ_IS_DIRTY(dqp)) {
724 struct xfs_buf *bp = NULL;
725 int error;
726
727 trace_xfs_dqreclaim_dirty(dqp);
728
729
730 spin_unlock(lru_lock);
731
732 error = xfs_qm_dqflush(dqp, &bp);
733 if (error) {
734 xfs_warn(dqp->q_mount, "%s: dquot %p flush failed",
735 __func__, dqp);
736 goto out_unlock_dirty;
737 }
738
739 xfs_buf_delwri_queue(bp, &isol->buffers);
740 xfs_buf_relse(bp);
741 goto out_unlock_dirty;
742 }
743 xfs_dqfunlock(dqp);
744
745
746
747
748 dqp->dq_flags |= XFS_DQ_FREEING;
749 xfs_dqunlock(dqp);
750
751 ASSERT(dqp->q_nrefs == 0);
752 list_move_tail(&dqp->q_lru, &isol->dispose);
753 XFS_STATS_DEC(xs_qm_dquot_unused);
754 trace_xfs_dqreclaim_done(dqp);
755 XFS_STATS_INC(xs_qm_dqreclaims);
756 return LRU_REMOVED;
757
758out_miss_busy:
759 trace_xfs_dqreclaim_busy(dqp);
760 XFS_STATS_INC(xs_qm_dqreclaim_misses);
761 return LRU_SKIP;
762
763out_unlock_dirty:
764 trace_xfs_dqreclaim_busy(dqp);
765 XFS_STATS_INC(xs_qm_dqreclaim_misses);
766 xfs_dqunlock(dqp);
767 spin_lock(lru_lock);
768 return LRU_RETRY;
769}
770
771static unsigned long
772xfs_qm_shrink_scan(
773 struct shrinker *shrink,
774 struct shrink_control *sc)
775{
776 struct xfs_quotainfo *qi = container_of(shrink,
777 struct xfs_quotainfo, qi_shrinker);
778 struct xfs_qm_isolate isol;
779 unsigned long freed;
780 int error;
781 unsigned long nr_to_scan = sc->nr_to_scan;
782
783 if ((sc->gfp_mask & (__GFP_FS|__GFP_WAIT)) != (__GFP_FS|__GFP_WAIT))
784 return 0;
785
786 INIT_LIST_HEAD(&isol.buffers);
787 INIT_LIST_HEAD(&isol.dispose);
788
789 freed = list_lru_walk_node(&qi->qi_lru, sc->nid, xfs_qm_dquot_isolate, &isol,
790 &nr_to_scan);
791
792 error = xfs_buf_delwri_submit(&isol.buffers);
793 if (error)
794 xfs_warn(NULL, "%s: dquot reclaim failed", __func__);
795
796 while (!list_empty(&isol.dispose)) {
797 struct xfs_dquot *dqp;
798
799 dqp = list_first_entry(&isol.dispose, struct xfs_dquot, q_lru);
800 list_del_init(&dqp->q_lru);
801 xfs_qm_dqfree_one(dqp);
802 }
803
804 return freed;
805}
806
807static unsigned long
808xfs_qm_shrink_count(
809 struct shrinker *shrink,
810 struct shrink_control *sc)
811{
812 struct xfs_quotainfo *qi = container_of(shrink,
813 struct xfs_quotainfo, qi_shrinker);
814
815 return list_lru_count_node(&qi->qi_lru, sc->nid);
816}
817
818
819
820
821
822STATIC int
823xfs_qm_init_quotainfo(
824 xfs_mount_t *mp)
825{
826 xfs_quotainfo_t *qinf;
827 int error;
828 xfs_dquot_t *dqp;
829
830 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
831
832 qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
833
834 if ((error = list_lru_init(&qinf->qi_lru))) {
835 kmem_free(qinf);
836 mp->m_quotainfo = NULL;
837 return error;
838 }
839
840
841
842
843
844 if ((error = xfs_qm_init_quotainos(mp))) {
845 list_lru_destroy(&qinf->qi_lru);
846 kmem_free(qinf);
847 mp->m_quotainfo = NULL;
848 return error;
849 }
850
851 INIT_RADIX_TREE(&qinf->qi_uquota_tree, GFP_NOFS);
852 INIT_RADIX_TREE(&qinf->qi_gquota_tree, GFP_NOFS);
853 INIT_RADIX_TREE(&qinf->qi_pquota_tree, GFP_NOFS);
854 mutex_init(&qinf->qi_tree_lock);
855
856
857 mutex_init(&qinf->qi_quotaofflock);
858
859
860 qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
861 qinf->qi_dqperchunk = xfs_qm_calc_dquots_per_chunk(mp,
862 qinf->qi_dqchunklen);
863
864 mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
865
866
867
868
869
870
871
872
873
874
875
876
877
878 error = xfs_qm_dqread(mp, 0,
879 XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
880 (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
881 XFS_DQ_PROJ),
882 XFS_QMOPT_DOWARN, &dqp);
883 if (!error) {
884 xfs_disk_dquot_t *ddqp = &dqp->q_core;
885
886
887
888
889
890
891 qinf->qi_btimelimit = ddqp->d_btimer ?
892 be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;
893 qinf->qi_itimelimit = ddqp->d_itimer ?
894 be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;
895 qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?
896 be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;
897 qinf->qi_bwarnlimit = ddqp->d_bwarns ?
898 be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;
899 qinf->qi_iwarnlimit = ddqp->d_iwarns ?
900 be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
901 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
902 be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
903 qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
904 qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
905 qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
906 qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
907 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
908 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
909
910 xfs_qm_dqdestroy(dqp);
911 } else {
912 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
913 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
914 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
915 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
916 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
917 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
918 }
919
920 qinf->qi_shrinker.count_objects = xfs_qm_shrink_count;
921 qinf->qi_shrinker.scan_objects = xfs_qm_shrink_scan;
922 qinf->qi_shrinker.seeks = DEFAULT_SEEKS;
923 qinf->qi_shrinker.flags = SHRINKER_NUMA_AWARE;
924 register_shrinker(&qinf->qi_shrinker);
925 return 0;
926}
927
928
929
930
931
932
933
934void
935xfs_qm_destroy_quotainfo(
936 xfs_mount_t *mp)
937{
938 xfs_quotainfo_t *qi;
939
940 qi = mp->m_quotainfo;
941 ASSERT(qi != NULL);
942
943 unregister_shrinker(&qi->qi_shrinker);
944 list_lru_destroy(&qi->qi_lru);
945
946 if (qi->qi_uquotaip) {
947 IRELE(qi->qi_uquotaip);
948 qi->qi_uquotaip = NULL;
949 }
950 if (qi->qi_gquotaip) {
951 IRELE(qi->qi_gquotaip);
952 qi->qi_gquotaip = NULL;
953 }
954 if (qi->qi_pquotaip) {
955 IRELE(qi->qi_pquotaip);
956 qi->qi_pquotaip = NULL;
957 }
958 mutex_destroy(&qi->qi_quotaofflock);
959 kmem_free(qi);
960 mp->m_quotainfo = NULL;
961}
962
963
964
965
966
967STATIC int
968xfs_qm_qino_alloc(
969 xfs_mount_t *mp,
970 xfs_inode_t **ip,
971 __int64_t sbfields,
972 uint flags)
973{
974 xfs_trans_t *tp;
975 int error;
976 int committed;
977
978 *ip = NULL;
979
980
981
982
983
984
985
986 if (!xfs_sb_version_has_pquotino(&mp->m_sb) &&
987 (flags & (XFS_QMOPT_PQUOTA|XFS_QMOPT_GQUOTA))) {
988 xfs_ino_t ino = NULLFSINO;
989
990 if ((flags & XFS_QMOPT_PQUOTA) &&
991 (mp->m_sb.sb_gquotino != NULLFSINO)) {
992 ino = mp->m_sb.sb_gquotino;
993 ASSERT(mp->m_sb.sb_pquotino == NULLFSINO);
994 } else if ((flags & XFS_QMOPT_GQUOTA) &&
995 (mp->m_sb.sb_pquotino != NULLFSINO)) {
996 ino = mp->m_sb.sb_pquotino;
997 ASSERT(mp->m_sb.sb_gquotino == NULLFSINO);
998 }
999 if (ino != NULLFSINO) {
1000 error = xfs_iget(mp, NULL, ino, 0, 0, ip);
1001 if (error)
1002 return error;
1003 mp->m_sb.sb_gquotino = NULLFSINO;
1004 mp->m_sb.sb_pquotino = NULLFSINO;
1005 }
1006 }
1007
1008 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
1009 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_create,
1010 XFS_QM_QINOCREATE_SPACE_RES(mp), 0);
1011 if (error) {
1012 xfs_trans_cancel(tp, 0);
1013 return error;
1014 }
1015
1016 if (!*ip) {
1017 error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0, 0, 1, ip,
1018 &committed);
1019 if (error) {
1020 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
1021 XFS_TRANS_ABORT);
1022 return error;
1023 }
1024 }
1025
1026
1027
1028
1029
1030
1031 spin_lock(&mp->m_sb_lock);
1032 if (flags & XFS_QMOPT_SBVERSION) {
1033 ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
1034 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1035 XFS_SB_GQUOTINO | XFS_SB_PQUOTINO | XFS_SB_QFLAGS)) ==
1036 (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1037 XFS_SB_GQUOTINO | XFS_SB_PQUOTINO |
1038 XFS_SB_QFLAGS));
1039
1040 xfs_sb_version_addquota(&mp->m_sb);
1041 mp->m_sb.sb_uquotino = NULLFSINO;
1042 mp->m_sb.sb_gquotino = NULLFSINO;
1043 mp->m_sb.sb_pquotino = NULLFSINO;
1044
1045
1046 mp->m_sb.sb_qflags = mp->m_qflags & XFS_ALL_QUOTA_ACCT;
1047 }
1048 if (flags & XFS_QMOPT_UQUOTA)
1049 mp->m_sb.sb_uquotino = (*ip)->i_ino;
1050 else if (flags & XFS_QMOPT_GQUOTA)
1051 mp->m_sb.sb_gquotino = (*ip)->i_ino;
1052 else
1053 mp->m_sb.sb_pquotino = (*ip)->i_ino;
1054 spin_unlock(&mp->m_sb_lock);
1055 xfs_mod_sb(tp, sbfields);
1056
1057 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) {
1058 xfs_alert(mp, "%s failed (error %d)!", __func__, error);
1059 return error;
1060 }
1061 return 0;
1062}
1063
1064
1065STATIC void
1066xfs_qm_reset_dqcounts(
1067 xfs_mount_t *mp,
1068 xfs_buf_t *bp,
1069 xfs_dqid_t id,
1070 uint type)
1071{
1072 struct xfs_dqblk *dqb;
1073 int j;
1074
1075 trace_xfs_reset_dqcounts(bp, _RET_IP_);
1076
1077
1078
1079
1080
1081#ifdef DEBUG
1082 j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1083 do_div(j, sizeof(xfs_dqblk_t));
1084 ASSERT(mp->m_quotainfo->qi_dqperchunk == j);
1085#endif
1086 dqb = bp->b_addr;
1087 for (j = 0; j < mp->m_quotainfo->qi_dqperchunk; j++) {
1088 struct xfs_disk_dquot *ddq;
1089
1090 ddq = (struct xfs_disk_dquot *)&dqb[j];
1091
1092
1093
1094
1095
1096
1097 (void) xfs_qm_dqcheck(mp, ddq, id+j, type, XFS_QMOPT_DQREPAIR,
1098 "xfs_quotacheck");
1099 ddq->d_bcount = 0;
1100 ddq->d_icount = 0;
1101 ddq->d_rtbcount = 0;
1102 ddq->d_btimer = 0;
1103 ddq->d_itimer = 0;
1104 ddq->d_rtbtimer = 0;
1105 ddq->d_bwarns = 0;
1106 ddq->d_iwarns = 0;
1107 ddq->d_rtbwarns = 0;
1108
1109 if (xfs_sb_version_hascrc(&mp->m_sb)) {
1110 xfs_update_cksum((char *)&dqb[j],
1111 sizeof(struct xfs_dqblk),
1112 XFS_DQUOT_CRC_OFF);
1113 }
1114 }
1115}
1116
1117STATIC int
1118xfs_qm_dqiter_bufs(
1119 struct xfs_mount *mp,
1120 xfs_dqid_t firstid,
1121 xfs_fsblock_t bno,
1122 xfs_filblks_t blkcnt,
1123 uint flags,
1124 struct list_head *buffer_list)
1125{
1126 struct xfs_buf *bp;
1127 int error;
1128 int type;
1129
1130 ASSERT(blkcnt > 0);
1131 type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
1132 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
1133 error = 0;
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144 while (blkcnt--) {
1145 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1146 XFS_FSB_TO_DADDR(mp, bno),
1147 mp->m_quotainfo->qi_dqchunklen, 0, &bp,
1148 &xfs_dquot_buf_ops);
1149
1150
1151
1152
1153
1154
1155
1156
1157 if (error == EFSCORRUPTED) {
1158 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1159 XFS_FSB_TO_DADDR(mp, bno),
1160 mp->m_quotainfo->qi_dqchunklen, 0, &bp,
1161 NULL);
1162 }
1163
1164 if (error)
1165 break;
1166
1167 xfs_qm_reset_dqcounts(mp, bp, firstid, type);
1168 xfs_buf_delwri_queue(bp, buffer_list);
1169 xfs_buf_relse(bp);
1170
1171
1172 bno++;
1173 firstid += mp->m_quotainfo->qi_dqperchunk;
1174 }
1175
1176 return error;
1177}
1178
1179
1180
1181
1182
1183STATIC int
1184xfs_qm_dqiterate(
1185 struct xfs_mount *mp,
1186 struct xfs_inode *qip,
1187 uint flags,
1188 struct list_head *buffer_list)
1189{
1190 struct xfs_bmbt_irec *map;
1191 int i, nmaps;
1192 int error;
1193 xfs_fileoff_t lblkno;
1194 xfs_filblks_t maxlblkcnt;
1195 xfs_dqid_t firstid;
1196 xfs_fsblock_t rablkno;
1197 xfs_filblks_t rablkcnt;
1198
1199 error = 0;
1200
1201
1202
1203
1204
1205 if (qip->i_d.di_nblocks == 0)
1206 return 0;
1207
1208 map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
1209
1210 lblkno = 0;
1211 maxlblkcnt = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
1212 do {
1213 nmaps = XFS_DQITER_MAP_SIZE;
1214
1215
1216
1217
1218
1219 xfs_ilock(qip, XFS_ILOCK_SHARED);
1220 error = xfs_bmapi_read(qip, lblkno, maxlblkcnt - lblkno,
1221 map, &nmaps, 0);
1222 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1223 if (error)
1224 break;
1225
1226 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
1227 for (i = 0; i < nmaps; i++) {
1228 ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
1229 ASSERT(map[i].br_blockcount);
1230
1231
1232 lblkno += map[i].br_blockcount;
1233
1234 if (map[i].br_startblock == HOLESTARTBLOCK)
1235 continue;
1236
1237 firstid = (xfs_dqid_t) map[i].br_startoff *
1238 mp->m_quotainfo->qi_dqperchunk;
1239
1240
1241
1242 if ((i+1 < nmaps) &&
1243 (map[i+1].br_startblock != HOLESTARTBLOCK)) {
1244 rablkcnt = map[i+1].br_blockcount;
1245 rablkno = map[i+1].br_startblock;
1246 while (rablkcnt--) {
1247 xfs_buf_readahead(mp->m_ddev_targp,
1248 XFS_FSB_TO_DADDR(mp, rablkno),
1249 mp->m_quotainfo->qi_dqchunklen,
1250 NULL);
1251 rablkno++;
1252 }
1253 }
1254
1255
1256
1257
1258 error = xfs_qm_dqiter_bufs(mp, firstid,
1259 map[i].br_startblock,
1260 map[i].br_blockcount,
1261 flags, buffer_list);
1262 if (error)
1263 goto out;
1264 }
1265 } while (nmaps > 0);
1266
1267out:
1268 kmem_free(map);
1269 return error;
1270}
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280STATIC int
1281xfs_qm_quotacheck_dqadjust(
1282 struct xfs_inode *ip,
1283 xfs_dqid_t id,
1284 uint type,
1285 xfs_qcnt_t nblks,
1286 xfs_qcnt_t rtblks)
1287{
1288 struct xfs_mount *mp = ip->i_mount;
1289 struct xfs_dquot *dqp;
1290 int error;
1291
1292 error = xfs_qm_dqget(mp, ip, id, type,
1293 XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN, &dqp);
1294 if (error) {
1295
1296
1297
1298 ASSERT(error != ESRCH);
1299 ASSERT(error != ENOENT);
1300 return error;
1301 }
1302
1303 trace_xfs_dqadjust(dqp);
1304
1305
1306
1307
1308
1309 be64_add_cpu(&dqp->q_core.d_icount, 1);
1310 dqp->q_res_icount++;
1311 if (nblks) {
1312 be64_add_cpu(&dqp->q_core.d_bcount, nblks);
1313 dqp->q_res_bcount += nblks;
1314 }
1315 if (rtblks) {
1316 be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
1317 dqp->q_res_rtbcount += rtblks;
1318 }
1319
1320
1321
1322
1323
1324
1325 if (dqp->q_core.d_id) {
1326 xfs_qm_adjust_dqlimits(mp, dqp);
1327 xfs_qm_adjust_dqtimers(mp, &dqp->q_core);
1328 }
1329
1330 dqp->dq_flags |= XFS_DQ_DIRTY;
1331 xfs_qm_dqput(dqp);
1332 return 0;
1333}
1334
1335STATIC int
1336xfs_qm_get_rtblks(
1337 xfs_inode_t *ip,
1338 xfs_qcnt_t *O_rtblks)
1339{
1340 xfs_filblks_t rtblks;
1341 xfs_extnum_t idx;
1342 xfs_ifork_t *ifp;
1343 xfs_extnum_t nextents;
1344 int error;
1345
1346 ASSERT(XFS_IS_REALTIME_INODE(ip));
1347 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1348 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1349 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
1350 return error;
1351 }
1352 rtblks = 0;
1353 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
1354 for (idx = 0; idx < nextents; idx++)
1355 rtblks += xfs_bmbt_get_blockcount(xfs_iext_get_ext(ifp, idx));
1356 *O_rtblks = (xfs_qcnt_t)rtblks;
1357 return 0;
1358}
1359
1360
1361
1362
1363
1364
1365STATIC int
1366xfs_qm_dqusage_adjust(
1367 xfs_mount_t *mp,
1368 xfs_ino_t ino,
1369 void __user *buffer,
1370 int ubsize,
1371 int *ubused,
1372 int *res)
1373{
1374 xfs_inode_t *ip;
1375 xfs_qcnt_t nblks, rtblks = 0;
1376 int error;
1377
1378 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1379
1380
1381
1382
1383
1384 if (xfs_is_quota_inode(&mp->m_sb, ino)) {
1385 *res = BULKSTAT_RV_NOTHING;
1386 return XFS_ERROR(EINVAL);
1387 }
1388
1389
1390
1391
1392
1393
1394
1395 error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip);
1396 if (error) {
1397 *res = BULKSTAT_RV_NOTHING;
1398 return error;
1399 }
1400
1401 ASSERT(ip->i_delayed_blks == 0);
1402
1403 if (XFS_IS_REALTIME_INODE(ip)) {
1404
1405
1406
1407 error = xfs_qm_get_rtblks(ip, &rtblks);
1408 if (error)
1409 goto error0;
1410 }
1411
1412 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426 if (XFS_IS_UQUOTA_ON(mp)) {
1427 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_uid,
1428 XFS_DQ_USER, nblks, rtblks);
1429 if (error)
1430 goto error0;
1431 }
1432
1433 if (XFS_IS_GQUOTA_ON(mp)) {
1434 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_gid,
1435 XFS_DQ_GROUP, nblks, rtblks);
1436 if (error)
1437 goto error0;
1438 }
1439
1440 if (XFS_IS_PQUOTA_ON(mp)) {
1441 error = xfs_qm_quotacheck_dqadjust(ip, xfs_get_projid(ip),
1442 XFS_DQ_PROJ, nblks, rtblks);
1443 if (error)
1444 goto error0;
1445 }
1446
1447 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1448 IRELE(ip);
1449 *res = BULKSTAT_RV_DIDONE;
1450 return 0;
1451
1452error0:
1453 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1454 IRELE(ip);
1455 *res = BULKSTAT_RV_GIVEUP;
1456 return error;
1457}
1458
1459STATIC int
1460xfs_qm_flush_one(
1461 struct xfs_dquot *dqp,
1462 void *data)
1463{
1464 struct list_head *buffer_list = data;
1465 struct xfs_buf *bp = NULL;
1466 int error = 0;
1467
1468 xfs_dqlock(dqp);
1469 if (dqp->dq_flags & XFS_DQ_FREEING)
1470 goto out_unlock;
1471 if (!XFS_DQ_IS_DIRTY(dqp))
1472 goto out_unlock;
1473
1474 xfs_dqflock(dqp);
1475 error = xfs_qm_dqflush(dqp, &bp);
1476 if (error)
1477 goto out_unlock;
1478
1479 xfs_buf_delwri_queue(bp, buffer_list);
1480 xfs_buf_relse(bp);
1481out_unlock:
1482 xfs_dqunlock(dqp);
1483 return error;
1484}
1485
1486
1487
1488
1489
1490int
1491xfs_qm_quotacheck(
1492 xfs_mount_t *mp)
1493{
1494 int done, count, error, error2;
1495 xfs_ino_t lastino;
1496 size_t structsz;
1497 uint flags;
1498 LIST_HEAD (buffer_list);
1499 struct xfs_inode *uip = mp->m_quotainfo->qi_uquotaip;
1500 struct xfs_inode *gip = mp->m_quotainfo->qi_gquotaip;
1501 struct xfs_inode *pip = mp->m_quotainfo->qi_pquotaip;
1502
1503 count = INT_MAX;
1504 structsz = 1;
1505 lastino = 0;
1506 flags = 0;
1507
1508 ASSERT(uip || gip || pip);
1509 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1510
1511 xfs_notice(mp, "Quotacheck needed: Please wait.");
1512
1513
1514
1515
1516
1517
1518 if (uip) {
1519 error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA,
1520 &buffer_list);
1521 if (error)
1522 goto error_return;
1523 flags |= XFS_UQUOTA_CHKD;
1524 }
1525
1526 if (gip) {
1527 error = xfs_qm_dqiterate(mp, gip, XFS_QMOPT_GQUOTA,
1528 &buffer_list);
1529 if (error)
1530 goto error_return;
1531 flags |= XFS_GQUOTA_CHKD;
1532 }
1533
1534 if (pip) {
1535 error = xfs_qm_dqiterate(mp, pip, XFS_QMOPT_PQUOTA,
1536 &buffer_list);
1537 if (error)
1538 goto error_return;
1539 flags |= XFS_PQUOTA_CHKD;
1540 }
1541
1542 do {
1543
1544
1545
1546
1547 error = xfs_bulkstat(mp, &lastino, &count,
1548 xfs_qm_dqusage_adjust,
1549 structsz, NULL, &done);
1550 if (error)
1551 break;
1552
1553 } while (!done);
1554
1555
1556
1557
1558
1559 if (XFS_IS_UQUOTA_ON(mp)) {
1560 error = xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_flush_one,
1561 &buffer_list);
1562 }
1563 if (XFS_IS_GQUOTA_ON(mp)) {
1564 error2 = xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_flush_one,
1565 &buffer_list);
1566 if (!error)
1567 error = error2;
1568 }
1569 if (XFS_IS_PQUOTA_ON(mp)) {
1570 error2 = xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_flush_one,
1571 &buffer_list);
1572 if (!error)
1573 error = error2;
1574 }
1575
1576 error2 = xfs_buf_delwri_submit(&buffer_list);
1577 if (!error)
1578 error = error2;
1579
1580
1581
1582
1583
1584
1585
1586
1587 if (error) {
1588 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
1589 goto error_return;
1590 }
1591
1592
1593
1594
1595
1596
1597 mp->m_qflags &= ~XFS_ALL_QUOTA_CHKD;
1598 mp->m_qflags |= flags;
1599
1600 error_return:
1601 while (!list_empty(&buffer_list)) {
1602 struct xfs_buf *bp =
1603 list_first_entry(&buffer_list, struct xfs_buf, b_list);
1604 list_del_init(&bp->b_list);
1605 xfs_buf_relse(bp);
1606 }
1607
1608 if (error) {
1609 xfs_warn(mp,
1610 "Quotacheck: Unsuccessful (Error %d): Disabling quotas.",
1611 error);
1612
1613
1614
1615 ASSERT(mp->m_quotainfo != NULL);
1616 xfs_qm_destroy_quotainfo(mp);
1617 if (xfs_mount_reset_sbqflags(mp)) {
1618 xfs_warn(mp,
1619 "Quotacheck: Failed to reset quota flags.");
1620 }
1621 } else
1622 xfs_notice(mp, "Quotacheck: Done.");
1623 return (error);
1624}
1625
1626
1627
1628
1629
1630STATIC int
1631xfs_qm_init_quotainos(
1632 xfs_mount_t *mp)
1633{
1634 struct xfs_inode *uip = NULL;
1635 struct xfs_inode *gip = NULL;
1636 struct xfs_inode *pip = NULL;
1637 int error;
1638 __int64_t sbflags = 0;
1639 uint flags = 0;
1640
1641 ASSERT(mp->m_quotainfo);
1642
1643
1644
1645
1646 if (xfs_sb_version_hasquota(&mp->m_sb)) {
1647 if (XFS_IS_UQUOTA_ON(mp) &&
1648 mp->m_sb.sb_uquotino != NULLFSINO) {
1649 ASSERT(mp->m_sb.sb_uquotino > 0);
1650 error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
1651 0, 0, &uip);
1652 if (error)
1653 return XFS_ERROR(error);
1654 }
1655 if (XFS_IS_GQUOTA_ON(mp) &&
1656 mp->m_sb.sb_gquotino != NULLFSINO) {
1657 ASSERT(mp->m_sb.sb_gquotino > 0);
1658 error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
1659 0, 0, &gip);
1660 if (error)
1661 goto error_rele;
1662 }
1663 if (XFS_IS_PQUOTA_ON(mp) &&
1664 mp->m_sb.sb_pquotino != NULLFSINO) {
1665 ASSERT(mp->m_sb.sb_pquotino > 0);
1666 error = xfs_iget(mp, NULL, mp->m_sb.sb_pquotino,
1667 0, 0, &pip);
1668 if (error)
1669 goto error_rele;
1670 }
1671 } else {
1672 flags |= XFS_QMOPT_SBVERSION;
1673 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1674 XFS_SB_GQUOTINO | XFS_SB_PQUOTINO |
1675 XFS_SB_QFLAGS);
1676 }
1677
1678
1679
1680
1681
1682
1683
1684 if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
1685 error = xfs_qm_qino_alloc(mp, &uip,
1686 sbflags | XFS_SB_UQUOTINO,
1687 flags | XFS_QMOPT_UQUOTA);
1688 if (error)
1689 goto error_rele;
1690
1691 flags &= ~XFS_QMOPT_SBVERSION;
1692 }
1693 if (XFS_IS_GQUOTA_ON(mp) && gip == NULL) {
1694 error = xfs_qm_qino_alloc(mp, &gip,
1695 sbflags | XFS_SB_GQUOTINO,
1696 flags | XFS_QMOPT_GQUOTA);
1697 if (error)
1698 goto error_rele;
1699
1700 flags &= ~XFS_QMOPT_SBVERSION;
1701 }
1702 if (XFS_IS_PQUOTA_ON(mp) && pip == NULL) {
1703 error = xfs_qm_qino_alloc(mp, &pip,
1704 sbflags | XFS_SB_PQUOTINO,
1705 flags | XFS_QMOPT_PQUOTA);
1706 if (error)
1707 goto error_rele;
1708 }
1709
1710 mp->m_quotainfo->qi_uquotaip = uip;
1711 mp->m_quotainfo->qi_gquotaip = gip;
1712 mp->m_quotainfo->qi_pquotaip = pip;
1713
1714 return 0;
1715
1716error_rele:
1717 if (uip)
1718 IRELE(uip);
1719 if (gip)
1720 IRELE(gip);
1721 if (pip)
1722 IRELE(pip);
1723 return XFS_ERROR(error);
1724}
1725
1726STATIC void
1727xfs_qm_dqfree_one(
1728 struct xfs_dquot *dqp)
1729{
1730 struct xfs_mount *mp = dqp->q_mount;
1731 struct xfs_quotainfo *qi = mp->m_quotainfo;
1732
1733 mutex_lock(&qi->qi_tree_lock);
1734 radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
1735 be32_to_cpu(dqp->q_core.d_id));
1736
1737 qi->qi_dquots--;
1738 mutex_unlock(&qi->qi_tree_lock);
1739
1740 xfs_qm_dqdestroy(dqp);
1741}
1742
1743
1744
1745
1746
1747int
1748xfs_qm_write_sb_changes(
1749 xfs_mount_t *mp,
1750 __int64_t flags)
1751{
1752 xfs_trans_t *tp;
1753 int error;
1754
1755 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
1756 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_sbchange, 0, 0);
1757 if (error) {
1758 xfs_trans_cancel(tp, 0);
1759 return error;
1760 }
1761
1762 xfs_mod_sb(tp, flags);
1763 error = xfs_trans_commit(tp, 0);
1764
1765 return error;
1766}
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782int
1783xfs_qm_vop_dqalloc(
1784 struct xfs_inode *ip,
1785 xfs_dqid_t uid,
1786 xfs_dqid_t gid,
1787 prid_t prid,
1788 uint flags,
1789 struct xfs_dquot **O_udqpp,
1790 struct xfs_dquot **O_gdqpp,
1791 struct xfs_dquot **O_pdqpp)
1792{
1793 struct xfs_mount *mp = ip->i_mount;
1794 struct xfs_dquot *uq = NULL;
1795 struct xfs_dquot *gq = NULL;
1796 struct xfs_dquot *pq = NULL;
1797 int error;
1798 uint lockflags;
1799
1800 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
1801 return 0;
1802
1803 lockflags = XFS_ILOCK_EXCL;
1804 xfs_ilock(ip, lockflags);
1805
1806 if ((flags & XFS_QMOPT_INHERIT) && XFS_INHERIT_GID(ip))
1807 gid = ip->i_d.di_gid;
1808
1809
1810
1811
1812
1813 if (XFS_NOT_DQATTACHED(mp, ip)) {
1814 error = xfs_qm_dqattach_locked(ip, XFS_QMOPT_DQALLOC);
1815 if (error) {
1816 xfs_iunlock(ip, lockflags);
1817 return error;
1818 }
1819 }
1820
1821 if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
1822 if (ip->i_d.di_uid != uid) {
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832 xfs_iunlock(ip, lockflags);
1833 error = xfs_qm_dqget(mp, NULL, uid,
1834 XFS_DQ_USER,
1835 XFS_QMOPT_DQALLOC |
1836 XFS_QMOPT_DOWARN,
1837 &uq);
1838 if (error) {
1839 ASSERT(error != ENOENT);
1840 return error;
1841 }
1842
1843
1844
1845 xfs_dqunlock(uq);
1846 lockflags = XFS_ILOCK_SHARED;
1847 xfs_ilock(ip, lockflags);
1848 } else {
1849
1850
1851
1852
1853 ASSERT(ip->i_udquot);
1854 uq = xfs_qm_dqhold(ip->i_udquot);
1855 }
1856 }
1857 if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
1858 if (ip->i_d.di_gid != gid) {
1859 xfs_iunlock(ip, lockflags);
1860 error = xfs_qm_dqget(mp, NULL, gid,
1861 XFS_DQ_GROUP,
1862 XFS_QMOPT_DQALLOC |
1863 XFS_QMOPT_DOWARN,
1864 &gq);
1865 if (error) {
1866 ASSERT(error != ENOENT);
1867 goto error_rele;
1868 }
1869 xfs_dqunlock(gq);
1870 lockflags = XFS_ILOCK_SHARED;
1871 xfs_ilock(ip, lockflags);
1872 } else {
1873 ASSERT(ip->i_gdquot);
1874 gq = xfs_qm_dqhold(ip->i_gdquot);
1875 }
1876 }
1877 if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
1878 if (xfs_get_projid(ip) != prid) {
1879 xfs_iunlock(ip, lockflags);
1880 error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
1881 XFS_DQ_PROJ,
1882 XFS_QMOPT_DQALLOC |
1883 XFS_QMOPT_DOWARN,
1884 &pq);
1885 if (error) {
1886 ASSERT(error != ENOENT);
1887 goto error_rele;
1888 }
1889 xfs_dqunlock(pq);
1890 lockflags = XFS_ILOCK_SHARED;
1891 xfs_ilock(ip, lockflags);
1892 } else {
1893 ASSERT(ip->i_pdquot);
1894 pq = xfs_qm_dqhold(ip->i_pdquot);
1895 }
1896 }
1897 if (uq)
1898 trace_xfs_dquot_dqalloc(ip);
1899
1900 xfs_iunlock(ip, lockflags);
1901 if (O_udqpp)
1902 *O_udqpp = uq;
1903 else if (uq)
1904 xfs_qm_dqrele(uq);
1905 if (O_gdqpp)
1906 *O_gdqpp = gq;
1907 else if (gq)
1908 xfs_qm_dqrele(gq);
1909 if (O_pdqpp)
1910 *O_pdqpp = pq;
1911 else if (pq)
1912 xfs_qm_dqrele(pq);
1913 return 0;
1914
1915error_rele:
1916 if (gq)
1917 xfs_qm_dqrele(gq);
1918 if (uq)
1919 xfs_qm_dqrele(uq);
1920 return error;
1921}
1922
1923
1924
1925
1926
1927xfs_dquot_t *
1928xfs_qm_vop_chown(
1929 xfs_trans_t *tp,
1930 xfs_inode_t *ip,
1931 xfs_dquot_t **IO_olddq,
1932 xfs_dquot_t *newdq)
1933{
1934 xfs_dquot_t *prevdq;
1935 uint bfield = XFS_IS_REALTIME_INODE(ip) ?
1936 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
1937
1938
1939 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1940 ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
1941
1942
1943 prevdq = *IO_olddq;
1944 ASSERT(prevdq);
1945 ASSERT(prevdq != newdq);
1946
1947 xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
1948 xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
1949
1950
1951 xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
1952 xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
1953
1954
1955
1956
1957
1958 *IO_olddq = xfs_qm_dqhold(newdq);
1959
1960 return prevdq;
1961}
1962
1963
1964
1965
1966int
1967xfs_qm_vop_chown_reserve(
1968 struct xfs_trans *tp,
1969 struct xfs_inode *ip,
1970 struct xfs_dquot *udqp,
1971 struct xfs_dquot *gdqp,
1972 struct xfs_dquot *pdqp,
1973 uint flags)
1974{
1975 struct xfs_mount *mp = ip->i_mount;
1976 uint delblks, blkflags, prjflags = 0;
1977 struct xfs_dquot *udq_unres = NULL;
1978 struct xfs_dquot *gdq_unres = NULL;
1979 struct xfs_dquot *pdq_unres = NULL;
1980 struct xfs_dquot *udq_delblks = NULL;
1981 struct xfs_dquot *gdq_delblks = NULL;
1982 struct xfs_dquot *pdq_delblks = NULL;
1983 int error;
1984
1985
1986 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
1987 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1988
1989 delblks = ip->i_delayed_blks;
1990 blkflags = XFS_IS_REALTIME_INODE(ip) ?
1991 XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
1992
1993 if (XFS_IS_UQUOTA_ON(mp) && udqp &&
1994 ip->i_d.di_uid != be32_to_cpu(udqp->q_core.d_id)) {
1995 udq_delblks = udqp;
1996
1997
1998
1999
2000
2001 if (delblks) {
2002 ASSERT(ip->i_udquot);
2003 udq_unres = ip->i_udquot;
2004 }
2005 }
2006 if (XFS_IS_GQUOTA_ON(ip->i_mount) && gdqp &&
2007 ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id)) {
2008 gdq_delblks = gdqp;
2009 if (delblks) {
2010 ASSERT(ip->i_gdquot);
2011 gdq_unres = ip->i_gdquot;
2012 }
2013 }
2014
2015 if (XFS_IS_PQUOTA_ON(ip->i_mount) && pdqp &&
2016 xfs_get_projid(ip) != be32_to_cpu(pdqp->q_core.d_id)) {
2017 prjflags = XFS_QMOPT_ENOSPC;
2018 pdq_delblks = pdqp;
2019 if (delblks) {
2020 ASSERT(ip->i_pdquot);
2021 pdq_unres = ip->i_pdquot;
2022 }
2023 }
2024
2025 error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
2026 udq_delblks, gdq_delblks, pdq_delblks,
2027 ip->i_d.di_nblocks, 1,
2028 flags | blkflags | prjflags);
2029 if (error)
2030 return error;
2031
2032
2033
2034
2035
2036
2037
2038 if (delblks) {
2039
2040
2041
2042 ASSERT(udq_delblks || gdq_delblks || pdq_delblks);
2043 ASSERT(udq_unres || gdq_unres || pdq_unres);
2044 error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2045 udq_delblks, gdq_delblks, pdq_delblks,
2046 (xfs_qcnt_t)delblks, 0,
2047 flags | blkflags | prjflags);
2048 if (error)
2049 return error;
2050 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2051 udq_unres, gdq_unres, pdq_unres,
2052 -((xfs_qcnt_t)delblks), 0, blkflags);
2053 }
2054
2055 return (0);
2056}
2057
2058int
2059xfs_qm_vop_rename_dqattach(
2060 struct xfs_inode **i_tab)
2061{
2062 struct xfs_mount *mp = i_tab[0]->i_mount;
2063 int i;
2064
2065 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
2066 return 0;
2067
2068 for (i = 0; (i < 4 && i_tab[i]); i++) {
2069 struct xfs_inode *ip = i_tab[i];
2070 int error;
2071
2072
2073
2074
2075 if (i == 0 || ip != i_tab[i-1]) {
2076 if (XFS_NOT_DQATTACHED(mp, ip)) {
2077 error = xfs_qm_dqattach(ip, 0);
2078 if (error)
2079 return error;
2080 }
2081 }
2082 }
2083 return 0;
2084}
2085
2086void
2087xfs_qm_vop_create_dqattach(
2088 struct xfs_trans *tp,
2089 struct xfs_inode *ip,
2090 struct xfs_dquot *udqp,
2091 struct xfs_dquot *gdqp,
2092 struct xfs_dquot *pdqp)
2093{
2094 struct xfs_mount *mp = tp->t_mountp;
2095
2096 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
2097 return;
2098
2099 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
2100 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2101
2102 if (udqp) {
2103 ASSERT(ip->i_udquot == NULL);
2104 ASSERT(XFS_IS_UQUOTA_ON(mp));
2105 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
2106
2107 ip->i_udquot = xfs_qm_dqhold(udqp);
2108 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
2109 }
2110 if (gdqp) {
2111 ASSERT(ip->i_gdquot == NULL);
2112 ASSERT(XFS_IS_GQUOTA_ON(mp));
2113 ASSERT(ip->i_d.di_gid == be32_to_cpu(gdqp->q_core.d_id));
2114 ip->i_gdquot = xfs_qm_dqhold(gdqp);
2115 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
2116 }
2117 if (pdqp) {
2118 ASSERT(ip->i_pdquot == NULL);
2119 ASSERT(XFS_IS_PQUOTA_ON(mp));
2120 ASSERT(xfs_get_projid(ip) == be32_to_cpu(pdqp->q_core.d_id));
2121
2122 ip->i_pdquot = xfs_qm_dqhold(pdqp);
2123 xfs_trans_mod_dquot(tp, pdqp, XFS_TRANS_DQ_ICOUNT, 1);
2124 }
2125}
2126
2127