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_trans.h"
23#include "xfs_sb.h"
24#include "xfs_ag.h"
25#include "xfs_alloc.h"
26#include "xfs_quota.h"
27#include "xfs_mount.h"
28#include "xfs_bmap_btree.h"
29#include "xfs_inode.h"
30#include "xfs_bmap.h"
31#include "xfs_rtalloc.h"
32#include "xfs_error.h"
33#include "xfs_itable.h"
34#include "xfs_attr.h"
35#include "xfs_buf_item.h"
36#include "xfs_trans_space.h"
37#include "xfs_trans_priv.h"
38#include "xfs_qm.h"
39#include "xfs_cksum.h"
40#include "xfs_trace.h"
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55#ifdef DEBUG
56xfs_buftarg_t *xfs_dqerror_target;
57int xfs_do_dqerror;
58int xfs_dqreq_num;
59int xfs_dqerror_mod = 33;
60#endif
61
62struct kmem_zone *xfs_qm_dqtrxzone;
63static struct kmem_zone *xfs_qm_dqzone;
64
65static struct lock_class_key xfs_dquot_other_class;
66
67
68
69
70void
71xfs_qm_dqdestroy(
72 xfs_dquot_t *dqp)
73{
74 ASSERT(list_empty(&dqp->q_lru));
75
76 mutex_destroy(&dqp->q_qlock);
77 kmem_zone_free(xfs_qm_dqzone, dqp);
78
79 XFS_STATS_DEC(xs_qm_dquot);
80}
81
82
83
84
85
86
87void
88xfs_qm_adjust_dqlimits(
89 struct xfs_mount *mp,
90 struct xfs_dquot *dq)
91{
92 struct xfs_quotainfo *q = mp->m_quotainfo;
93 struct xfs_disk_dquot *d = &dq->q_core;
94 int prealloc = 0;
95
96 ASSERT(d->d_id);
97
98 if (q->qi_bsoftlimit && !d->d_blk_softlimit) {
99 d->d_blk_softlimit = cpu_to_be64(q->qi_bsoftlimit);
100 prealloc = 1;
101 }
102 if (q->qi_bhardlimit && !d->d_blk_hardlimit) {
103 d->d_blk_hardlimit = cpu_to_be64(q->qi_bhardlimit);
104 prealloc = 1;
105 }
106 if (q->qi_isoftlimit && !d->d_ino_softlimit)
107 d->d_ino_softlimit = cpu_to_be64(q->qi_isoftlimit);
108 if (q->qi_ihardlimit && !d->d_ino_hardlimit)
109 d->d_ino_hardlimit = cpu_to_be64(q->qi_ihardlimit);
110 if (q->qi_rtbsoftlimit && !d->d_rtb_softlimit)
111 d->d_rtb_softlimit = cpu_to_be64(q->qi_rtbsoftlimit);
112 if (q->qi_rtbhardlimit && !d->d_rtb_hardlimit)
113 d->d_rtb_hardlimit = cpu_to_be64(q->qi_rtbhardlimit);
114
115 if (prealloc)
116 xfs_dquot_set_prealloc_limits(dq);
117}
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132void
133xfs_qm_adjust_dqtimers(
134 xfs_mount_t *mp,
135 xfs_disk_dquot_t *d)
136{
137 ASSERT(d->d_id);
138
139#ifdef DEBUG
140 if (d->d_blk_hardlimit)
141 ASSERT(be64_to_cpu(d->d_blk_softlimit) <=
142 be64_to_cpu(d->d_blk_hardlimit));
143 if (d->d_ino_hardlimit)
144 ASSERT(be64_to_cpu(d->d_ino_softlimit) <=
145 be64_to_cpu(d->d_ino_hardlimit));
146 if (d->d_rtb_hardlimit)
147 ASSERT(be64_to_cpu(d->d_rtb_softlimit) <=
148 be64_to_cpu(d->d_rtb_hardlimit));
149#endif
150
151 if (!d->d_btimer) {
152 if ((d->d_blk_softlimit &&
153 (be64_to_cpu(d->d_bcount) >
154 be64_to_cpu(d->d_blk_softlimit))) ||
155 (d->d_blk_hardlimit &&
156 (be64_to_cpu(d->d_bcount) >
157 be64_to_cpu(d->d_blk_hardlimit)))) {
158 d->d_btimer = cpu_to_be32(get_seconds() +
159 mp->m_quotainfo->qi_btimelimit);
160 } else {
161 d->d_bwarns = 0;
162 }
163 } else {
164 if ((!d->d_blk_softlimit ||
165 (be64_to_cpu(d->d_bcount) <=
166 be64_to_cpu(d->d_blk_softlimit))) &&
167 (!d->d_blk_hardlimit ||
168 (be64_to_cpu(d->d_bcount) <=
169 be64_to_cpu(d->d_blk_hardlimit)))) {
170 d->d_btimer = 0;
171 }
172 }
173
174 if (!d->d_itimer) {
175 if ((d->d_ino_softlimit &&
176 (be64_to_cpu(d->d_icount) >
177 be64_to_cpu(d->d_ino_softlimit))) ||
178 (d->d_ino_hardlimit &&
179 (be64_to_cpu(d->d_icount) >
180 be64_to_cpu(d->d_ino_hardlimit)))) {
181 d->d_itimer = cpu_to_be32(get_seconds() +
182 mp->m_quotainfo->qi_itimelimit);
183 } else {
184 d->d_iwarns = 0;
185 }
186 } else {
187 if ((!d->d_ino_softlimit ||
188 (be64_to_cpu(d->d_icount) <=
189 be64_to_cpu(d->d_ino_softlimit))) &&
190 (!d->d_ino_hardlimit ||
191 (be64_to_cpu(d->d_icount) <=
192 be64_to_cpu(d->d_ino_hardlimit)))) {
193 d->d_itimer = 0;
194 }
195 }
196
197 if (!d->d_rtbtimer) {
198 if ((d->d_rtb_softlimit &&
199 (be64_to_cpu(d->d_rtbcount) >
200 be64_to_cpu(d->d_rtb_softlimit))) ||
201 (d->d_rtb_hardlimit &&
202 (be64_to_cpu(d->d_rtbcount) >
203 be64_to_cpu(d->d_rtb_hardlimit)))) {
204 d->d_rtbtimer = cpu_to_be32(get_seconds() +
205 mp->m_quotainfo->qi_rtbtimelimit);
206 } else {
207 d->d_rtbwarns = 0;
208 }
209 } else {
210 if ((!d->d_rtb_softlimit ||
211 (be64_to_cpu(d->d_rtbcount) <=
212 be64_to_cpu(d->d_rtb_softlimit))) &&
213 (!d->d_rtb_hardlimit ||
214 (be64_to_cpu(d->d_rtbcount) <=
215 be64_to_cpu(d->d_rtb_hardlimit)))) {
216 d->d_rtbtimer = 0;
217 }
218 }
219}
220
221
222
223
224STATIC void
225xfs_qm_init_dquot_blk(
226 xfs_trans_t *tp,
227 xfs_mount_t *mp,
228 xfs_dqid_t id,
229 uint type,
230 xfs_buf_t *bp)
231{
232 struct xfs_quotainfo *q = mp->m_quotainfo;
233 xfs_dqblk_t *d;
234 int curid, i;
235
236 ASSERT(tp);
237 ASSERT(xfs_buf_islocked(bp));
238
239 d = bp->b_addr;
240
241
242
243
244 curid = id - (id % q->qi_dqperchunk);
245 ASSERT(curid >= 0);
246 memset(d, 0, BBTOB(q->qi_dqchunklen));
247 for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++) {
248 d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
249 d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
250 d->dd_diskdq.d_id = cpu_to_be32(curid);
251 d->dd_diskdq.d_flags = type;
252 if (xfs_sb_version_hascrc(&mp->m_sb)) {
253 uuid_copy(&d->dd_uuid, &mp->m_sb.sb_uuid);
254 xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
255 XFS_DQUOT_CRC_OFF);
256 }
257 }
258
259 xfs_trans_dquot_buf(tp, bp,
260 (type & XFS_DQ_USER ? XFS_BLF_UDQUOT_BUF :
261 ((type & XFS_DQ_PROJ) ? XFS_BLF_PDQUOT_BUF :
262 XFS_BLF_GDQUOT_BUF)));
263 xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1);
264}
265
266
267
268
269
270
271void
272xfs_dquot_set_prealloc_limits(struct xfs_dquot *dqp)
273{
274 __uint64_t space;
275
276 dqp->q_prealloc_hi_wmark = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
277 dqp->q_prealloc_lo_wmark = be64_to_cpu(dqp->q_core.d_blk_softlimit);
278 if (!dqp->q_prealloc_lo_wmark) {
279 dqp->q_prealloc_lo_wmark = dqp->q_prealloc_hi_wmark;
280 do_div(dqp->q_prealloc_lo_wmark, 100);
281 dqp->q_prealloc_lo_wmark *= 95;
282 }
283
284 space = dqp->q_prealloc_hi_wmark;
285
286 do_div(space, 100);
287 dqp->q_low_space[XFS_QLOWSP_1_PCNT] = space;
288 dqp->q_low_space[XFS_QLOWSP_3_PCNT] = space * 3;
289 dqp->q_low_space[XFS_QLOWSP_5_PCNT] = space * 5;
290}
291
292STATIC bool
293xfs_dquot_buf_verify_crc(
294 struct xfs_mount *mp,
295 struct xfs_buf *bp)
296{
297 struct xfs_dqblk *d = (struct xfs_dqblk *)bp->b_addr;
298 int ndquots;
299 int i;
300
301 if (!xfs_sb_version_hascrc(&mp->m_sb))
302 return true;
303
304
305
306
307
308
309 if (mp->m_quotainfo)
310 ndquots = mp->m_quotainfo->qi_dqperchunk;
311 else
312 ndquots = xfs_qm_calc_dquots_per_chunk(mp,
313 XFS_BB_TO_FSB(mp, bp->b_length));
314
315 for (i = 0; i < ndquots; i++, d++) {
316 if (!xfs_verify_cksum((char *)d, sizeof(struct xfs_dqblk),
317 XFS_DQUOT_CRC_OFF))
318 return false;
319 if (!uuid_equal(&d->dd_uuid, &mp->m_sb.sb_uuid))
320 return false;
321 }
322 return true;
323}
324
325STATIC bool
326xfs_dquot_buf_verify(
327 struct xfs_mount *mp,
328 struct xfs_buf *bp)
329{
330 struct xfs_dqblk *d = (struct xfs_dqblk *)bp->b_addr;
331 xfs_dqid_t id = 0;
332 int ndquots;
333 int i;
334
335
336
337
338
339
340 if (mp->m_quotainfo)
341 ndquots = mp->m_quotainfo->qi_dqperchunk;
342 else
343 ndquots = xfs_qm_calc_dquots_per_chunk(mp, bp->b_length);
344
345
346
347
348
349
350
351
352 for (i = 0; i < ndquots; i++) {
353 struct xfs_disk_dquot *ddq;
354 int error;
355
356 ddq = &d[i].dd_diskdq;
357
358 if (i == 0)
359 id = be32_to_cpu(ddq->d_id);
360
361 error = xfs_qm_dqcheck(mp, ddq, id + i, 0, XFS_QMOPT_DOWARN,
362 "xfs_dquot_buf_verify");
363 if (error)
364 return false;
365 }
366 return true;
367}
368
369static void
370xfs_dquot_buf_read_verify(
371 struct xfs_buf *bp)
372{
373 struct xfs_mount *mp = bp->b_target->bt_mount;
374
375 if (!xfs_dquot_buf_verify_crc(mp, bp) || !xfs_dquot_buf_verify(mp, bp)) {
376 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
377 xfs_buf_ioerror(bp, EFSCORRUPTED);
378 }
379}
380
381
382
383
384
385
386void
387xfs_dquot_buf_write_verify(
388 struct xfs_buf *bp)
389{
390 struct xfs_mount *mp = bp->b_target->bt_mount;
391
392 if (!xfs_dquot_buf_verify(mp, bp)) {
393 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
394 xfs_buf_ioerror(bp, EFSCORRUPTED);
395 return;
396 }
397}
398
399const struct xfs_buf_ops xfs_dquot_buf_ops = {
400 .verify_read = xfs_dquot_buf_read_verify,
401 .verify_write = xfs_dquot_buf_write_verify,
402};
403
404
405
406
407
408STATIC int
409xfs_qm_dqalloc(
410 xfs_trans_t **tpp,
411 xfs_mount_t *mp,
412 xfs_dquot_t *dqp,
413 xfs_inode_t *quotip,
414 xfs_fileoff_t offset_fsb,
415 xfs_buf_t **O_bpp)
416{
417 xfs_fsblock_t firstblock;
418 xfs_bmap_free_t flist;
419 xfs_bmbt_irec_t map;
420 int nmaps, error, committed;
421 xfs_buf_t *bp;
422 xfs_trans_t *tp = *tpp;
423
424 ASSERT(tp != NULL);
425
426 trace_xfs_dqalloc(dqp);
427
428
429
430
431 xfs_bmap_init(&flist, &firstblock);
432 xfs_ilock(quotip, XFS_ILOCK_EXCL);
433
434
435
436
437 if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
438 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
439 return (ESRCH);
440 }
441
442 xfs_trans_ijoin(tp, quotip, XFS_ILOCK_EXCL);
443 nmaps = 1;
444 error = xfs_bmapi_write(tp, quotip, offset_fsb,
445 XFS_DQUOT_CLUSTER_SIZE_FSB, XFS_BMAPI_METADATA,
446 &firstblock, XFS_QM_DQALLOC_SPACE_RES(mp),
447 &map, &nmaps, &flist);
448 if (error)
449 goto error0;
450 ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB);
451 ASSERT(nmaps == 1);
452 ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
453 (map.br_startblock != HOLESTARTBLOCK));
454
455
456
457
458 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
459
460
461 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
462 dqp->q_blkno,
463 mp->m_quotainfo->qi_dqchunklen,
464 0);
465
466 error = xfs_buf_geterror(bp);
467 if (error)
468 goto error1;
469 bp->b_ops = &xfs_dquot_buf_ops;
470
471
472
473
474
475 xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id),
476 dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491 xfs_trans_bhold(tp, bp);
492
493 if ((error = xfs_bmap_finish(tpp, &flist, &committed))) {
494 goto error1;
495 }
496
497 if (committed) {
498 tp = *tpp;
499 xfs_trans_bjoin(tp, bp);
500 } else {
501 xfs_trans_bhold_release(tp, bp);
502 }
503
504 *O_bpp = bp;
505 return 0;
506
507 error1:
508 xfs_bmap_cancel(&flist);
509 error0:
510 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
511
512 return (error);
513}
514STATIC int
515xfs_qm_dqrepair(
516 struct xfs_mount *mp,
517 struct xfs_trans *tp,
518 struct xfs_dquot *dqp,
519 xfs_dqid_t firstid,
520 struct xfs_buf **bpp)
521{
522 int error;
523 struct xfs_disk_dquot *ddq;
524 struct xfs_dqblk *d;
525 int i;
526
527
528
529
530
531 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, dqp->q_blkno,
532 mp->m_quotainfo->qi_dqchunklen,
533 0, bpp, NULL);
534
535 if (error) {
536 ASSERT(*bpp == NULL);
537 return XFS_ERROR(error);
538 }
539 (*bpp)->b_ops = &xfs_dquot_buf_ops;
540
541 ASSERT(xfs_buf_islocked(*bpp));
542 d = (struct xfs_dqblk *)(*bpp)->b_addr;
543
544
545 for (i = 0; i < mp->m_quotainfo->qi_dqperchunk; i++) {
546 ddq = &d[i].dd_diskdq;
547 error = xfs_qm_dqcheck(mp, ddq, firstid + i,
548 dqp->dq_flags & XFS_DQ_ALLTYPES,
549 XFS_QMOPT_DQREPAIR, "xfs_qm_dqrepair");
550 if (error) {
551
552 xfs_trans_brelse(tp, *bpp);
553 return XFS_ERROR(EIO);
554 }
555 }
556
557 return 0;
558}
559
560
561
562
563
564
565STATIC int
566xfs_qm_dqtobp(
567 xfs_trans_t **tpp,
568 xfs_dquot_t *dqp,
569 xfs_disk_dquot_t **O_ddpp,
570 xfs_buf_t **O_bpp,
571 uint flags)
572{
573 xfs_bmbt_irec_t map;
574 int nmaps = 1, error;
575 xfs_buf_t *bp;
576 xfs_inode_t *quotip = XFS_DQ_TO_QIP(dqp);
577 xfs_mount_t *mp = dqp->q_mount;
578 xfs_dqid_t id = be32_to_cpu(dqp->q_core.d_id);
579 xfs_trans_t *tp = (tpp ? *tpp : NULL);
580
581 dqp->q_fileoffset = (xfs_fileoff_t)id / mp->m_quotainfo->qi_dqperchunk;
582
583 xfs_ilock(quotip, XFS_ILOCK_SHARED);
584 if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
585
586
587
588
589 xfs_iunlock(quotip, XFS_ILOCK_SHARED);
590 return ESRCH;
591 }
592
593
594
595
596 error = xfs_bmapi_read(quotip, dqp->q_fileoffset,
597 XFS_DQUOT_CLUSTER_SIZE_FSB, &map, &nmaps, 0);
598
599 xfs_iunlock(quotip, XFS_ILOCK_SHARED);
600 if (error)
601 return error;
602
603 ASSERT(nmaps == 1);
604 ASSERT(map.br_blockcount == 1);
605
606
607
608
609 dqp->q_bufoffset = (id % mp->m_quotainfo->qi_dqperchunk) *
610 sizeof(xfs_dqblk_t);
611
612 ASSERT(map.br_startblock != DELAYSTARTBLOCK);
613 if (map.br_startblock == HOLESTARTBLOCK) {
614
615
616
617 if (!(flags & XFS_QMOPT_DQALLOC))
618 return ENOENT;
619
620 ASSERT(tp);
621 error = xfs_qm_dqalloc(tpp, mp, dqp, quotip,
622 dqp->q_fileoffset, &bp);
623 if (error)
624 return error;
625 tp = *tpp;
626 } else {
627 trace_xfs_dqtobp_read(dqp);
628
629
630
631
632
633 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
634
635 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
636 dqp->q_blkno,
637 mp->m_quotainfo->qi_dqchunklen,
638 0, &bp, &xfs_dquot_buf_ops);
639
640 if (error == EFSCORRUPTED && (flags & XFS_QMOPT_DQREPAIR)) {
641 xfs_dqid_t firstid = (xfs_dqid_t)map.br_startoff *
642 mp->m_quotainfo->qi_dqperchunk;
643 ASSERT(bp == NULL);
644 error = xfs_qm_dqrepair(mp, tp, dqp, firstid, &bp);
645 }
646
647 if (error) {
648 ASSERT(bp == NULL);
649 return XFS_ERROR(error);
650 }
651 }
652
653 ASSERT(xfs_buf_islocked(bp));
654 *O_bpp = bp;
655 *O_ddpp = bp->b_addr + dqp->q_bufoffset;
656
657 return (0);
658}
659
660
661
662
663
664
665
666
667int
668xfs_qm_dqread(
669 struct xfs_mount *mp,
670 xfs_dqid_t id,
671 uint type,
672 uint flags,
673 struct xfs_dquot **O_dqpp)
674{
675 struct xfs_dquot *dqp;
676 struct xfs_disk_dquot *ddqp;
677 struct xfs_buf *bp;
678 struct xfs_trans *tp = NULL;
679 int error;
680 int cancelflags = 0;
681
682
683 dqp = kmem_zone_zalloc(xfs_qm_dqzone, KM_SLEEP);
684
685 dqp->dq_flags = type;
686 dqp->q_core.d_id = cpu_to_be32(id);
687 dqp->q_mount = mp;
688 INIT_LIST_HEAD(&dqp->q_lru);
689 mutex_init(&dqp->q_qlock);
690 init_waitqueue_head(&dqp->q_pinwait);
691
692
693
694
695
696
697 init_completion(&dqp->q_flush);
698 complete(&dqp->q_flush);
699
700
701
702
703
704 if (!(type & XFS_DQ_USER))
705 lockdep_set_class(&dqp->q_qlock, &xfs_dquot_other_class);
706
707 XFS_STATS_INC(xs_qm_dquot);
708
709 trace_xfs_dqread(dqp);
710
711 if (flags & XFS_QMOPT_DQALLOC) {
712 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_DQALLOC);
713 error = xfs_trans_reserve(tp, XFS_QM_DQALLOC_SPACE_RES(mp),
714 XFS_QM_DQALLOC_LOG_RES(mp), 0,
715 XFS_TRANS_PERM_LOG_RES,
716 XFS_WRITE_LOG_COUNT);
717 if (error)
718 goto error1;
719 cancelflags = XFS_TRANS_RELEASE_LOG_RES;
720 }
721
722
723
724
725
726 error = xfs_qm_dqtobp(&tp, dqp, &ddqp, &bp, flags);
727 if (error) {
728
729
730
731
732
733 trace_xfs_dqread_fail(dqp);
734 cancelflags |= XFS_TRANS_ABORT;
735 goto error1;
736 }
737
738
739 memcpy(&dqp->q_core, ddqp, sizeof(xfs_disk_dquot_t));
740 xfs_qm_dquot_logitem_init(dqp);
741
742
743
744
745
746 dqp->q_res_bcount = be64_to_cpu(ddqp->d_bcount);
747 dqp->q_res_icount = be64_to_cpu(ddqp->d_icount);
748 dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount);
749
750
751 xfs_dquot_set_prealloc_limits(dqp);
752
753
754 xfs_buf_set_ref(bp, XFS_DQUOT_REF);
755
756
757
758
759
760
761
762
763
764
765
766
767
768 ASSERT(xfs_buf_islocked(bp));
769 xfs_trans_brelse(tp, bp);
770
771 if (tp) {
772 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
773 if (error)
774 goto error0;
775 }
776
777 *O_dqpp = dqp;
778 return error;
779
780error1:
781 if (tp)
782 xfs_trans_cancel(tp, cancelflags);
783error0:
784 xfs_qm_dqdestroy(dqp);
785 *O_dqpp = NULL;
786 return error;
787}
788
789
790
791
792
793
794
795
796
797int
798xfs_qm_dqget(
799 xfs_mount_t *mp,
800 xfs_inode_t *ip,
801 xfs_dqid_t id,
802 uint type,
803 uint flags,
804 xfs_dquot_t **O_dqpp)
805{
806 struct xfs_quotainfo *qi = mp->m_quotainfo;
807 struct radix_tree_root *tree = XFS_DQUOT_TREE(qi, type);
808 struct xfs_dquot *dqp;
809 int error;
810
811 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
812 if ((! XFS_IS_UQUOTA_ON(mp) && type == XFS_DQ_USER) ||
813 (! XFS_IS_PQUOTA_ON(mp) && type == XFS_DQ_PROJ) ||
814 (! XFS_IS_GQUOTA_ON(mp) && type == XFS_DQ_GROUP)) {
815 return (ESRCH);
816 }
817
818#ifdef DEBUG
819 if (xfs_do_dqerror) {
820 if ((xfs_dqerror_target == mp->m_ddev_targp) &&
821 (xfs_dqreq_num++ % xfs_dqerror_mod) == 0) {
822 xfs_debug(mp, "Returning error in dqget");
823 return (EIO);
824 }
825 }
826
827 ASSERT(type == XFS_DQ_USER ||
828 type == XFS_DQ_PROJ ||
829 type == XFS_DQ_GROUP);
830 if (ip) {
831 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
832 ASSERT(xfs_inode_dquot(ip, type) == NULL);
833 }
834#endif
835
836restart:
837 mutex_lock(&qi->qi_tree_lock);
838 dqp = radix_tree_lookup(tree, id);
839 if (dqp) {
840 xfs_dqlock(dqp);
841 if (dqp->dq_flags & XFS_DQ_FREEING) {
842 xfs_dqunlock(dqp);
843 mutex_unlock(&qi->qi_tree_lock);
844 trace_xfs_dqget_freeing(dqp);
845 delay(1);
846 goto restart;
847 }
848
849 dqp->q_nrefs++;
850 mutex_unlock(&qi->qi_tree_lock);
851
852 trace_xfs_dqget_hit(dqp);
853 XFS_STATS_INC(xs_qm_dqcachehits);
854 *O_dqpp = dqp;
855 return 0;
856 }
857 mutex_unlock(&qi->qi_tree_lock);
858 XFS_STATS_INC(xs_qm_dqcachemisses);
859
860
861
862
863
864
865
866
867 if (ip)
868 xfs_iunlock(ip, XFS_ILOCK_EXCL);
869
870 error = xfs_qm_dqread(mp, id, type, flags, &dqp);
871
872 if (ip)
873 xfs_ilock(ip, XFS_ILOCK_EXCL);
874
875 if (error)
876 return error;
877
878 if (ip) {
879
880
881
882
883 if (xfs_this_quota_on(mp, type)) {
884 struct xfs_dquot *dqp1;
885
886 dqp1 = xfs_inode_dquot(ip, type);
887 if (dqp1) {
888 xfs_qm_dqdestroy(dqp);
889 dqp = dqp1;
890 xfs_dqlock(dqp);
891 goto dqret;
892 }
893 } else {
894
895 xfs_qm_dqdestroy(dqp);
896 return XFS_ERROR(ESRCH);
897 }
898 }
899
900 mutex_lock(&qi->qi_tree_lock);
901 error = -radix_tree_insert(tree, id, dqp);
902 if (unlikely(error)) {
903 WARN_ON(error != EEXIST);
904
905
906
907
908
909 mutex_unlock(&qi->qi_tree_lock);
910 trace_xfs_dqget_dup(dqp);
911 xfs_qm_dqdestroy(dqp);
912 XFS_STATS_INC(xs_qm_dquot_dups);
913 goto restart;
914 }
915
916
917
918
919 xfs_dqlock(dqp);
920 dqp->q_nrefs = 1;
921
922 qi->qi_dquots++;
923 mutex_unlock(&qi->qi_tree_lock);
924
925 dqret:
926 ASSERT((ip == NULL) || xfs_isilocked(ip, XFS_ILOCK_EXCL));
927 trace_xfs_dqget_miss(dqp);
928 *O_dqpp = dqp;
929 return (0);
930}
931
932
933STATIC void
934xfs_qm_dqput_final(
935 struct xfs_dquot *dqp)
936{
937 struct xfs_quotainfo *qi = dqp->q_mount->m_quotainfo;
938 struct xfs_dquot *gdqp;
939
940 trace_xfs_dqput_free(dqp);
941
942 mutex_lock(&qi->qi_lru_lock);
943 if (list_empty(&dqp->q_lru)) {
944 list_add_tail(&dqp->q_lru, &qi->qi_lru_list);
945 qi->qi_lru_count++;
946 XFS_STATS_INC(xs_qm_dquot_unused);
947 }
948 mutex_unlock(&qi->qi_lru_lock);
949
950
951
952
953
954
955 gdqp = dqp->q_gdquot;
956 if (gdqp) {
957 xfs_dqlock(gdqp);
958 dqp->q_gdquot = NULL;
959 }
960 xfs_dqunlock(dqp);
961
962
963
964
965 if (gdqp)
966 xfs_qm_dqput(gdqp);
967}
968
969
970
971
972
973
974
975void
976xfs_qm_dqput(
977 struct xfs_dquot *dqp)
978{
979 ASSERT(dqp->q_nrefs > 0);
980 ASSERT(XFS_DQ_IS_LOCKED(dqp));
981
982 trace_xfs_dqput(dqp);
983
984 if (--dqp->q_nrefs > 0)
985 xfs_dqunlock(dqp);
986 else
987 xfs_qm_dqput_final(dqp);
988}
989
990
991
992
993
994void
995xfs_qm_dqrele(
996 xfs_dquot_t *dqp)
997{
998 if (!dqp)
999 return;
1000
1001 trace_xfs_dqrele(dqp);
1002
1003 xfs_dqlock(dqp);
1004
1005
1006
1007
1008
1009
1010 xfs_qm_dqput(dqp);
1011}
1012
1013
1014
1015
1016
1017
1018
1019
1020STATIC void
1021xfs_qm_dqflush_done(
1022 struct xfs_buf *bp,
1023 struct xfs_log_item *lip)
1024{
1025 xfs_dq_logitem_t *qip = (struct xfs_dq_logitem *)lip;
1026 xfs_dquot_t *dqp = qip->qli_dquot;
1027 struct xfs_ail *ailp = lip->li_ailp;
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037 if ((lip->li_flags & XFS_LI_IN_AIL) &&
1038 lip->li_lsn == qip->qli_flush_lsn) {
1039
1040
1041 spin_lock(&ailp->xa_lock);
1042 if (lip->li_lsn == qip->qli_flush_lsn)
1043 xfs_trans_ail_delete(ailp, lip, SHUTDOWN_CORRUPT_INCORE);
1044 else
1045 spin_unlock(&ailp->xa_lock);
1046 }
1047
1048
1049
1050
1051 xfs_dqfunlock(dqp);
1052}
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062int
1063xfs_qm_dqflush(
1064 struct xfs_dquot *dqp,
1065 struct xfs_buf **bpp)
1066{
1067 struct xfs_mount *mp = dqp->q_mount;
1068 struct xfs_buf *bp;
1069 struct xfs_disk_dquot *ddqp;
1070 int error;
1071
1072 ASSERT(XFS_DQ_IS_LOCKED(dqp));
1073 ASSERT(!completion_done(&dqp->q_flush));
1074
1075 trace_xfs_dqflush(dqp);
1076
1077 *bpp = NULL;
1078
1079 xfs_qm_dqunpin_wait(dqp);
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089 if (XFS_FORCED_SHUTDOWN(mp)) {
1090 struct xfs_log_item *lip = &dqp->q_logitem.qli_item;
1091 dqp->dq_flags &= ~XFS_DQ_DIRTY;
1092
1093 spin_lock(&mp->m_ail->xa_lock);
1094 if (lip->li_flags & XFS_LI_IN_AIL)
1095 xfs_trans_ail_delete(mp->m_ail, lip,
1096 SHUTDOWN_CORRUPT_INCORE);
1097 else
1098 spin_unlock(&mp->m_ail->xa_lock);
1099 error = XFS_ERROR(EIO);
1100 goto out_unlock;
1101 }
1102
1103
1104
1105
1106 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,
1107 mp->m_quotainfo->qi_dqchunklen, 0, &bp, NULL);
1108 if (error)
1109 goto out_unlock;
1110
1111
1112
1113
1114 ddqp = bp->b_addr + dqp->q_bufoffset;
1115
1116
1117
1118
1119 error = xfs_qm_dqcheck(mp, &dqp->q_core, be32_to_cpu(ddqp->d_id), 0,
1120 XFS_QMOPT_DOWARN, "dqflush (incore copy)");
1121 if (error) {
1122 xfs_buf_relse(bp);
1123 xfs_dqfunlock(dqp);
1124 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1125 return XFS_ERROR(EIO);
1126 }
1127
1128
1129 memcpy(ddqp, &dqp->q_core, sizeof(xfs_disk_dquot_t));
1130
1131
1132
1133
1134 dqp->dq_flags &= ~XFS_DQ_DIRTY;
1135
1136 xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn,
1137 &dqp->q_logitem.qli_item.li_lsn);
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148 if (xfs_sb_version_hascrc(&mp->m_sb)) {
1149 struct xfs_dqblk *dqb = (struct xfs_dqblk *)ddqp;
1150
1151 dqb->dd_lsn = cpu_to_be64(dqp->q_logitem.qli_item.li_lsn);
1152 xfs_update_cksum((char *)dqb, sizeof(struct xfs_dqblk),
1153 XFS_DQUOT_CRC_OFF);
1154 }
1155
1156
1157
1158
1159
1160 xfs_buf_attach_iodone(bp, xfs_qm_dqflush_done,
1161 &dqp->q_logitem.qli_item);
1162
1163
1164
1165
1166
1167 if (xfs_buf_ispinned(bp)) {
1168 trace_xfs_dqflush_force(dqp);
1169 xfs_log_force(mp, 0);
1170 }
1171
1172 trace_xfs_dqflush_done(dqp);
1173 *bpp = bp;
1174 return 0;
1175
1176out_unlock:
1177 xfs_dqfunlock(dqp);
1178 return XFS_ERROR(EIO);
1179}
1180
1181
1182
1183
1184
1185
1186
1187void
1188xfs_dqlock2(
1189 xfs_dquot_t *d1,
1190 xfs_dquot_t *d2)
1191{
1192 if (d1 && d2) {
1193 ASSERT(d1 != d2);
1194 if (be32_to_cpu(d1->q_core.d_id) >
1195 be32_to_cpu(d2->q_core.d_id)) {
1196 mutex_lock(&d2->q_qlock);
1197 mutex_lock_nested(&d1->q_qlock, XFS_QLOCK_NESTED);
1198 } else {
1199 mutex_lock(&d1->q_qlock);
1200 mutex_lock_nested(&d2->q_qlock, XFS_QLOCK_NESTED);
1201 }
1202 } else if (d1) {
1203 mutex_lock(&d1->q_qlock);
1204 } else if (d2) {
1205 mutex_lock(&d2->q_qlock);
1206 }
1207}
1208
1209int __init
1210xfs_qm_init(void)
1211{
1212 xfs_qm_dqzone =
1213 kmem_zone_init(sizeof(struct xfs_dquot), "xfs_dquot");
1214 if (!xfs_qm_dqzone)
1215 goto out;
1216
1217 xfs_qm_dqtrxzone =
1218 kmem_zone_init(sizeof(struct xfs_dquot_acct), "xfs_dqtrx");
1219 if (!xfs_qm_dqtrxzone)
1220 goto out_free_dqzone;
1221
1222 return 0;
1223
1224out_free_dqzone:
1225 kmem_zone_destroy(xfs_qm_dqzone);
1226out:
1227 return -ENOMEM;
1228}
1229
1230void
1231xfs_qm_exit(void)
1232{
1233 kmem_zone_destroy(xfs_qm_dqtrxzone);
1234 kmem_zone_destroy(xfs_qm_dqzone);
1235}
1236