2 * Copyright (c) 2000-2001,2005-2006 Silicon Graphics, Inc.
3 * Copyright (C) 2010 Red Hat, Inc.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation.
10 * This program is distributed in the hope that it would be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 #include "libxfs_priv.h"
22 #include "xfs_shared.h"
23 #include "xfs_format.h"
24 #include "xfs_log_format.h"
25 #include "xfs_trans_resv.h"
26 #include "xfs_mount.h"
27 #include "xfs_inode_buf.h"
28 #include "xfs_inode_fork.h"
29 #include "xfs_inode.h"
30 #include "xfs_trans.h"
33 static void xfs_trans_free_items(struct xfs_trans
*tp
);
36 * Simple transaction interface
39 kmem_zone_t
*xfs_trans_zone
;
40 kmem_zone_t
*xfs_log_item_desc_zone
;
43 * Initialize the precomputed transaction reservation values
44 * in the mount structure.
50 xfs_trans_resv_calc(mp
, &mp
->m_resv
);
54 * Add the given log item to the transaction's list of log items.
56 * The log item will now point to its new descriptor with its li_desc field.
59 libxfs_trans_add_item(
61 struct xfs_log_item
*lip
)
63 struct xfs_log_item_desc
*lidp
;
65 ASSERT(lip
->li_mountp
== tp
->t_mountp
);
66 ASSERT(lip
->li_ailp
== tp
->t_mountp
->m_ail
);
68 lidp
= calloc(sizeof(struct xfs_log_item_desc
), 1);
70 fprintf(stderr
, _("%s: lidp calloc failed (%d bytes): %s\n"),
71 progname
, (int)sizeof(struct xfs_log_item_desc
),
78 list_add_tail(&lidp
->lid_trans
, &tp
->t_items
);
84 * Unlink and free the given descriptor.
87 libxfs_trans_del_item(
88 struct xfs_log_item
*lip
)
90 list_del_init(&lip
->li_desc
->lid_trans
);
96 * Roll from one trans in the sequence of PERMANENT transactions to
97 * the next: permanent transactions are only flushed out when
98 * committed with XFS_TRANS_RELEASE_LOG_RES, but we still want as soon
99 * as possible to let chunks of it go to the log. So we commit the
100 * chunk we've been working on and get a new transaction to continue.
104 struct xfs_trans
**tpp
)
106 struct xfs_mount
*mp
;
107 struct xfs_trans
*trans
= *tpp
;
108 struct xfs_trans_res tres
;
109 unsigned int old_blk_res
;
113 * Copy the critical parameters from one trans to the next.
115 mp
= trans
->t_mountp
;
116 tres
.tr_logres
= trans
->t_log_res
;
117 tres
.tr_logcount
= trans
->t_log_count
;
118 old_blk_res
= trans
->t_blk_res
;
121 * Commit the current transaction.
122 * If this commit failed, then it'd just unlock those items that
123 * are marked to be released. That also means that a filesystem shutdown
124 * is in progress. The caller takes the responsibility to cancel
125 * the duplicate transaction that gets returned.
127 error
= xfs_trans_commit(trans
);
132 * Reserve space in the log for the next transaction.
133 * This also pushes items in the "AIL", the list of logged items,
134 * out to disk if they are taking up space at the tail of the log
135 * that we want to use. This requires that either nothing be locked
136 * across this call, or that anything that is locked be logged in
137 * the prior and the next transactions.
139 tres
.tr_logflags
= XFS_TRANS_PERM_LOG_RES
;
140 error
= libxfs_trans_alloc(mp
, &tres
, 0, 0, 0, tpp
);
142 trans
->t_blk_res
= old_blk_res
;
148 * Free the transaction structure. If there is more clean up
149 * to do when the structure is freed, add it here.
153 struct xfs_trans
*tp
)
155 kmem_zone_free(xfs_trans_zone
, tp
);
160 struct xfs_mount
*mp
,
161 struct xfs_trans_res
*resp
,
163 unsigned int rtextents
,
165 struct xfs_trans
**tpp
)
168 struct xfs_sb
*sb
= &mp
->m_sb
;
169 struct xfs_trans
*ptr
;
172 * Attempt to reserve the needed disk blocks by decrementing
173 * the number needed from the number available. This will
174 * fail if the count would go below zero.
177 if (sb
->sb_fdblocks
< blocks
)
181 ptr
= kmem_zone_zalloc(xfs_trans_zone
,
182 (flags
& XFS_TRANS_NOFS
) ? KM_NOFS
: KM_SLEEP
);
184 ptr
->t_blk_res
= blocks
;
185 INIT_LIST_HEAD(&ptr
->t_items
);
187 fprintf(stderr
, "allocated new transaction %p\n", ptr
);
194 * Create an empty transaction with no reservation. This is a defensive
195 * mechanism for routines that query metadata without actually modifying
196 * them -- if the metadata being queried is somehow cross-linked (think a
197 * btree block pointer that points higher in the tree), we risk deadlock.
198 * However, blocks grabbed as part of a transaction can be re-grabbed.
199 * The verifiers will notice the corrupt block and the operation will fail
200 * back to userspace without deadlocking.
202 * Note the zero-length reservation; this transaction MUST be cancelled
203 * without any dirty data.
206 libxfs_trans_alloc_empty(
207 struct xfs_mount
*mp
,
208 struct xfs_trans
**tpp
)
210 struct xfs_trans_res resv
= {0};
212 return xfs_trans_alloc(mp
, &resv
, 0, 0, XFS_TRANS_NO_WRITECOUNT
, tpp
);
220 xfs_trans_t
*otp
= tp
;
223 xfs_trans_free_items(tp
);
227 fprintf(stderr
, "## cancelled transaction %p\n", otp
);
242 xfs_inode_log_item_t
*iip
;
245 return libxfs_iget(mp
, tp
, ino
, lock_flags
, ipp
);
247 error
= libxfs_iget(mp
, tp
, ino
, lock_flags
, &ip
);
252 if (ip
->i_itemp
== NULL
)
253 xfs_inode_item_init(ip
, mp
);
255 xfs_trans_add_item(tp
, (xfs_log_item_t
*)(iip
));
257 /* initialize i_transp so we can find it incore */
270 xfs_inode_log_item_t
*iip
;
272 ASSERT(ip
->i_transp
== NULL
);
273 if (ip
->i_itemp
== NULL
)
274 xfs_inode_item_init(ip
, ip
->i_mount
);
276 ASSERT(iip
->ili_flags
== 0);
277 ASSERT(iip
->ili_inode
!= NULL
);
279 xfs_trans_add_item(tp
, (xfs_log_item_t
*)(iip
));
283 fprintf(stderr
, "ijoin'd inode %llu, transaction %p\n", ip
->i_ino
, tp
);
288 libxfs_trans_ijoin_ref(
293 ASSERT(ip
->i_transp
== tp
);
294 ASSERT(ip
->i_itemp
!= NULL
);
296 xfs_trans_ijoin(tp
, ip
, lock_flags
);
299 fprintf(stderr
, "ijoin_ref'd inode %llu, transaction %p\n", ip
->i_ino
, tp
);
304 libxfs_trans_inode_alloc_buf(
308 xfs_buf_log_item_t
*bip
= bp
->b_fspriv
;;
310 ASSERT(bp
->bp_transp
== tp
);
312 bip
->bli_flags
|= XFS_BLI_INODE_ALLOC_BUF
;
313 xfs_trans_buf_set_type(tp
, bp
, XFS_BLFT_DINO_BUF
);
317 * This is called to mark the fields indicated in fieldmask as needing
318 * to be logged when the transaction is committed. The inode must
319 * already be associated with the given transaction.
321 * The values for fieldmask are defined in xfs_log_format.h. We always
322 * log all of the core inode if any of it has changed, and we always log
323 * all of the inline data/extents/b-tree root if any of them has changed.
331 ASSERT(ip
->i_transp
== tp
);
332 ASSERT(ip
->i_itemp
!= NULL
);
334 fprintf(stderr
, "dirtied inode %llu, transaction %p\n", ip
->i_ino
, tp
);
337 tp
->t_flags
|= XFS_TRANS_DIRTY
;
338 ip
->i_itemp
->ili_item
.li_desc
->lid_flags
|= XFS_LID_DIRTY
;
341 * Always OR in the bits from the ili_last_fields field.
342 * This is to coordinate with the xfs_iflush() and xfs_iflush_done()
343 * routines in the eventual clearing of the ilf_fields bits.
344 * See the big comment in xfs_iflush() for an explanation of
345 * this coordination mechanism.
347 flags
|= ip
->i_itemp
->ili_last_fields
;
348 ip
->i_itemp
->ili_fields
|= flags
;
352 libxfs_trans_roll_inode(
353 struct xfs_trans
**tpp
,
354 struct xfs_inode
*ip
)
358 xfs_trans_log_inode(*tpp
, ip
, XFS_ILOG_CORE
);
359 error
= xfs_trans_roll(tpp
);
361 xfs_trans_ijoin(*tpp
, ip
, 0);
367 * Mark a buffer dirty in the transaction.
370 libxfs_trans_dirty_buf(
371 struct xfs_trans
*tp
,
374 struct xfs_buf_log_item
*bip
= bp
->b_fspriv
;
376 ASSERT(bp
->bp_transp
== tp
);
380 fprintf(stderr
, "dirtied buffer %p, transaction %p\n", bp
, tp
);
382 tp
->t_flags
|= XFS_TRANS_DIRTY
;
383 bip
->bli_item
.li_desc
->lid_flags
|= XFS_LID_DIRTY
;
387 * This is called to mark bytes first through last inclusive of the given
388 * buffer as needing to be logged when the transaction is committed.
389 * The buffer must already be associated with the given transaction.
391 * First and last are numbers relative to the beginning of this buffer,
392 * so the first byte in the buffer is numbered 0 regardless of the
396 libxfs_trans_log_buf(
397 struct xfs_trans
*tp
,
402 struct xfs_buf_log_item
*bip
= bp
->b_fspriv
;
404 ASSERT((first
<= last
) && (last
< XFS_BUF_COUNT(bp
)));
406 xfs_trans_dirty_buf(tp
, bp
);
407 xfs_buf_item_log(bip
, first
, last
);
411 * For userspace, ordered buffers just need to be marked dirty so
412 * the transaction commit will write them and mark them up-to-date.
413 * In essence, they are just like any other logged buffer in userspace.
415 * If the buffer is already dirty, trigger the "already logged" return condition.
418 libxfs_trans_ordered_buf(
419 struct xfs_trans
*tp
,
422 struct xfs_buf_log_item
*bip
= bp
->b_fspriv
;
425 ret
= (bip
->bli_item
.li_desc
->lid_flags
& XFS_LID_DIRTY
);
426 libxfs_trans_log_buf(tp
, bp
, 0, bp
->b_bcount
);
435 xfs_buf_log_item_t
*bip
;
437 fprintf(stderr
, "released buffer %p, transaction %p\n", bp
, tp
);
441 ASSERT(bp
->bp_transp
== NULL
);
445 ASSERT(bp
->bp_transp
== tp
);
447 ASSERT(bip
->bli_item
.li_type
== XFS_LI_BUF
);
448 if (bip
->bli_recur
> 0) {
452 /* If dirty/stale, can't release till transaction committed */
453 if (bip
->bli_flags
& XFS_BLI_STALE
)
455 if (bip
->bli_item
.li_desc
->lid_flags
& XFS_LID_DIRTY
)
457 xfs_trans_del_item(&bip
->bli_item
);
458 if (bip
->bli_flags
& XFS_BLI_HOLD
)
459 bip
->bli_flags
&= ~XFS_BLI_HOLD
;
469 xfs_buf_log_item_t
*bip
= bp
->b_fspriv
;
471 fprintf(stderr
, "binval'd buffer %p, transaction %p\n", bp
, tp
);
474 ASSERT(bp
->bp_transp
== tp
);
477 if (bip
->bli_flags
& XFS_BLI_STALE
)
479 XFS_BUF_UNDELAYWRITE(bp
);
481 bip
->bli_flags
|= XFS_BLI_STALE
;
482 bip
->bli_flags
&= ~XFS_BLI_DIRTY
;
483 bip
->bli_format
.blf_flags
&= ~XFS_BLF_INODE_BUF
;
484 bip
->bli_format
.blf_flags
|= XFS_BLF_CANCEL
;
485 bip
->bli_item
.li_desc
->lid_flags
|= XFS_LID_DIRTY
;
486 tp
->t_flags
|= XFS_TRANS_DIRTY
;
494 xfs_buf_log_item_t
*bip
;
496 ASSERT(bp
->bp_transp
== NULL
);
498 fprintf(stderr
, "bjoin'd buffer %p, transaction %p\n", bp
, tp
);
501 xfs_buf_item_init(bp
, tp
->t_mountp
);
503 xfs_trans_add_item(tp
, (xfs_log_item_t
*)bip
);
512 xfs_buf_log_item_t
*bip
=bp
->b_fspriv
;
514 ASSERT(bp
->bp_transp
== tp
);
515 ASSERT(bp
->b_fspriv
!= NULL
);
517 fprintf(stderr
, "bhold'd buffer %p, transaction %p\n", bp
, tp
);
520 bip
->bli_flags
|= XFS_BLI_HOLD
;
524 libxfs_trans_get_buf_map(
526 struct xfs_buftarg
*btp
,
527 struct xfs_buf_map
*map
,
532 xfs_buf_log_item_t
*bip
;
535 return libxfs_getbuf_map(btp
, map
, nmaps
, 0);
537 bp
= xfs_trans_buf_item_match(tp
, btp
, map
, nmaps
);
539 ASSERT(bp
->bp_transp
== tp
);
546 bp
= libxfs_getbuf_map(btp
, map
, nmaps
, 0);
550 fprintf(stderr
, "trans_get_buf buffer %p, transaction %p\n", bp
, tp
);
553 xfs_buf_item_init(bp
, tp
->t_mountp
);
556 xfs_trans_add_item(tp
, (xfs_log_item_t
*)bip
);
558 /* initialize b_transp so we can find it incore */
570 xfs_buf_log_item_t
*bip
;
571 int len
= XFS_FSS_TO_BB(mp
, 1);
572 DEFINE_SINGLE_BUF_MAP(map
, XFS_SB_DADDR
, len
);
575 return libxfs_getsb(mp
, flags
);
577 bp
= xfs_trans_buf_item_match(tp
, mp
->m_dev
, &map
, 1);
579 ASSERT(bp
->bp_transp
== tp
);
586 bp
= libxfs_getsb(mp
, flags
);
588 fprintf(stderr
, "trans_get_sb buffer %p, transaction %p\n", bp
, tp
);
591 xfs_buf_item_init(bp
, mp
);
594 xfs_trans_add_item(tp
, (xfs_log_item_t
*)bip
);
596 /* initialize b_transp so we can find it incore */
602 libxfs_trans_read_buf_map(
605 struct xfs_buftarg
*btp
,
606 struct xfs_buf_map
*map
,
610 const struct xfs_buf_ops
*ops
)
613 xfs_buf_log_item_t
*bip
;
619 bp
= libxfs_readbuf_map(btp
, map
, nmaps
, flags
, ops
);
621 return (flags
& XBF_TRYLOCK
) ? -EAGAIN
: -ENOMEM
;
628 bp
= xfs_trans_buf_item_match(tp
, btp
, map
, nmaps
);
630 ASSERT(bp
->bp_transp
== tp
);
631 ASSERT(bp
->b_fspriv
!= NULL
);
637 bp
= libxfs_readbuf_map(btp
, map
, nmaps
, flags
, ops
);
639 return (flags
& XBF_TRYLOCK
) ? -EAGAIN
: -ENOMEM
;
645 fprintf(stderr
, "trans_read_buf buffer %p, transaction %p\n", bp
, tp
);
648 xfs_buf_item_init(bp
, tp
->t_mountp
);
651 xfs_trans_add_item(tp
, (xfs_log_item_t
*)bip
);
653 /* initialise b_transp so we can find it incore */
665 * Record the indicated change to the given field for application
666 * to the file system's superblock when the transaction commits.
667 * For now, just store the change in the transaction structure.
668 * Mark the transaction structure to indicate that the superblock
669 * needs to be updated before committing.
671 * Originally derived from xfs_trans_mod_sb().
680 case XFS_TRANS_SB_RES_FDBLOCKS
:
682 case XFS_TRANS_SB_FDBLOCKS
:
683 tp
->t_fdblocks_delta
+= delta
;
685 case XFS_TRANS_SB_ICOUNT
:
687 tp
->t_icount_delta
+= delta
;
689 case XFS_TRANS_SB_IFREE
:
690 tp
->t_ifree_delta
+= delta
;
692 case XFS_TRANS_SB_FREXTENTS
:
693 tp
->t_frextents_delta
+= delta
;
699 tp
->t_flags
|= (XFS_TRANS_SB_DIRTY
| XFS_TRANS_DIRTY
);
704 * Transaction commital code follows (i.e. write to disk in libxfs)
709 xfs_inode_log_item_t
*iip
)
718 mp
= iip
->ili_item
.li_mountp
;
721 if (!(iip
->ili_fields
& XFS_ILOG_ALL
)) {
722 ip
->i_transp
= NULL
; /* disassociate from transaction */
723 iip
->ili_flags
= 0; /* reset all flags */
728 * Get the buffer containing the on-disk inode.
730 error
= xfs_imap_to_bp(mp
, NULL
, &ip
->i_imap
, &dip
, &bp
, 0, 0);
732 fprintf(stderr
, _("%s: warning - imap_to_bp failed (%d)\n"),
738 error
= libxfs_iflush_int(ip
, bp
);
740 fprintf(stderr
, _("%s: warning - iflush_int failed (%d)\n"),
745 ip
->i_transp
= NULL
; /* disassociate from transaction */
746 bp
->b_fspriv
= NULL
; /* remove log item */
747 bp
->b_transp
= NULL
; /* remove xact ptr */
748 libxfs_writebuf(bp
, 0);
750 fprintf(stderr
, "flushing dirty inode %llu, buffer %p\n",
757 xfs_buf_log_item_t
*bip
)
761 extern kmem_zone_t
*xfs_buf_item_zone
;
765 bp
->b_fspriv
= NULL
; /* remove log item */
766 bp
->b_transp
= NULL
; /* remove xact ptr */
768 hold
= (bip
->bli_flags
& XFS_BLI_HOLD
);
769 if (bip
->bli_flags
& XFS_BLI_DIRTY
) {
771 fprintf(stderr
, "flushing/staling buffer %p (hold=%d)\n",
774 libxfs_writebuf_int(bp
, 0);
777 bip
->bli_flags
&= ~XFS_BLI_HOLD
;
780 /* release the buf item */
781 kmem_zone_free(xfs_buf_item_zone
, bip
);
788 struct xfs_log_item_desc
*lidp
, *next
;
790 list_for_each_entry_safe(lidp
, next
, &tp
->t_items
, lid_trans
) {
791 struct xfs_log_item
*lip
= lidp
->lid_item
;
793 xfs_trans_del_item(lip
);
795 if (lip
->li_type
== XFS_LI_BUF
)
796 buf_item_done((xfs_buf_log_item_t
*)lip
);
797 else if (lip
->li_type
== XFS_LI_INODE
)
798 inode_item_done((xfs_inode_log_item_t
*)lip
);
800 fprintf(stderr
, _("%s: unrecognised log item type\n"),
809 xfs_buf_log_item_t
*bip
)
811 xfs_buf_t
*bp
= bip
->bli_buf
;
814 /* Clear the buffer's association with this transaction. */
815 bip
->bli_buf
->b_transp
= NULL
;
817 hold
= bip
->bli_flags
& XFS_BLI_HOLD
;
818 bip
->bli_flags
&= ~XFS_BLI_HOLD
;
825 xfs_inode_log_item_t
*iip
)
827 xfs_inode_t
*ip
= iip
->ili_inode
;
829 /* Clear the transaction pointer in the inode. */
836 * Unlock all of the items of a transaction and free all the descriptors
837 * of that transaction.
840 xfs_trans_free_items(
841 struct xfs_trans
*tp
)
843 struct xfs_log_item_desc
*lidp
, *next
;
845 list_for_each_entry_safe(lidp
, next
, &tp
->t_items
, lid_trans
) {
846 struct xfs_log_item
*lip
= lidp
->lid_item
;
848 xfs_trans_del_item(lip
);
849 if (lip
->li_type
== XFS_LI_BUF
)
850 buf_item_unlock((xfs_buf_log_item_t
*)lip
);
851 else if (lip
->li_type
== XFS_LI_INODE
)
852 inode_item_unlock((xfs_inode_log_item_t
*)lip
);
854 fprintf(stderr
, _("%s: unrecognised log item type\n"),
862 * Commit the changes represented by this transaction
873 if (!(tp
->t_flags
& XFS_TRANS_DIRTY
)) {
875 fprintf(stderr
, "committed clean transaction %p\n", tp
);
877 xfs_trans_free_items(tp
);
882 if (tp
->t_flags
& XFS_TRANS_SB_DIRTY
) {
883 sbp
= &(tp
->t_mountp
->m_sb
);
884 if (tp
->t_icount_delta
)
885 sbp
->sb_icount
+= tp
->t_icount_delta
;
886 if (tp
->t_ifree_delta
)
887 sbp
->sb_ifree
+= tp
->t_ifree_delta
;
888 if (tp
->t_fdblocks_delta
)
889 sbp
->sb_fdblocks
+= tp
->t_fdblocks_delta
;
890 if (tp
->t_frextents_delta
)
891 sbp
->sb_frextents
+= tp
->t_frextents_delta
;
896 fprintf(stderr
, "committing dirty transaction %p\n", tp
);
900 /* That's it for the transaction structure. Free it. */