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
|= (XFS_TRANS_SB_DIRTY
| XFS_TRANS_DIRTY
);
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
642 * reservations and apply superblock counter changes to the in-core
645 * This is done efficiently with a single call to xfs_mod_incore_sb_batch().
648 xfs_trans_unreserve_and_mod_sb(
651 xfs_mod_sb_t msb
[14]; /* If you add cases, add entries */
653 xfs_mount_t
*mp
= tp
->t_mountp
;
659 rsvd
= (tp
->t_flags
& XFS_TRANS_RESERVE
) != 0;
662 * Release any reserved blocks. Any that were allocated
663 * will be taken back again by fdblocks_delta below.
665 if (tp
->t_blk_res
> 0) {
666 msbp
->msb_field
= XFS_SBS_FDBLOCKS
;
667 msbp
->msb_delta
= tp
->t_blk_res
;
672 * Release any reserved real time extents . Any that were
673 * allocated will be taken back again by frextents_delta below.
675 if (tp
->t_rtx_res
> 0) {
676 msbp
->msb_field
= XFS_SBS_FREXTENTS
;
677 msbp
->msb_delta
= tp
->t_rtx_res
;
682 * Apply any superblock modifications to the in-core version.
683 * The t_res_fdblocks_delta and t_res_frextents_delta fields are
684 * explicitly NOT applied to the in-core superblock.
685 * The idea is that that has already been done.
687 * If we are not logging superblock counters, then the inode
688 * allocated/free and used block counts are not updated in the
689 * on disk superblock. In this case, XFS_TRANS_SB_DIRTY will
690 * not be set when the transaction is updated but we still need
691 * to update the incore superblock with the changes.
693 if (xfs_sb_version_haslazysbcount(&mp
->m_sb
) ||
694 (tp
->t_flags
& XFS_TRANS_SB_DIRTY
)) {
695 if (tp
->t_icount_delta
!= 0) {
696 msbp
->msb_field
= XFS_SBS_ICOUNT
;
697 msbp
->msb_delta
= tp
->t_icount_delta
;
700 if (tp
->t_ifree_delta
!= 0) {
701 msbp
->msb_field
= XFS_SBS_IFREE
;
702 msbp
->msb_delta
= tp
->t_ifree_delta
;
705 if (tp
->t_fdblocks_delta
!= 0) {
706 msbp
->msb_field
= XFS_SBS_FDBLOCKS
;
707 msbp
->msb_delta
= tp
->t_fdblocks_delta
;
712 if (tp
->t_flags
& XFS_TRANS_SB_DIRTY
) {
713 if (tp
->t_frextents_delta
!= 0) {
714 msbp
->msb_field
= XFS_SBS_FREXTENTS
;
715 msbp
->msb_delta
= tp
->t_frextents_delta
;
718 if (tp
->t_dblocks_delta
!= 0) {
719 msbp
->msb_field
= XFS_SBS_DBLOCKS
;
720 msbp
->msb_delta
= tp
->t_dblocks_delta
;
723 if (tp
->t_agcount_delta
!= 0) {
724 msbp
->msb_field
= XFS_SBS_AGCOUNT
;
725 msbp
->msb_delta
= tp
->t_agcount_delta
;
728 if (tp
->t_imaxpct_delta
!= 0) {
729 msbp
->msb_field
= XFS_SBS_IMAX_PCT
;
730 msbp
->msb_delta
= tp
->t_imaxpct_delta
;
733 if (tp
->t_rextsize_delta
!= 0) {
734 msbp
->msb_field
= XFS_SBS_REXTSIZE
;
735 msbp
->msb_delta
= tp
->t_rextsize_delta
;
738 if (tp
->t_rbmblocks_delta
!= 0) {
739 msbp
->msb_field
= XFS_SBS_RBMBLOCKS
;
740 msbp
->msb_delta
= tp
->t_rbmblocks_delta
;
743 if (tp
->t_rblocks_delta
!= 0) {
744 msbp
->msb_field
= XFS_SBS_RBLOCKS
;
745 msbp
->msb_delta
= tp
->t_rblocks_delta
;
748 if (tp
->t_rextents_delta
!= 0) {
749 msbp
->msb_field
= XFS_SBS_REXTENTS
;
750 msbp
->msb_delta
= tp
->t_rextents_delta
;
753 if (tp
->t_rextslog_delta
!= 0) {
754 msbp
->msb_field
= XFS_SBS_REXTSLOG
;
755 msbp
->msb_delta
= tp
->t_rextslog_delta
;
761 * If we need to change anything, do it.
764 error
= xfs_mod_incore_sb_batch(tp
->t_mountp
, msb
,
765 (uint
)(msbp
- msb
), rsvd
);
774 * Commit the given transaction to the log a/synchronously.
776 * XFS disk error handling mechanism is not based on a typical
777 * transaction abort mechanism. Logically after the filesystem
778 * gets marked 'SHUTDOWN', we can't let any new transactions
779 * be durable - ie. committed to disk - because some metadata might
780 * be inconsistent. In such cases, this returns an error, and the
781 * caller may assume that all locked objects joined to the transaction
782 * have already been unlocked as if the commit had succeeded.
783 * Do not reference the transaction structure after this call.
792 xfs_log_iovec_t
*log_vector
;
795 xfs_lsn_t commit_lsn
;
800 #define XFS_TRANS_LOGVEC_COUNT 16
801 xfs_log_iovec_t log_vector_fast
[XFS_TRANS_LOGVEC_COUNT
];
808 * Determine whether this commit is releasing a permanent
809 * log reservation or not.
811 if (flags
& XFS_TRANS_RELEASE_LOG_RES
) {
812 ASSERT(tp
->t_flags
& XFS_TRANS_PERM_LOG_RES
);
813 log_flags
= XFS_LOG_REL_PERM_RESERV
;
820 * If there is nothing to be logged by the transaction,
821 * then unlock all of the items associated with the
822 * transaction and free the transaction structure.
823 * Also make sure to return any reserved blocks to
827 shutdown
= XFS_FORCED_SHUTDOWN(mp
) ? EIO
: 0;
828 if (!(tp
->t_flags
& XFS_TRANS_DIRTY
) || shutdown
) {
829 xfs_trans_unreserve_and_mod_sb(tp
);
831 * It is indeed possible for the transaction to be
832 * not dirty but the dqinfo portion to be. All that
833 * means is that we have some (non-persistent) quota
834 * reservations that need to be unreserved.
836 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(mp
, tp
);
838 commit_lsn
= xfs_log_done(mp
, tp
->t_ticket
,
840 if (commit_lsn
== -1 && !shutdown
)
841 shutdown
= XFS_ERROR(EIO
);
843 current_restore_flags_nested(&tp
->t_pflags
, PF_FSTRANS
);
844 xfs_trans_free_items(tp
, shutdown
? XFS_TRANS_ABORT
: 0);
845 xfs_trans_free_busy(tp
);
847 XFS_STATS_INC(xs_trans_empty
);
850 ASSERT(tp
->t_ticket
!= NULL
);
853 * If we need to update the superblock, then do it now.
855 if (tp
->t_flags
& XFS_TRANS_SB_DIRTY
) {
856 xfs_trans_apply_sb_deltas(tp
);
858 XFS_TRANS_APPLY_DQUOT_DELTAS(mp
, tp
);
861 * Ask each log item how many log_vector entries it will
862 * need so we can figure out how many to allocate.
863 * Try to avoid the kmem_alloc() call in the common case
864 * by using a vector from the stack when it fits.
866 nvec
= xfs_trans_count_vecs(tp
);
868 xfs_force_shutdown(mp
, SHUTDOWN_LOG_IO_ERROR
);
870 } else if (nvec
<= XFS_TRANS_LOGVEC_COUNT
) {
871 log_vector
= log_vector_fast
;
873 log_vector
= (xfs_log_iovec_t
*)kmem_alloc(nvec
*
874 sizeof(xfs_log_iovec_t
),
879 * Fill in the log_vector and pin the logged items, and
880 * then write the transaction to the log.
882 xfs_trans_fill_vecs(tp
, log_vector
);
884 error
= xfs_log_write(mp
, log_vector
, nvec
, tp
->t_ticket
, &(tp
->t_lsn
));
887 * The transaction is committed incore here, and can go out to disk
888 * at any time after this call. However, all the items associated
889 * with the transaction are still locked and pinned in memory.
891 commit_lsn
= xfs_log_done(mp
, tp
->t_ticket
, &commit_iclog
, log_flags
);
893 tp
->t_commit_lsn
= commit_lsn
;
894 if (nvec
> XFS_TRANS_LOGVEC_COUNT
) {
895 kmem_free(log_vector
, nvec
* sizeof(xfs_log_iovec_t
));
899 * If we got a log write error. Unpin the logitems that we
900 * had pinned, clean up, free trans structure, and return error.
902 if (error
|| commit_lsn
== -1) {
903 current_restore_flags_nested(&tp
->t_pflags
, PF_FSTRANS
);
904 xfs_trans_uncommit(tp
, flags
|XFS_TRANS_ABORT
);
905 return XFS_ERROR(EIO
);
909 * Once the transaction has committed, unused
910 * reservations need to be released and changes to
911 * the superblock need to be reflected in the in-core
912 * version. Do that now.
914 xfs_trans_unreserve_and_mod_sb(tp
);
916 sync
= tp
->t_flags
& XFS_TRANS_SYNC
;
919 * Tell the LM to call the transaction completion routine
920 * when the log write with LSN commit_lsn completes (e.g.
921 * when the transaction commit really hits the on-disk log).
922 * After this call we cannot reference tp, because the call
923 * can happen at any time and the call will free the transaction
924 * structure pointed to by tp. The only case where we call
925 * the completion routine (xfs_trans_committed) directly is
926 * if the log is turned off on a debug kernel or we're
927 * running in simulation mode (the log is explicitly turned
930 tp
->t_logcb
.cb_func
= (void(*)(void*, int))xfs_trans_committed
;
931 tp
->t_logcb
.cb_arg
= tp
;
934 * We need to pass the iclog buffer which was used for the
935 * transaction commit record into this function, and attach
936 * the callback to it. The callback must be attached before
937 * the items are unlocked to avoid racing with other threads
938 * waiting for an item to unlock.
940 shutdown
= xfs_log_notify(mp
, commit_iclog
, &(tp
->t_logcb
));
943 * Mark this thread as no longer being in a transaction
945 current_restore_flags_nested(&tp
->t_pflags
, PF_FSTRANS
);
948 * Once all the items of the transaction have been copied
949 * to the in core log and the callback is attached, the
950 * items can be unlocked.
952 * This will free descriptors pointing to items which were
953 * not logged since there is nothing more to do with them.
954 * For items which were logged, we will keep pointers to them
955 * so they can be unpinned after the transaction commits to disk.
956 * This will also stamp each modified meta-data item with
957 * the commit lsn of this transaction for dependency tracking
960 xfs_trans_unlock_items(tp
, commit_lsn
);
963 * If we detected a log error earlier, finish committing
964 * the transaction now (unpin log items, etc).
966 * Order is critical here, to avoid using the transaction
967 * pointer after its been freed (by xfs_trans_committed
968 * either here now, or as a callback). We cannot do this
969 * step inside xfs_log_notify as was done earlier because
973 xfs_trans_committed(tp
, XFS_LI_ABORTED
);
976 * Now that the xfs_trans_committed callback has been attached,
977 * and the items are released we can finally allow the iclog to
980 error
= xfs_log_release_iclog(mp
, commit_iclog
);
983 * If the transaction needs to be synchronous, then force the
984 * log out now and wait for it.
988 error
= _xfs_log_force(mp
, commit_lsn
,
989 XFS_LOG_FORCE
| XFS_LOG_SYNC
,
992 XFS_STATS_INC(xs_trans_sync
);
994 XFS_STATS_INC(xs_trans_async
);
1002 * Total up the number of log iovecs needed to commit this
1003 * transaction. The transaction itself needs one for the
1004 * transaction header. Ask each dirty item in turn how many
1005 * it needs to get the total.
1008 xfs_trans_count_vecs(
1012 xfs_log_item_desc_t
*lidp
;
1015 lidp
= xfs_trans_first_item(tp
);
1016 ASSERT(lidp
!= NULL
);
1018 /* In the non-debug case we need to start bailing out if we
1019 * didn't find a log_item here, return zero and let trans_commit
1025 while (lidp
!= NULL
) {
1027 * Skip items which aren't dirty in this transaction.
1029 if (!(lidp
->lid_flags
& XFS_LID_DIRTY
)) {
1030 lidp
= xfs_trans_next_item(tp
, lidp
);
1033 lidp
->lid_size
= IOP_SIZE(lidp
->lid_item
);
1034 nvecs
+= lidp
->lid_size
;
1035 lidp
= xfs_trans_next_item(tp
, lidp
);
1042 * Called from the trans_commit code when we notice that
1043 * the filesystem is in the middle of a forced shutdown.
1050 xfs_log_item_desc_t
*lidp
;
1052 for (lidp
= xfs_trans_first_item(tp
);
1054 lidp
= xfs_trans_next_item(tp
, lidp
)) {
1056 * Unpin all but those that aren't dirty.
1058 if (lidp
->lid_flags
& XFS_LID_DIRTY
)
1059 IOP_UNPIN_REMOVE(lidp
->lid_item
, tp
);
1062 xfs_trans_unreserve_and_mod_sb(tp
);
1063 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(tp
->t_mountp
, tp
);
1065 xfs_trans_free_items(tp
, flags
);
1066 xfs_trans_free_busy(tp
);
1071 * Fill in the vector with pointers to data to be logged
1072 * by this transaction. The transaction header takes
1073 * the first vector, and then each dirty item takes the
1074 * number of vectors it indicated it needed in xfs_trans_count_vecs().
1076 * As each item fills in the entries it needs, also pin the item
1077 * so that it cannot be flushed out until the log write completes.
1080 xfs_trans_fill_vecs(
1082 xfs_log_iovec_t
*log_vector
)
1084 xfs_log_item_desc_t
*lidp
;
1085 xfs_log_iovec_t
*vecp
;
1089 * Skip over the entry for the transaction header, we'll
1090 * fill that in at the end.
1092 vecp
= log_vector
+ 1; /* pointer arithmetic */
1095 lidp
= xfs_trans_first_item(tp
);
1096 ASSERT(lidp
!= NULL
);
1097 while (lidp
!= NULL
) {
1099 * Skip items which aren't dirty in this transaction.
1101 if (!(lidp
->lid_flags
& XFS_LID_DIRTY
)) {
1102 lidp
= xfs_trans_next_item(tp
, lidp
);
1106 * The item may be marked dirty but not log anything.
1107 * This can be used to get called when a transaction
1110 if (lidp
->lid_size
) {
1113 IOP_FORMAT(lidp
->lid_item
, vecp
);
1114 vecp
+= lidp
->lid_size
; /* pointer arithmetic */
1115 IOP_PIN(lidp
->lid_item
);
1116 lidp
= xfs_trans_next_item(tp
, lidp
);
1120 * Now that we've counted the number of items in this
1121 * transaction, fill in the transaction header.
1123 tp
->t_header
.th_magic
= XFS_TRANS_HEADER_MAGIC
;
1124 tp
->t_header
.th_type
= tp
->t_type
;
1125 tp
->t_header
.th_num_items
= nitems
;
1126 log_vector
->i_addr
= (xfs_caddr_t
)&tp
->t_header
;
1127 log_vector
->i_len
= sizeof(xfs_trans_header_t
);
1128 XLOG_VEC_SET_TYPE(log_vector
, XLOG_REG_TYPE_TRANSHDR
);
1133 * Unlock all of the transaction's items and free the transaction.
1134 * The transaction must not have modified any of its items, because
1135 * there is no way to restore them to their previous state.
1137 * If the transaction has made a log reservation, make sure to release
1147 xfs_log_item_chunk_t
*licp
;
1148 xfs_log_item_desc_t
*lidp
;
1149 xfs_log_item_t
*lip
;
1152 xfs_mount_t
*mp
= tp
->t_mountp
;
1155 * See if the caller is being too lazy to figure out if
1156 * the transaction really needs an abort.
1158 if ((flags
& XFS_TRANS_ABORT
) && !(tp
->t_flags
& XFS_TRANS_DIRTY
))
1159 flags
&= ~XFS_TRANS_ABORT
;
1161 * See if the caller is relying on us to shut down the
1162 * filesystem. This happens in paths where we detect
1163 * corruption and decide to give up.
1165 if ((tp
->t_flags
& XFS_TRANS_DIRTY
) && !XFS_FORCED_SHUTDOWN(mp
)) {
1166 XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW
, mp
);
1167 xfs_force_shutdown(mp
, SHUTDOWN_CORRUPT_INCORE
);
1170 if (!(flags
& XFS_TRANS_ABORT
)) {
1171 licp
= &(tp
->t_items
);
1172 while (licp
!= NULL
) {
1173 lidp
= licp
->lic_descs
;
1174 for (i
= 0; i
< licp
->lic_unused
; i
++, lidp
++) {
1175 if (XFS_LIC_ISFREE(licp
, i
)) {
1179 lip
= lidp
->lid_item
;
1180 if (!XFS_FORCED_SHUTDOWN(mp
))
1181 ASSERT(!(lip
->li_type
== XFS_LI_EFD
));
1183 licp
= licp
->lic_next
;
1187 xfs_trans_unreserve_and_mod_sb(tp
);
1188 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(mp
, tp
);
1191 if (flags
& XFS_TRANS_RELEASE_LOG_RES
) {
1192 ASSERT(tp
->t_flags
& XFS_TRANS_PERM_LOG_RES
);
1193 log_flags
= XFS_LOG_REL_PERM_RESERV
;
1197 xfs_log_done(mp
, tp
->t_ticket
, NULL
, log_flags
);
1200 /* mark this thread as no longer being in a transaction */
1201 current_restore_flags_nested(&tp
->t_pflags
, PF_FSTRANS
);
1203 xfs_trans_free_items(tp
, flags
);
1204 xfs_trans_free_busy(tp
);
1210 * Free the transaction structure. If there is more clean up
1211 * to do when the structure is freed, add it here.
1217 atomic_dec(&tp
->t_mountp
->m_active_trans
);
1218 XFS_TRANS_FREE_DQINFO(tp
->t_mountp
, tp
);
1219 kmem_zone_free(xfs_trans_zone
, tp
);
1224 * THIS SHOULD BE REWRITTEN TO USE xfs_trans_next_item().
1226 * This is typically called by the LM when a transaction has been fully
1227 * committed to disk. It needs to unpin the items which have
1228 * been logged by the transaction and update their positions
1229 * in the AIL if necessary.
1230 * This also gets called when the transactions didn't get written out
1231 * because of an I/O error. Abortflag & XFS_LI_ABORTED is set then.
1233 * Call xfs_trans_chunk_committed() to process the items in
1237 xfs_trans_committed(
1241 xfs_log_item_chunk_t
*licp
;
1242 xfs_log_item_chunk_t
*next_licp
;
1243 xfs_log_busy_chunk_t
*lbcp
;
1244 xfs_log_busy_slot_t
*lbsp
;
1248 * Call the transaction's completion callback if there
1251 if (tp
->t_callback
!= NULL
) {
1252 tp
->t_callback(tp
, tp
->t_callarg
);
1256 * Special case the chunk embedded in the transaction.
1258 licp
= &(tp
->t_items
);
1259 if (!(XFS_LIC_ARE_ALL_FREE(licp
))) {
1260 xfs_trans_chunk_committed(licp
, tp
->t_lsn
, abortflag
);
1264 * Process the items in each chunk in turn.
1266 licp
= licp
->lic_next
;
1267 while (licp
!= NULL
) {
1268 ASSERT(!XFS_LIC_ARE_ALL_FREE(licp
));
1269 xfs_trans_chunk_committed(licp
, tp
->t_lsn
, abortflag
);
1270 next_licp
= licp
->lic_next
;
1271 kmem_free(licp
, sizeof(xfs_log_item_chunk_t
));
1276 * Clear all the per-AG busy list items listed in this transaction
1279 while (lbcp
!= NULL
) {
1280 for (i
= 0, lbsp
= lbcp
->lbc_busy
; i
< lbcp
->lbc_unused
; i
++, lbsp
++) {
1281 if (!XFS_LBC_ISFREE(lbcp
, i
)) {
1282 xfs_alloc_clear_busy(tp
, lbsp
->lbc_ag
,
1286 lbcp
= lbcp
->lbc_next
;
1288 xfs_trans_free_busy(tp
);
1291 * That's it for the transaction structure. Free it.
1297 * This is called to perform the commit processing for each
1298 * item described by the given chunk.
1300 * The commit processing consists of unlocking items which were
1301 * held locked with the SYNC_UNLOCK attribute, calling the committed
1302 * routine of each logged item, updating the item's position in the AIL
1303 * if necessary, and unpinning each item. If the committed routine
1304 * returns -1, then do nothing further with the item because it
1305 * may have been freed.
1307 * Since items are unlocked when they are copied to the incore
1308 * log, it is possible for two transactions to be completing
1309 * and manipulating the same item simultaneously. The AIL lock
1310 * will protect the lsn field of each item. The value of this
1311 * field can never go backwards.
1313 * We unpin the items after repositioning them in the AIL, because
1314 * otherwise they could be immediately flushed and we'd have to race
1315 * with the flusher trying to pull the item from the AIL as we add it.
1318 xfs_trans_chunk_committed(
1319 xfs_log_item_chunk_t
*licp
,
1323 xfs_log_item_desc_t
*lidp
;
1324 xfs_log_item_t
*lip
;
1326 struct xfs_mount
*mp
;
1330 lidp
= licp
->lic_descs
;
1331 for (i
= 0; i
< licp
->lic_unused
; i
++, lidp
++) {
1332 if (XFS_LIC_ISFREE(licp
, i
)) {
1336 lip
= lidp
->lid_item
;
1338 lip
->li_flags
|= XFS_LI_ABORTED
;
1341 * Send in the ABORTED flag to the COMMITTED routine
1342 * so that it knows whether the transaction was aborted
1345 item_lsn
= IOP_COMMITTED(lip
, lsn
);
1348 * If the committed routine returns -1, make
1349 * no more references to the item.
1351 if (XFS_LSN_CMP(item_lsn
, (xfs_lsn_t
)-1) == 0) {
1356 * If the returned lsn is greater than what it
1357 * contained before, update the location of the
1358 * item in the AIL. If it is not, then do nothing.
1359 * Items can never move backwards in the AIL.
1361 * While the new lsn should usually be greater, it
1362 * is possible that a later transaction completing
1363 * simultaneously with an earlier one using the
1364 * same item could complete first with a higher lsn.
1365 * This would cause the earlier transaction to fail
1368 mp
= lip
->li_mountp
;
1370 if (XFS_LSN_CMP(item_lsn
, lip
->li_lsn
) > 0) {
1372 * This will set the item's lsn to item_lsn
1373 * and update the position of the item in
1376 * xfs_trans_update_ail() drops the AIL lock.
1378 xfs_trans_update_ail(mp
, lip
, item_lsn
, s
);
1384 * Now that we've repositioned the item in the AIL,
1385 * unpin it so it can be flushed. Pass information
1386 * about buffer stale state down from the log item
1387 * flags, if anyone else stales the buffer we do not
1388 * want to pay any attention to it.
1390 IOP_UNPIN(lip
, lidp
->lid_flags
& XFS_LID_BUF_STALE
);