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_types.h"
21#include "xfs_bit.h"
22#include "xfs_log.h"
23#include "xfs_inum.h"
24#include "xfs_trans.h"
25#include "xfs_sb.h"
26#include "xfs_ag.h"
27#include "xfs_dir2.h"
28#include "xfs_dmapi.h"
29#include "xfs_mount.h"
30#include "xfs_error.h"
31#include "xfs_da_btree.h"
32#include "xfs_bmap_btree.h"
33#include "xfs_alloc_btree.h"
34#include "xfs_ialloc_btree.h"
35#include "xfs_dir2_sf.h"
36#include "xfs_attr_sf.h"
37#include "xfs_dinode.h"
38#include "xfs_inode.h"
39#include "xfs_btree.h"
40#include "xfs_ialloc.h"
41#include "xfs_alloc.h"
42#include "xfs_bmap.h"
43#include "xfs_quota.h"
44#include "xfs_trans_priv.h"
45#include "xfs_trans_space.h"
46#include "xfs_inode_item.h"
47
48
49STATIC void xfs_trans_apply_sb_deltas(xfs_trans_t *);
50STATIC uint xfs_trans_count_vecs(xfs_trans_t *);
51STATIC void xfs_trans_fill_vecs(xfs_trans_t *, xfs_log_iovec_t *);
52STATIC void xfs_trans_uncommit(xfs_trans_t *, uint);
53STATIC void xfs_trans_committed(xfs_trans_t *, int);
54STATIC void xfs_trans_chunk_committed(xfs_log_item_chunk_t *, xfs_lsn_t, int);
55STATIC void xfs_trans_free(xfs_trans_t *);
56
57kmem_zone_t *xfs_trans_zone;
58
59
60
61
62
63
64
65STATIC uint
66xfs_calc_write_reservation(xfs_mount_t *mp)
67{
68 return XFS_CALC_WRITE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
69}
70
71STATIC uint
72xfs_calc_itruncate_reservation(xfs_mount_t *mp)
73{
74 return XFS_CALC_ITRUNCATE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
75}
76
77STATIC uint
78xfs_calc_rename_reservation(xfs_mount_t *mp)
79{
80 return XFS_CALC_RENAME_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
81}
82
83STATIC uint
84xfs_calc_link_reservation(xfs_mount_t *mp)
85{
86 return XFS_CALC_LINK_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
87}
88
89STATIC uint
90xfs_calc_remove_reservation(xfs_mount_t *mp)
91{
92 return XFS_CALC_REMOVE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
93}
94
95STATIC uint
96xfs_calc_symlink_reservation(xfs_mount_t *mp)
97{
98 return XFS_CALC_SYMLINK_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
99}
100
101STATIC uint
102xfs_calc_create_reservation(xfs_mount_t *mp)
103{
104 return XFS_CALC_CREATE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
105}
106
107STATIC uint
108xfs_calc_mkdir_reservation(xfs_mount_t *mp)
109{
110 return XFS_CALC_MKDIR_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
111}
112
113STATIC uint
114xfs_calc_ifree_reservation(xfs_mount_t *mp)
115{
116 return XFS_CALC_IFREE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
117}
118
119STATIC uint
120xfs_calc_ichange_reservation(xfs_mount_t *mp)
121{
122 return XFS_CALC_ICHANGE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
123}
124
125STATIC uint
126xfs_calc_growdata_reservation(xfs_mount_t *mp)
127{
128 return XFS_CALC_GROWDATA_LOG_RES(mp);
129}
130
131STATIC uint
132xfs_calc_growrtalloc_reservation(xfs_mount_t *mp)
133{
134 return XFS_CALC_GROWRTALLOC_LOG_RES(mp);
135}
136
137STATIC uint
138xfs_calc_growrtzero_reservation(xfs_mount_t *mp)
139{
140 return XFS_CALC_GROWRTZERO_LOG_RES(mp);
141}
142
143STATIC uint
144xfs_calc_growrtfree_reservation(xfs_mount_t *mp)
145{
146 return XFS_CALC_GROWRTFREE_LOG_RES(mp);
147}
148
149STATIC uint
150xfs_calc_swrite_reservation(xfs_mount_t *mp)
151{
152 return XFS_CALC_SWRITE_LOG_RES(mp);
153}
154
155STATIC uint
156xfs_calc_writeid_reservation(xfs_mount_t *mp)
157{
158 return XFS_CALC_WRITEID_LOG_RES(mp);
159}
160
161STATIC uint
162xfs_calc_addafork_reservation(xfs_mount_t *mp)
163{
164 return XFS_CALC_ADDAFORK_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
165}
166
167STATIC uint
168xfs_calc_attrinval_reservation(xfs_mount_t *mp)
169{
170 return XFS_CALC_ATTRINVAL_LOG_RES(mp);
171}
172
173STATIC uint
174xfs_calc_attrset_reservation(xfs_mount_t *mp)
175{
176 return XFS_CALC_ATTRSET_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
177}
178
179STATIC uint
180xfs_calc_attrrm_reservation(xfs_mount_t *mp)
181{
182 return XFS_CALC_ATTRRM_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
183}
184
185STATIC uint
186xfs_calc_clear_agi_bucket_reservation(xfs_mount_t *mp)
187{
188 return XFS_CALC_CLEAR_AGI_BUCKET_LOG_RES(mp);
189}
190
191
192
193
194
195void
196xfs_trans_init(
197 xfs_mount_t *mp)
198{
199 xfs_trans_reservations_t *resp;
200
201 resp = &(mp->m_reservations);
202 resp->tr_write = xfs_calc_write_reservation(mp);
203 resp->tr_itruncate = xfs_calc_itruncate_reservation(mp);
204 resp->tr_rename = xfs_calc_rename_reservation(mp);
205 resp->tr_link = xfs_calc_link_reservation(mp);
206 resp->tr_remove = xfs_calc_remove_reservation(mp);
207 resp->tr_symlink = xfs_calc_symlink_reservation(mp);
208 resp->tr_create = xfs_calc_create_reservation(mp);
209 resp->tr_mkdir = xfs_calc_mkdir_reservation(mp);
210 resp->tr_ifree = xfs_calc_ifree_reservation(mp);
211 resp->tr_ichange = xfs_calc_ichange_reservation(mp);
212 resp->tr_growdata = xfs_calc_growdata_reservation(mp);
213 resp->tr_swrite = xfs_calc_swrite_reservation(mp);
214 resp->tr_writeid = xfs_calc_writeid_reservation(mp);
215 resp->tr_addafork = xfs_calc_addafork_reservation(mp);
216 resp->tr_attrinval = xfs_calc_attrinval_reservation(mp);
217 resp->tr_attrset = xfs_calc_attrset_reservation(mp);
218 resp->tr_attrrm = xfs_calc_attrrm_reservation(mp);
219 resp->tr_clearagi = xfs_calc_clear_agi_bucket_reservation(mp);
220 resp->tr_growrtalloc = xfs_calc_growrtalloc_reservation(mp);
221 resp->tr_growrtzero = xfs_calc_growrtzero_reservation(mp);
222 resp->tr_growrtfree = xfs_calc_growrtfree_reservation(mp);
223}
224
225
226
227
228
229
230
231
232
233xfs_trans_t *
234xfs_trans_alloc(
235 xfs_mount_t *mp,
236 uint type)
237{
238 xfs_wait_for_freeze(mp, SB_FREEZE_TRANS);
239 return _xfs_trans_alloc(mp, type);
240}
241
242xfs_trans_t *
243_xfs_trans_alloc(
244 xfs_mount_t *mp,
245 uint type)
246{
247 xfs_trans_t *tp;
248
249 atomic_inc(&mp->m_active_trans);
250
251 tp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
252 tp->t_magic = XFS_TRANS_MAGIC;
253 tp->t_type = type;
254 tp->t_mountp = mp;
255 tp->t_items_free = XFS_LIC_NUM_SLOTS;
256 tp->t_busy_free = XFS_LBC_NUM_SLOTS;
257 xfs_lic_init(&(tp->t_items));
258 XFS_LBC_INIT(&(tp->t_busy));
259 return tp;
260}
261
262
263
264
265
266
267
268
269
270xfs_trans_t *
271xfs_trans_dup(
272 xfs_trans_t *tp)
273{
274 xfs_trans_t *ntp;
275
276 ntp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
277
278
279
280
281 ntp->t_magic = XFS_TRANS_MAGIC;
282 ntp->t_type = tp->t_type;
283 ntp->t_mountp = tp->t_mountp;
284 ntp->t_items_free = XFS_LIC_NUM_SLOTS;
285 ntp->t_busy_free = XFS_LBC_NUM_SLOTS;
286 xfs_lic_init(&(ntp->t_items));
287 XFS_LBC_INIT(&(ntp->t_busy));
288
289 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
290 ASSERT(tp->t_ticket != NULL);
291
292 ntp->t_flags = XFS_TRANS_PERM_LOG_RES | (tp->t_flags & XFS_TRANS_RESERVE);
293 ntp->t_ticket = tp->t_ticket;
294 ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used;
295 tp->t_blk_res = tp->t_blk_res_used;
296 ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
297 tp->t_rtx_res = tp->t_rtx_res_used;
298 ntp->t_pflags = tp->t_pflags;
299
300 XFS_TRANS_DUP_DQINFO(tp->t_mountp, tp, ntp);
301
302 atomic_inc(&tp->t_mountp->m_active_trans);
303 return ntp;
304}
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320int
321xfs_trans_reserve(
322 xfs_trans_t *tp,
323 uint blocks,
324 uint logspace,
325 uint rtextents,
326 uint flags,
327 uint logcount)
328{
329 int log_flags;
330 int error = 0;
331 int rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
332
333
334 current_set_flags_nested(&tp->t_pflags, PF_FSTRANS);
335
336
337
338
339
340
341 if (blocks > 0) {
342 error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FDBLOCKS,
343 -((int64_t)blocks), rsvd);
344 if (error != 0) {
345 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
346 return (XFS_ERROR(ENOSPC));
347 }
348 tp->t_blk_res += blocks;
349 }
350
351
352
353
354 if (logspace > 0) {
355 ASSERT((tp->t_log_res == 0) || (tp->t_log_res == logspace));
356 ASSERT((tp->t_log_count == 0) ||
357 (tp->t_log_count == logcount));
358 if (flags & XFS_TRANS_PERM_LOG_RES) {
359 log_flags = XFS_LOG_PERM_RESERV;
360 tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
361 } else {
362 ASSERT(tp->t_ticket == NULL);
363 ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
364 log_flags = 0;
365 }
366
367 error = xfs_log_reserve(tp->t_mountp, logspace, logcount,
368 &tp->t_ticket,
369 XFS_TRANSACTION, log_flags, tp->t_type);
370 if (error) {
371 goto undo_blocks;
372 }
373 tp->t_log_res = logspace;
374 tp->t_log_count = logcount;
375 }
376
377
378
379
380
381
382 if (rtextents > 0) {
383 error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FREXTENTS,
384 -((int64_t)rtextents), rsvd);
385 if (error) {
386 error = XFS_ERROR(ENOSPC);
387 goto undo_log;
388 }
389 tp->t_rtx_res += rtextents;
390 }
391
392 return 0;
393
394
395
396
397
398undo_log:
399 if (logspace > 0) {
400 if (flags & XFS_TRANS_PERM_LOG_RES) {
401 log_flags = XFS_LOG_REL_PERM_RESERV;
402 } else {
403 log_flags = 0;
404 }
405 xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, log_flags);
406 tp->t_ticket = NULL;
407 tp->t_log_res = 0;
408 tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
409 }
410
411undo_blocks:
412 if (blocks > 0) {
413 (void) xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FDBLOCKS,
414 (int64_t)blocks, rsvd);
415 tp->t_blk_res = 0;
416 }
417
418 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
419
420 return error;
421}
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440void
441xfs_trans_mod_sb(
442 xfs_trans_t *tp,
443 uint field,
444 int64_t delta)
445{
446 uint32_t flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
447 xfs_mount_t *mp = tp->t_mountp;
448
449 switch (field) {
450 case XFS_TRANS_SB_ICOUNT:
451 tp->t_icount_delta += delta;
452 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
453 flags &= ~XFS_TRANS_SB_DIRTY;
454 break;
455 case XFS_TRANS_SB_IFREE:
456 tp->t_ifree_delta += delta;
457 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
458 flags &= ~XFS_TRANS_SB_DIRTY;
459 break;
460 case XFS_TRANS_SB_FDBLOCKS:
461
462
463
464
465
466 if (delta < 0) {
467 tp->t_blk_res_used += (uint)-delta;
468 ASSERT(tp->t_blk_res_used <= tp->t_blk_res);
469 }
470 tp->t_fdblocks_delta += delta;
471 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
472 flags &= ~XFS_TRANS_SB_DIRTY;
473 break;
474 case XFS_TRANS_SB_RES_FDBLOCKS:
475
476
477
478
479
480 ASSERT(delta < 0);
481 tp->t_res_fdblocks_delta += delta;
482 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
483 flags &= ~XFS_TRANS_SB_DIRTY;
484 break;
485 case XFS_TRANS_SB_FREXTENTS:
486
487
488
489
490
491 if (delta < 0) {
492 tp->t_rtx_res_used += (uint)-delta;
493 ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res);
494 }
495 tp->t_frextents_delta += delta;
496 break;
497 case XFS_TRANS_SB_RES_FREXTENTS:
498
499
500
501
502
503 ASSERT(delta < 0);
504 tp->t_res_frextents_delta += delta;
505 break;
506 case XFS_TRANS_SB_DBLOCKS:
507 ASSERT(delta > 0);
508 tp->t_dblocks_delta += delta;
509 break;
510 case XFS_TRANS_SB_AGCOUNT:
511 ASSERT(delta > 0);
512 tp->t_agcount_delta += delta;
513 break;
514 case XFS_TRANS_SB_IMAXPCT:
515 tp->t_imaxpct_delta += delta;
516 break;
517 case XFS_TRANS_SB_REXTSIZE:
518 tp->t_rextsize_delta += delta;
519 break;
520 case XFS_TRANS_SB_RBMBLOCKS:
521 tp->t_rbmblocks_delta += delta;
522 break;
523 case XFS_TRANS_SB_RBLOCKS:
524 tp->t_rblocks_delta += delta;
525 break;
526 case XFS_TRANS_SB_REXTENTS:
527 tp->t_rextents_delta += delta;
528 break;
529 case XFS_TRANS_SB_REXTSLOG:
530 tp->t_rextslog_delta += delta;
531 break;
532 default:
533 ASSERT(0);
534 return;
535 }
536
537 tp->t_flags |= flags;
538}
539
540
541
542
543
544
545
546
547
548STATIC void
549xfs_trans_apply_sb_deltas(
550 xfs_trans_t *tp)
551{
552 xfs_dsb_t *sbp;
553 xfs_buf_t *bp;
554 int whole = 0;
555
556 bp = xfs_trans_getsb(tp, tp->t_mountp, 0);
557 sbp = XFS_BUF_TO_SBP(bp);
558
559
560
561
562 ASSERT((tp->t_fdblocks_delta + tp->t_res_fdblocks_delta) ==
563 (tp->t_ag_freeblks_delta + tp->t_ag_flist_delta +
564 tp->t_ag_btree_delta));
565
566
567
568
569 if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) {
570 if (tp->t_icount_delta)
571 be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta);
572 if (tp->t_ifree_delta)
573 be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta);
574 if (tp->t_fdblocks_delta)
575 be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
576 if (tp->t_res_fdblocks_delta)
577 be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta);
578 }
579
580 if (tp->t_frextents_delta)
581 be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta);
582 if (tp->t_res_frextents_delta)
583 be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta);
584
585 if (tp->t_dblocks_delta) {
586 be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta);
587 whole = 1;
588 }
589 if (tp->t_agcount_delta) {
590 be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta);
591 whole = 1;
592 }
593 if (tp->t_imaxpct_delta) {
594 sbp->sb_imax_pct += tp->t_imaxpct_delta;
595 whole = 1;
596 }
597 if (tp->t_rextsize_delta) {
598 be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta);
599 whole = 1;
600 }
601 if (tp->t_rbmblocks_delta) {
602 be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
603 whole = 1;
604 }
605 if (tp->t_rblocks_delta) {
606 be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta);
607 whole = 1;
608 }
609 if (tp->t_rextents_delta) {
610 be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta);
611 whole = 1;
612 }
613 if (tp->t_rextslog_delta) {
614 sbp->sb_rextslog += tp->t_rextslog_delta;
615 whole = 1;
616 }
617
618 if (whole)
619
620
621
622 xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1);
623 else
624
625
626
627
628 xfs_trans_log_buf(tp, bp, offsetof(xfs_dsb_t, sb_icount),
629 offsetof(xfs_dsb_t, sb_frextents) +
630 sizeof(sbp->sb_frextents) - 1);
631
632 tp->t_mountp->m_super->s_dirt = 1;
633}
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654STATIC void
655xfs_trans_unreserve_and_mod_sb(
656 xfs_trans_t *tp)
657{
658 xfs_mod_sb_t msb[14];
659 xfs_mod_sb_t *msbp;
660 xfs_mount_t *mp = tp->t_mountp;
661
662 int error;
663 int rsvd;
664 int64_t blkdelta = 0;
665 int64_t rtxdelta = 0;
666
667 msbp = msb;
668 rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
669
670
671 if (tp->t_blk_res > 0)
672 blkdelta = tp->t_blk_res;
673
674 if ((tp->t_fdblocks_delta != 0) &&
675 (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
676 (tp->t_flags & XFS_TRANS_SB_DIRTY)))
677 blkdelta += tp->t_fdblocks_delta;
678
679 if (blkdelta != 0) {
680 msbp->msb_field = XFS_SBS_FDBLOCKS;
681 msbp->msb_delta = blkdelta;
682 msbp++;
683 }
684
685
686 if (tp->t_rtx_res > 0)
687 rtxdelta = tp->t_rtx_res;
688
689 if ((tp->t_frextents_delta != 0) &&
690 (tp->t_flags & XFS_TRANS_SB_DIRTY))
691 rtxdelta += tp->t_frextents_delta;
692
693 if (rtxdelta != 0) {
694 msbp->msb_field = XFS_SBS_FREXTENTS;
695 msbp->msb_delta = rtxdelta;
696 msbp++;
697 }
698
699
700
701 if (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
702 (tp->t_flags & XFS_TRANS_SB_DIRTY)) {
703 if (tp->t_icount_delta != 0) {
704 msbp->msb_field = XFS_SBS_ICOUNT;
705 msbp->msb_delta = tp->t_icount_delta;
706 msbp++;
707 }
708 if (tp->t_ifree_delta != 0) {
709 msbp->msb_field = XFS_SBS_IFREE;
710 msbp->msb_delta = tp->t_ifree_delta;
711 msbp++;
712 }
713 }
714
715 if (tp->t_flags & XFS_TRANS_SB_DIRTY) {
716 if (tp->t_dblocks_delta != 0) {
717 msbp->msb_field = XFS_SBS_DBLOCKS;
718 msbp->msb_delta = tp->t_dblocks_delta;
719 msbp++;
720 }
721 if (tp->t_agcount_delta != 0) {
722 msbp->msb_field = XFS_SBS_AGCOUNT;
723 msbp->msb_delta = tp->t_agcount_delta;
724 msbp++;
725 }
726 if (tp->t_imaxpct_delta != 0) {
727 msbp->msb_field = XFS_SBS_IMAX_PCT;
728 msbp->msb_delta = tp->t_imaxpct_delta;
729 msbp++;
730 }
731 if (tp->t_rextsize_delta != 0) {
732 msbp->msb_field = XFS_SBS_REXTSIZE;
733 msbp->msb_delta = tp->t_rextsize_delta;
734 msbp++;
735 }
736 if (tp->t_rbmblocks_delta != 0) {
737 msbp->msb_field = XFS_SBS_RBMBLOCKS;
738 msbp->msb_delta = tp->t_rbmblocks_delta;
739 msbp++;
740 }
741 if (tp->t_rblocks_delta != 0) {
742 msbp->msb_field = XFS_SBS_RBLOCKS;
743 msbp->msb_delta = tp->t_rblocks_delta;
744 msbp++;
745 }
746 if (tp->t_rextents_delta != 0) {
747 msbp->msb_field = XFS_SBS_REXTENTS;
748 msbp->msb_delta = tp->t_rextents_delta;
749 msbp++;
750 }
751 if (tp->t_rextslog_delta != 0) {
752 msbp->msb_field = XFS_SBS_REXTSLOG;
753 msbp->msb_delta = tp->t_rextslog_delta;
754 msbp++;
755 }
756 }
757
758
759
760
761 if (msbp > msb) {
762 error = xfs_mod_incore_sb_batch(tp->t_mountp, msb,
763 (uint)(msbp - msb), rsvd);
764 ASSERT(error == 0);
765 }
766}
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784int
785_xfs_trans_commit(
786 xfs_trans_t *tp,
787 uint flags,
788 int *log_flushed)
789{
790 xfs_log_iovec_t *log_vector;
791 int nvec;
792 xfs_mount_t *mp;
793 xfs_lsn_t commit_lsn;
794
795 int error;
796 int log_flags;
797 int sync;
798#define XFS_TRANS_LOGVEC_COUNT 16
799 xfs_log_iovec_t log_vector_fast[XFS_TRANS_LOGVEC_COUNT];
800 void *commit_iclog;
801 int shutdown;
802
803 commit_lsn = -1;
804
805
806
807
808
809 if (flags & XFS_TRANS_RELEASE_LOG_RES) {
810 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
811 log_flags = XFS_LOG_REL_PERM_RESERV;
812 } else {
813 log_flags = 0;
814 }
815 mp = tp->t_mountp;
816
817
818
819
820
821
822
823
824shut_us_down:
825 shutdown = XFS_FORCED_SHUTDOWN(mp) ? EIO : 0;
826 if (!(tp->t_flags & XFS_TRANS_DIRTY) || shutdown) {
827 xfs_trans_unreserve_and_mod_sb(tp);
828
829
830
831
832
833
834 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(mp, tp);
835 if (tp->t_ticket) {
836 commit_lsn = xfs_log_done(mp, tp->t_ticket,
837 NULL, log_flags);
838 if (commit_lsn == -1 && !shutdown)
839 shutdown = XFS_ERROR(EIO);
840 }
841 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
842 xfs_trans_free_items(tp, shutdown? XFS_TRANS_ABORT : 0);
843 xfs_trans_free_busy(tp);
844 xfs_trans_free(tp);
845 XFS_STATS_INC(xs_trans_empty);
846 return (shutdown);
847 }
848 ASSERT(tp->t_ticket != NULL);
849
850
851
852
853 if (tp->t_flags & XFS_TRANS_SB_DIRTY) {
854 xfs_trans_apply_sb_deltas(tp);
855 }
856 XFS_TRANS_APPLY_DQUOT_DELTAS(mp, tp);
857
858
859
860
861
862
863
864 nvec = xfs_trans_count_vecs(tp);
865 if (nvec == 0) {
866 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
867 goto shut_us_down;
868 } else if (nvec <= XFS_TRANS_LOGVEC_COUNT) {
869 log_vector = log_vector_fast;
870 } else {
871 log_vector = (xfs_log_iovec_t *)kmem_alloc(nvec *
872 sizeof(xfs_log_iovec_t),
873 KM_SLEEP);
874 }
875
876
877
878
879
880 xfs_trans_fill_vecs(tp, log_vector);
881
882 error = xfs_log_write(mp, log_vector, nvec, tp->t_ticket, &(tp->t_lsn));
883
884
885
886
887
888
889 commit_lsn = xfs_log_done(mp, tp->t_ticket, &commit_iclog, log_flags);
890
891 tp->t_commit_lsn = commit_lsn;
892 if (nvec > XFS_TRANS_LOGVEC_COUNT) {
893 kmem_free(log_vector);
894 }
895
896
897
898
899
900 if (error || commit_lsn == -1) {
901 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
902 xfs_trans_uncommit(tp, flags|XFS_TRANS_ABORT);
903 return XFS_ERROR(EIO);
904 }
905
906
907
908
909
910
911
912 xfs_trans_unreserve_and_mod_sb(tp);
913
914 sync = tp->t_flags & XFS_TRANS_SYNC;
915
916
917
918
919
920
921
922
923
924
925
926
927
928 tp->t_logcb.cb_func = (void(*)(void*, int))xfs_trans_committed;
929 tp->t_logcb.cb_arg = tp;
930
931
932
933
934
935
936
937
938 shutdown = xfs_log_notify(mp, commit_iclog, &(tp->t_logcb));
939
940
941
942
943 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958 xfs_trans_unlock_items(tp, commit_lsn);
959
960
961
962
963
964
965
966
967
968
969
970 if (shutdown)
971 xfs_trans_committed(tp, XFS_LI_ABORTED);
972
973
974
975
976
977
978 error = xfs_log_release_iclog(mp, commit_iclog);
979
980
981
982
983
984 if (sync) {
985 if (!error) {
986 error = _xfs_log_force(mp, commit_lsn,
987 XFS_LOG_FORCE | XFS_LOG_SYNC,
988 log_flushed);
989 }
990 XFS_STATS_INC(xs_trans_sync);
991 } else {
992 XFS_STATS_INC(xs_trans_async);
993 }
994
995 return (error);
996}
997
998
999
1000
1001
1002
1003
1004
1005STATIC uint
1006xfs_trans_count_vecs(
1007 xfs_trans_t *tp)
1008{
1009 int nvecs;
1010 xfs_log_item_desc_t *lidp;
1011
1012 nvecs = 1;
1013 lidp = xfs_trans_first_item(tp);
1014 ASSERT(lidp != NULL);
1015
1016
1017
1018
1019
1020 if (lidp == NULL)
1021 return 0;
1022
1023 while (lidp != NULL) {
1024
1025
1026
1027 if (!(lidp->lid_flags & XFS_LID_DIRTY)) {
1028 lidp = xfs_trans_next_item(tp, lidp);
1029 continue;
1030 }
1031 lidp->lid_size = IOP_SIZE(lidp->lid_item);
1032 nvecs += lidp->lid_size;
1033 lidp = xfs_trans_next_item(tp, lidp);
1034 }
1035
1036 return nvecs;
1037}
1038
1039
1040
1041
1042
1043STATIC void
1044xfs_trans_uncommit(
1045 xfs_trans_t *tp,
1046 uint flags)
1047{
1048 xfs_log_item_desc_t *lidp;
1049
1050 for (lidp = xfs_trans_first_item(tp);
1051 lidp != NULL;
1052 lidp = xfs_trans_next_item(tp, lidp)) {
1053
1054
1055
1056 if (lidp->lid_flags & XFS_LID_DIRTY)
1057 IOP_UNPIN_REMOVE(lidp->lid_item, tp);
1058 }
1059
1060 xfs_trans_unreserve_and_mod_sb(tp);
1061 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(tp->t_mountp, tp);
1062
1063 xfs_trans_free_items(tp, flags);
1064 xfs_trans_free_busy(tp);
1065 xfs_trans_free(tp);
1066}
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077STATIC void
1078xfs_trans_fill_vecs(
1079 xfs_trans_t *tp,
1080 xfs_log_iovec_t *log_vector)
1081{
1082 xfs_log_item_desc_t *lidp;
1083 xfs_log_iovec_t *vecp;
1084 uint nitems;
1085
1086
1087
1088
1089
1090 vecp = log_vector + 1;
1091
1092 nitems = 0;
1093 lidp = xfs_trans_first_item(tp);
1094 ASSERT(lidp != NULL);
1095 while (lidp != NULL) {
1096
1097
1098
1099 if (!(lidp->lid_flags & XFS_LID_DIRTY)) {
1100 lidp = xfs_trans_next_item(tp, lidp);
1101 continue;
1102 }
1103
1104
1105
1106
1107
1108 if (lidp->lid_size) {
1109 nitems++;
1110 }
1111 IOP_FORMAT(lidp->lid_item, vecp);
1112 vecp += lidp->lid_size;
1113 IOP_PIN(lidp->lid_item);
1114 lidp = xfs_trans_next_item(tp, lidp);
1115 }
1116
1117
1118
1119
1120
1121 tp->t_header.th_magic = XFS_TRANS_HEADER_MAGIC;
1122 tp->t_header.th_type = tp->t_type;
1123 tp->t_header.th_num_items = nitems;
1124 log_vector->i_addr = (xfs_caddr_t)&tp->t_header;
1125 log_vector->i_len = sizeof(xfs_trans_header_t);
1126 XLOG_VEC_SET_TYPE(log_vector, XLOG_REG_TYPE_TRANSHDR);
1127}
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138void
1139xfs_trans_cancel(
1140 xfs_trans_t *tp,
1141 int flags)
1142{
1143 int log_flags;
1144#ifdef DEBUG
1145 xfs_log_item_chunk_t *licp;
1146 xfs_log_item_desc_t *lidp;
1147 xfs_log_item_t *lip;
1148 int i;
1149#endif
1150 xfs_mount_t *mp = tp->t_mountp;
1151
1152
1153
1154
1155
1156 if ((flags & XFS_TRANS_ABORT) && !(tp->t_flags & XFS_TRANS_DIRTY))
1157 flags &= ~XFS_TRANS_ABORT;
1158
1159
1160
1161
1162
1163 if ((tp->t_flags & XFS_TRANS_DIRTY) && !XFS_FORCED_SHUTDOWN(mp)) {
1164 XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
1165 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1166 }
1167#ifdef DEBUG
1168 if (!(flags & XFS_TRANS_ABORT)) {
1169 licp = &(tp->t_items);
1170 while (licp != NULL) {
1171 lidp = licp->lic_descs;
1172 for (i = 0; i < licp->lic_unused; i++, lidp++) {
1173 if (xfs_lic_isfree(licp, i)) {
1174 continue;
1175 }
1176
1177 lip = lidp->lid_item;
1178 if (!XFS_FORCED_SHUTDOWN(mp))
1179 ASSERT(!(lip->li_type == XFS_LI_EFD));
1180 }
1181 licp = licp->lic_next;
1182 }
1183 }
1184#endif
1185 xfs_trans_unreserve_and_mod_sb(tp);
1186 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(mp, tp);
1187
1188 if (tp->t_ticket) {
1189 if (flags & XFS_TRANS_RELEASE_LOG_RES) {
1190 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
1191 log_flags = XFS_LOG_REL_PERM_RESERV;
1192 } else {
1193 log_flags = 0;
1194 }
1195 xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
1196 }
1197
1198
1199 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
1200
1201 xfs_trans_free_items(tp, flags);
1202 xfs_trans_free_busy(tp);
1203 xfs_trans_free(tp);
1204}
1205
1206
1207
1208
1209
1210
1211STATIC void
1212xfs_trans_free(
1213 xfs_trans_t *tp)
1214{
1215 atomic_dec(&tp->t_mountp->m_active_trans);
1216 XFS_TRANS_FREE_DQINFO(tp->t_mountp, tp);
1217 kmem_zone_free(xfs_trans_zone, tp);
1218}
1219
1220
1221
1222
1223
1224
1225
1226
1227int
1228xfs_trans_roll(
1229 struct xfs_trans **tpp,
1230 struct xfs_inode *dp)
1231{
1232 struct xfs_trans *trans;
1233 unsigned int logres, count;
1234 int error;
1235
1236
1237
1238
1239 trans = *tpp;
1240 xfs_trans_log_inode(trans, dp, XFS_ILOG_CORE);
1241
1242
1243
1244
1245 logres = trans->t_log_res;
1246 count = trans->t_log_count;
1247 *tpp = xfs_trans_dup(trans);
1248
1249
1250
1251
1252
1253
1254
1255
1256 error = xfs_trans_commit(trans, 0);
1257 if (error)
1258 return (error);
1259
1260 trans = *tpp;
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270 error = xfs_trans_reserve(trans, 0, logres, 0,
1271 XFS_TRANS_PERM_LOG_RES, count);
1272
1273
1274
1275 if (error)
1276 return error;
1277
1278 xfs_trans_ijoin(trans, dp, XFS_ILOCK_EXCL);
1279 xfs_trans_ihold(trans, dp);
1280 return 0;
1281}
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296STATIC void
1297xfs_trans_committed(
1298 xfs_trans_t *tp,
1299 int abortflag)
1300{
1301 xfs_log_item_chunk_t *licp;
1302 xfs_log_item_chunk_t *next_licp;
1303 xfs_log_busy_chunk_t *lbcp;
1304 xfs_log_busy_slot_t *lbsp;
1305 int i;
1306
1307
1308
1309
1310
1311 if (tp->t_callback != NULL) {
1312 tp->t_callback(tp, tp->t_callarg);
1313 }
1314
1315
1316
1317
1318 licp = &(tp->t_items);
1319 if (!(xfs_lic_are_all_free(licp))) {
1320 xfs_trans_chunk_committed(licp, tp->t_lsn, abortflag);
1321 }
1322
1323
1324
1325
1326 licp = licp->lic_next;
1327 while (licp != NULL) {
1328 ASSERT(!xfs_lic_are_all_free(licp));
1329 xfs_trans_chunk_committed(licp, tp->t_lsn, abortflag);
1330 next_licp = licp->lic_next;
1331 kmem_free(licp);
1332 licp = next_licp;
1333 }
1334
1335
1336
1337
1338 lbcp = &tp->t_busy;
1339 while (lbcp != NULL) {
1340 for (i = 0, lbsp = lbcp->lbc_busy; i < lbcp->lbc_unused; i++, lbsp++) {
1341 if (!XFS_LBC_ISFREE(lbcp, i)) {
1342 xfs_alloc_clear_busy(tp, lbsp->lbc_ag,
1343 lbsp->lbc_idx);
1344 }
1345 }
1346 lbcp = lbcp->lbc_next;
1347 }
1348 xfs_trans_free_busy(tp);
1349
1350
1351
1352
1353 xfs_trans_free(tp);
1354}
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377STATIC void
1378xfs_trans_chunk_committed(
1379 xfs_log_item_chunk_t *licp,
1380 xfs_lsn_t lsn,
1381 int aborted)
1382{
1383 xfs_log_item_desc_t *lidp;
1384 xfs_log_item_t *lip;
1385 xfs_lsn_t item_lsn;
1386 struct xfs_mount *mp;
1387 int i;
1388
1389 lidp = licp->lic_descs;
1390 for (i = 0; i < licp->lic_unused; i++, lidp++) {
1391 if (xfs_lic_isfree(licp, i)) {
1392 continue;
1393 }
1394
1395 lip = lidp->lid_item;
1396 if (aborted)
1397 lip->li_flags |= XFS_LI_ABORTED;
1398
1399
1400
1401
1402
1403
1404 item_lsn = IOP_COMMITTED(lip, lsn);
1405
1406
1407
1408
1409
1410 if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0) {
1411 continue;
1412 }
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427 mp = lip->li_mountp;
1428 spin_lock(&mp->m_ail_lock);
1429 if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0) {
1430
1431
1432
1433
1434
1435
1436
1437 xfs_trans_update_ail(mp, lip, item_lsn);
1438 } else {
1439 spin_unlock(&mp->m_ail_lock);
1440 }
1441
1442
1443
1444
1445
1446
1447
1448
1449 IOP_UNPIN(lip, lidp->lid_flags & XFS_LID_BUF_STALE);
1450 }
1451}