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_trans.h"
24#include "xfs_sb.h"
25#include "xfs_ag.h"
26#include "xfs_dir2.h"
27#include "xfs_alloc.h"
28#include "xfs_dmapi.h"
29#include "xfs_quota.h"
30#include "xfs_mount.h"
31#include "xfs_bmap_btree.h"
32#include "xfs_alloc_btree.h"
33#include "xfs_ialloc_btree.h"
34#include "xfs_dir2_sf.h"
35#include "xfs_attr_sf.h"
36#include "xfs_dinode.h"
37#include "xfs_inode.h"
38#include "xfs_btree.h"
39#include "xfs_ialloc.h"
40#include "xfs_bmap.h"
41#include "xfs_rtalloc.h"
42#include "xfs_error.h"
43#include "xfs_itable.h"
44#include "xfs_rw.h"
45#include "xfs_attr.h"
46#include "xfs_buf_item.h"
47#include "xfs_trans_space.h"
48#include "xfs_trans_priv.h"
49#include "xfs_qm.h"
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66STATIC void xfs_qm_dqflush_done(xfs_buf_t *, xfs_dq_logitem_t *);
67
68#ifdef DEBUG
69xfs_buftarg_t *xfs_dqerror_target;
70int xfs_do_dqerror;
71int xfs_dqreq_num;
72int xfs_dqerror_mod = 33;
73#endif
74
75static struct lock_class_key xfs_dquot_other_class;
76
77
78
79
80
81
82
83
84
85STATIC xfs_dquot_t *
86xfs_qm_dqinit(
87 xfs_mount_t *mp,
88 xfs_dqid_t id,
89 uint type)
90{
91 xfs_dquot_t *dqp;
92 boolean_t brandnewdquot;
93
94 brandnewdquot = xfs_qm_dqalloc_incore(&dqp);
95 dqp->dq_flags = type;
96 dqp->q_core.d_id = cpu_to_be32(id);
97 dqp->q_mount = mp;
98
99
100
101
102 if (brandnewdquot) {
103 dqp->dq_flnext = dqp->dq_flprev = dqp;
104 mutex_init(&dqp->q_qlock);
105 init_waitqueue_head(&dqp->q_pinwait);
106
107
108
109
110
111
112 init_completion(&dqp->q_flush);
113 complete(&dqp->q_flush);
114
115#ifdef XFS_DQUOT_TRACE
116 dqp->q_trace = ktrace_alloc(DQUOT_TRACE_SIZE, KM_NOFS);
117 xfs_dqtrace_entry(dqp, "DQINIT");
118#endif
119 } else {
120
121
122
123
124 dqp->q_nrefs = 0;
125 dqp->q_blkno = 0;
126 dqp->MPL_NEXT = dqp->HL_NEXT = NULL;
127 dqp->HL_PREVP = dqp->MPL_PREVP = NULL;
128 dqp->q_bufoffset = 0;
129 dqp->q_fileoffset = 0;
130 dqp->q_transp = NULL;
131 dqp->q_gdquot = NULL;
132 dqp->q_res_bcount = 0;
133 dqp->q_res_icount = 0;
134 dqp->q_res_rtbcount = 0;
135 atomic_set(&dqp->q_pincount, 0);
136 dqp->q_hash = NULL;
137 ASSERT(dqp->dq_flnext == dqp->dq_flprev);
138
139#ifdef XFS_DQUOT_TRACE
140 ASSERT(dqp->q_trace);
141 xfs_dqtrace_entry(dqp, "DQRECLAIMED_INIT");
142#endif
143 }
144
145
146
147
148
149
150 if (!(type & XFS_DQ_USER))
151 lockdep_set_class(&dqp->q_qlock, &xfs_dquot_other_class);
152
153
154
155
156 return (dqp);
157}
158
159
160
161
162void
163xfs_qm_dqdestroy(
164 xfs_dquot_t *dqp)
165{
166 ASSERT(! XFS_DQ_IS_ON_FREELIST(dqp));
167
168 mutex_destroy(&dqp->q_qlock);
169 sv_destroy(&dqp->q_pinwait);
170
171#ifdef XFS_DQUOT_TRACE
172 if (dqp->q_trace)
173 ktrace_free(dqp->q_trace);
174 dqp->q_trace = NULL;
175#endif
176 kmem_zone_free(xfs_Gqm->qm_dqzone, dqp);
177 atomic_dec(&xfs_Gqm->qm_totaldquots);
178}
179
180
181
182
183STATIC void
184xfs_qm_dqinit_core(
185 xfs_dqid_t id,
186 uint type,
187 xfs_dqblk_t *d)
188{
189
190
191
192 d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
193 d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
194 d->dd_diskdq.d_id = cpu_to_be32(id);
195 d->dd_diskdq.d_flags = type;
196}
197
198
199#ifdef XFS_DQUOT_TRACE
200
201
202
203
204void
205__xfs_dqtrace_entry(
206 xfs_dquot_t *dqp,
207 char *func,
208 void *retaddr,
209 xfs_inode_t *ip)
210{
211 xfs_dquot_t *udqp = NULL;
212 xfs_ino_t ino = 0;
213
214 ASSERT(dqp->q_trace);
215 if (ip) {
216 ino = ip->i_ino;
217 udqp = ip->i_udquot;
218 }
219 ktrace_enter(dqp->q_trace,
220 (void *)(__psint_t)DQUOT_KTRACE_ENTRY,
221 (void *)func,
222 (void *)(__psint_t)dqp->q_nrefs,
223 (void *)(__psint_t)dqp->dq_flags,
224 (void *)(__psint_t)dqp->q_res_bcount,
225 (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_bcount),
226 (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_icount),
227 (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_blk_hardlimit),
228 (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_blk_softlimit),
229 (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_ino_hardlimit),
230 (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_ino_softlimit),
231 (void *)(__psint_t)be32_to_cpu(dqp->q_core.d_id),
232 (void *)(__psint_t)current_pid(),
233 (void *)(__psint_t)ino,
234 (void *)(__psint_t)retaddr,
235 (void *)(__psint_t)udqp);
236 return;
237}
238#endif
239
240
241
242
243
244
245
246void
247xfs_qm_adjust_dqlimits(
248 xfs_mount_t *mp,
249 xfs_disk_dquot_t *d)
250{
251 xfs_quotainfo_t *q = mp->m_quotainfo;
252
253 ASSERT(d->d_id);
254
255 if (q->qi_bsoftlimit && !d->d_blk_softlimit)
256 d->d_blk_softlimit = cpu_to_be64(q->qi_bsoftlimit);
257 if (q->qi_bhardlimit && !d->d_blk_hardlimit)
258 d->d_blk_hardlimit = cpu_to_be64(q->qi_bhardlimit);
259 if (q->qi_isoftlimit && !d->d_ino_softlimit)
260 d->d_ino_softlimit = cpu_to_be64(q->qi_isoftlimit);
261 if (q->qi_ihardlimit && !d->d_ino_hardlimit)
262 d->d_ino_hardlimit = cpu_to_be64(q->qi_ihardlimit);
263 if (q->qi_rtbsoftlimit && !d->d_rtb_softlimit)
264 d->d_rtb_softlimit = cpu_to_be64(q->qi_rtbsoftlimit);
265 if (q->qi_rtbhardlimit && !d->d_rtb_hardlimit)
266 d->d_rtb_hardlimit = cpu_to_be64(q->qi_rtbhardlimit);
267}
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282void
283xfs_qm_adjust_dqtimers(
284 xfs_mount_t *mp,
285 xfs_disk_dquot_t *d)
286{
287 ASSERT(d->d_id);
288
289#ifdef QUOTADEBUG
290 if (d->d_blk_hardlimit)
291 ASSERT(be64_to_cpu(d->d_blk_softlimit) <=
292 be64_to_cpu(d->d_blk_hardlimit));
293 if (d->d_ino_hardlimit)
294 ASSERT(be64_to_cpu(d->d_ino_softlimit) <=
295 be64_to_cpu(d->d_ino_hardlimit));
296 if (d->d_rtb_hardlimit)
297 ASSERT(be64_to_cpu(d->d_rtb_softlimit) <=
298 be64_to_cpu(d->d_rtb_hardlimit));
299#endif
300 if (!d->d_btimer) {
301 if ((d->d_blk_softlimit &&
302 (be64_to_cpu(d->d_bcount) >=
303 be64_to_cpu(d->d_blk_softlimit))) ||
304 (d->d_blk_hardlimit &&
305 (be64_to_cpu(d->d_bcount) >=
306 be64_to_cpu(d->d_blk_hardlimit)))) {
307 d->d_btimer = cpu_to_be32(get_seconds() +
308 XFS_QI_BTIMELIMIT(mp));
309 } else {
310 d->d_bwarns = 0;
311 }
312 } else {
313 if ((!d->d_blk_softlimit ||
314 (be64_to_cpu(d->d_bcount) <
315 be64_to_cpu(d->d_blk_softlimit))) &&
316 (!d->d_blk_hardlimit ||
317 (be64_to_cpu(d->d_bcount) <
318 be64_to_cpu(d->d_blk_hardlimit)))) {
319 d->d_btimer = 0;
320 }
321 }
322
323 if (!d->d_itimer) {
324 if ((d->d_ino_softlimit &&
325 (be64_to_cpu(d->d_icount) >=
326 be64_to_cpu(d->d_ino_softlimit))) ||
327 (d->d_ino_hardlimit &&
328 (be64_to_cpu(d->d_icount) >=
329 be64_to_cpu(d->d_ino_hardlimit)))) {
330 d->d_itimer = cpu_to_be32(get_seconds() +
331 XFS_QI_ITIMELIMIT(mp));
332 } else {
333 d->d_iwarns = 0;
334 }
335 } else {
336 if ((!d->d_ino_softlimit ||
337 (be64_to_cpu(d->d_icount) <
338 be64_to_cpu(d->d_ino_softlimit))) &&
339 (!d->d_ino_hardlimit ||
340 (be64_to_cpu(d->d_icount) <
341 be64_to_cpu(d->d_ino_hardlimit)))) {
342 d->d_itimer = 0;
343 }
344 }
345
346 if (!d->d_rtbtimer) {
347 if ((d->d_rtb_softlimit &&
348 (be64_to_cpu(d->d_rtbcount) >=
349 be64_to_cpu(d->d_rtb_softlimit))) ||
350 (d->d_rtb_hardlimit &&
351 (be64_to_cpu(d->d_rtbcount) >=
352 be64_to_cpu(d->d_rtb_hardlimit)))) {
353 d->d_rtbtimer = cpu_to_be32(get_seconds() +
354 XFS_QI_RTBTIMELIMIT(mp));
355 } else {
356 d->d_rtbwarns = 0;
357 }
358 } else {
359 if ((!d->d_rtb_softlimit ||
360 (be64_to_cpu(d->d_rtbcount) <
361 be64_to_cpu(d->d_rtb_softlimit))) &&
362 (!d->d_rtb_hardlimit ||
363 (be64_to_cpu(d->d_rtbcount) <
364 be64_to_cpu(d->d_rtb_hardlimit)))) {
365 d->d_rtbtimer = 0;
366 }
367 }
368}
369
370
371
372
373STATIC void
374xfs_qm_init_dquot_blk(
375 xfs_trans_t *tp,
376 xfs_mount_t *mp,
377 xfs_dqid_t id,
378 uint type,
379 xfs_buf_t *bp)
380{
381 xfs_dqblk_t *d;
382 int curid, i;
383
384 ASSERT(tp);
385 ASSERT(XFS_BUF_ISBUSY(bp));
386 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
387
388 d = (xfs_dqblk_t *)XFS_BUF_PTR(bp);
389
390
391
392
393 curid = id - (id % XFS_QM_DQPERBLK(mp));
394 ASSERT(curid >= 0);
395 memset(d, 0, BBTOB(XFS_QI_DQCHUNKLEN(mp)));
396 for (i = 0; i < XFS_QM_DQPERBLK(mp); i++, d++, curid++)
397 xfs_qm_dqinit_core(curid, type, d);
398 xfs_trans_dquot_buf(tp, bp,
399 (type & XFS_DQ_USER ? XFS_BLI_UDQUOT_BUF :
400 ((type & XFS_DQ_PROJ) ? XFS_BLI_PDQUOT_BUF :
401 XFS_BLI_GDQUOT_BUF)));
402 xfs_trans_log_buf(tp, bp, 0, BBTOB(XFS_QI_DQCHUNKLEN(mp)) - 1);
403}
404
405
406
407
408
409
410
411STATIC int
412xfs_qm_dqalloc(
413 xfs_trans_t **tpp,
414 xfs_mount_t *mp,
415 xfs_dquot_t *dqp,
416 xfs_inode_t *quotip,
417 xfs_fileoff_t offset_fsb,
418 xfs_buf_t **O_bpp)
419{
420 xfs_fsblock_t firstblock;
421 xfs_bmap_free_t flist;
422 xfs_bmbt_irec_t map;
423 int nmaps, error, committed;
424 xfs_buf_t *bp;
425 xfs_trans_t *tp = *tpp;
426
427 ASSERT(tp != NULL);
428 xfs_dqtrace_entry(dqp, "DQALLOC");
429
430
431
432
433 xfs_bmap_init(&flist, &firstblock);
434 xfs_ilock(quotip, XFS_ILOCK_EXCL);
435
436
437
438
439 if (XFS_IS_THIS_QUOTA_OFF(dqp)) {
440 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
441 return (ESRCH);
442 }
443
444
445
446
447
448
449 IHOLD(quotip);
450
451 xfs_trans_ijoin(tp, quotip, XFS_ILOCK_EXCL);
452 nmaps = 1;
453 if ((error = xfs_bmapi(tp, quotip,
454 offset_fsb, XFS_DQUOT_CLUSTER_SIZE_FSB,
455 XFS_BMAPI_METADATA | XFS_BMAPI_WRITE,
456 &firstblock,
457 XFS_QM_DQALLOC_SPACE_RES(mp),
458 &map, &nmaps, &flist, NULL))) {
459 goto error0;
460 }
461 ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB);
462 ASSERT(nmaps == 1);
463 ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
464 (map.br_startblock != HOLESTARTBLOCK));
465
466
467
468
469 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
470
471
472 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
473 dqp->q_blkno,
474 XFS_QI_DQCHUNKLEN(mp),
475 0);
476 if (!bp || (error = XFS_BUF_GETERROR(bp)))
477 goto error1;
478
479
480
481
482 xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id),
483 dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498 xfs_trans_bhold(tp, bp);
499
500 if ((error = xfs_bmap_finish(tpp, &flist, &committed))) {
501 goto error1;
502 }
503
504 if (committed) {
505 tp = *tpp;
506 xfs_trans_bjoin(tp, bp);
507 } else {
508 xfs_trans_bhold_release(tp, bp);
509 }
510
511 *O_bpp = bp;
512 return 0;
513
514 error1:
515 xfs_bmap_cancel(&flist);
516 error0:
517 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
518
519 return (error);
520}
521
522
523
524
525
526
527STATIC int
528xfs_qm_dqtobp(
529 xfs_trans_t **tpp,
530 xfs_dquot_t *dqp,
531 xfs_disk_dquot_t **O_ddpp,
532 xfs_buf_t **O_bpp,
533 uint flags)
534{
535 xfs_bmbt_irec_t map;
536 int nmaps, error;
537 xfs_buf_t *bp;
538 xfs_inode_t *quotip;
539 xfs_mount_t *mp;
540 xfs_disk_dquot_t *ddq;
541 xfs_dqid_t id;
542 boolean_t newdquot;
543 xfs_trans_t *tp = (tpp ? *tpp : NULL);
544
545 mp = dqp->q_mount;
546 id = be32_to_cpu(dqp->q_core.d_id);
547 nmaps = 1;
548 newdquot = B_FALSE;
549
550
551
552
553 if (dqp->q_blkno == (xfs_daddr_t) 0) {
554
555 dqp->q_fileoffset = (xfs_fileoff_t)id / XFS_QM_DQPERBLK(mp);
556 nmaps = 1;
557 quotip = XFS_DQ_TO_QIP(dqp);
558 xfs_ilock(quotip, XFS_ILOCK_SHARED);
559
560
561
562
563 if (XFS_IS_THIS_QUOTA_OFF(dqp)) {
564 xfs_iunlock(quotip, XFS_ILOCK_SHARED);
565 return (ESRCH);
566 }
567
568
569
570 error = xfs_bmapi(NULL, quotip, dqp->q_fileoffset,
571 XFS_DQUOT_CLUSTER_SIZE_FSB,
572 XFS_BMAPI_METADATA,
573 NULL, 0, &map, &nmaps, NULL, NULL);
574
575 xfs_iunlock(quotip, XFS_ILOCK_SHARED);
576 if (error)
577 return (error);
578 ASSERT(nmaps == 1);
579 ASSERT(map.br_blockcount == 1);
580
581
582
583
584 dqp->q_bufoffset = (id % XFS_QM_DQPERBLK(mp)) *
585 sizeof(xfs_dqblk_t);
586 if (map.br_startblock == HOLESTARTBLOCK) {
587
588
589
590 if (!(flags & XFS_QMOPT_DQALLOC))
591 return (ENOENT);
592
593 ASSERT(tp);
594 if ((error = xfs_qm_dqalloc(tpp, mp, dqp, quotip,
595 dqp->q_fileoffset, &bp)))
596 return (error);
597 tp = *tpp;
598 newdquot = B_TRUE;
599 } else {
600
601
602
603
604 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
605 }
606 }
607 ASSERT(dqp->q_blkno != DELAYSTARTBLOCK);
608 ASSERT(dqp->q_blkno != HOLESTARTBLOCK);
609
610
611
612
613
614 if (! newdquot) {
615 xfs_dqtrace_entry(dqp, "DQTOBP READBUF");
616 if ((error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
617 dqp->q_blkno,
618 XFS_QI_DQCHUNKLEN(mp),
619 0, &bp))) {
620 return (error);
621 }
622 if (error || !bp)
623 return XFS_ERROR(error);
624 }
625 ASSERT(XFS_BUF_ISBUSY(bp));
626 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
627
628
629
630
631 ddq = (xfs_disk_dquot_t *)((char *)XFS_BUF_PTR(bp) + dqp->q_bufoffset);
632
633
634
635
636 if (xfs_qm_dqcheck(ddq, id, dqp->dq_flags & XFS_DQ_ALLTYPES,
637 flags & (XFS_QMOPT_DQREPAIR|XFS_QMOPT_DOWARN),
638 "dqtobp")) {
639 if (!(flags & XFS_QMOPT_DQREPAIR)) {
640 xfs_trans_brelse(tp, bp);
641 return XFS_ERROR(EIO);
642 }
643 XFS_BUF_BUSY(bp);
644 }
645
646 *O_bpp = bp;
647 *O_ddpp = ddq;
648
649 return (0);
650}
651
652
653
654
655
656
657
658
659STATIC int
660xfs_qm_dqread(
661 xfs_trans_t **tpp,
662 xfs_dqid_t id,
663 xfs_dquot_t *dqp,
664 uint flags)
665{
666 xfs_disk_dquot_t *ddqp;
667 xfs_buf_t *bp;
668 int error;
669 xfs_trans_t *tp;
670
671 ASSERT(tpp);
672
673
674
675
676
677 xfs_dqtrace_entry(dqp, "DQREAD");
678 if ((error = xfs_qm_dqtobp(tpp, dqp, &ddqp, &bp, flags))) {
679 return (error);
680 }
681 tp = *tpp;
682
683
684 memcpy(&dqp->q_core, ddqp, sizeof(xfs_disk_dquot_t));
685 ASSERT(be32_to_cpu(dqp->q_core.d_id) == id);
686 xfs_qm_dquot_logitem_init(dqp);
687
688
689
690
691
692 dqp->q_res_bcount = be64_to_cpu(ddqp->d_bcount);
693 dqp->q_res_icount = be64_to_cpu(ddqp->d_icount);
694 dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount);
695
696
697 XFS_BUF_SET_VTYPE_REF(bp, B_FS_DQUOT, XFS_DQUOT_REF);
698
699
700
701
702
703
704
705
706
707
708
709
710
711 ASSERT(XFS_BUF_ISBUSY(bp));
712 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
713 xfs_trans_brelse(tp, bp);
714
715 return (error);
716}
717
718
719
720
721
722
723
724
725STATIC int
726xfs_qm_idtodq(
727 xfs_mount_t *mp,
728 xfs_dqid_t id,
729 uint type,
730 uint flags,
731 xfs_dquot_t **O_dqpp)
732{
733 xfs_dquot_t *dqp;
734 int error;
735 xfs_trans_t *tp;
736 int cancelflags=0;
737
738 dqp = xfs_qm_dqinit(mp, id, type);
739 tp = NULL;
740 if (flags & XFS_QMOPT_DQALLOC) {
741 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_DQALLOC);
742 if ((error = xfs_trans_reserve(tp,
743 XFS_QM_DQALLOC_SPACE_RES(mp),
744 XFS_WRITE_LOG_RES(mp) +
745 BBTOB(XFS_QI_DQCHUNKLEN(mp)) - 1 +
746 128,
747 0,
748 XFS_TRANS_PERM_LOG_RES,
749 XFS_WRITE_LOG_COUNT))) {
750 cancelflags = 0;
751 goto error0;
752 }
753 cancelflags = XFS_TRANS_RELEASE_LOG_RES;
754 }
755
756
757
758
759
760 if ((error = xfs_qm_dqread(&tp, id, dqp, flags))) {
761
762
763
764
765
766 xfs_dqtrace_entry(dqp, "DQREAD FAIL");
767 cancelflags |= XFS_TRANS_ABORT;
768 goto error0;
769 }
770 if (tp) {
771 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES)))
772 goto error1;
773 }
774
775 *O_dqpp = dqp;
776 return (0);
777
778 error0:
779 ASSERT(error);
780 if (tp)
781 xfs_trans_cancel(tp, cancelflags);
782 error1:
783 xfs_qm_dqdestroy(dqp);
784 *O_dqpp = NULL;
785 return (error);
786}
787
788
789
790
791
792
793
794
795STATIC int
796xfs_qm_dqlookup(
797 xfs_mount_t *mp,
798 xfs_dqid_t id,
799 xfs_dqhash_t *qh,
800 xfs_dquot_t **O_dqpp)
801{
802 xfs_dquot_t *dqp;
803 uint flist_locked;
804 xfs_dquot_t *d;
805
806 ASSERT(mutex_is_locked(&qh->qh_lock));
807
808 flist_locked = B_FALSE;
809
810
811
812
813 for (dqp = qh->qh_next; dqp != NULL; dqp = dqp->HL_NEXT) {
814
815
816
817
818
819 if (be32_to_cpu(dqp->q_core.d_id) == id && dqp->q_mount == mp) {
820 xfs_dqtrace_entry(dqp, "DQFOUND BY LOOKUP");
821
822
823
824 ASSERT(dqp->MPL_PREVP != NULL);
825
826 xfs_dqlock(dqp);
827 if (dqp->q_nrefs == 0) {
828 ASSERT (XFS_DQ_IS_ON_FREELIST(dqp));
829 if (! xfs_qm_freelist_lock_nowait(xfs_Gqm)) {
830 xfs_dqtrace_entry(dqp, "DQLOOKUP: WANT");
831
832
833
834
835
836
837 dqp->dq_flags |= XFS_DQ_WANT;
838 xfs_dqunlock(dqp);
839 xfs_qm_freelist_lock(xfs_Gqm);
840 xfs_dqlock(dqp);
841 dqp->dq_flags &= ~(XFS_DQ_WANT);
842 }
843 flist_locked = B_TRUE;
844 }
845
846
847
848
849
850 ASSERT(be32_to_cpu(dqp->q_core.d_id) == id);
851
852 if (flist_locked) {
853 if (dqp->q_nrefs != 0) {
854 xfs_qm_freelist_unlock(xfs_Gqm);
855 flist_locked = B_FALSE;
856 } else {
857
858
859
860 xfs_dqtrace_entry(dqp,
861 "DQLOOKUP: TAKEOFF FL");
862 XQM_FREELIST_REMOVE(dqp);
863
864
865
866 }
867 }
868
869
870
871
872 XFS_DQHOLD(dqp);
873
874 if (flist_locked)
875 xfs_qm_freelist_unlock(xfs_Gqm);
876
877
878
879 ASSERT(mutex_is_locked(&qh->qh_lock));
880 if (dqp->HL_PREVP != &qh->qh_next) {
881 xfs_dqtrace_entry(dqp,
882 "DQLOOKUP: HASH MOVETOFRONT");
883 if ((d = dqp->HL_NEXT))
884 d->HL_PREVP = dqp->HL_PREVP;
885 *(dqp->HL_PREVP) = d;
886 d = qh->qh_next;
887 d->HL_PREVP = &dqp->HL_NEXT;
888 dqp->HL_NEXT = d;
889 dqp->HL_PREVP = &qh->qh_next;
890 qh->qh_next = dqp;
891 }
892 xfs_dqtrace_entry(dqp, "LOOKUP END");
893 *O_dqpp = dqp;
894 ASSERT(mutex_is_locked(&qh->qh_lock));
895 return (0);
896 }
897 }
898
899 *O_dqpp = NULL;
900 ASSERT(mutex_is_locked(&qh->qh_lock));
901 return (1);
902}
903
904
905
906
907
908
909
910
911
912int
913xfs_qm_dqget(
914 xfs_mount_t *mp,
915 xfs_inode_t *ip,
916 xfs_dqid_t id,
917 uint type,
918 uint flags,
919 xfs_dquot_t **O_dqpp)
920{
921 xfs_dquot_t *dqp;
922 xfs_dqhash_t *h;
923 uint version;
924 int error;
925
926 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
927 if ((! XFS_IS_UQUOTA_ON(mp) && type == XFS_DQ_USER) ||
928 (! XFS_IS_PQUOTA_ON(mp) && type == XFS_DQ_PROJ) ||
929 (! XFS_IS_GQUOTA_ON(mp) && type == XFS_DQ_GROUP)) {
930 return (ESRCH);
931 }
932 h = XFS_DQ_HASH(mp, id, type);
933
934#ifdef DEBUG
935 if (xfs_do_dqerror) {
936 if ((xfs_dqerror_target == mp->m_ddev_targp) &&
937 (xfs_dqreq_num++ % xfs_dqerror_mod) == 0) {
938 cmn_err(CE_DEBUG, "Returning error in dqget");
939 return (EIO);
940 }
941 }
942#endif
943
944 again:
945
946#ifdef DEBUG
947 ASSERT(type == XFS_DQ_USER ||
948 type == XFS_DQ_PROJ ||
949 type == XFS_DQ_GROUP);
950 if (ip) {
951 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
952 if (type == XFS_DQ_USER)
953 ASSERT(ip->i_udquot == NULL);
954 else
955 ASSERT(ip->i_gdquot == NULL);
956 }
957#endif
958 mutex_lock(&h->qh_lock);
959
960
961
962
963
964 if (xfs_qm_dqlookup(mp, id, h, O_dqpp) == 0) {
965 XQM_STATS_INC(xqmstats.xs_qm_dqcachehits);
966
967
968
969
970
971 ASSERT(*O_dqpp);
972 ASSERT(XFS_DQ_IS_LOCKED(*O_dqpp));
973 mutex_unlock(&h->qh_lock);
974 xfs_dqtrace_entry(*O_dqpp, "DQGET DONE (FROM CACHE)");
975 return (0);
976 }
977 XQM_STATS_INC(xqmstats.xs_qm_dqcachemisses);
978
979
980
981
982
983
984
985
986 if (ip)
987 xfs_iunlock(ip, XFS_ILOCK_EXCL);
988
989
990
991
992 version = h->qh_version;
993 mutex_unlock(&h->qh_lock);
994
995
996
997
998
999
1000
1001 if ((error = xfs_qm_idtodq(mp, id, type,
1002 flags & (XFS_QMOPT_DQALLOC|XFS_QMOPT_DQREPAIR|
1003 XFS_QMOPT_DOWARN),
1004 &dqp))) {
1005 if (ip)
1006 xfs_ilock(ip, XFS_ILOCK_EXCL);
1007 return (error);
1008 }
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018 if (flags & XFS_QMOPT_DQSUSER) {
1019 ASSERT(id == 0);
1020 ASSERT(! ip);
1021 goto dqret;
1022 }
1023
1024
1025
1026
1027 if (ip) {
1028 xfs_ilock(ip, XFS_ILOCK_EXCL);
1029 if (! XFS_IS_DQTYPE_ON(mp, type)) {
1030
1031 xfs_qm_dqdestroy(dqp);
1032 return XFS_ERROR(ESRCH);
1033 }
1034
1035
1036
1037
1038 if (type == XFS_DQ_USER) {
1039 if (ip->i_udquot) {
1040 xfs_qm_dqdestroy(dqp);
1041 dqp = ip->i_udquot;
1042 xfs_dqlock(dqp);
1043 goto dqret;
1044 }
1045 } else {
1046 if (ip->i_gdquot) {
1047 xfs_qm_dqdestroy(dqp);
1048 dqp = ip->i_gdquot;
1049 xfs_dqlock(dqp);
1050 goto dqret;
1051 }
1052 }
1053 }
1054
1055
1056
1057
1058 mutex_lock(&h->qh_lock);
1059 if (version != h->qh_version) {
1060 xfs_dquot_t *tmpdqp;
1061
1062
1063
1064
1065
1066
1067
1068 if (xfs_qm_dqlookup(mp, id, h, &tmpdqp) == 0) {
1069
1070
1071
1072
1073 xfs_qm_dqput(tmpdqp);
1074 mutex_unlock(&h->qh_lock);
1075 xfs_qm_dqdestroy(dqp);
1076 XQM_STATS_INC(xqmstats.xs_qm_dquot_dups);
1077 goto again;
1078 }
1079 }
1080
1081
1082
1083
1084
1085 ASSERT(mutex_is_locked(&h->qh_lock));
1086 dqp->q_hash = h;
1087 XQM_HASHLIST_INSERT(h, dqp);
1088
1089
1090
1091
1092
1093 xfs_qm_mplist_lock(mp);
1094
1095
1096
1097
1098 xfs_dqlock(dqp);
1099 dqp->q_nrefs = 1;
1100
1101 XQM_MPLIST_INSERT(&(XFS_QI_MPL_LIST(mp)), dqp);
1102
1103 xfs_qm_mplist_unlock(mp);
1104 mutex_unlock(&h->qh_lock);
1105 dqret:
1106 ASSERT((ip == NULL) || xfs_isilocked(ip, XFS_ILOCK_EXCL));
1107 xfs_dqtrace_entry(dqp, "DQGET DONE");
1108 *O_dqpp = dqp;
1109 return (0);
1110}
1111
1112
1113
1114
1115
1116
1117
1118
1119void
1120xfs_qm_dqput(
1121 xfs_dquot_t *dqp)
1122{
1123 xfs_dquot_t *gdqp;
1124
1125 ASSERT(dqp->q_nrefs > 0);
1126 ASSERT(XFS_DQ_IS_LOCKED(dqp));
1127 xfs_dqtrace_entry(dqp, "DQPUT");
1128
1129 if (dqp->q_nrefs != 1) {
1130 dqp->q_nrefs--;
1131 xfs_dqunlock(dqp);
1132 return;
1133 }
1134
1135
1136
1137
1138
1139 if (! xfs_qm_freelist_lock_nowait(xfs_Gqm)) {
1140 xfs_dqtrace_entry(dqp, "DQPUT: FLLOCK-WAIT");
1141 xfs_dqunlock(dqp);
1142 xfs_qm_freelist_lock(xfs_Gqm);
1143 xfs_dqlock(dqp);
1144 }
1145
1146 while (1) {
1147 gdqp = NULL;
1148
1149
1150 if (--dqp->q_nrefs == 0) {
1151 xfs_dqtrace_entry(dqp, "DQPUT: ON FREELIST");
1152
1153
1154
1155 XQM_FREELIST_INSERT(&(xfs_Gqm->qm_dqfreelist), dqp);
1156
1157
1158
1159
1160
1161
1162
1163 if ((gdqp = dqp->q_gdquot)) {
1164
1165
1166
1167 xfs_dqlock(gdqp);
1168 dqp->q_gdquot = NULL;
1169 }
1170
1171
1172
1173
1174 }
1175 xfs_dqunlock(dqp);
1176
1177
1178
1179
1180
1181 if (! gdqp)
1182 break;
1183 dqp = gdqp;
1184 }
1185 xfs_qm_freelist_unlock(xfs_Gqm);
1186}
1187
1188
1189
1190
1191
1192void
1193xfs_qm_dqrele(
1194 xfs_dquot_t *dqp)
1195{
1196 if (!dqp)
1197 return;
1198
1199 xfs_dqtrace_entry(dqp, "DQRELE");
1200
1201 xfs_dqlock(dqp);
1202
1203
1204
1205
1206
1207
1208 xfs_qm_dqput(dqp);
1209}
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220int
1221xfs_qm_dqflush(
1222 xfs_dquot_t *dqp,
1223 uint flags)
1224{
1225 xfs_mount_t *mp;
1226 xfs_buf_t *bp;
1227 xfs_disk_dquot_t *ddqp;
1228 int error;
1229
1230 ASSERT(XFS_DQ_IS_LOCKED(dqp));
1231 ASSERT(!completion_done(&dqp->q_flush));
1232 xfs_dqtrace_entry(dqp, "DQFLUSH");
1233
1234
1235
1236
1237
1238 if (!XFS_DQ_IS_DIRTY(dqp) ||
1239 (!(flags & XFS_QMOPT_SYNC) && atomic_read(&dqp->q_pincount) > 0)) {
1240 xfs_dqfunlock(dqp);
1241 return 0;
1242 }
1243 xfs_qm_dqunpin_wait(dqp);
1244
1245
1246
1247
1248
1249
1250 if (XFS_FORCED_SHUTDOWN(dqp->q_mount)) {
1251 dqp->dq_flags &= ~(XFS_DQ_DIRTY);
1252 xfs_dqfunlock(dqp);
1253 return XFS_ERROR(EIO);
1254 }
1255
1256
1257
1258
1259
1260
1261 if ((error = xfs_qm_dqtobp(NULL, dqp, &ddqp, &bp, XFS_QMOPT_DOWARN))) {
1262 xfs_dqtrace_entry(dqp, "DQTOBP FAIL");
1263 ASSERT(error != ENOENT);
1264
1265
1266
1267 xfs_dqfunlock(dqp);
1268 return (error);
1269 }
1270
1271 if (xfs_qm_dqcheck(&dqp->q_core, be32_to_cpu(ddqp->d_id),
1272 0, XFS_QMOPT_DOWARN, "dqflush (incore copy)")) {
1273 xfs_force_shutdown(dqp->q_mount, SHUTDOWN_CORRUPT_INCORE);
1274 return XFS_ERROR(EIO);
1275 }
1276
1277
1278 memcpy(ddqp, &(dqp->q_core), sizeof(xfs_disk_dquot_t));
1279
1280
1281
1282
1283 dqp->dq_flags &= ~(XFS_DQ_DIRTY);
1284 mp = dqp->q_mount;
1285
1286 xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn,
1287 &dqp->q_logitem.qli_item.li_lsn);
1288
1289
1290
1291
1292
1293 xfs_buf_attach_iodone(bp, (void(*)(xfs_buf_t *, xfs_log_item_t *))
1294 xfs_qm_dqflush_done, &(dqp->q_logitem.qli_item));
1295
1296
1297
1298
1299 if (XFS_BUF_ISPINNED(bp)) {
1300 xfs_dqtrace_entry(dqp, "DQFLUSH LOG FORCE");
1301 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE);
1302 }
1303
1304 if (flags & XFS_QMOPT_DELWRI) {
1305 xfs_bdwrite(mp, bp);
1306 } else if (flags & XFS_QMOPT_ASYNC) {
1307 error = xfs_bawrite(mp, bp);
1308 } else {
1309 error = xfs_bwrite(mp, bp);
1310 }
1311 xfs_dqtrace_entry(dqp, "DQFLUSH END");
1312
1313
1314
1315 return (error);
1316
1317}
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327STATIC void
1328xfs_qm_dqflush_done(
1329 xfs_buf_t *bp,
1330 xfs_dq_logitem_t *qip)
1331{
1332 xfs_dquot_t *dqp;
1333 struct xfs_ail *ailp;
1334
1335 dqp = qip->qli_dquot;
1336 ailp = qip->qli_item.li_ailp;
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346 if ((qip->qli_item.li_flags & XFS_LI_IN_AIL) &&
1347 qip->qli_item.li_lsn == qip->qli_flush_lsn) {
1348
1349
1350 spin_lock(&ailp->xa_lock);
1351 if (qip->qli_item.li_lsn == qip->qli_flush_lsn)
1352 xfs_trans_ail_delete(ailp, (xfs_log_item_t*)qip);
1353 else
1354 spin_unlock(&ailp->xa_lock);
1355 }
1356
1357
1358
1359
1360 xfs_dqfunlock(dqp);
1361}
1362
1363int
1364xfs_qm_dqlock_nowait(
1365 xfs_dquot_t *dqp)
1366{
1367 return mutex_trylock(&dqp->q_qlock);
1368}
1369
1370void
1371xfs_dqlock(
1372 xfs_dquot_t *dqp)
1373{
1374 mutex_lock(&dqp->q_qlock);
1375}
1376
1377void
1378xfs_dqunlock(
1379 xfs_dquot_t *dqp)
1380{
1381 mutex_unlock(&(dqp->q_qlock));
1382 if (dqp->q_logitem.qli_dquot == dqp) {
1383
1384 xfs_trans_unlocked_item(dqp->q_logitem.qli_item.li_ailp,
1385 (xfs_log_item_t*)&(dqp->q_logitem));
1386 }
1387}
1388
1389
1390void
1391xfs_dqunlock_nonotify(
1392 xfs_dquot_t *dqp)
1393{
1394 mutex_unlock(&(dqp->q_qlock));
1395}
1396
1397
1398
1399
1400
1401
1402
1403void
1404xfs_dqlock2(
1405 xfs_dquot_t *d1,
1406 xfs_dquot_t *d2)
1407{
1408 if (d1 && d2) {
1409 ASSERT(d1 != d2);
1410 if (be32_to_cpu(d1->q_core.d_id) >
1411 be32_to_cpu(d2->q_core.d_id)) {
1412 mutex_lock(&d2->q_qlock);
1413 mutex_lock_nested(&d1->q_qlock, XFS_QLOCK_NESTED);
1414 } else {
1415 mutex_lock(&d1->q_qlock);
1416 mutex_lock_nested(&d2->q_qlock, XFS_QLOCK_NESTED);
1417 }
1418 } else if (d1) {
1419 mutex_lock(&d1->q_qlock);
1420 } else if (d2) {
1421 mutex_lock(&d2->q_qlock);
1422 }
1423}
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436int
1437xfs_qm_dqpurge(
1438 xfs_dquot_t *dqp)
1439{
1440 xfs_dqhash_t *thishash;
1441 xfs_mount_t *mp = dqp->q_mount;
1442
1443 ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
1444 ASSERT(mutex_is_locked(&dqp->q_hash->qh_lock));
1445
1446 xfs_dqlock(dqp);
1447
1448
1449
1450
1451
1452
1453
1454
1455 if (dqp->q_nrefs != 0) {
1456 xfs_dqunlock(dqp);
1457 mutex_unlock(&dqp->q_hash->qh_lock);
1458 return (1);
1459 }
1460
1461 ASSERT(XFS_DQ_IS_ON_FREELIST(dqp));
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471 if (!xfs_dqflock_nowait(dqp)) {
1472
1473
1474
1475
1476 xfs_qm_dqflock_pushbuf_wait(dqp);
1477 }
1478
1479
1480
1481
1482
1483
1484 if (XFS_DQ_IS_DIRTY(dqp)) {
1485 int error;
1486 xfs_dqtrace_entry(dqp, "DQPURGE ->DQFLUSH: DQDIRTY");
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496 error = xfs_qm_dqflush(dqp, XFS_QMOPT_SYNC);
1497 if (error)
1498 xfs_fs_cmn_err(CE_WARN, mp,
1499 "xfs_qm_dqpurge: dquot %p flush failed", dqp);
1500 xfs_dqflock(dqp);
1501 }
1502 ASSERT(atomic_read(&dqp->q_pincount) == 0);
1503 ASSERT(XFS_FORCED_SHUTDOWN(mp) ||
1504 !(dqp->q_logitem.qli_item.li_flags & XFS_LI_IN_AIL));
1505
1506 thishash = dqp->q_hash;
1507 XQM_HASHLIST_REMOVE(thishash, dqp);
1508 XQM_MPLIST_REMOVE(&(XFS_QI_MPL_LIST(mp)), dqp);
1509
1510
1511
1512
1513 ASSERT(XFS_DQ_IS_ON_FREELIST(dqp));
1514
1515 dqp->q_mount = NULL;
1516 dqp->q_hash = NULL;
1517 dqp->dq_flags = XFS_DQ_INACTIVE;
1518 memset(&dqp->q_core, 0, sizeof(dqp->q_core));
1519 xfs_dqfunlock(dqp);
1520 xfs_dqunlock(dqp);
1521 mutex_unlock(&thishash->qh_lock);
1522 return (0);
1523}
1524
1525
1526#ifdef QUOTADEBUG
1527void
1528xfs_qm_dqprint(xfs_dquot_t *dqp)
1529{
1530 cmn_err(CE_DEBUG, "-----------KERNEL DQUOT----------------");
1531 cmn_err(CE_DEBUG, "---- dquotID = %d",
1532 (int)be32_to_cpu(dqp->q_core.d_id));
1533 cmn_err(CE_DEBUG, "---- type = %s", DQFLAGTO_TYPESTR(dqp));
1534 cmn_err(CE_DEBUG, "---- fs = 0x%p", dqp->q_mount);
1535 cmn_err(CE_DEBUG, "---- blkno = 0x%x", (int) dqp->q_blkno);
1536 cmn_err(CE_DEBUG, "---- boffset = 0x%x", (int) dqp->q_bufoffset);
1537 cmn_err(CE_DEBUG, "---- blkhlimit = %Lu (0x%x)",
1538 be64_to_cpu(dqp->q_core.d_blk_hardlimit),
1539 (int)be64_to_cpu(dqp->q_core.d_blk_hardlimit));
1540 cmn_err(CE_DEBUG, "---- blkslimit = %Lu (0x%x)",
1541 be64_to_cpu(dqp->q_core.d_blk_softlimit),
1542 (int)be64_to_cpu(dqp->q_core.d_blk_softlimit));
1543 cmn_err(CE_DEBUG, "---- inohlimit = %Lu (0x%x)",
1544 be64_to_cpu(dqp->q_core.d_ino_hardlimit),
1545 (int)be64_to_cpu(dqp->q_core.d_ino_hardlimit));
1546 cmn_err(CE_DEBUG, "---- inoslimit = %Lu (0x%x)",
1547 be64_to_cpu(dqp->q_core.d_ino_softlimit),
1548 (int)be64_to_cpu(dqp->q_core.d_ino_softlimit));
1549 cmn_err(CE_DEBUG, "---- bcount = %Lu (0x%x)",
1550 be64_to_cpu(dqp->q_core.d_bcount),
1551 (int)be64_to_cpu(dqp->q_core.d_bcount));
1552 cmn_err(CE_DEBUG, "---- icount = %Lu (0x%x)",
1553 be64_to_cpu(dqp->q_core.d_icount),
1554 (int)be64_to_cpu(dqp->q_core.d_icount));
1555 cmn_err(CE_DEBUG, "---- btimer = %d",
1556 (int)be32_to_cpu(dqp->q_core.d_btimer));
1557 cmn_err(CE_DEBUG, "---- itimer = %d",
1558 (int)be32_to_cpu(dqp->q_core.d_itimer));
1559 cmn_err(CE_DEBUG, "---------------------------");
1560}
1561#endif
1562
1563
1564
1565
1566
1567void
1568xfs_qm_dqflock_pushbuf_wait(
1569 xfs_dquot_t *dqp)
1570{
1571 xfs_buf_t *bp;
1572
1573
1574
1575
1576
1577
1578
1579 bp = xfs_incore(dqp->q_mount->m_ddev_targp, dqp->q_blkno,
1580 XFS_QI_DQCHUNKLEN(dqp->q_mount),
1581 XFS_INCORE_TRYLOCK);
1582 if (bp != NULL) {
1583 if (XFS_BUF_ISDELAYWRITE(bp)) {
1584 int error;
1585 if (XFS_BUF_ISPINNED(bp)) {
1586 xfs_log_force(dqp->q_mount,
1587 (xfs_lsn_t)0,
1588 XFS_LOG_FORCE);
1589 }
1590 error = xfs_bawrite(dqp->q_mount, bp);
1591 if (error)
1592 xfs_fs_cmn_err(CE_WARN, dqp->q_mount,
1593 "xfs_qm_dqflock_pushbuf_wait: "
1594 "pushbuf error %d on dqp %p, bp %p",
1595 error, dqp, bp);
1596 } else {
1597 xfs_buf_relse(bp);
1598 }
1599 }
1600 xfs_dqflock(dqp);
1601}
1602