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"
29 #include "xfs_dmapi.h"
30 #include "xfs_mount.h"
31 #include "xfs_error.h"
32 #include "xfs_da_btree.h"
33 #include "xfs_bmap_btree.h"
34 #include "xfs_alloc_btree.h"
35 #include "xfs_ialloc_btree.h"
36 #include "xfs_dir_sf.h"
37 #include "xfs_dir2_sf.h"
38 #include "xfs_attr_sf.h"
39 #include "xfs_dinode.h"
40 #include "xfs_inode.h"
41 #include "xfs_btree.h"
42 #include "xfs_ialloc.h"
43 #include "xfs_alloc.h"
45 #include "xfs_quota.h"
46 #include "xfs_trans_priv.h"
47 #include "xfs_trans_space.h"
50 STATIC
void xfs_trans_apply_sb_deltas(xfs_trans_t
*);
51 STATIC uint
xfs_trans_count_vecs(xfs_trans_t
*);
52 STATIC
void xfs_trans_fill_vecs(xfs_trans_t
*, xfs_log_iovec_t
*);
53 STATIC
void xfs_trans_uncommit(xfs_trans_t
*, uint
);
54 STATIC
void xfs_trans_committed(xfs_trans_t
*, int);
55 STATIC
void xfs_trans_chunk_committed(xfs_log_item_chunk_t
*, xfs_lsn_t
, int);
56 STATIC
void xfs_trans_free(xfs_trans_t
*);
58 kmem_zone_t
*xfs_trans_zone
;
62 * Initialize the precomputed transaction reservation values
63 * in the mount structure.
69 xfs_trans_reservations_t
*resp
;
71 resp
= &(mp
->m_reservations
);
73 (uint
)(XFS_CALC_WRITE_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
));
75 (uint
)(XFS_CALC_ITRUNCATE_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
));
77 (uint
)(XFS_CALC_RENAME_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
));
78 resp
->tr_link
= (uint
)XFS_CALC_LINK_LOG_RES(mp
);
80 (uint
)(XFS_CALC_REMOVE_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
));
82 (uint
)(XFS_CALC_SYMLINK_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
));
84 (uint
)(XFS_CALC_CREATE_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
));
86 (uint
)(XFS_CALC_MKDIR_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
));
88 (uint
)(XFS_CALC_IFREE_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
));
90 (uint
)(XFS_CALC_ICHANGE_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
));
91 resp
->tr_growdata
= (uint
)XFS_CALC_GROWDATA_LOG_RES(mp
);
92 resp
->tr_swrite
= (uint
)XFS_CALC_SWRITE_LOG_RES(mp
);
93 resp
->tr_writeid
= (uint
)XFS_CALC_WRITEID_LOG_RES(mp
);
95 (uint
)(XFS_CALC_ADDAFORK_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
));
96 resp
->tr_attrinval
= (uint
)XFS_CALC_ATTRINVAL_LOG_RES(mp
);
98 (uint
)(XFS_CALC_ATTRSET_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
));
100 (uint
)(XFS_CALC_ATTRRM_LOG_RES(mp
) + XFS_DQUOT_LOGRES(mp
));
101 resp
->tr_clearagi
= (uint
)XFS_CALC_CLEAR_AGI_BUCKET_LOG_RES(mp
);
102 resp
->tr_growrtalloc
= (uint
)XFS_CALC_GROWRTALLOC_LOG_RES(mp
);
103 resp
->tr_growrtzero
= (uint
)XFS_CALC_GROWRTZERO_LOG_RES(mp
);
104 resp
->tr_growrtfree
= (uint
)XFS_CALC_GROWRTFREE_LOG_RES(mp
);
108 * This routine is called to allocate a transaction structure.
109 * The type parameter indicates the type of the transaction. These
110 * are enumerated in xfs_trans.h.
112 * Dynamically allocate the transaction structure from the transaction
113 * zone, initialize it, and return it to the caller.
120 fs_check_frozen(XFS_MTOVFS(mp
), SB_FREEZE_TRANS
);
121 atomic_inc(&mp
->m_active_trans
);
123 return (_xfs_trans_alloc(mp
, type
));
134 ASSERT(xfs_trans_zone
!= NULL
);
135 tp
= kmem_zone_zalloc(xfs_trans_zone
, KM_SLEEP
);
138 * Initialize the transaction structure.
140 tp
->t_magic
= XFS_TRANS_MAGIC
;
143 tp
->t_items_free
= XFS_LIC_NUM_SLOTS
;
144 tp
->t_busy_free
= XFS_LBC_NUM_SLOTS
;
145 XFS_LIC_INIT(&(tp
->t_items
));
146 XFS_LBC_INIT(&(tp
->t_busy
));
152 * This is called to create a new transaction which will share the
153 * permanent log reservation of the given transaction. The remaining
154 * unused block and rt extent reservations are also inherited. This
155 * implies that the original transaction is no longer allowed to allocate
156 * blocks. Locks and log items, however, are no inherited. They must
157 * be added to the new transaction explicitly.
165 ntp
= kmem_zone_zalloc(xfs_trans_zone
, KM_SLEEP
);
168 * Initialize the new transaction structure.
170 ntp
->t_magic
= XFS_TRANS_MAGIC
;
171 ntp
->t_type
= tp
->t_type
;
172 ntp
->t_mountp
= tp
->t_mountp
;
173 ntp
->t_items_free
= XFS_LIC_NUM_SLOTS
;
174 ntp
->t_busy_free
= XFS_LBC_NUM_SLOTS
;
175 XFS_LIC_INIT(&(ntp
->t_items
));
176 XFS_LBC_INIT(&(ntp
->t_busy
));
178 ASSERT(tp
->t_flags
& XFS_TRANS_PERM_LOG_RES
);
180 #if defined(XLOG_NOLOG) || defined(DEBUG)
181 ASSERT(!xlog_debug
|| tp
->t_ticket
!= NULL
);
183 ASSERT(tp
->t_ticket
!= NULL
);
185 ntp
->t_flags
= XFS_TRANS_PERM_LOG_RES
| (tp
->t_flags
& XFS_TRANS_RESERVE
);
186 ntp
->t_ticket
= tp
->t_ticket
;
187 ntp
->t_blk_res
= tp
->t_blk_res
- tp
->t_blk_res_used
;
188 tp
->t_blk_res
= tp
->t_blk_res_used
;
189 ntp
->t_rtx_res
= tp
->t_rtx_res
- tp
->t_rtx_res_used
;
190 tp
->t_rtx_res
= tp
->t_rtx_res_used
;
191 PFLAGS_DUP(&tp
->t_pflags
, &ntp
->t_pflags
);
193 XFS_TRANS_DUP_DQINFO(tp
->t_mountp
, tp
, ntp
);
195 atomic_inc(&tp
->t_mountp
->m_active_trans
);
200 * This is called to reserve free disk blocks and log space for the
201 * given transaction. This must be done before allocating any resources
202 * within the transaction.
204 * This will return ENOSPC if there are not enough blocks available.
205 * It will sleep waiting for available log space.
206 * The only valid value for the flags parameter is XFS_RES_LOG_PERM, which
207 * is used by long running transactions. If any one of the reservations
208 * fails then they will all be backed out.
210 * This does not do quota reservations. That typically is done by the
227 rsvd
= (tp
->t_flags
& XFS_TRANS_RESERVE
) != 0;
229 /* Mark this thread as being in a transaction */
230 PFLAGS_SET_FSTRANS(&tp
->t_pflags
);
233 * Attempt to reserve the needed disk blocks by decrementing
234 * the number needed from the number available. This will
235 * fail if the count would go below zero.
238 error
= xfs_mod_incore_sb(tp
->t_mountp
, XFS_SBS_FDBLOCKS
,
241 PFLAGS_RESTORE_FSTRANS(&tp
->t_pflags
);
242 return (XFS_ERROR(ENOSPC
));
244 tp
->t_blk_res
+= blocks
;
248 * Reserve the log space needed for this transaction.
251 ASSERT((tp
->t_log_res
== 0) || (tp
->t_log_res
== logspace
));
252 ASSERT((tp
->t_log_count
== 0) ||
253 (tp
->t_log_count
== logcount
));
254 if (flags
& XFS_TRANS_PERM_LOG_RES
) {
255 log_flags
= XFS_LOG_PERM_RESERV
;
256 tp
->t_flags
|= XFS_TRANS_PERM_LOG_RES
;
258 ASSERT(tp
->t_ticket
== NULL
);
259 ASSERT(!(tp
->t_flags
& XFS_TRANS_PERM_LOG_RES
));
263 error
= xfs_log_reserve(tp
->t_mountp
, logspace
, logcount
,
265 XFS_TRANSACTION
, log_flags
, tp
->t_type
);
269 tp
->t_log_res
= logspace
;
270 tp
->t_log_count
= logcount
;
274 * Attempt to reserve the needed realtime extents by decrementing
275 * the number needed from the number available. This will
276 * fail if the count would go below zero.
279 error
= xfs_mod_incore_sb(tp
->t_mountp
, XFS_SBS_FREXTENTS
,
282 error
= XFS_ERROR(ENOSPC
);
285 tp
->t_rtx_res
+= rtextents
;
291 * Error cases jump to one of these labels to undo any
292 * reservations which have already been performed.
296 if (flags
& XFS_TRANS_PERM_LOG_RES
) {
297 log_flags
= XFS_LOG_REL_PERM_RESERV
;
301 xfs_log_done(tp
->t_mountp
, tp
->t_ticket
, NULL
, log_flags
);
304 tp
->t_flags
&= ~XFS_TRANS_PERM_LOG_RES
;
309 (void) xfs_mod_incore_sb(tp
->t_mountp
, XFS_SBS_FDBLOCKS
,
314 PFLAGS_RESTORE_FSTRANS(&tp
->t_pflags
);
321 * Record the indicated change to the given field for application
322 * to the file system's superblock when the transaction commits.
323 * For now, just store the change in the transaction structure.
325 * Mark the transaction structure to indicate that the superblock
326 * needs to be updated before committing.
336 case XFS_TRANS_SB_ICOUNT
:
337 tp
->t_icount_delta
+= delta
;
339 case XFS_TRANS_SB_IFREE
:
340 tp
->t_ifree_delta
+= delta
;
342 case XFS_TRANS_SB_FDBLOCKS
:
344 * Track the number of blocks allocated in the
345 * transaction. Make sure it does not exceed the
349 tp
->t_blk_res_used
+= (uint
)-delta
;
350 ASSERT(tp
->t_blk_res_used
<= tp
->t_blk_res
);
352 tp
->t_fdblocks_delta
+= delta
;
354 case XFS_TRANS_SB_RES_FDBLOCKS
:
356 * The allocation has already been applied to the
357 * in-core superblock's counter. This should only
358 * be applied to the on-disk superblock.
361 tp
->t_res_fdblocks_delta
+= delta
;
363 case XFS_TRANS_SB_FREXTENTS
:
365 * Track the number of blocks allocated in the
366 * transaction. Make sure it does not exceed the
370 tp
->t_rtx_res_used
+= (uint
)-delta
;
371 ASSERT(tp
->t_rtx_res_used
<= tp
->t_rtx_res
);
373 tp
->t_frextents_delta
+= delta
;
375 case XFS_TRANS_SB_RES_FREXTENTS
:
377 * The allocation has already been applied to the
378 * in-core superblocks's counter. This should only
379 * be applied to the on-disk superblock.
382 tp
->t_res_frextents_delta
+= delta
;
384 case XFS_TRANS_SB_DBLOCKS
:
386 tp
->t_dblocks_delta
+= delta
;
388 case XFS_TRANS_SB_AGCOUNT
:
390 tp
->t_agcount_delta
+= delta
;
392 case XFS_TRANS_SB_IMAXPCT
:
393 tp
->t_imaxpct_delta
+= delta
;
395 case XFS_TRANS_SB_REXTSIZE
:
396 tp
->t_rextsize_delta
+= delta
;
398 case XFS_TRANS_SB_RBMBLOCKS
:
399 tp
->t_rbmblocks_delta
+= delta
;
401 case XFS_TRANS_SB_RBLOCKS
:
402 tp
->t_rblocks_delta
+= delta
;
404 case XFS_TRANS_SB_REXTENTS
:
405 tp
->t_rextents_delta
+= delta
;
407 case XFS_TRANS_SB_REXTSLOG
:
408 tp
->t_rextslog_delta
+= delta
;
415 tp
->t_flags
|= (XFS_TRANS_SB_DIRTY
| XFS_TRANS_DIRTY
);
419 * xfs_trans_apply_sb_deltas() is called from the commit code
420 * to bring the superblock buffer into the current transaction
421 * and modify it as requested by earlier calls to xfs_trans_mod_sb().
423 * For now we just look at each field allowed to change and change
427 xfs_trans_apply_sb_deltas(
434 bp
= xfs_trans_getsb(tp
, tp
->t_mountp
, 0);
435 sbp
= XFS_BUF_TO_SBP(bp
);
438 * Check that superblock mods match the mods made to AGF counters.
440 ASSERT((tp
->t_fdblocks_delta
+ tp
->t_res_fdblocks_delta
) ==
441 (tp
->t_ag_freeblks_delta
+ tp
->t_ag_flist_delta
+
442 tp
->t_ag_btree_delta
));
444 if (tp
->t_icount_delta
!= 0) {
445 INT_MOD(sbp
->sb_icount
, ARCH_CONVERT
, tp
->t_icount_delta
);
447 if (tp
->t_ifree_delta
!= 0) {
448 INT_MOD(sbp
->sb_ifree
, ARCH_CONVERT
, tp
->t_ifree_delta
);
451 if (tp
->t_fdblocks_delta
!= 0) {
452 INT_MOD(sbp
->sb_fdblocks
, ARCH_CONVERT
, tp
->t_fdblocks_delta
);
454 if (tp
->t_res_fdblocks_delta
!= 0) {
455 INT_MOD(sbp
->sb_fdblocks
, ARCH_CONVERT
, tp
->t_res_fdblocks_delta
);
458 if (tp
->t_frextents_delta
!= 0) {
459 INT_MOD(sbp
->sb_frextents
, ARCH_CONVERT
, tp
->t_frextents_delta
);
461 if (tp
->t_res_frextents_delta
!= 0) {
462 INT_MOD(sbp
->sb_frextents
, ARCH_CONVERT
, tp
->t_res_frextents_delta
);
464 if (tp
->t_dblocks_delta
!= 0) {
465 INT_MOD(sbp
->sb_dblocks
, ARCH_CONVERT
, tp
->t_dblocks_delta
);
468 if (tp
->t_agcount_delta
!= 0) {
469 INT_MOD(sbp
->sb_agcount
, ARCH_CONVERT
, tp
->t_agcount_delta
);
472 if (tp
->t_imaxpct_delta
!= 0) {
473 INT_MOD(sbp
->sb_imax_pct
, ARCH_CONVERT
, tp
->t_imaxpct_delta
);
476 if (tp
->t_rextsize_delta
!= 0) {
477 INT_MOD(sbp
->sb_rextsize
, ARCH_CONVERT
, tp
->t_rextsize_delta
);
480 if (tp
->t_rbmblocks_delta
!= 0) {
481 INT_MOD(sbp
->sb_rbmblocks
, ARCH_CONVERT
, tp
->t_rbmblocks_delta
);
484 if (tp
->t_rblocks_delta
!= 0) {
485 INT_MOD(sbp
->sb_rblocks
, ARCH_CONVERT
, tp
->t_rblocks_delta
);
488 if (tp
->t_rextents_delta
!= 0) {
489 INT_MOD(sbp
->sb_rextents
, ARCH_CONVERT
, tp
->t_rextents_delta
);
492 if (tp
->t_rextslog_delta
!= 0) {
493 INT_MOD(sbp
->sb_rextslog
, ARCH_CONVERT
, tp
->t_rextslog_delta
);
499 * Log the whole thing, the fields are discontiguous.
501 xfs_trans_log_buf(tp
, bp
, 0, sizeof(xfs_sb_t
) - 1);
504 * Since all the modifiable fields are contiguous, we
505 * can get away with this.
507 xfs_trans_log_buf(tp
, bp
, offsetof(xfs_sb_t
, sb_icount
),
508 offsetof(xfs_sb_t
, sb_frextents
) +
509 sizeof(sbp
->sb_frextents
) - 1);
511 XFS_MTOVFS(tp
->t_mountp
)->vfs_super
->s_dirt
= 1;
515 * xfs_trans_unreserve_and_mod_sb() is called to release unused
516 * reservations and apply superblock counter changes to the in-core
519 * This is done efficiently with a single call to xfs_mod_incore_sb_batch().
522 xfs_trans_unreserve_and_mod_sb(
525 xfs_mod_sb_t msb
[14]; /* If you add cases, add entries */
532 rsvd
= (tp
->t_flags
& XFS_TRANS_RESERVE
) != 0;
535 * Release any reserved blocks. Any that were allocated
536 * will be taken back again by fdblocks_delta below.
538 if (tp
->t_blk_res
> 0) {
539 msbp
->msb_field
= XFS_SBS_FDBLOCKS
;
540 msbp
->msb_delta
= tp
->t_blk_res
;
545 * Release any reserved real time extents . Any that were
546 * allocated will be taken back again by frextents_delta below.
548 if (tp
->t_rtx_res
> 0) {
549 msbp
->msb_field
= XFS_SBS_FREXTENTS
;
550 msbp
->msb_delta
= tp
->t_rtx_res
;
555 * Apply any superblock modifications to the in-core version.
556 * The t_res_fdblocks_delta and t_res_frextents_delta fields are
557 * explicity NOT applied to the in-core superblock.
558 * The idea is that that has already been done.
560 if (tp
->t_flags
& XFS_TRANS_SB_DIRTY
) {
561 if (tp
->t_icount_delta
!= 0) {
562 msbp
->msb_field
= XFS_SBS_ICOUNT
;
563 msbp
->msb_delta
= (int)tp
->t_icount_delta
;
566 if (tp
->t_ifree_delta
!= 0) {
567 msbp
->msb_field
= XFS_SBS_IFREE
;
568 msbp
->msb_delta
= (int)tp
->t_ifree_delta
;
571 if (tp
->t_fdblocks_delta
!= 0) {
572 msbp
->msb_field
= XFS_SBS_FDBLOCKS
;
573 msbp
->msb_delta
= (int)tp
->t_fdblocks_delta
;
576 if (tp
->t_frextents_delta
!= 0) {
577 msbp
->msb_field
= XFS_SBS_FREXTENTS
;
578 msbp
->msb_delta
= (int)tp
->t_frextents_delta
;
581 if (tp
->t_dblocks_delta
!= 0) {
582 msbp
->msb_field
= XFS_SBS_DBLOCKS
;
583 msbp
->msb_delta
= (int)tp
->t_dblocks_delta
;
586 if (tp
->t_agcount_delta
!= 0) {
587 msbp
->msb_field
= XFS_SBS_AGCOUNT
;
588 msbp
->msb_delta
= (int)tp
->t_agcount_delta
;
591 if (tp
->t_imaxpct_delta
!= 0) {
592 msbp
->msb_field
= XFS_SBS_IMAX_PCT
;
593 msbp
->msb_delta
= (int)tp
->t_imaxpct_delta
;
596 if (tp
->t_rextsize_delta
!= 0) {
597 msbp
->msb_field
= XFS_SBS_REXTSIZE
;
598 msbp
->msb_delta
= (int)tp
->t_rextsize_delta
;
601 if (tp
->t_rbmblocks_delta
!= 0) {
602 msbp
->msb_field
= XFS_SBS_RBMBLOCKS
;
603 msbp
->msb_delta
= (int)tp
->t_rbmblocks_delta
;
606 if (tp
->t_rblocks_delta
!= 0) {
607 msbp
->msb_field
= XFS_SBS_RBLOCKS
;
608 msbp
->msb_delta
= (int)tp
->t_rblocks_delta
;
611 if (tp
->t_rextents_delta
!= 0) {
612 msbp
->msb_field
= XFS_SBS_REXTENTS
;
613 msbp
->msb_delta
= (int)tp
->t_rextents_delta
;
616 if (tp
->t_rextslog_delta
!= 0) {
617 msbp
->msb_field
= XFS_SBS_REXTSLOG
;
618 msbp
->msb_delta
= (int)tp
->t_rextslog_delta
;
624 * If we need to change anything, do it.
627 error
= xfs_mod_incore_sb_batch(tp
->t_mountp
, msb
,
628 (uint
)(msbp
- msb
), rsvd
);
637 * Commit the given transaction to the log a/synchronously.
639 * XFS disk error handling mechanism is not based on a typical
640 * transaction abort mechanism. Logically after the filesystem
641 * gets marked 'SHUTDOWN', we can't let any new transactions
642 * be durable - ie. committed to disk - because some metadata might
643 * be inconsistent. In such cases, this returns an error, and the
644 * caller may assume that all locked objects joined to the transaction
645 * have already been unlocked as if the commit had succeeded.
646 * Do not reference the transaction structure after this call.
653 xfs_lsn_t
*commit_lsn_p
,
656 xfs_log_iovec_t
*log_vector
;
659 xfs_lsn_t commit_lsn
;
664 #define XFS_TRANS_LOGVEC_COUNT 16
665 xfs_log_iovec_t log_vector_fast
[XFS_TRANS_LOGVEC_COUNT
];
666 #if defined(XLOG_NOLOG) || defined(DEBUG)
667 static xfs_lsn_t trans_lsn
= 1;
675 * Determine whether this commit is releasing a permanent
676 * log reservation or not.
678 if (flags
& XFS_TRANS_RELEASE_LOG_RES
) {
679 ASSERT(tp
->t_flags
& XFS_TRANS_PERM_LOG_RES
);
680 log_flags
= XFS_LOG_REL_PERM_RESERV
;
687 * If there is nothing to be logged by the transaction,
688 * then unlock all of the items associated with the
689 * transaction and free the transaction structure.
690 * Also make sure to return any reserved blocks to
694 shutdown
= XFS_FORCED_SHUTDOWN(mp
) ? EIO
: 0;
695 if (!(tp
->t_flags
& XFS_TRANS_DIRTY
) || shutdown
) {
696 xfs_trans_unreserve_and_mod_sb(tp
);
698 * It is indeed possible for the transaction to be
699 * not dirty but the dqinfo portion to be. All that
700 * means is that we have some (non-persistent) quota
701 * reservations that need to be unreserved.
703 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(mp
, tp
);
705 commit_lsn
= xfs_log_done(mp
, tp
->t_ticket
,
707 if (commit_lsn
== -1 && !shutdown
)
708 shutdown
= XFS_ERROR(EIO
);
710 PFLAGS_RESTORE_FSTRANS(&tp
->t_pflags
);
711 xfs_trans_free_items(tp
, shutdown
? XFS_TRANS_ABORT
: 0);
712 xfs_trans_free_busy(tp
);
714 XFS_STATS_INC(xs_trans_empty
);
716 *commit_lsn_p
= commit_lsn
;
719 #if defined(XLOG_NOLOG) || defined(DEBUG)
720 ASSERT(!xlog_debug
|| tp
->t_ticket
!= NULL
);
722 ASSERT(tp
->t_ticket
!= NULL
);
726 * If we need to update the superblock, then do it now.
728 if (tp
->t_flags
& XFS_TRANS_SB_DIRTY
) {
729 xfs_trans_apply_sb_deltas(tp
);
731 XFS_TRANS_APPLY_DQUOT_DELTAS(mp
, tp
);
734 * Ask each log item how many log_vector entries it will
735 * need so we can figure out how many to allocate.
736 * Try to avoid the kmem_alloc() call in the common case
737 * by using a vector from the stack when it fits.
739 nvec
= xfs_trans_count_vecs(tp
);
742 xfs_force_shutdown(mp
, XFS_LOG_IO_ERROR
);
747 if (nvec
<= XFS_TRANS_LOGVEC_COUNT
) {
748 log_vector
= log_vector_fast
;
750 log_vector
= (xfs_log_iovec_t
*)kmem_alloc(nvec
*
751 sizeof(xfs_log_iovec_t
),
756 * Fill in the log_vector and pin the logged items, and
757 * then write the transaction to the log.
759 xfs_trans_fill_vecs(tp
, log_vector
);
762 * Ignore errors here. xfs_log_done would do the right thing.
763 * We need to put the ticket, etc. away.
765 error
= xfs_log_write(mp
, log_vector
, nvec
, tp
->t_ticket
,
768 #if defined(XLOG_NOLOG) || defined(DEBUG)
770 commit_lsn
= xfs_log_done(mp
, tp
->t_ticket
,
771 &commit_iclog
, log_flags
);
774 tp
->t_lsn
= trans_lsn
++;
778 * This is the regular case. At this point (after the call finishes),
779 * the transaction is committed incore and could go out to disk at
780 * any time. However, all the items associated with the transaction
781 * are still locked and pinned in memory.
783 commit_lsn
= xfs_log_done(mp
, tp
->t_ticket
, &commit_iclog
, log_flags
);
786 tp
->t_commit_lsn
= commit_lsn
;
787 if (nvec
> XFS_TRANS_LOGVEC_COUNT
) {
788 kmem_free(log_vector
, nvec
* sizeof(xfs_log_iovec_t
));
792 *commit_lsn_p
= commit_lsn
;
795 * If we got a log write error. Unpin the logitems that we
796 * had pinned, clean up, free trans structure, and return error.
798 if (error
|| commit_lsn
== -1) {
799 PFLAGS_RESTORE_FSTRANS(&tp
->t_pflags
);
800 xfs_trans_uncommit(tp
, flags
|XFS_TRANS_ABORT
);
801 return XFS_ERROR(EIO
);
805 * Once the transaction has committed, unused
806 * reservations need to be released and changes to
807 * the superblock need to be reflected in the in-core
808 * version. Do that now.
810 xfs_trans_unreserve_and_mod_sb(tp
);
812 sync
= tp
->t_flags
& XFS_TRANS_SYNC
;
815 * Tell the LM to call the transaction completion routine
816 * when the log write with LSN commit_lsn completes (e.g.
817 * when the transaction commit really hits the on-disk log).
818 * After this call we cannot reference tp, because the call
819 * can happen at any time and the call will free the transaction
820 * structure pointed to by tp. The only case where we call
821 * the completion routine (xfs_trans_committed) directly is
822 * if the log is turned off on a debug kernel or we're
823 * running in simulation mode (the log is explicitly turned
826 tp
->t_logcb
.cb_func
= (void(*)(void*, int))xfs_trans_committed
;
827 tp
->t_logcb
.cb_arg
= tp
;
830 * We need to pass the iclog buffer which was used for the
831 * transaction commit record into this function, and attach
832 * the callback to it. The callback must be attached before
833 * the items are unlocked to avoid racing with other threads
834 * waiting for an item to unlock.
836 shutdown
= xfs_log_notify(mp
, commit_iclog
, &(tp
->t_logcb
));
839 * Mark this thread as no longer being in a transaction
841 PFLAGS_RESTORE_FSTRANS(&tp
->t_pflags
);
844 * Once all the items of the transaction have been copied
845 * to the in core log and the callback is attached, the
846 * items can be unlocked.
848 * This will free descriptors pointing to items which were
849 * not logged since there is nothing more to do with them.
850 * For items which were logged, we will keep pointers to them
851 * so they can be unpinned after the transaction commits to disk.
852 * This will also stamp each modified meta-data item with
853 * the commit lsn of this transaction for dependency tracking
856 xfs_trans_unlock_items(tp
, commit_lsn
);
859 * If we detected a log error earlier, finish committing
860 * the transaction now (unpin log items, etc).
862 * Order is critical here, to avoid using the transaction
863 * pointer after its been freed (by xfs_trans_committed
864 * either here now, or as a callback). We cannot do this
865 * step inside xfs_log_notify as was done earlier because
869 xfs_trans_committed(tp
, XFS_LI_ABORTED
);
872 * Now that the xfs_trans_committed callback has been attached,
873 * and the items are released we can finally allow the iclog to
876 error
= xfs_log_release_iclog(mp
, commit_iclog
);
879 * If the transaction needs to be synchronous, then force the
880 * log out now and wait for it.
884 error
= _xfs_log_force(mp
, commit_lsn
,
885 XFS_LOG_FORCE
| XFS_LOG_SYNC
,
888 XFS_STATS_INC(xs_trans_sync
);
890 XFS_STATS_INC(xs_trans_async
);
898 * Total up the number of log iovecs needed to commit this
899 * transaction. The transaction itself needs one for the
900 * transaction header. Ask each dirty item in turn how many
901 * it needs to get the total.
904 xfs_trans_count_vecs(
908 xfs_log_item_desc_t
*lidp
;
911 lidp
= xfs_trans_first_item(tp
);
912 ASSERT(lidp
!= NULL
);
914 /* In the non-debug case we need to start bailing out if we
915 * didn't find a log_item here, return zero and let trans_commit
921 while (lidp
!= NULL
) {
923 * Skip items which aren't dirty in this transaction.
925 if (!(lidp
->lid_flags
& XFS_LID_DIRTY
)) {
926 lidp
= xfs_trans_next_item(tp
, lidp
);
929 lidp
->lid_size
= IOP_SIZE(lidp
->lid_item
);
930 nvecs
+= lidp
->lid_size
;
931 lidp
= xfs_trans_next_item(tp
, lidp
);
938 * Called from the trans_commit code when we notice that
939 * the filesystem is in the middle of a forced shutdown.
946 xfs_log_item_desc_t
*lidp
;
948 for (lidp
= xfs_trans_first_item(tp
);
950 lidp
= xfs_trans_next_item(tp
, lidp
)) {
952 * Unpin all but those that aren't dirty.
954 if (lidp
->lid_flags
& XFS_LID_DIRTY
)
955 IOP_UNPIN_REMOVE(lidp
->lid_item
, tp
);
958 xfs_trans_unreserve_and_mod_sb(tp
);
959 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(tp
->t_mountp
, tp
);
961 xfs_trans_free_items(tp
, flags
);
962 xfs_trans_free_busy(tp
);
967 * Fill in the vector with pointers to data to be logged
968 * by this transaction. The transaction header takes
969 * the first vector, and then each dirty item takes the
970 * number of vectors it indicated it needed in xfs_trans_count_vecs().
972 * As each item fills in the entries it needs, also pin the item
973 * so that it cannot be flushed out until the log write completes.
978 xfs_log_iovec_t
*log_vector
)
980 xfs_log_item_desc_t
*lidp
;
981 xfs_log_iovec_t
*vecp
;
985 * Skip over the entry for the transaction header, we'll
986 * fill that in at the end.
988 vecp
= log_vector
+ 1; /* pointer arithmetic */
991 lidp
= xfs_trans_first_item(tp
);
992 ASSERT(lidp
!= NULL
);
993 while (lidp
!= NULL
) {
995 * Skip items which aren't dirty in this transaction.
997 if (!(lidp
->lid_flags
& XFS_LID_DIRTY
)) {
998 lidp
= xfs_trans_next_item(tp
, lidp
);
1002 * The item may be marked dirty but not log anything.
1003 * This can be used to get called when a transaction
1006 if (lidp
->lid_size
) {
1009 IOP_FORMAT(lidp
->lid_item
, vecp
);
1010 vecp
+= lidp
->lid_size
; /* pointer arithmetic */
1011 IOP_PIN(lidp
->lid_item
);
1012 lidp
= xfs_trans_next_item(tp
, lidp
);
1016 * Now that we've counted the number of items in this
1017 * transaction, fill in the transaction header.
1019 tp
->t_header
.th_magic
= XFS_TRANS_HEADER_MAGIC
;
1020 tp
->t_header
.th_type
= tp
->t_type
;
1021 tp
->t_header
.th_num_items
= nitems
;
1022 log_vector
->i_addr
= (xfs_caddr_t
)&tp
->t_header
;
1023 log_vector
->i_len
= sizeof(xfs_trans_header_t
);
1024 XLOG_VEC_SET_TYPE(log_vector
, XLOG_REG_TYPE_TRANSHDR
);
1029 * Unlock all of the transaction's items and free the transaction.
1030 * The transaction must not have modified any of its items, because
1031 * there is no way to restore them to their previous state.
1033 * If the transaction has made a log reservation, make sure to release
1043 xfs_log_item_chunk_t
*licp
;
1044 xfs_log_item_desc_t
*lidp
;
1045 xfs_log_item_t
*lip
;
1050 * See if the caller is being too lazy to figure out if
1051 * the transaction really needs an abort.
1053 if ((flags
& XFS_TRANS_ABORT
) && !(tp
->t_flags
& XFS_TRANS_DIRTY
))
1054 flags
&= ~XFS_TRANS_ABORT
;
1056 * See if the caller is relying on us to shut down the
1057 * filesystem. This happens in paths where we detect
1058 * corruption and decide to give up.
1060 if ((tp
->t_flags
& XFS_TRANS_DIRTY
) &&
1061 !XFS_FORCED_SHUTDOWN(tp
->t_mountp
))
1062 xfs_force_shutdown(tp
->t_mountp
, XFS_CORRUPT_INCORE
);
1064 if (!(flags
& XFS_TRANS_ABORT
)) {
1065 licp
= &(tp
->t_items
);
1066 while (licp
!= NULL
) {
1067 lidp
= licp
->lic_descs
;
1068 for (i
= 0; i
< licp
->lic_unused
; i
++, lidp
++) {
1069 if (XFS_LIC_ISFREE(licp
, i
)) {
1073 lip
= lidp
->lid_item
;
1074 if (!XFS_FORCED_SHUTDOWN(tp
->t_mountp
))
1075 ASSERT(!(lip
->li_type
== XFS_LI_EFD
));
1077 licp
= licp
->lic_next
;
1081 xfs_trans_unreserve_and_mod_sb(tp
);
1082 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(tp
->t_mountp
, tp
);
1085 if (flags
& XFS_TRANS_RELEASE_LOG_RES
) {
1086 ASSERT(tp
->t_flags
& XFS_TRANS_PERM_LOG_RES
);
1087 log_flags
= XFS_LOG_REL_PERM_RESERV
;
1091 xfs_log_done(tp
->t_mountp
, tp
->t_ticket
, NULL
, log_flags
);
1094 /* mark this thread as no longer being in a transaction */
1095 PFLAGS_RESTORE_FSTRANS(&tp
->t_pflags
);
1097 xfs_trans_free_items(tp
, flags
);
1098 xfs_trans_free_busy(tp
);
1104 * Free the transaction structure. If there is more clean up
1105 * to do when the structure is freed, add it here.
1111 atomic_dec(&tp
->t_mountp
->m_active_trans
);
1112 XFS_TRANS_FREE_DQINFO(tp
->t_mountp
, tp
);
1113 kmem_zone_free(xfs_trans_zone
, tp
);
1118 * THIS SHOULD BE REWRITTEN TO USE xfs_trans_next_item().
1120 * This is typically called by the LM when a transaction has been fully
1121 * committed to disk. It needs to unpin the items which have
1122 * been logged by the transaction and update their positions
1123 * in the AIL if necessary.
1124 * This also gets called when the transactions didn't get written out
1125 * because of an I/O error. Abortflag & XFS_LI_ABORTED is set then.
1127 * Call xfs_trans_chunk_committed() to process the items in
1131 xfs_trans_committed(
1135 xfs_log_item_chunk_t
*licp
;
1136 xfs_log_item_chunk_t
*next_licp
;
1137 xfs_log_busy_chunk_t
*lbcp
;
1138 xfs_log_busy_slot_t
*lbsp
;
1142 * Call the transaction's completion callback if there
1145 if (tp
->t_callback
!= NULL
) {
1146 tp
->t_callback(tp
, tp
->t_callarg
);
1150 * Special case the chunk embedded in the transaction.
1152 licp
= &(tp
->t_items
);
1153 if (!(XFS_LIC_ARE_ALL_FREE(licp
))) {
1154 xfs_trans_chunk_committed(licp
, tp
->t_lsn
, abortflag
);
1158 * Process the items in each chunk in turn.
1160 licp
= licp
->lic_next
;
1161 while (licp
!= NULL
) {
1162 ASSERT(!XFS_LIC_ARE_ALL_FREE(licp
));
1163 xfs_trans_chunk_committed(licp
, tp
->t_lsn
, abortflag
);
1164 next_licp
= licp
->lic_next
;
1165 kmem_free(licp
, sizeof(xfs_log_item_chunk_t
));
1170 * Clear all the per-AG busy list items listed in this transaction
1173 while (lbcp
!= NULL
) {
1174 for (i
= 0, lbsp
= lbcp
->lbc_busy
; i
< lbcp
->lbc_unused
; i
++, lbsp
++) {
1175 if (!XFS_LBC_ISFREE(lbcp
, i
)) {
1176 xfs_alloc_clear_busy(tp
, lbsp
->lbc_ag
,
1180 lbcp
= lbcp
->lbc_next
;
1182 xfs_trans_free_busy(tp
);
1185 * That's it for the transaction structure. Free it.
1191 * This is called to perform the commit processing for each
1192 * item described by the given chunk.
1194 * The commit processing consists of unlocking items which were
1195 * held locked with the SYNC_UNLOCK attribute, calling the committed
1196 * routine of each logged item, updating the item's position in the AIL
1197 * if necessary, and unpinning each item. If the committed routine
1198 * returns -1, then do nothing further with the item because it
1199 * may have been freed.
1201 * Since items are unlocked when they are copied to the incore
1202 * log, it is possible for two transactions to be completing
1203 * and manipulating the same item simultaneously. The AIL lock
1204 * will protect the lsn field of each item. The value of this
1205 * field can never go backwards.
1207 * We unpin the items after repositioning them in the AIL, because
1208 * otherwise they could be immediately flushed and we'd have to race
1209 * with the flusher trying to pull the item from the AIL as we add it.
1212 xfs_trans_chunk_committed(
1213 xfs_log_item_chunk_t
*licp
,
1217 xfs_log_item_desc_t
*lidp
;
1218 xfs_log_item_t
*lip
;
1220 struct xfs_mount
*mp
;
1224 lidp
= licp
->lic_descs
;
1225 for (i
= 0; i
< licp
->lic_unused
; i
++, lidp
++) {
1226 if (XFS_LIC_ISFREE(licp
, i
)) {
1230 lip
= lidp
->lid_item
;
1232 lip
->li_flags
|= XFS_LI_ABORTED
;
1235 * Send in the ABORTED flag to the COMMITTED routine
1236 * so that it knows whether the transaction was aborted
1239 item_lsn
= IOP_COMMITTED(lip
, lsn
);
1242 * If the committed routine returns -1, make
1243 * no more references to the item.
1245 if (XFS_LSN_CMP(item_lsn
, (xfs_lsn_t
)-1) == 0) {
1250 * If the returned lsn is greater than what it
1251 * contained before, update the location of the
1252 * item in the AIL. If it is not, then do nothing.
1253 * Items can never move backwards in the AIL.
1255 * While the new lsn should usually be greater, it
1256 * is possible that a later transaction completing
1257 * simultaneously with an earlier one using the
1258 * same item could complete first with a higher lsn.
1259 * This would cause the earlier transaction to fail
1262 mp
= lip
->li_mountp
;
1264 if (XFS_LSN_CMP(item_lsn
, lip
->li_lsn
) > 0) {
1266 * This will set the item's lsn to item_lsn
1267 * and update the position of the item in
1270 * xfs_trans_update_ail() drops the AIL lock.
1272 xfs_trans_update_ail(mp
, lip
, item_lsn
, s
);
1278 * Now that we've repositioned the item in the AIL,
1279 * unpin it so it can be flushed. Pass information
1280 * about buffer stale state down from the log item
1281 * flags, if anyone else stales the buffer we do not
1282 * want to pay any attention to it.
1284 IOP_UNPIN(lip
, lidp
->lid_flags
& XFS_LID_BUF_STALE
);