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_inode.h"
15#include "xfs_extent_busy.h"
16#include "xfs_quota.h"
17#include "xfs_trans.h"
18#include "xfs_trans_priv.h"
19#include "xfs_log.h"
20#include "xfs_trace.h"
21#include "xfs_error.h"
22#include "xfs_defer.h"
23
24kmem_zone_t *xfs_trans_zone;
25
26#if defined(CONFIG_TRACEPOINTS)
27static void
28xfs_trans_trace_reservations(
29 struct xfs_mount *mp)
30{
31 struct xfs_trans_res resv;
32 struct xfs_trans_res *res;
33 struct xfs_trans_res *end_res;
34 int i;
35
36 res = (struct xfs_trans_res *)M_RES(mp);
37 end_res = (struct xfs_trans_res *)(M_RES(mp) + 1);
38 for (i = 0; res < end_res; i++, res++)
39 trace_xfs_trans_resv_calc(mp, i, res);
40 xfs_log_get_max_trans_res(mp, &resv);
41 trace_xfs_trans_resv_calc(mp, -1, &resv);
42}
43#else
44# define xfs_trans_trace_reservations(mp)
45#endif
46
47
48
49
50
51void
52xfs_trans_init(
53 struct xfs_mount *mp)
54{
55 xfs_trans_resv_calc(mp, M_RES(mp));
56 xfs_trans_trace_reservations(mp);
57}
58
59
60
61
62
63STATIC void
64xfs_trans_free(
65 struct xfs_trans *tp)
66{
67 xfs_extent_busy_sort(&tp->t_busy);
68 xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false);
69
70 trace_xfs_trans_free(tp, _RET_IP_);
71 atomic_dec(&tp->t_mountp->m_active_trans);
72 if (!(tp->t_flags & XFS_TRANS_NO_WRITECOUNT))
73 sb_end_intwrite(tp->t_mountp->m_super);
74 xfs_trans_free_dqinfo(tp);
75 kmem_zone_free(xfs_trans_zone, tp);
76}
77
78
79
80
81
82
83
84
85
86STATIC struct xfs_trans *
87xfs_trans_dup(
88 struct xfs_trans *tp)
89{
90 struct xfs_trans *ntp;
91
92 trace_xfs_trans_dup(tp, _RET_IP_);
93
94 ntp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
95
96
97
98
99 ntp->t_magic = XFS_TRANS_HEADER_MAGIC;
100 ntp->t_mountp = tp->t_mountp;
101 INIT_LIST_HEAD(&ntp->t_items);
102 INIT_LIST_HEAD(&ntp->t_busy);
103 INIT_LIST_HEAD(&ntp->t_dfops);
104 ntp->t_firstblock = NULLFSBLOCK;
105
106 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
107 ASSERT(tp->t_ticket != NULL);
108
109 ntp->t_flags = XFS_TRANS_PERM_LOG_RES |
110 (tp->t_flags & XFS_TRANS_RESERVE) |
111 (tp->t_flags & XFS_TRANS_NO_WRITECOUNT);
112
113 tp->t_flags |= XFS_TRANS_NO_WRITECOUNT;
114 ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket);
115
116 ASSERT(tp->t_blk_res >= tp->t_blk_res_used);
117 ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used;
118 tp->t_blk_res = tp->t_blk_res_used;
119
120 ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
121 tp->t_rtx_res = tp->t_rtx_res_used;
122 ntp->t_pflags = tp->t_pflags;
123
124
125 xfs_defer_move(ntp, tp);
126
127 xfs_trans_dup_dqinfo(tp, ntp);
128
129 atomic_inc(&tp->t_mountp->m_active_trans);
130 return ntp;
131}
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147static int
148xfs_trans_reserve(
149 struct xfs_trans *tp,
150 struct xfs_trans_res *resp,
151 uint blocks,
152 uint rtextents)
153{
154 int error = 0;
155 bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
156
157
158 current_set_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
159
160
161
162
163
164
165 if (blocks > 0) {
166 error = xfs_mod_fdblocks(tp->t_mountp, -((int64_t)blocks), rsvd);
167 if (error != 0) {
168 current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
169 return -ENOSPC;
170 }
171 tp->t_blk_res += blocks;
172 }
173
174
175
176
177 if (resp->tr_logres > 0) {
178 bool permanent = false;
179
180 ASSERT(tp->t_log_res == 0 ||
181 tp->t_log_res == resp->tr_logres);
182 ASSERT(tp->t_log_count == 0 ||
183 tp->t_log_count == resp->tr_logcount);
184
185 if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
186 tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
187 permanent = true;
188 } else {
189 ASSERT(tp->t_ticket == NULL);
190 ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
191 }
192
193 if (tp->t_ticket != NULL) {
194 ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
195 error = xfs_log_regrant(tp->t_mountp, tp->t_ticket);
196 } else {
197 error = xfs_log_reserve(tp->t_mountp,
198 resp->tr_logres,
199 resp->tr_logcount,
200 &tp->t_ticket, XFS_TRANSACTION,
201 permanent);
202 }
203
204 if (error)
205 goto undo_blocks;
206
207 tp->t_log_res = resp->tr_logres;
208 tp->t_log_count = resp->tr_logcount;
209 }
210
211
212
213
214
215
216 if (rtextents > 0) {
217 error = xfs_mod_frextents(tp->t_mountp, -((int64_t)rtextents));
218 if (error) {
219 error = -ENOSPC;
220 goto undo_log;
221 }
222 tp->t_rtx_res += rtextents;
223 }
224
225 return 0;
226
227
228
229
230
231undo_log:
232 if (resp->tr_logres > 0) {
233 xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, false);
234 tp->t_ticket = NULL;
235 tp->t_log_res = 0;
236 tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
237 }
238
239undo_blocks:
240 if (blocks > 0) {
241 xfs_mod_fdblocks(tp->t_mountp, (int64_t)blocks, rsvd);
242 tp->t_blk_res = 0;
243 }
244
245 current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
246
247 return error;
248}
249
250int
251xfs_trans_alloc(
252 struct xfs_mount *mp,
253 struct xfs_trans_res *resp,
254 uint blocks,
255 uint rtextents,
256 uint flags,
257 struct xfs_trans **tpp)
258{
259 struct xfs_trans *tp;
260 int error;
261
262
263
264
265
266
267 tp = kmem_zone_zalloc(xfs_trans_zone,
268 (flags & XFS_TRANS_NOFS) ? KM_NOFS : KM_SLEEP);
269
270 if (!(flags & XFS_TRANS_NO_WRITECOUNT))
271 sb_start_intwrite(mp->m_super);
272
273
274
275
276
277 WARN_ON(resp->tr_logres > 0 &&
278 mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
279 atomic_inc(&mp->m_active_trans);
280
281 tp->t_magic = XFS_TRANS_HEADER_MAGIC;
282 tp->t_flags = flags;
283 tp->t_mountp = mp;
284 INIT_LIST_HEAD(&tp->t_items);
285 INIT_LIST_HEAD(&tp->t_busy);
286 INIT_LIST_HEAD(&tp->t_dfops);
287 tp->t_firstblock = NULLFSBLOCK;
288
289 error = xfs_trans_reserve(tp, resp, blocks, rtextents);
290 if (error) {
291 xfs_trans_cancel(tp);
292 return error;
293 }
294
295 trace_xfs_trans_alloc(tp, _RET_IP_);
296
297 *tpp = tp;
298 return 0;
299}
300
301
302
303
304
305
306
307
308
309
310
311
312
313int
314xfs_trans_alloc_empty(
315 struct xfs_mount *mp,
316 struct xfs_trans **tpp)
317{
318 struct xfs_trans_res resv = {0};
319
320 return xfs_trans_alloc(mp, &resv, 0, 0, XFS_TRANS_NO_WRITECOUNT, tpp);
321}
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339void
340xfs_trans_mod_sb(
341 xfs_trans_t *tp,
342 uint field,
343 int64_t delta)
344{
345 uint32_t flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
346 xfs_mount_t *mp = tp->t_mountp;
347
348 switch (field) {
349 case XFS_TRANS_SB_ICOUNT:
350 tp->t_icount_delta += delta;
351 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
352 flags &= ~XFS_TRANS_SB_DIRTY;
353 break;
354 case XFS_TRANS_SB_IFREE:
355 tp->t_ifree_delta += delta;
356 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
357 flags &= ~XFS_TRANS_SB_DIRTY;
358 break;
359 case XFS_TRANS_SB_FDBLOCKS:
360
361
362
363
364
365 if (delta < 0) {
366 tp->t_blk_res_used += (uint)-delta;
367 if (tp->t_blk_res_used > tp->t_blk_res)
368 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
369 }
370 tp->t_fdblocks_delta += delta;
371 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
372 flags &= ~XFS_TRANS_SB_DIRTY;
373 break;
374 case XFS_TRANS_SB_RES_FDBLOCKS:
375
376
377
378
379
380 tp->t_res_fdblocks_delta += delta;
381 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
382 flags &= ~XFS_TRANS_SB_DIRTY;
383 break;
384 case XFS_TRANS_SB_FREXTENTS:
385
386
387
388
389
390 if (delta < 0) {
391 tp->t_rtx_res_used += (uint)-delta;
392 ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res);
393 }
394 tp->t_frextents_delta += delta;
395 break;
396 case XFS_TRANS_SB_RES_FREXTENTS:
397
398
399
400
401
402 ASSERT(delta < 0);
403 tp->t_res_frextents_delta += delta;
404 break;
405 case XFS_TRANS_SB_DBLOCKS:
406 ASSERT(delta > 0);
407 tp->t_dblocks_delta += delta;
408 break;
409 case XFS_TRANS_SB_AGCOUNT:
410 ASSERT(delta > 0);
411 tp->t_agcount_delta += delta;
412 break;
413 case XFS_TRANS_SB_IMAXPCT:
414 tp->t_imaxpct_delta += delta;
415 break;
416 case XFS_TRANS_SB_REXTSIZE:
417 tp->t_rextsize_delta += delta;
418 break;
419 case XFS_TRANS_SB_RBMBLOCKS:
420 tp->t_rbmblocks_delta += delta;
421 break;
422 case XFS_TRANS_SB_RBLOCKS:
423 tp->t_rblocks_delta += delta;
424 break;
425 case XFS_TRANS_SB_REXTENTS:
426 tp->t_rextents_delta += delta;
427 break;
428 case XFS_TRANS_SB_REXTSLOG:
429 tp->t_rextslog_delta += delta;
430 break;
431 default:
432 ASSERT(0);
433 return;
434 }
435
436 tp->t_flags |= flags;
437}
438
439
440
441
442
443
444
445
446
447STATIC void
448xfs_trans_apply_sb_deltas(
449 xfs_trans_t *tp)
450{
451 xfs_dsb_t *sbp;
452 xfs_buf_t *bp;
453 int whole = 0;
454
455 bp = xfs_trans_getsb(tp, tp->t_mountp, 0);
456 sbp = XFS_BUF_TO_SBP(bp);
457
458
459
460
461 ASSERT((tp->t_fdblocks_delta + tp->t_res_fdblocks_delta) ==
462 (tp->t_ag_freeblks_delta + tp->t_ag_flist_delta +
463 tp->t_ag_btree_delta));
464
465
466
467
468 if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) {
469 if (tp->t_icount_delta)
470 be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta);
471 if (tp->t_ifree_delta)
472 be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta);
473 if (tp->t_fdblocks_delta)
474 be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
475 if (tp->t_res_fdblocks_delta)
476 be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta);
477 }
478
479 if (tp->t_frextents_delta)
480 be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta);
481 if (tp->t_res_frextents_delta)
482 be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta);
483
484 if (tp->t_dblocks_delta) {
485 be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta);
486 whole = 1;
487 }
488 if (tp->t_agcount_delta) {
489 be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta);
490 whole = 1;
491 }
492 if (tp->t_imaxpct_delta) {
493 sbp->sb_imax_pct += tp->t_imaxpct_delta;
494 whole = 1;
495 }
496 if (tp->t_rextsize_delta) {
497 be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta);
498 whole = 1;
499 }
500 if (tp->t_rbmblocks_delta) {
501 be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
502 whole = 1;
503 }
504 if (tp->t_rblocks_delta) {
505 be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta);
506 whole = 1;
507 }
508 if (tp->t_rextents_delta) {
509 be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta);
510 whole = 1;
511 }
512 if (tp->t_rextslog_delta) {
513 sbp->sb_rextslog += tp->t_rextslog_delta;
514 whole = 1;
515 }
516
517 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
518 if (whole)
519
520
521
522 xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1);
523 else
524
525
526
527
528 xfs_trans_log_buf(tp, bp, offsetof(xfs_dsb_t, sb_icount),
529 offsetof(xfs_dsb_t, sb_frextents) +
530 sizeof(sbp->sb_frextents) - 1);
531}
532
533STATIC int
534xfs_sb_mod8(
535 uint8_t *field,
536 int8_t delta)
537{
538 int8_t counter = *field;
539
540 counter += delta;
541 if (counter < 0) {
542 ASSERT(0);
543 return -EINVAL;
544 }
545 *field = counter;
546 return 0;
547}
548
549STATIC int
550xfs_sb_mod32(
551 uint32_t *field,
552 int32_t delta)
553{
554 int32_t counter = *field;
555
556 counter += delta;
557 if (counter < 0) {
558 ASSERT(0);
559 return -EINVAL;
560 }
561 *field = counter;
562 return 0;
563}
564
565STATIC int
566xfs_sb_mod64(
567 uint64_t *field,
568 int64_t delta)
569{
570 int64_t counter = *field;
571
572 counter += delta;
573 if (counter < 0) {
574 ASSERT(0);
575 return -EINVAL;
576 }
577 *field = counter;
578 return 0;
579}
580
581
582
583
584
585
586
587
588
589
590
591
592
593void
594xfs_trans_unreserve_and_mod_sb(
595 struct xfs_trans *tp)
596{
597 struct xfs_mount *mp = tp->t_mountp;
598 bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
599 int64_t blkdelta = 0;
600 int64_t rtxdelta = 0;
601 int64_t idelta = 0;
602 int64_t ifreedelta = 0;
603 int error;
604
605
606 if (tp->t_blk_res > 0)
607 blkdelta = tp->t_blk_res;
608 if ((tp->t_fdblocks_delta != 0) &&
609 (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
610 (tp->t_flags & XFS_TRANS_SB_DIRTY)))
611 blkdelta += tp->t_fdblocks_delta;
612
613 if (tp->t_rtx_res > 0)
614 rtxdelta = tp->t_rtx_res;
615 if ((tp->t_frextents_delta != 0) &&
616 (tp->t_flags & XFS_TRANS_SB_DIRTY))
617 rtxdelta += tp->t_frextents_delta;
618
619 if (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
620 (tp->t_flags & XFS_TRANS_SB_DIRTY)) {
621 idelta = tp->t_icount_delta;
622 ifreedelta = tp->t_ifree_delta;
623 }
624
625
626 if (blkdelta) {
627 error = xfs_mod_fdblocks(mp, blkdelta, rsvd);
628 if (error)
629 goto out;
630 }
631
632 if (idelta) {
633 error = xfs_mod_icount(mp, idelta);
634 if (error)
635 goto out_undo_fdblocks;
636 }
637
638 if (ifreedelta) {
639 error = xfs_mod_ifree(mp, ifreedelta);
640 if (error)
641 goto out_undo_icount;
642 }
643
644 if (rtxdelta == 0 && !(tp->t_flags & XFS_TRANS_SB_DIRTY))
645 return;
646
647
648 spin_lock(&mp->m_sb_lock);
649 if (rtxdelta) {
650 error = xfs_sb_mod64(&mp->m_sb.sb_frextents, rtxdelta);
651 if (error)
652 goto out_undo_ifree;
653 }
654
655 if (tp->t_dblocks_delta != 0) {
656 error = xfs_sb_mod64(&mp->m_sb.sb_dblocks, tp->t_dblocks_delta);
657 if (error)
658 goto out_undo_frextents;
659 }
660 if (tp->t_agcount_delta != 0) {
661 error = xfs_sb_mod32(&mp->m_sb.sb_agcount, tp->t_agcount_delta);
662 if (error)
663 goto out_undo_dblocks;
664 }
665 if (tp->t_imaxpct_delta != 0) {
666 error = xfs_sb_mod8(&mp->m_sb.sb_imax_pct, tp->t_imaxpct_delta);
667 if (error)
668 goto out_undo_agcount;
669 }
670 if (tp->t_rextsize_delta != 0) {
671 error = xfs_sb_mod32(&mp->m_sb.sb_rextsize,
672 tp->t_rextsize_delta);
673 if (error)
674 goto out_undo_imaxpct;
675 }
676 if (tp->t_rbmblocks_delta != 0) {
677 error = xfs_sb_mod32(&mp->m_sb.sb_rbmblocks,
678 tp->t_rbmblocks_delta);
679 if (error)
680 goto out_undo_rextsize;
681 }
682 if (tp->t_rblocks_delta != 0) {
683 error = xfs_sb_mod64(&mp->m_sb.sb_rblocks, tp->t_rblocks_delta);
684 if (error)
685 goto out_undo_rbmblocks;
686 }
687 if (tp->t_rextents_delta != 0) {
688 error = xfs_sb_mod64(&mp->m_sb.sb_rextents,
689 tp->t_rextents_delta);
690 if (error)
691 goto out_undo_rblocks;
692 }
693 if (tp->t_rextslog_delta != 0) {
694 error = xfs_sb_mod8(&mp->m_sb.sb_rextslog,
695 tp->t_rextslog_delta);
696 if (error)
697 goto out_undo_rextents;
698 }
699 spin_unlock(&mp->m_sb_lock);
700 return;
701
702out_undo_rextents:
703 if (tp->t_rextents_delta)
704 xfs_sb_mod64(&mp->m_sb.sb_rextents, -tp->t_rextents_delta);
705out_undo_rblocks:
706 if (tp->t_rblocks_delta)
707 xfs_sb_mod64(&mp->m_sb.sb_rblocks, -tp->t_rblocks_delta);
708out_undo_rbmblocks:
709 if (tp->t_rbmblocks_delta)
710 xfs_sb_mod32(&mp->m_sb.sb_rbmblocks, -tp->t_rbmblocks_delta);
711out_undo_rextsize:
712 if (tp->t_rextsize_delta)
713 xfs_sb_mod32(&mp->m_sb.sb_rextsize, -tp->t_rextsize_delta);
714out_undo_imaxpct:
715 if (tp->t_rextsize_delta)
716 xfs_sb_mod8(&mp->m_sb.sb_imax_pct, -tp->t_imaxpct_delta);
717out_undo_agcount:
718 if (tp->t_agcount_delta)
719 xfs_sb_mod32(&mp->m_sb.sb_agcount, -tp->t_agcount_delta);
720out_undo_dblocks:
721 if (tp->t_dblocks_delta)
722 xfs_sb_mod64(&mp->m_sb.sb_dblocks, -tp->t_dblocks_delta);
723out_undo_frextents:
724 if (rtxdelta)
725 xfs_sb_mod64(&mp->m_sb.sb_frextents, -rtxdelta);
726out_undo_ifree:
727 spin_unlock(&mp->m_sb_lock);
728 if (ifreedelta)
729 xfs_mod_ifree(mp, -ifreedelta);
730out_undo_icount:
731 if (idelta)
732 xfs_mod_icount(mp, -idelta);
733out_undo_fdblocks:
734 if (blkdelta)
735 xfs_mod_fdblocks(mp, -blkdelta, rsvd);
736out:
737 ASSERT(error == 0);
738 return;
739}
740
741
742void
743xfs_trans_add_item(
744 struct xfs_trans *tp,
745 struct xfs_log_item *lip)
746{
747 ASSERT(lip->li_mountp == tp->t_mountp);
748 ASSERT(lip->li_ailp == tp->t_mountp->m_ail);
749 ASSERT(list_empty(&lip->li_trans));
750 ASSERT(!test_bit(XFS_LI_DIRTY, &lip->li_flags));
751
752 list_add_tail(&lip->li_trans, &tp->t_items);
753 trace_xfs_trans_add_item(tp, _RET_IP_);
754}
755
756
757
758
759
760
761void
762xfs_trans_del_item(
763 struct xfs_log_item *lip)
764{
765 clear_bit(XFS_LI_DIRTY, &lip->li_flags);
766 list_del_init(&lip->li_trans);
767}
768
769
770void
771xfs_trans_free_items(
772 struct xfs_trans *tp,
773 xfs_lsn_t commit_lsn,
774 bool abort)
775{
776 struct xfs_log_item *lip, *next;
777
778 trace_xfs_trans_free_items(tp, _RET_IP_);
779
780 list_for_each_entry_safe(lip, next, &tp->t_items, li_trans) {
781 xfs_trans_del_item(lip);
782 if (commit_lsn != NULLCOMMITLSN)
783 lip->li_ops->iop_committing(lip, commit_lsn);
784 if (abort)
785 set_bit(XFS_LI_ABORTED, &lip->li_flags);
786 lip->li_ops->iop_unlock(lip);
787 }
788}
789
790static inline void
791xfs_log_item_batch_insert(
792 struct xfs_ail *ailp,
793 struct xfs_ail_cursor *cur,
794 struct xfs_log_item **log_items,
795 int nr_items,
796 xfs_lsn_t commit_lsn)
797{
798 int i;
799
800 spin_lock(&ailp->ail_lock);
801
802 xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
803
804 for (i = 0; i < nr_items; i++) {
805 struct xfs_log_item *lip = log_items[i];
806
807 lip->li_ops->iop_unpin(lip, 0);
808 }
809}
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831void
832xfs_trans_committed_bulk(
833 struct xfs_ail *ailp,
834 struct xfs_log_vec *log_vector,
835 xfs_lsn_t commit_lsn,
836 int aborted)
837{
838#define LOG_ITEM_BATCH_SIZE 32
839 struct xfs_log_item *log_items[LOG_ITEM_BATCH_SIZE];
840 struct xfs_log_vec *lv;
841 struct xfs_ail_cursor cur;
842 int i = 0;
843
844 spin_lock(&ailp->ail_lock);
845 xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn);
846 spin_unlock(&ailp->ail_lock);
847
848
849 for (lv = log_vector; lv; lv = lv->lv_next ) {
850 struct xfs_log_item *lip = lv->lv_item;
851 xfs_lsn_t item_lsn;
852
853 if (aborted)
854 set_bit(XFS_LI_ABORTED, &lip->li_flags);
855 item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
856
857
858 if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
859 continue;
860
861
862
863
864
865 if (aborted) {
866 ASSERT(XFS_FORCED_SHUTDOWN(ailp->ail_mount));
867 lip->li_ops->iop_unpin(lip, 1);
868 continue;
869 }
870
871 if (item_lsn != commit_lsn) {
872
873
874
875
876
877
878
879
880 spin_lock(&ailp->ail_lock);
881 if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0)
882 xfs_trans_ail_update(ailp, lip, item_lsn);
883 else
884 spin_unlock(&ailp->ail_lock);
885 lip->li_ops->iop_unpin(lip, 0);
886 continue;
887 }
888
889
890 log_items[i++] = lv->lv_item;
891 if (i >= LOG_ITEM_BATCH_SIZE) {
892 xfs_log_item_batch_insert(ailp, &cur, log_items,
893 LOG_ITEM_BATCH_SIZE, commit_lsn);
894 i = 0;
895 }
896 }
897
898
899 if (i)
900 xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn);
901
902 spin_lock(&ailp->ail_lock);
903 xfs_trans_ail_cursor_done(&cur);
904 spin_unlock(&ailp->ail_lock);
905}
906
907
908
909
910
911
912
913
914
915
916
917
918
919static int
920__xfs_trans_commit(
921 struct xfs_trans *tp,
922 bool regrant)
923{
924 struct xfs_mount *mp = tp->t_mountp;
925 xfs_lsn_t commit_lsn = -1;
926 int error = 0;
927 int sync = tp->t_flags & XFS_TRANS_SYNC;
928
929 trace_xfs_trans_commit(tp, _RET_IP_);
930
931
932
933
934
935 WARN_ON_ONCE(!list_empty(&tp->t_dfops) &&
936 !(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
937 if (!regrant && (tp->t_flags & XFS_TRANS_PERM_LOG_RES)) {
938 error = xfs_defer_finish_noroll(&tp);
939 if (error)
940 goto out_unreserve;
941 }
942
943
944
945
946
947
948
949
950 if (!(tp->t_flags & XFS_TRANS_DIRTY))
951 goto out_unreserve;
952
953 if (XFS_FORCED_SHUTDOWN(mp)) {
954 error = -EIO;
955 goto out_unreserve;
956 }
957
958 ASSERT(tp->t_ticket != NULL);
959
960
961
962
963 if (tp->t_flags & XFS_TRANS_SB_DIRTY)
964 xfs_trans_apply_sb_deltas(tp);
965 xfs_trans_apply_dquot_deltas(tp);
966
967 xfs_log_commit_cil(mp, tp, &commit_lsn, regrant);
968
969 current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
970 xfs_trans_free(tp);
971
972
973
974
975
976 if (sync) {
977 error = xfs_log_force_lsn(mp, commit_lsn, XFS_LOG_SYNC, NULL);
978 XFS_STATS_INC(mp, xs_trans_sync);
979 } else {
980 XFS_STATS_INC(mp, xs_trans_async);
981 }
982
983 return error;
984
985out_unreserve:
986 xfs_trans_unreserve_and_mod_sb(tp);
987
988
989
990
991
992
993 xfs_trans_unreserve_and_mod_dquots(tp);
994 if (tp->t_ticket) {
995 commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, regrant);
996 if (commit_lsn == -1 && !error)
997 error = -EIO;
998 tp->t_ticket = NULL;
999 }
1000 current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
1001 xfs_trans_free_items(tp, NULLCOMMITLSN, !!error);
1002 xfs_trans_free(tp);
1003
1004 XFS_STATS_INC(mp, xs_trans_empty);
1005 return error;
1006}
1007
1008int
1009xfs_trans_commit(
1010 struct xfs_trans *tp)
1011{
1012 return __xfs_trans_commit(tp, false);
1013}
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023void
1024xfs_trans_cancel(
1025 struct xfs_trans *tp)
1026{
1027 struct xfs_mount *mp = tp->t_mountp;
1028 bool dirty = (tp->t_flags & XFS_TRANS_DIRTY);
1029
1030 trace_xfs_trans_cancel(tp, _RET_IP_);
1031
1032 if (tp->t_flags & XFS_TRANS_PERM_LOG_RES)
1033 xfs_defer_cancel(tp);
1034
1035
1036
1037
1038
1039
1040 if (dirty && !XFS_FORCED_SHUTDOWN(mp)) {
1041 XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
1042 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1043 }
1044#ifdef DEBUG
1045 if (!dirty && !XFS_FORCED_SHUTDOWN(mp)) {
1046 struct xfs_log_item *lip;
1047
1048 list_for_each_entry(lip, &tp->t_items, li_trans)
1049 ASSERT(!(lip->li_type == XFS_LI_EFD));
1050 }
1051#endif
1052 xfs_trans_unreserve_and_mod_sb(tp);
1053 xfs_trans_unreserve_and_mod_dquots(tp);
1054
1055 if (tp->t_ticket) {
1056 xfs_log_done(mp, tp->t_ticket, NULL, false);
1057 tp->t_ticket = NULL;
1058 }
1059
1060
1061 current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
1062
1063 xfs_trans_free_items(tp, NULLCOMMITLSN, dirty);
1064 xfs_trans_free(tp);
1065}
1066
1067
1068
1069
1070
1071
1072
1073
1074int
1075xfs_trans_roll(
1076 struct xfs_trans **tpp)
1077{
1078 struct xfs_trans *trans = *tpp;
1079 struct xfs_trans_res tres;
1080 int error;
1081
1082 trace_xfs_trans_roll(trans, _RET_IP_);
1083
1084
1085
1086
1087 tres.tr_logres = trans->t_log_res;
1088 tres.tr_logcount = trans->t_log_count;
1089
1090 *tpp = xfs_trans_dup(trans);
1091
1092
1093
1094
1095
1096
1097
1098
1099 error = __xfs_trans_commit(trans, true);
1100 if (error)
1101 return error;
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111 tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
1112 return xfs_trans_reserve(*tpp, &tres, 0, 0);
1113}
1114