2 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 #include "xfs_types.h"
24 #include "xfs_trans.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"
43 #include "xfs_quota.h"
44 #include "xfs_trans_priv.h"
45 #include "xfs_trans_space.h"
48 STATIC
void xfs_trans_apply_sb_deltas(xfs_trans_t
*);
49 STATIC uint
xfs_trans_count_vecs(xfs_trans_t
*);
50 STATIC
void xfs_trans_fill_vecs(xfs_trans_t
*, xfs_log_iovec_t
*);
51 STATIC
void xfs_trans_uncommit(xfs_trans_t
*, uint
);
52 STATIC
void xfs_trans_committed(xfs_trans_t
*, int);
53 STATIC
void xfs_trans_chunk_committed(xfs_log_item_chunk_t
*, xfs_lsn_t
, int);
54 STATIC
void xfs_trans_free(xfs_trans_t
*);
56 kmem_zone_t
*xfs_trans_zone
;
60 * Reservation functions here avoid a huge stack in xfs_trans_init
61 * due to register overflow from temporaries in the calculations.
65 xfs_calc_write_reservation(xfs_mount_t
*mp
)
67 return XFS_CALC_WRITE_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
71 xfs_calc_itruncate_reservation(xfs_mount_t
*mp
)
73 return XFS_CALC_ITRUNCATE_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
77 xfs_calc_rename_reservation(xfs_mount_t
*mp
)
79 return XFS_CALC_RENAME_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
83 xfs_calc_link_reservation(xfs_mount_t
*mp
)
85 return XFS_CALC_LINK_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
89 xfs_calc_remove_reservation(xfs_mount_t
*mp
)
91 return XFS_CALC_REMOVE_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
95 xfs_calc_symlink_reservation(xfs_mount_t
*mp
)
97 return XFS_CALC_SYMLINK_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
101 xfs_calc_create_reservation(xfs_mount_t
*mp
)
103 return XFS_CALC_CREATE_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
107 xfs_calc_mkdir_reservation(xfs_mount_t
*mp
)
109 return XFS_CALC_MKDIR_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
113 xfs_calc_ifree_reservation(xfs_mount_t
*mp
)
115 return XFS_CALC_IFREE_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
119 xfs_calc_ichange_reservation(xfs_mount_t
*mp
)
121 return XFS_CALC_ICHANGE_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
125 xfs_calc_growdata_reservation(xfs_mount_t
*mp
)
127 return XFS_CALC_GROWDATA_LOG_RES(mp
);
131 xfs_calc_growrtalloc_reservation(xfs_mount_t
*mp
)
133 return XFS_CALC_GROWRTALLOC_LOG_RES(mp
);
137 xfs_calc_growrtzero_reservation(xfs_mount_t
*mp
)
139 return XFS_CALC_GROWRTZERO_LOG_RES(mp
);
143 xfs_calc_growrtfree_reservation(xfs_mount_t
*mp
)
145 return XFS_CALC_GROWRTFREE_LOG_RES(mp
);
149 xfs_calc_swrite_reservation(xfs_mount_t
*mp
)
151 return XFS_CALC_SWRITE_LOG_RES(mp
);
155 xfs_calc_writeid_reservation(xfs_mount_t
*mp
)
157 return XFS_CALC_WRITEID_LOG_RES(mp
);
161 xfs_calc_addafork_reservation(xfs_mount_t
*mp
)
163 return XFS_CALC_ADDAFORK_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
167 xfs_calc_attrinval_reservation(xfs_mount_t
*mp
)
169 return XFS_CALC_ATTRINVAL_LOG_RES(mp
);
173 xfs_calc_attrset_reservation(xfs_mount_t
*mp
)
175 return XFS_CALC_ATTRSET_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
179 xfs_calc_attrrm_reservation(xfs_mount_t
*mp
)
181 return XFS_CALC_ATTRRM_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
);
185 xfs_calc_clear_agi_bucket_reservation(xfs_mount_t
*mp
)
187 return XFS_CALC_CLEAR_AGI_BUCKET_LOG_RES(mp
);
191 * Initialize the precomputed transaction reservation values
192 * in the mount structure.
198 xfs_trans_reservations_t
*resp
;
200 resp
= &(mp
->m_reservations
);
201 resp
->tr_write
= xfs_calc_write_reservation(mp
);
202 resp
->tr_itruncate
= xfs_calc_itruncate_reservation(mp
);
203 resp
->tr_rename
= xfs_calc_rename_reservation(mp
);
204 resp
->tr_link
= xfs_calc_link_reservation(mp
);
205 resp
->tr_remove
= xfs_calc_remove_reservation(mp
);
206 resp
->tr_symlink
= xfs_calc_symlink_reservation(mp
);
207 resp
->tr_create
= xfs_calc_create_reservation(mp
);
208 resp
->tr_mkdir
= xfs_calc_mkdir_reservation(mp
);
209 resp
->tr_ifree
= xfs_calc_ifree_reservation(mp
);
210 resp
->tr_ichange
= xfs_calc_ichange_reservation(mp
);
211 resp
->tr_growdata
= xfs_calc_growdata_reservation(mp
);
212 resp
->tr_swrite
= xfs_calc_swrite_reservation(mp
);
213 resp
->tr_writeid
= xfs_calc_writeid_reservation(mp
);
214 resp
->tr_addafork
= xfs_calc_addafork_reservation(mp
);
215 resp
->tr_attrinval
= xfs_calc_attrinval_reservation(mp
);
216 resp
->tr_attrset
= xfs_calc_attrset_reservation(mp
);
217 resp
->tr_attrrm
= xfs_calc_attrrm_reservation(mp
);
218 resp
->tr_clearagi
= xfs_calc_clear_agi_bucket_reservation(mp
);
219 resp
->tr_growrtalloc
= xfs_calc_growrtalloc_reservation(mp
);
220 resp
->tr_growrtzero
= xfs_calc_growrtzero_reservation(mp
);
221 resp
->tr_growrtfree
= xfs_calc_growrtfree_reservation(mp
);
225 * This routine is called to allocate a transaction structure.
226 * The type parameter indicates the type of the transaction. These
227 * are enumerated in xfs_trans.h.
229 * Dynamically allocate the transaction structure from the transaction
230 * zone, initialize it, and return it to the caller.
237 vfs_wait_for_freeze(XFS_MTOVFS(mp
), SB_FREEZE_TRANS
);
238 return _xfs_trans_alloc(mp
, type
);
248 atomic_inc(&mp
->m_active_trans
);
250 tp
= kmem_zone_zalloc(xfs_trans_zone
, KM_SLEEP
);
251 tp
->t_magic
= XFS_TRANS_MAGIC
;
254 tp
->t_items_free
= XFS_LIC_NUM_SLOTS
;
255 tp
->t_busy_free
= XFS_LBC_NUM_SLOTS
;
256 XFS_LIC_INIT(&(tp
->t_items
));
257 XFS_LBC_INIT(&(tp
->t_busy
));
262 * This is called to create a new transaction which will share the
263 * permanent log reservation of the given transaction. The remaining
264 * unused block and rt extent reservations are also inherited. This
265 * implies that the original transaction is no longer allowed to allocate
266 * blocks. Locks and log items, however, are no inherited. They must
267 * be added to the new transaction explicitly.
275 ntp
= kmem_zone_zalloc(xfs_trans_zone
, KM_SLEEP
);
278 * Initialize the new transaction structure.
280 ntp
->t_magic
= XFS_TRANS_MAGIC
;
281 ntp
->t_type
= tp
->t_type
;
282 ntp
->t_mountp
= tp
->t_mountp
;
283 ntp
->t_items_free
= XFS_LIC_NUM_SLOTS
;
284 ntp
->t_busy_free
= XFS_LBC_NUM_SLOTS
;
285 XFS_LIC_INIT(&(ntp
->t_items
));
286 XFS_LBC_INIT(&(ntp
->t_busy
));
288 ASSERT(tp
->t_flags
& XFS_TRANS_PERM_LOG_RES
);
289 ASSERT(tp
->t_ticket
!= NULL
);
291 ntp
->t_flags
= XFS_TRANS_PERM_LOG_RES
| (tp
->t_flags
& XFS_TRANS_RESERVE
);
292 ntp
->t_ticket
= tp
->t_ticket
;
293 ntp
->t_blk_res
= tp
->t_blk_res
- tp
->t_blk_res_used
;
294 tp
->t_blk_res
= tp
->t_blk_res_used
;
295 ntp
->t_rtx_res
= tp
->t_rtx_res
- tp
->t_rtx_res_used
;
296 tp
->t_rtx_res
= tp
->t_rtx_res_used
;
297 ntp
->t_pflags
= tp
->t_pflags
;
299 XFS_TRANS_DUP_DQINFO(tp
->t_mountp
, tp
, ntp
);
301 atomic_inc(&tp
->t_mountp
->m_active_trans
);
306 * This is called to reserve free disk blocks and log space for the
307 * given transaction. This must be done before allocating any resources
308 * within the transaction.
310 * This will return ENOSPC if there are not enough blocks available.
311 * It will sleep waiting for available log space.
312 * The only valid value for the flags parameter is XFS_RES_LOG_PERM, which
313 * is used by long running transactions. If any one of the reservations
314 * fails then they will all be backed out.
316 * This does not do quota reservations. That typically is done by the
330 int rsvd
= (tp
->t_flags
& XFS_TRANS_RESERVE
) != 0;
332 /* Mark this thread as being in a transaction */
333 current_set_flags_nested(&tp
->t_pflags
, PF_FSTRANS
);
336 * Attempt to reserve the needed disk blocks by decrementing
337 * the number needed from the number available. This will
338 * fail if the count would go below zero.
341 error
= xfs_mod_incore_sb(tp
->t_mountp
, XFS_SBS_FDBLOCKS
,
342 -((int64_t)blocks
), rsvd
);
344 current_restore_flags_nested(&tp
->t_pflags
, PF_FSTRANS
);
345 return (XFS_ERROR(ENOSPC
));
347 tp
->t_blk_res
+= blocks
;
351 * Reserve the log space needed for this transaction.
354 ASSERT((tp
->t_log_res
== 0) || (tp
->t_log_res
== logspace
));
355 ASSERT((tp
->t_log_count
== 0) ||
356 (tp
->t_log_count
== logcount
));
357 if (flags
& XFS_TRANS_PERM_LOG_RES
) {
358 log_flags
= XFS_LOG_PERM_RESERV
;
359 tp
->t_flags
|= XFS_TRANS_PERM_LOG_RES
;
361 ASSERT(tp
->t_ticket
== NULL
);
362 ASSERT(!(tp
->t_flags
& XFS_TRANS_PERM_LOG_RES
));
366 error
= xfs_log_reserve(tp
->t_mountp
, logspace
, logcount
,
368 XFS_TRANSACTION
, log_flags
, tp
->t_type
);
372 tp
->t_log_res
= logspace
;
373 tp
->t_log_count
= logcount
;
377 * Attempt to reserve the needed realtime extents by decrementing
378 * the number needed from the number available. This will
379 * fail if the count would go below zero.
382 error
= xfs_mod_incore_sb(tp
->t_mountp
, XFS_SBS_FREXTENTS
,
383 -((int64_t)rtextents
), rsvd
);
385 error
= XFS_ERROR(ENOSPC
);
388 tp
->t_rtx_res
+= rtextents
;
394 * Error cases jump to one of these labels to undo any
395 * reservations which have already been performed.
399 if (flags
& XFS_TRANS_PERM_LOG_RES
) {
400 log_flags
= XFS_LOG_REL_PERM_RESERV
;
404 xfs_log_done(tp
->t_mountp
, tp
->t_ticket
, NULL
, log_flags
);
407 tp
->t_flags
&= ~XFS_TRANS_PERM_LOG_RES
;
412 (void) xfs_mod_incore_sb(tp
->t_mountp
, XFS_SBS_FDBLOCKS
,
413 (int64_t)blocks
, rsvd
);
417 current_restore_flags_nested(&tp
->t_pflags
, PF_FSTRANS
);
424 * Record the indicated change to the given field for application
425 * to the file system's superblock when the transaction commits.
426 * For now, just store the change in the transaction structure.
428 * Mark the transaction structure to indicate that the superblock
429 * needs to be updated before committing.
431 * Because we may not be keeping track of allocated/free inodes and
432 * used filesystem blocks in the superblock, we do not mark the
433 * superblock dirty in this transaction if we modify these fields.
434 * We still need to update the transaction deltas so that they get
435 * applied to the incore superblock, but we don't want them to
436 * cause the superblock to get locked and logged if these are the
437 * only fields in the superblock that the transaction modifies.
445 uint32_t flags
= (XFS_TRANS_DIRTY
|XFS_TRANS_SB_DIRTY
);
446 xfs_mount_t
*mp
= tp
->t_mountp
;
449 case XFS_TRANS_SB_ICOUNT
:
450 tp
->t_icount_delta
+= delta
;
451 if (xfs_sb_version_haslazysbcount(&mp
->m_sb
))
452 flags
&= ~XFS_TRANS_SB_DIRTY
;
454 case XFS_TRANS_SB_IFREE
:
455 tp
->t_ifree_delta
+= delta
;
456 if (xfs_sb_version_haslazysbcount(&mp
->m_sb
))
457 flags
&= ~XFS_TRANS_SB_DIRTY
;
459 case XFS_TRANS_SB_FDBLOCKS
:
461 * Track the number of blocks allocated in the
462 * transaction. Make sure it does not exceed the
466 tp
->t_blk_res_used
+= (uint
)-delta
;
467 ASSERT(tp
->t_blk_res_used
<= tp
->t_blk_res
);
469 tp
->t_fdblocks_delta
+= delta
;
470 if (xfs_sb_version_haslazysbcount(&mp
->m_sb
))
471 flags
&= ~XFS_TRANS_SB_DIRTY
;
473 case XFS_TRANS_SB_RES_FDBLOCKS
:
475 * The allocation has already been applied to the
476 * in-core superblock's counter. This should only
477 * be applied to the on-disk superblock.
480 tp
->t_res_fdblocks_delta
+= delta
;
481 if (xfs_sb_version_haslazysbcount(&mp
->m_sb
))
482 flags
&= ~XFS_TRANS_SB_DIRTY
;
484 case XFS_TRANS_SB_FREXTENTS
:
486 * Track the number of blocks allocated in the
487 * transaction. Make sure it does not exceed the
491 tp
->t_rtx_res_used
+= (uint
)-delta
;
492 ASSERT(tp
->t_rtx_res_used
<= tp
->t_rtx_res
);
494 tp
->t_frextents_delta
+= delta
;
496 case XFS_TRANS_SB_RES_FREXTENTS
:
498 * The allocation has already been applied to the
499 * in-core superblock's counter. This should only
500 * be applied to the on-disk superblock.
503 tp
->t_res_frextents_delta
+= delta
;
505 case XFS_TRANS_SB_DBLOCKS
:
507 tp
->t_dblocks_delta
+= delta
;
509 case XFS_TRANS_SB_AGCOUNT
:
511 tp
->t_agcount_delta
+= delta
;
513 case XFS_TRANS_SB_IMAXPCT
:
514 tp
->t_imaxpct_delta
+= delta
;
516 case XFS_TRANS_SB_REXTSIZE
:
517 tp
->t_rextsize_delta
+= delta
;
519 case XFS_TRANS_SB_RBMBLOCKS
:
520 tp
->t_rbmblocks_delta
+= delta
;
522 case XFS_TRANS_SB_RBLOCKS
:
523 tp
->t_rblocks_delta
+= delta
;
525 case XFS_TRANS_SB_REXTENTS
:
526 tp
->t_rextents_delta
+= delta
;
528 case XFS_TRANS_SB_REXTSLOG
:
529 tp
->t_rextslog_delta
+= delta
;
536 tp
->t_flags
|= flags
;
540 * xfs_trans_apply_sb_deltas() is called from the commit code
541 * to bring the superblock buffer into the current transaction
542 * and modify it as requested by earlier calls to xfs_trans_mod_sb().
544 * For now we just look at each field allowed to change and change
548 xfs_trans_apply_sb_deltas(
555 bp
= xfs_trans_getsb(tp
, tp
->t_mountp
, 0);
556 sbp
= XFS_BUF_TO_SBP(bp
);
559 * Check that superblock mods match the mods made to AGF counters.
561 ASSERT((tp
->t_fdblocks_delta
+ tp
->t_res_fdblocks_delta
) ==
562 (tp
->t_ag_freeblks_delta
+ tp
->t_ag_flist_delta
+
563 tp
->t_ag_btree_delta
));
566 * Only update the superblock counters if we are logging them
568 if (!xfs_sb_version_haslazysbcount(&(tp
->t_mountp
->m_sb
))) {
569 if (tp
->t_icount_delta
!= 0) {
570 INT_MOD(sbp
->sb_icount
, ARCH_CONVERT
, tp
->t_icount_delta
);
572 if (tp
->t_ifree_delta
!= 0) {
573 INT_MOD(sbp
->sb_ifree
, ARCH_CONVERT
, tp
->t_ifree_delta
);
576 if (tp
->t_fdblocks_delta
!= 0) {
577 INT_MOD(sbp
->sb_fdblocks
, ARCH_CONVERT
, tp
->t_fdblocks_delta
);
579 if (tp
->t_res_fdblocks_delta
!= 0) {
580 INT_MOD(sbp
->sb_fdblocks
, ARCH_CONVERT
, tp
->t_res_fdblocks_delta
);
584 if (tp
->t_frextents_delta
!= 0) {
585 INT_MOD(sbp
->sb_frextents
, ARCH_CONVERT
, tp
->t_frextents_delta
);
587 if (tp
->t_res_frextents_delta
!= 0) {
588 INT_MOD(sbp
->sb_frextents
, ARCH_CONVERT
, tp
->t_res_frextents_delta
);
590 if (tp
->t_dblocks_delta
!= 0) {
591 INT_MOD(sbp
->sb_dblocks
, ARCH_CONVERT
, tp
->t_dblocks_delta
);
594 if (tp
->t_agcount_delta
!= 0) {
595 INT_MOD(sbp
->sb_agcount
, ARCH_CONVERT
, tp
->t_agcount_delta
);
598 if (tp
->t_imaxpct_delta
!= 0) {
599 INT_MOD(sbp
->sb_imax_pct
, ARCH_CONVERT
, tp
->t_imaxpct_delta
);
602 if (tp
->t_rextsize_delta
!= 0) {
603 INT_MOD(sbp
->sb_rextsize
, ARCH_CONVERT
, tp
->t_rextsize_delta
);
606 if (tp
->t_rbmblocks_delta
!= 0) {
607 INT_MOD(sbp
->sb_rbmblocks
, ARCH_CONVERT
, tp
->t_rbmblocks_delta
);
610 if (tp
->t_rblocks_delta
!= 0) {
611 INT_MOD(sbp
->sb_rblocks
, ARCH_CONVERT
, tp
->t_rblocks_delta
);
614 if (tp
->t_rextents_delta
!= 0) {
615 INT_MOD(sbp
->sb_rextents
, ARCH_CONVERT
, tp
->t_rextents_delta
);
618 if (tp
->t_rextslog_delta
!= 0) {
619 INT_MOD(sbp
->sb_rextslog
, ARCH_CONVERT
, tp
->t_rextslog_delta
);
625 * Log the whole thing, the fields are noncontiguous.
627 xfs_trans_log_buf(tp
, bp
, 0, sizeof(xfs_sb_t
) - 1);
630 * Since all the modifiable fields are contiguous, we
631 * can get away with this.
633 xfs_trans_log_buf(tp
, bp
, offsetof(xfs_sb_t
, sb_icount
),
634 offsetof(xfs_sb_t
, sb_frextents
) +
635 sizeof(sbp
->sb_frextents
) - 1);
637 XFS_MTOVFS(tp
->t_mountp
)->vfs_super
->s_dirt
= 1;
641 * xfs_trans_unreserve_and_mod_sb() is called to release unused reservations
642 * and apply superblock counter changes to the in-core superblock. The
643 * t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT
644 * applied to the in-core superblock. The idea is that that has already been
647 * This is done efficiently with a single call to xfs_mod_incore_sb_batch().
648 * However, we have to ensure that we only modify each superblock field only
649 * once because the application of the delta values may not be atomic. That can
650 * lead to ENOSPC races occurring if we have two separate modifcations of the
651 * free space counter to put back the entire reservation and then take away
654 * If we are not logging superblock counters, then the inode allocated/free and
655 * used block counts are not updated in the on disk superblock. In this case,
656 * XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we
657 * still need to update the incore superblock with the changes.
660 xfs_trans_unreserve_and_mod_sb(
663 xfs_mod_sb_t msb
[14]; /* If you add cases, add entries */
665 xfs_mount_t
*mp
= tp
->t_mountp
;
669 int64_t blkdelta
= 0;
670 int64_t rtxdelta
= 0;
673 rsvd
= (tp
->t_flags
& XFS_TRANS_RESERVE
) != 0;
675 /* calculate free blocks delta */
676 if (tp
->t_blk_res
> 0)
677 blkdelta
= tp
->t_blk_res
;
679 if ((tp
->t_fdblocks_delta
!= 0) &&
680 (xfs_sb_version_haslazysbcount(&mp
->m_sb
) ||
681 (tp
->t_flags
& XFS_TRANS_SB_DIRTY
)))
682 blkdelta
+= tp
->t_fdblocks_delta
;
685 msbp
->msb_field
= XFS_SBS_FDBLOCKS
;
686 msbp
->msb_delta
= blkdelta
;
690 /* calculate free realtime extents delta */
691 if (tp
->t_rtx_res
> 0)
692 rtxdelta
= tp
->t_rtx_res
;
694 if ((tp
->t_frextents_delta
!= 0) &&
695 (tp
->t_flags
& XFS_TRANS_SB_DIRTY
))
696 rtxdelta
+= tp
->t_frextents_delta
;
699 msbp
->msb_field
= XFS_SBS_FREXTENTS
;
700 msbp
->msb_delta
= rtxdelta
;
704 /* apply remaining deltas */
706 if (xfs_sb_version_haslazysbcount(&mp
->m_sb
) ||
707 (tp
->t_flags
& XFS_TRANS_SB_DIRTY
)) {
708 if (tp
->t_icount_delta
!= 0) {
709 msbp
->msb_field
= XFS_SBS_ICOUNT
;
710 msbp
->msb_delta
= tp
->t_icount_delta
;
713 if (tp
->t_ifree_delta
!= 0) {
714 msbp
->msb_field
= XFS_SBS_IFREE
;
715 msbp
->msb_delta
= tp
->t_ifree_delta
;
720 if (tp
->t_flags
& XFS_TRANS_SB_DIRTY
) {
721 if (tp
->t_dblocks_delta
!= 0) {
722 msbp
->msb_field
= XFS_SBS_DBLOCKS
;
723 msbp
->msb_delta
= tp
->t_dblocks_delta
;
726 if (tp
->t_agcount_delta
!= 0) {
727 msbp
->msb_field
= XFS_SBS_AGCOUNT
;
728 msbp
->msb_delta
= tp
->t_agcount_delta
;
731 if (tp
->t_imaxpct_delta
!= 0) {
732 msbp
->msb_field
= XFS_SBS_IMAX_PCT
;
733 msbp
->msb_delta
= tp
->t_imaxpct_delta
;
736 if (tp
->t_rextsize_delta
!= 0) {
737 msbp
->msb_field
= XFS_SBS_REXTSIZE
;
738 msbp
->msb_delta
= tp
->t_rextsize_delta
;
741 if (tp
->t_rbmblocks_delta
!= 0) {
742 msbp
->msb_field
= XFS_SBS_RBMBLOCKS
;
743 msbp
->msb_delta
= tp
->t_rbmblocks_delta
;
746 if (tp
->t_rblocks_delta
!= 0) {
747 msbp
->msb_field
= XFS_SBS_RBLOCKS
;
748 msbp
->msb_delta
= tp
->t_rblocks_delta
;
751 if (tp
->t_rextents_delta
!= 0) {
752 msbp
->msb_field
= XFS_SBS_REXTENTS
;
753 msbp
->msb_delta
= tp
->t_rextents_delta
;
756 if (tp
->t_rextslog_delta
!= 0) {
757 msbp
->msb_field
= XFS_SBS_REXTSLOG
;
758 msbp
->msb_delta
= tp
->t_rextslog_delta
;
764 * If we need to change anything, do it.
767 error
= xfs_mod_incore_sb_batch(tp
->t_mountp
, msb
,
768 (uint
)(msbp
- msb
), rsvd
);
777 * Commit the given transaction to the log a/synchronously.
779 * XFS disk error handling mechanism is not based on a typical
780 * transaction abort mechanism. Logically after the filesystem
781 * gets marked 'SHUTDOWN', we can't let any new transactions
782 * be durable - ie. committed to disk - because some metadata might
783 * be inconsistent. In such cases, this returns an error, and the
784 * caller may assume that all locked objects joined to the transaction
785 * have already been unlocked as if the commit had succeeded.
786 * Do not reference the transaction structure after this call.
795 xfs_log_iovec_t
*log_vector
;
798 xfs_lsn_t commit_lsn
;
803 #define XFS_TRANS_LOGVEC_COUNT 16
804 xfs_log_iovec_t log_vector_fast
[XFS_TRANS_LOGVEC_COUNT
];
811 * Determine whether this commit is releasing a permanent
812 * log reservation or not.
814 if (flags
& XFS_TRANS_RELEASE_LOG_RES
) {
815 ASSERT(tp
->t_flags
& XFS_TRANS_PERM_LOG_RES
);
816 log_flags
= XFS_LOG_REL_PERM_RESERV
;
823 * If there is nothing to be logged by the transaction,
824 * then unlock all of the items associated with the
825 * transaction and free the transaction structure.
826 * Also make sure to return any reserved blocks to
830 shutdown
= XFS_FORCED_SHUTDOWN(mp
) ? EIO
: 0;
831 if (!(tp
->t_flags
& XFS_TRANS_DIRTY
) || shutdown
) {
832 xfs_trans_unreserve_and_mod_sb(tp
);
834 * It is indeed possible for the transaction to be
835 * not dirty but the dqinfo portion to be. All that
836 * means is that we have some (non-persistent) quota
837 * reservations that need to be unreserved.
839 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(mp
, tp
);
841 commit_lsn
= xfs_log_done(mp
, tp
->t_ticket
,
843 if (commit_lsn
== -1 && !shutdown
)
844 shutdown
= XFS_ERROR(EIO
);
846 current_restore_flags_nested(&tp
->t_pflags
, PF_FSTRANS
);
847 xfs_trans_free_items(tp
, shutdown
? XFS_TRANS_ABORT
: 0);
848 xfs_trans_free_busy(tp
);
850 XFS_STATS_INC(xs_trans_empty
);
853 ASSERT(tp
->t_ticket
!= NULL
);
856 * If we need to update the superblock, then do it now.
858 if (tp
->t_flags
& XFS_TRANS_SB_DIRTY
) {
859 xfs_trans_apply_sb_deltas(tp
);
861 XFS_TRANS_APPLY_DQUOT_DELTAS(mp
, tp
);
864 * Ask each log item how many log_vector entries it will
865 * need so we can figure out how many to allocate.
866 * Try to avoid the kmem_alloc() call in the common case
867 * by using a vector from the stack when it fits.
869 nvec
= xfs_trans_count_vecs(tp
);
871 xfs_force_shutdown(mp
, SHUTDOWN_LOG_IO_ERROR
);
873 } else if (nvec
<= XFS_TRANS_LOGVEC_COUNT
) {
874 log_vector
= log_vector_fast
;
876 log_vector
= (xfs_log_iovec_t
*)kmem_alloc(nvec
*
877 sizeof(xfs_log_iovec_t
),
882 * Fill in the log_vector and pin the logged items, and
883 * then write the transaction to the log.
885 xfs_trans_fill_vecs(tp
, log_vector
);
887 error
= xfs_log_write(mp
, log_vector
, nvec
, tp
->t_ticket
, &(tp
->t_lsn
));
890 * The transaction is committed incore here, and can go out to disk
891 * at any time after this call. However, all the items associated
892 * with the transaction are still locked and pinned in memory.
894 commit_lsn
= xfs_log_done(mp
, tp
->t_ticket
, &commit_iclog
, log_flags
);
896 tp
->t_commit_lsn
= commit_lsn
;
897 if (nvec
> XFS_TRANS_LOGVEC_COUNT
) {
898 kmem_free(log_vector
, nvec
* sizeof(xfs_log_iovec_t
));
902 * If we got a log write error. Unpin the logitems that we
903 * had pinned, clean up, free trans structure, and return error.
905 if (error
|| commit_lsn
== -1) {
906 current_restore_flags_nested(&tp
->t_pflags
, PF_FSTRANS
);
907 xfs_trans_uncommit(tp
, flags
|XFS_TRANS_ABORT
);
908 return XFS_ERROR(EIO
);
912 * Once the transaction has committed, unused
913 * reservations need to be released and changes to
914 * the superblock need to be reflected in the in-core
915 * version. Do that now.
917 xfs_trans_unreserve_and_mod_sb(tp
);
919 sync
= tp
->t_flags
& XFS_TRANS_SYNC
;
922 * Tell the LM to call the transaction completion routine
923 * when the log write with LSN commit_lsn completes (e.g.
924 * when the transaction commit really hits the on-disk log).
925 * After this call we cannot reference tp, because the call
926 * can happen at any time and the call will free the transaction
927 * structure pointed to by tp. The only case where we call
928 * the completion routine (xfs_trans_committed) directly is
929 * if the log is turned off on a debug kernel or we're
930 * running in simulation mode (the log is explicitly turned
933 tp
->t_logcb
.cb_func
= (void(*)(void*, int))xfs_trans_committed
;
934 tp
->t_logcb
.cb_arg
= tp
;
937 * We need to pass the iclog buffer which was used for the
938 * transaction commit record into this function, and attach
939 * the callback to it. The callback must be attached before
940 * the items are unlocked to avoid racing with other threads
941 * waiting for an item to unlock.
943 shutdown
= xfs_log_notify(mp
, commit_iclog
, &(tp
->t_logcb
));
946 * Mark this thread as no longer being in a transaction
948 current_restore_flags_nested(&tp
->t_pflags
, PF_FSTRANS
);
951 * Once all the items of the transaction have been copied
952 * to the in core log and the callback is attached, the
953 * items can be unlocked.
955 * This will free descriptors pointing to items which were
956 * not logged since there is nothing more to do with them.
957 * For items which were logged, we will keep pointers to them
958 * so they can be unpinned after the transaction commits to disk.
959 * This will also stamp each modified meta-data item with
960 * the commit lsn of this transaction for dependency tracking
963 xfs_trans_unlock_items(tp
, commit_lsn
);
966 * If we detected a log error earlier, finish committing
967 * the transaction now (unpin log items, etc).
969 * Order is critical here, to avoid using the transaction
970 * pointer after its been freed (by xfs_trans_committed
971 * either here now, or as a callback). We cannot do this
972 * step inside xfs_log_notify as was done earlier because
976 xfs_trans_committed(tp
, XFS_LI_ABORTED
);
979 * Now that the xfs_trans_committed callback has been attached,
980 * and the items are released we can finally allow the iclog to
983 error
= xfs_log_release_iclog(mp
, commit_iclog
);
986 * If the transaction needs to be synchronous, then force the
987 * log out now and wait for it.
991 error
= _xfs_log_force(mp
, commit_lsn
,
992 XFS_LOG_FORCE
| XFS_LOG_SYNC
,
995 XFS_STATS_INC(xs_trans_sync
);
997 XFS_STATS_INC(xs_trans_async
);
1005 * Total up the number of log iovecs needed to commit this
1006 * transaction. The transaction itself needs one for the
1007 * transaction header. Ask each dirty item in turn how many
1008 * it needs to get the total.
1011 xfs_trans_count_vecs(
1015 xfs_log_item_desc_t
*lidp
;
1018 lidp
= xfs_trans_first_item(tp
);
1019 ASSERT(lidp
!= NULL
);
1021 /* In the non-debug case we need to start bailing out if we
1022 * didn't find a log_item here, return zero and let trans_commit
1028 while (lidp
!= NULL
) {
1030 * Skip items which aren't dirty in this transaction.
1032 if (!(lidp
->lid_flags
& XFS_LID_DIRTY
)) {
1033 lidp
= xfs_trans_next_item(tp
, lidp
);
1036 lidp
->lid_size
= IOP_SIZE(lidp
->lid_item
);
1037 nvecs
+= lidp
->lid_size
;
1038 lidp
= xfs_trans_next_item(tp
, lidp
);
1045 * Called from the trans_commit code when we notice that
1046 * the filesystem is in the middle of a forced shutdown.
1053 xfs_log_item_desc_t
*lidp
;
1055 for (lidp
= xfs_trans_first_item(tp
);
1057 lidp
= xfs_trans_next_item(tp
, lidp
)) {
1059 * Unpin all but those that aren't dirty.
1061 if (lidp
->lid_flags
& XFS_LID_DIRTY
)
1062 IOP_UNPIN_REMOVE(lidp
->lid_item
, tp
);
1065 xfs_trans_unreserve_and_mod_sb(tp
);
1066 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(tp
->t_mountp
, tp
);
1068 xfs_trans_free_items(tp
, flags
);
1069 xfs_trans_free_busy(tp
);
1074 * Fill in the vector with pointers to data to be logged
1075 * by this transaction. The transaction header takes
1076 * the first vector, and then each dirty item takes the
1077 * number of vectors it indicated it needed in xfs_trans_count_vecs().
1079 * As each item fills in the entries it needs, also pin the item
1080 * so that it cannot be flushed out until the log write completes.
1083 xfs_trans_fill_vecs(
1085 xfs_log_iovec_t
*log_vector
)
1087 xfs_log_item_desc_t
*lidp
;
1088 xfs_log_iovec_t
*vecp
;
1092 * Skip over the entry for the transaction header, we'll
1093 * fill that in at the end.
1095 vecp
= log_vector
+ 1; /* pointer arithmetic */
1098 lidp
= xfs_trans_first_item(tp
);
1099 ASSERT(lidp
!= NULL
);
1100 while (lidp
!= NULL
) {
1102 * Skip items which aren't dirty in this transaction.
1104 if (!(lidp
->lid_flags
& XFS_LID_DIRTY
)) {
1105 lidp
= xfs_trans_next_item(tp
, lidp
);
1109 * The item may be marked dirty but not log anything.
1110 * This can be used to get called when a transaction
1113 if (lidp
->lid_size
) {
1116 IOP_FORMAT(lidp
->lid_item
, vecp
);
1117 vecp
+= lidp
->lid_size
; /* pointer arithmetic */
1118 IOP_PIN(lidp
->lid_item
);
1119 lidp
= xfs_trans_next_item(tp
, lidp
);
1123 * Now that we've counted the number of items in this
1124 * transaction, fill in the transaction header.
1126 tp
->t_header
.th_magic
= XFS_TRANS_HEADER_MAGIC
;
1127 tp
->t_header
.th_type
= tp
->t_type
;
1128 tp
->t_header
.th_num_items
= nitems
;
1129 log_vector
->i_addr
= (xfs_caddr_t
)&tp
->t_header
;
1130 log_vector
->i_len
= sizeof(xfs_trans_header_t
);
1131 XLOG_VEC_SET_TYPE(log_vector
, XLOG_REG_TYPE_TRANSHDR
);
1136 * Unlock all of the transaction's items and free the transaction.
1137 * The transaction must not have modified any of its items, because
1138 * there is no way to restore them to their previous state.
1140 * If the transaction has made a log reservation, make sure to release
1150 xfs_log_item_chunk_t
*licp
;
1151 xfs_log_item_desc_t
*lidp
;
1152 xfs_log_item_t
*lip
;
1155 xfs_mount_t
*mp
= tp
->t_mountp
;
1158 * See if the caller is being too lazy to figure out if
1159 * the transaction really needs an abort.
1161 if ((flags
& XFS_TRANS_ABORT
) && !(tp
->t_flags
& XFS_TRANS_DIRTY
))
1162 flags
&= ~XFS_TRANS_ABORT
;
1164 * See if the caller is relying on us to shut down the
1165 * filesystem. This happens in paths where we detect
1166 * corruption and decide to give up.
1168 if ((tp
->t_flags
& XFS_TRANS_DIRTY
) && !XFS_FORCED_SHUTDOWN(mp
)) {
1169 XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW
, mp
);
1170 xfs_force_shutdown(mp
, SHUTDOWN_CORRUPT_INCORE
);
1173 if (!(flags
& XFS_TRANS_ABORT
)) {
1174 licp
= &(tp
->t_items
);
1175 while (licp
!= NULL
) {
1176 lidp
= licp
->lic_descs
;
1177 for (i
= 0; i
< licp
->lic_unused
; i
++, lidp
++) {
1178 if (XFS_LIC_ISFREE(licp
, i
)) {
1182 lip
= lidp
->lid_item
;
1183 if (!XFS_FORCED_SHUTDOWN(mp
))
1184 ASSERT(!(lip
->li_type
== XFS_LI_EFD
));
1186 licp
= licp
->lic_next
;
1190 xfs_trans_unreserve_and_mod_sb(tp
);
1191 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(mp
, tp
);
1194 if (flags
& XFS_TRANS_RELEASE_LOG_RES
) {
1195 ASSERT(tp
->t_flags
& XFS_TRANS_PERM_LOG_RES
);
1196 log_flags
= XFS_LOG_REL_PERM_RESERV
;
1200 xfs_log_done(mp
, tp
->t_ticket
, NULL
, log_flags
);
1203 /* mark this thread as no longer being in a transaction */
1204 current_restore_flags_nested(&tp
->t_pflags
, PF_FSTRANS
);
1206 xfs_trans_free_items(tp
, flags
);
1207 xfs_trans_free_busy(tp
);
1213 * Free the transaction structure. If there is more clean up
1214 * to do when the structure is freed, add it here.
1220 atomic_dec(&tp
->t_mountp
->m_active_trans
);
1221 XFS_TRANS_FREE_DQINFO(tp
->t_mountp
, tp
);
1222 kmem_zone_free(xfs_trans_zone
, tp
);
1227 * THIS SHOULD BE REWRITTEN TO USE xfs_trans_next_item().
1229 * This is typically called by the LM when a transaction has been fully
1230 * committed to disk. It needs to unpin the items which have
1231 * been logged by the transaction and update their positions
1232 * in the AIL if necessary.
1233 * This also gets called when the transactions didn't get written out
1234 * because of an I/O error. Abortflag & XFS_LI_ABORTED is set then.
1236 * Call xfs_trans_chunk_committed() to process the items in
1240 xfs_trans_committed(
1244 xfs_log_item_chunk_t
*licp
;
1245 xfs_log_item_chunk_t
*next_licp
;
1246 xfs_log_busy_chunk_t
*lbcp
;
1247 xfs_log_busy_slot_t
*lbsp
;
1251 * Call the transaction's completion callback if there
1254 if (tp
->t_callback
!= NULL
) {
1255 tp
->t_callback(tp
, tp
->t_callarg
);
1259 * Special case the chunk embedded in the transaction.
1261 licp
= &(tp
->t_items
);
1262 if (!(XFS_LIC_ARE_ALL_FREE(licp
))) {
1263 xfs_trans_chunk_committed(licp
, tp
->t_lsn
, abortflag
);
1267 * Process the items in each chunk in turn.
1269 licp
= licp
->lic_next
;
1270 while (licp
!= NULL
) {
1271 ASSERT(!XFS_LIC_ARE_ALL_FREE(licp
));
1272 xfs_trans_chunk_committed(licp
, tp
->t_lsn
, abortflag
);
1273 next_licp
= licp
->lic_next
;
1274 kmem_free(licp
, sizeof(xfs_log_item_chunk_t
));
1279 * Clear all the per-AG busy list items listed in this transaction
1282 while (lbcp
!= NULL
) {
1283 for (i
= 0, lbsp
= lbcp
->lbc_busy
; i
< lbcp
->lbc_unused
; i
++, lbsp
++) {
1284 if (!XFS_LBC_ISFREE(lbcp
, i
)) {
1285 xfs_alloc_clear_busy(tp
, lbsp
->lbc_ag
,
1289 lbcp
= lbcp
->lbc_next
;
1291 xfs_trans_free_busy(tp
);
1294 * That's it for the transaction structure. Free it.
1300 * This is called to perform the commit processing for each
1301 * item described by the given chunk.
1303 * The commit processing consists of unlocking items which were
1304 * held locked with the SYNC_UNLOCK attribute, calling the committed
1305 * routine of each logged item, updating the item's position in the AIL
1306 * if necessary, and unpinning each item. If the committed routine
1307 * returns -1, then do nothing further with the item because it
1308 * may have been freed.
1310 * Since items are unlocked when they are copied to the incore
1311 * log, it is possible for two transactions to be completing
1312 * and manipulating the same item simultaneously. The AIL lock
1313 * will protect the lsn field of each item. The value of this
1314 * field can never go backwards.
1316 * We unpin the items after repositioning them in the AIL, because
1317 * otherwise they could be immediately flushed and we'd have to race
1318 * with the flusher trying to pull the item from the AIL as we add it.
1321 xfs_trans_chunk_committed(
1322 xfs_log_item_chunk_t
*licp
,
1326 xfs_log_item_desc_t
*lidp
;
1327 xfs_log_item_t
*lip
;
1329 struct xfs_mount
*mp
;
1333 lidp
= licp
->lic_descs
;
1334 for (i
= 0; i
< licp
->lic_unused
; i
++, lidp
++) {
1335 if (XFS_LIC_ISFREE(licp
, i
)) {
1339 lip
= lidp
->lid_item
;
1341 lip
->li_flags
|= XFS_LI_ABORTED
;
1344 * Send in the ABORTED flag to the COMMITTED routine
1345 * so that it knows whether the transaction was aborted
1348 item_lsn
= IOP_COMMITTED(lip
, lsn
);
1351 * If the committed routine returns -1, make
1352 * no more references to the item.
1354 if (XFS_LSN_CMP(item_lsn
, (xfs_lsn_t
)-1) == 0) {
1359 * If the returned lsn is greater than what it
1360 * contained before, update the location of the
1361 * item in the AIL. If it is not, then do nothing.
1362 * Items can never move backwards in the AIL.
1364 * While the new lsn should usually be greater, it
1365 * is possible that a later transaction completing
1366 * simultaneously with an earlier one using the
1367 * same item could complete first with a higher lsn.
1368 * This would cause the earlier transaction to fail
1371 mp
= lip
->li_mountp
;
1373 if (XFS_LSN_CMP(item_lsn
, lip
->li_lsn
) > 0) {
1375 * This will set the item's lsn to item_lsn
1376 * and update the position of the item in
1379 * xfs_trans_update_ail() drops the AIL lock.
1381 xfs_trans_update_ail(mp
, lip
, item_lsn
, s
);
1387 * Now that we've repositioned the item in the AIL,
1388 * unpin it so it can be flushed. Pass information
1389 * about buffer stale state down from the log item
1390 * flags, if anyone else stales the buffer we do not
1391 * want to pay any attention to it.
1393 IOP_UNPIN(lip
, lidp
->lid_flags
& XFS_LID_BUF_STALE
);