This source file includes following definitions.
- xfs_buf_log_overhead
- xfs_calc_buf_res
- xfs_allocfree_log_count
- xfs_calc_inode_res
- xfs_calc_inobt_res
- xfs_calc_finobt_res
- xfs_calc_inode_chunk_res
- xfs_calc_write_reservation
- xfs_calc_itruncate_reservation
- xfs_calc_rename_reservation
- xfs_calc_iunlink_remove_reservation
- xfs_calc_link_reservation
- xfs_calc_iunlink_add_reservation
- xfs_calc_remove_reservation
- xfs_calc_create_resv_modify
- xfs_calc_icreate_resv_alloc
- xfs_calc_icreate_reservation
- xfs_calc_create_tmpfile_reservation
- xfs_calc_mkdir_reservation
- xfs_calc_symlink_reservation
- xfs_calc_ifree_reservation
- xfs_calc_ichange_reservation
- xfs_calc_growdata_reservation
- xfs_calc_growrtalloc_reservation
- xfs_calc_growrtzero_reservation
- xfs_calc_growrtfree_reservation
- xfs_calc_swrite_reservation
- xfs_calc_writeid_reservation
- xfs_calc_addafork_reservation
- xfs_calc_attrinval_reservation
- xfs_calc_attrsetm_reservation
- xfs_calc_attrsetrt_reservation
- xfs_calc_attrrm_reservation
- xfs_calc_clear_agi_bucket_reservation
- xfs_calc_qm_setqlim_reservation
- xfs_calc_qm_dqalloc_reservation
- xfs_calc_qm_quotaoff_reservation
- xfs_calc_qm_quotaoff_end_reservation
- xfs_calc_sb_reservation
- xfs_trans_resv_calc
1
2
3
4
5
6
7 #include "xfs.h"
8 #include "xfs_fs.h"
9 #include "xfs_shared.h"
10 #include "xfs_format.h"
11 #include "xfs_log_format.h"
12 #include "xfs_trans_resv.h"
13 #include "xfs_mount.h"
14 #include "xfs_da_format.h"
15 #include "xfs_da_btree.h"
16 #include "xfs_inode.h"
17 #include "xfs_bmap_btree.h"
18 #include "xfs_quota.h"
19 #include "xfs_trans.h"
20 #include "xfs_qm.h"
21 #include "xfs_trans_space.h"
22
23 #define _ALLOC true
24 #define _FREE false
25
26
27
28
29
30
31
32
33 STATIC uint
34 xfs_buf_log_overhead(void)
35 {
36 return round_up(sizeof(struct xlog_op_header) +
37 sizeof(struct xfs_buf_log_format), 128);
38 }
39
40
41
42
43
44
45
46
47 STATIC uint
48 xfs_calc_buf_res(
49 uint nbufs,
50 uint size)
51 {
52 return nbufs * (size + xfs_buf_log_overhead());
53 }
54
55
56
57
58
59
60
61
62
63
64
65
66 uint
67 xfs_allocfree_log_count(
68 struct xfs_mount *mp,
69 uint num_ops)
70 {
71 uint blocks;
72
73 blocks = num_ops * 2 * (2 * mp->m_ag_maxlevels - 1);
74 if (xfs_sb_version_hasrmapbt(&mp->m_sb))
75 blocks += num_ops * (2 * mp->m_rmap_maxlevels - 1);
76 if (xfs_sb_version_hasreflink(&mp->m_sb))
77 blocks += num_ops * (2 * mp->m_refc_maxlevels - 1);
78
79 return blocks;
80 }
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111 STATIC uint
112 xfs_calc_inode_res(
113 struct xfs_mount *mp,
114 uint ninodes)
115 {
116 return ninodes *
117 (4 * sizeof(struct xlog_op_header) +
118 sizeof(struct xfs_inode_log_format) +
119 mp->m_sb.sb_inodesize +
120 2 * XFS_BMBT_BLOCK_LEN(mp));
121 }
122
123
124
125
126
127
128
129
130
131
132
133 STATIC uint
134 xfs_calc_inobt_res(
135 struct xfs_mount *mp)
136 {
137 return xfs_calc_buf_res(M_IGEO(mp)->inobt_maxlevels,
138 XFS_FSB_TO_B(mp, 1)) +
139 xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
140 XFS_FSB_TO_B(mp, 1));
141 }
142
143
144
145
146
147
148
149
150
151
152
153
154 STATIC uint
155 xfs_calc_finobt_res(
156 struct xfs_mount *mp)
157 {
158 if (!xfs_sb_version_hasfinobt(&mp->m_sb))
159 return 0;
160
161 return xfs_calc_inobt_res(mp);
162 }
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179 STATIC uint
180 xfs_calc_inode_chunk_res(
181 struct xfs_mount *mp,
182 bool alloc)
183 {
184 uint res, size = 0;
185
186 res = xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
187 XFS_FSB_TO_B(mp, 1));
188 if (alloc) {
189
190 if (xfs_sb_version_hascrc(&mp->m_sb))
191 return res;
192 size = XFS_FSB_TO_B(mp, 1);
193 }
194
195 res += xfs_calc_buf_res(M_IGEO(mp)->ialloc_blks, size);
196 return res;
197 }
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233 STATIC uint
234 xfs_calc_write_reservation(
235 struct xfs_mount *mp)
236 {
237 return XFS_DQUOT_LOGRES(mp) +
238 max((xfs_calc_inode_res(mp, 1) +
239 xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK),
240 XFS_FSB_TO_B(mp, 1)) +
241 xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
242 xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2),
243 XFS_FSB_TO_B(mp, 1))),
244 (xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
245 xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2),
246 XFS_FSB_TO_B(mp, 1))));
247 }
248
249
250
251
252
253
254
255
256
257
258
259
260 STATIC uint
261 xfs_calc_itruncate_reservation(
262 struct xfs_mount *mp)
263 {
264 return XFS_DQUOT_LOGRES(mp) +
265 max((xfs_calc_inode_res(mp, 1) +
266 xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 1,
267 XFS_FSB_TO_B(mp, 1))),
268 (xfs_calc_buf_res(9, mp->m_sb.sb_sectsize) +
269 xfs_calc_buf_res(xfs_allocfree_log_count(mp, 4),
270 XFS_FSB_TO_B(mp, 1))));
271 }
272
273
274
275
276
277
278
279
280
281
282
283
284
285 STATIC uint
286 xfs_calc_rename_reservation(
287 struct xfs_mount *mp)
288 {
289 return XFS_DQUOT_LOGRES(mp) +
290 max((xfs_calc_inode_res(mp, 4) +
291 xfs_calc_buf_res(2 * XFS_DIROP_LOG_COUNT(mp),
292 XFS_FSB_TO_B(mp, 1))),
293 (xfs_calc_buf_res(7, mp->m_sb.sb_sectsize) +
294 xfs_calc_buf_res(xfs_allocfree_log_count(mp, 3),
295 XFS_FSB_TO_B(mp, 1))));
296 }
297
298
299
300
301
302
303
304 STATIC uint
305 xfs_calc_iunlink_remove_reservation(
306 struct xfs_mount *mp)
307 {
308 return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
309 2 * M_IGEO(mp)->inode_cluster_size;
310 }
311
312
313
314
315
316
317
318
319
320
321
322
323
324 STATIC uint
325 xfs_calc_link_reservation(
326 struct xfs_mount *mp)
327 {
328 return XFS_DQUOT_LOGRES(mp) +
329 xfs_calc_iunlink_remove_reservation(mp) +
330 max((xfs_calc_inode_res(mp, 2) +
331 xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
332 XFS_FSB_TO_B(mp, 1))),
333 (xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
334 xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
335 XFS_FSB_TO_B(mp, 1))));
336 }
337
338
339
340
341
342
343 STATIC uint
344 xfs_calc_iunlink_add_reservation(xfs_mount_t *mp)
345 {
346 return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
347 M_IGEO(mp)->inode_cluster_size;
348 }
349
350
351
352
353
354
355
356
357
358
359
360
361
362 STATIC uint
363 xfs_calc_remove_reservation(
364 struct xfs_mount *mp)
365 {
366 return XFS_DQUOT_LOGRES(mp) +
367 xfs_calc_iunlink_add_reservation(mp) +
368 max((xfs_calc_inode_res(mp, 1) +
369 xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
370 XFS_FSB_TO_B(mp, 1))),
371 (xfs_calc_buf_res(4, mp->m_sb.sb_sectsize) +
372 xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2),
373 XFS_FSB_TO_B(mp, 1))));
374 }
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392 STATIC uint
393 xfs_calc_create_resv_modify(
394 struct xfs_mount *mp)
395 {
396 return xfs_calc_inode_res(mp, 2) +
397 xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
398 (uint)XFS_FSB_TO_B(mp, 1) +
399 xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp), XFS_FSB_TO_B(mp, 1)) +
400 xfs_calc_finobt_res(mp);
401 }
402
403
404
405
406
407
408
409
410
411 STATIC uint
412 xfs_calc_icreate_resv_alloc(
413 struct xfs_mount *mp)
414 {
415 return xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
416 mp->m_sb.sb_sectsize +
417 xfs_calc_inode_chunk_res(mp, _ALLOC) +
418 xfs_calc_inobt_res(mp) +
419 xfs_calc_finobt_res(mp);
420 }
421
422 STATIC uint
423 xfs_calc_icreate_reservation(xfs_mount_t *mp)
424 {
425 return XFS_DQUOT_LOGRES(mp) +
426 max(xfs_calc_icreate_resv_alloc(mp),
427 xfs_calc_create_resv_modify(mp));
428 }
429
430 STATIC uint
431 xfs_calc_create_tmpfile_reservation(
432 struct xfs_mount *mp)
433 {
434 uint res = XFS_DQUOT_LOGRES(mp);
435
436 res += xfs_calc_icreate_resv_alloc(mp);
437 return res + xfs_calc_iunlink_add_reservation(mp);
438 }
439
440
441
442
443 STATIC uint
444 xfs_calc_mkdir_reservation(
445 struct xfs_mount *mp)
446 {
447 return xfs_calc_icreate_reservation(mp);
448 }
449
450
451
452
453
454
455
456 STATIC uint
457 xfs_calc_symlink_reservation(
458 struct xfs_mount *mp)
459 {
460 return xfs_calc_icreate_reservation(mp) +
461 xfs_calc_buf_res(1, XFS_SYMLINK_MAXLEN);
462 }
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479 STATIC uint
480 xfs_calc_ifree_reservation(
481 struct xfs_mount *mp)
482 {
483 return XFS_DQUOT_LOGRES(mp) +
484 xfs_calc_inode_res(mp, 1) +
485 xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
486 xfs_calc_iunlink_remove_reservation(mp) +
487 xfs_calc_inode_chunk_res(mp, _FREE) +
488 xfs_calc_inobt_res(mp) +
489 xfs_calc_finobt_res(mp);
490 }
491
492
493
494
495
496 STATIC uint
497 xfs_calc_ichange_reservation(
498 struct xfs_mount *mp)
499 {
500 return XFS_DQUOT_LOGRES(mp) +
501 xfs_calc_inode_res(mp, 1) +
502 xfs_calc_buf_res(1, mp->m_sb.sb_sectsize);
503
504 }
505
506
507
508
509
510
511
512 STATIC uint
513 xfs_calc_growdata_reservation(
514 struct xfs_mount *mp)
515 {
516 return xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
517 xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
518 XFS_FSB_TO_B(mp, 1));
519 }
520
521
522
523
524
525
526
527
528
529
530
531 STATIC uint
532 xfs_calc_growrtalloc_reservation(
533 struct xfs_mount *mp)
534 {
535 return xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
536 xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK),
537 XFS_FSB_TO_B(mp, 1)) +
538 xfs_calc_inode_res(mp, 1) +
539 xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
540 XFS_FSB_TO_B(mp, 1));
541 }
542
543
544
545
546
547
548 STATIC uint
549 xfs_calc_growrtzero_reservation(
550 struct xfs_mount *mp)
551 {
552 return xfs_calc_buf_res(1, mp->m_sb.sb_blocksize);
553 }
554
555
556
557
558
559
560
561
562
563
564
565 STATIC uint
566 xfs_calc_growrtfree_reservation(
567 struct xfs_mount *mp)
568 {
569 return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
570 xfs_calc_inode_res(mp, 2) +
571 xfs_calc_buf_res(1, mp->m_sb.sb_blocksize) +
572 xfs_calc_buf_res(1, mp->m_rsumsize);
573 }
574
575
576
577
578
579 STATIC uint
580 xfs_calc_swrite_reservation(
581 struct xfs_mount *mp)
582 {
583 return xfs_calc_inode_res(mp, 1);
584 }
585
586
587
588
589
590 STATIC uint
591 xfs_calc_writeid_reservation(
592 struct xfs_mount *mp)
593 {
594 return xfs_calc_inode_res(mp, 1);
595 }
596
597
598
599
600
601
602
603
604
605 STATIC uint
606 xfs_calc_addafork_reservation(
607 struct xfs_mount *mp)
608 {
609 return XFS_DQUOT_LOGRES(mp) +
610 xfs_calc_inode_res(mp, 1) +
611 xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
612 xfs_calc_buf_res(1, mp->m_dir_geo->blksize) +
613 xfs_calc_buf_res(XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1,
614 XFS_FSB_TO_B(mp, 1)) +
615 xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
616 XFS_FSB_TO_B(mp, 1));
617 }
618
619
620
621
622
623
624
625
626
627
628
629
630 STATIC uint
631 xfs_calc_attrinval_reservation(
632 struct xfs_mount *mp)
633 {
634 return max((xfs_calc_inode_res(mp, 1) +
635 xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK),
636 XFS_FSB_TO_B(mp, 1))),
637 (xfs_calc_buf_res(9, mp->m_sb.sb_sectsize) +
638 xfs_calc_buf_res(xfs_allocfree_log_count(mp, 4),
639 XFS_FSB_TO_B(mp, 1))));
640 }
641
642
643
644
645
646
647
648
649
650
651
652
653 STATIC uint
654 xfs_calc_attrsetm_reservation(
655 struct xfs_mount *mp)
656 {
657 return XFS_DQUOT_LOGRES(mp) +
658 xfs_calc_inode_res(mp, 1) +
659 xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
660 xfs_calc_buf_res(XFS_DA_NODE_MAXDEPTH, XFS_FSB_TO_B(mp, 1));
661 }
662
663
664
665
666
667
668
669
670
671
672
673 STATIC uint
674 xfs_calc_attrsetrt_reservation(
675 struct xfs_mount *mp)
676 {
677 return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
678 xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK),
679 XFS_FSB_TO_B(mp, 1));
680 }
681
682
683
684
685
686
687
688
689
690
691
692
693 STATIC uint
694 xfs_calc_attrrm_reservation(
695 struct xfs_mount *mp)
696 {
697 return XFS_DQUOT_LOGRES(mp) +
698 max((xfs_calc_inode_res(mp, 1) +
699 xfs_calc_buf_res(XFS_DA_NODE_MAXDEPTH,
700 XFS_FSB_TO_B(mp, 1)) +
701 (uint)XFS_FSB_TO_B(mp,
702 XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) +
703 xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK), 0)),
704 (xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
705 xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2),
706 XFS_FSB_TO_B(mp, 1))));
707 }
708
709
710
711
712 STATIC uint
713 xfs_calc_clear_agi_bucket_reservation(
714 struct xfs_mount *mp)
715 {
716 return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize);
717 }
718
719
720
721
722
723 STATIC uint
724 xfs_calc_qm_setqlim_reservation(void)
725 {
726 return xfs_calc_buf_res(1, sizeof(struct xfs_disk_dquot));
727 }
728
729
730
731
732
733
734 STATIC uint
735 xfs_calc_qm_dqalloc_reservation(
736 struct xfs_mount *mp)
737 {
738 return xfs_calc_write_reservation(mp) +
739 xfs_calc_buf_res(1,
740 XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB) - 1);
741 }
742
743
744
745
746
747
748 STATIC uint
749 xfs_calc_qm_quotaoff_reservation(
750 struct xfs_mount *mp)
751 {
752 return sizeof(struct xfs_qoff_logitem) * 2 +
753 xfs_calc_buf_res(1, mp->m_sb.sb_sectsize);
754 }
755
756
757
758
759
760 STATIC uint
761 xfs_calc_qm_quotaoff_end_reservation(void)
762 {
763 return sizeof(struct xfs_qoff_logitem) * 2;
764 }
765
766
767
768
769
770 STATIC uint
771 xfs_calc_sb_reservation(
772 struct xfs_mount *mp)
773 {
774 return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize);
775 }
776
777 void
778 xfs_trans_resv_calc(
779 struct xfs_mount *mp,
780 struct xfs_trans_resv *resp)
781 {
782
783
784
785
786 resp->tr_write.tr_logres = xfs_calc_write_reservation(mp);
787 if (xfs_sb_version_hasreflink(&mp->m_sb))
788 resp->tr_write.tr_logcount = XFS_WRITE_LOG_COUNT_REFLINK;
789 else
790 resp->tr_write.tr_logcount = XFS_WRITE_LOG_COUNT;
791 resp->tr_write.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
792
793 resp->tr_itruncate.tr_logres = xfs_calc_itruncate_reservation(mp);
794 if (xfs_sb_version_hasreflink(&mp->m_sb))
795 resp->tr_itruncate.tr_logcount =
796 XFS_ITRUNCATE_LOG_COUNT_REFLINK;
797 else
798 resp->tr_itruncate.tr_logcount = XFS_ITRUNCATE_LOG_COUNT;
799 resp->tr_itruncate.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
800
801 resp->tr_rename.tr_logres = xfs_calc_rename_reservation(mp);
802 resp->tr_rename.tr_logcount = XFS_RENAME_LOG_COUNT;
803 resp->tr_rename.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
804
805 resp->tr_link.tr_logres = xfs_calc_link_reservation(mp);
806 resp->tr_link.tr_logcount = XFS_LINK_LOG_COUNT;
807 resp->tr_link.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
808
809 resp->tr_remove.tr_logres = xfs_calc_remove_reservation(mp);
810 resp->tr_remove.tr_logcount = XFS_REMOVE_LOG_COUNT;
811 resp->tr_remove.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
812
813 resp->tr_symlink.tr_logres = xfs_calc_symlink_reservation(mp);
814 resp->tr_symlink.tr_logcount = XFS_SYMLINK_LOG_COUNT;
815 resp->tr_symlink.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
816
817 resp->tr_create.tr_logres = xfs_calc_icreate_reservation(mp);
818 resp->tr_create.tr_logcount = XFS_CREATE_LOG_COUNT;
819 resp->tr_create.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
820
821 resp->tr_create_tmpfile.tr_logres =
822 xfs_calc_create_tmpfile_reservation(mp);
823 resp->tr_create_tmpfile.tr_logcount = XFS_CREATE_TMPFILE_LOG_COUNT;
824 resp->tr_create_tmpfile.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
825
826 resp->tr_mkdir.tr_logres = xfs_calc_mkdir_reservation(mp);
827 resp->tr_mkdir.tr_logcount = XFS_MKDIR_LOG_COUNT;
828 resp->tr_mkdir.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
829
830 resp->tr_ifree.tr_logres = xfs_calc_ifree_reservation(mp);
831 resp->tr_ifree.tr_logcount = XFS_INACTIVE_LOG_COUNT;
832 resp->tr_ifree.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
833
834 resp->tr_addafork.tr_logres = xfs_calc_addafork_reservation(mp);
835 resp->tr_addafork.tr_logcount = XFS_ADDAFORK_LOG_COUNT;
836 resp->tr_addafork.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
837
838 resp->tr_attrinval.tr_logres = xfs_calc_attrinval_reservation(mp);
839 resp->tr_attrinval.tr_logcount = XFS_ATTRINVAL_LOG_COUNT;
840 resp->tr_attrinval.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
841
842 resp->tr_attrsetm.tr_logres = xfs_calc_attrsetm_reservation(mp);
843 resp->tr_attrsetm.tr_logcount = XFS_ATTRSET_LOG_COUNT;
844 resp->tr_attrsetm.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
845
846 resp->tr_attrrm.tr_logres = xfs_calc_attrrm_reservation(mp);
847 resp->tr_attrrm.tr_logcount = XFS_ATTRRM_LOG_COUNT;
848 resp->tr_attrrm.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
849
850 resp->tr_growrtalloc.tr_logres = xfs_calc_growrtalloc_reservation(mp);
851 resp->tr_growrtalloc.tr_logcount = XFS_DEFAULT_PERM_LOG_COUNT;
852 resp->tr_growrtalloc.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
853
854 resp->tr_qm_dqalloc.tr_logres = xfs_calc_qm_dqalloc_reservation(mp);
855 if (xfs_sb_version_hasreflink(&mp->m_sb))
856 resp->tr_qm_dqalloc.tr_logcount = XFS_WRITE_LOG_COUNT_REFLINK;
857 else
858 resp->tr_qm_dqalloc.tr_logcount = XFS_WRITE_LOG_COUNT;
859 resp->tr_qm_dqalloc.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
860
861
862
863
864
865 resp->tr_qm_setqlim.tr_logres = xfs_calc_qm_setqlim_reservation();
866 resp->tr_qm_setqlim.tr_logcount = XFS_DEFAULT_LOG_COUNT;
867
868 resp->tr_qm_quotaoff.tr_logres = xfs_calc_qm_quotaoff_reservation(mp);
869 resp->tr_qm_quotaoff.tr_logcount = XFS_DEFAULT_LOG_COUNT;
870
871 resp->tr_qm_equotaoff.tr_logres =
872 xfs_calc_qm_quotaoff_end_reservation();
873 resp->tr_qm_equotaoff.tr_logcount = XFS_DEFAULT_LOG_COUNT;
874
875 resp->tr_sb.tr_logres = xfs_calc_sb_reservation(mp);
876 resp->tr_sb.tr_logcount = XFS_DEFAULT_LOG_COUNT;
877
878
879 resp->tr_growdata.tr_logres = xfs_calc_growdata_reservation(mp);
880 resp->tr_growdata.tr_logcount = XFS_DEFAULT_PERM_LOG_COUNT;
881 resp->tr_growdata.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
882
883
884 resp->tr_ichange.tr_logres = xfs_calc_ichange_reservation(mp);
885 resp->tr_fsyncts.tr_logres = xfs_calc_swrite_reservation(mp);
886 resp->tr_writeid.tr_logres = xfs_calc_writeid_reservation(mp);
887 resp->tr_attrsetrt.tr_logres = xfs_calc_attrsetrt_reservation(mp);
888 resp->tr_clearagi.tr_logres = xfs_calc_clear_agi_bucket_reservation(mp);
889 resp->tr_growrtzero.tr_logres = xfs_calc_growrtzero_reservation(mp);
890 resp->tr_growrtfree.tr_logres = xfs_calc_growrtfree_reservation(mp);
891 }