xfs: miscellaneous logging, recovery, umount fixes
PATCH v2 4/12 xfs: ensure EFD trans aborts on log recovery extent free failure
In reply to Brian FosterLog recovery attempts to free extents with leftover EFIs in the AIL after initial processing. If the extent free fails (e.g., due to unrelated fs corruption), the transaction is cancelled, though it might not be dirtied at the time. If this is the case, the EFD does not abort and thus does not release the EFI. This can lead to hangs as the EFI pins the AIL.
Update xlog_recover_process_efi() to log the EFD in the transaction before xfs_free_extent() errors are handled to ensure the transaction is dirty, aborts the EFD and releases the EFI on error. This is consistent with how EFDs are handled at runtime in xfs_bmap_finish().
--- fs/xfs/xfs_log_recover.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
fs/xfs/xfs_log_recover.c +7 -2
@@ -3779,11 +3779,16 @@ xlog_recover_process_efi(for (i =0 ; i < efip->efi_format.efi_nextents; i++) { extp = &(efip->efi_format.efi_extents[i]); +/* +* Log the EFD before error handling to ensure the EFD aborts +* (and releases the EFI) on error. +*/ error =xfs_free_extent (tp, extp->ext_start, extp->ext_len); -if (error) - goto abort_error;xfs_trans_log_efd_extent (tp, efdp, extp->ext_start, extp->ext_len); +if (error) + goto abort_error; + }set_bit (XFS_EFI_RECOVERED , &efip->efi_flags);
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 3/12 xfs: fix efi/efd error handling to avoid fs shutdown hangs
In reply to Brian FosterFreeing an extent in XFS involves logging an EFI (extent free intention), freeing the actual extent, and logging an EFD (extent free done). The EFI object is created with a reference count of 2: one for the current transaction and one for the subsequently created EFD. Under normal circumstances, the first reference is dropped when the EFI is unpinned and the second reference is dropped when the EFD is committed to the on-disk log.
In event of errors or filesystem shutdown, there are various potential cleanup scenarios depending on the state of the EFI/EFD. The cleanup scenarios are confusing and racy, as demonstrated by the following test sequence:
# mount $dev $mnt # fsstress -d $mnt -n 99999 -p 16 -z -f fallocate=1 \ -f punch=1 -f creat=1 -f unlink=1 & # sleep 5 # killall -9 fsstress; wait # godown -f $mnt # umount
... in which the final umount can hang due to the AIL being pinned indefinitely by one or more EFI items. This can occur due to several conditions. For example, if the shutdown occurs after the EFI is committed to the on-disk log and the EFD committed to the CIL, but before the EFD committed to the log, the EFD iop_committed() abort handler does not drop its reference to the EFI. Alternatively, manual error injection in the xfs_bmap_finish() codepath shows that if an error occurs after the EFI transaction is committed but before the EFD is constructed and logged, the EFI is never released from the AIL.
Update the EFI/EFD item handling code to use a more straightforward and reliable approach to error handling. If an error occurs after the EFI transaction is committed and before the EFD is constructed, release the EFI explicitly from xfs_bmap_finish(). If the EFI transaction is cancelled, release the EFI in the unlock handler.
Once the EFD is constructed, it is responsible for releasing the EFI under any circumstances (including whether the EFI item aborts due to log I/O error). Update the EFD item handlers to release the EFI if the transaction is cancelled or aborts due to log I/O error. Finally, update xfs_bmap_finish() to log at least one EFD extent to the transaction before xfs_free_extent() errors are handled to ensure the transaction is dirty and EFD item error handling is triggered.
--- fs/xfs/xfs_bmap_util.c | 84 +++++++++++++++++++++++++++-------------------- fs/xfs/xfs_extfree_item.c | 71 ++++++++++++++++++++++----------------- fs/xfs/xfs_extfree_item.h | 25 ++++++++++++-- 3 files changed, 112 insertions(+), 68 deletions(-)
fs/xfs/xfs_bmap_util.c +49 -35
@@ -67,16 +67,15 @@ xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb)*/ int /* error */ xfs_bmap_finish ( -xfs_trans_t **tp,/* transaction pointer addr */ -xfs_bmap_free_t *flist,/* i/o: list extents to free */ -int *committed)/* xact committed or not */ +struct xfs_trans **tp,/* transaction pointer addr */ +struct xfs_bmap_free *flist,/* i/o: list extents to free */ +int *committed)/* xact committed or not */ { -xfs_efd_log_item_t *efd;/* extent free data */ -xfs_efi_log_item_t *efi;/* extent free intention */ -int error;/* error return value */ -xfs_bmap_free_item_t *free;/* free extent item */ -xfs_mount_t *mp;/* filesystem mount structure */ -xfs_bmap_free_item_t *next;/* next item on free list */ +struct xfs_efd_log_item *efd;/* extent free data */ +struct xfs_efi_log_item *efi;/* extent free intention */ +int error;/* error return value */ +struct xfs_bmap_free_item *free;/* free extent item */ +struct xfs_bmap_free_item *next;/* next item on free list */ ASSERT ((*tp)->t_flags &XFS_TRANS_PERM_LOG_RES );if (flist->xbf_count ==0 ) {
@@ -88,40 +87,55 @@ xfs_bmap_finish(xfs_trans_log_efi_extent (*tp, efi, free->xbfi_startblock, free->xbfi_blockcount); - error =xfs_trans_roll (tp,NULL ); - *committed =1 ; -/* -* We have a new transaction, so we should return committed=1, -* even though we're returning an error. -*/ -if (error) + error =__xfs_trans_roll (tp,NULL , committed); +if (error) { +/* +* If the transaction was committed, drop the EFD reference +* since we're bailing out of here. The other reference is +* dropped when the EFI hits the AIL. +* +* If the transaction was not committed, the EFI is freed by the +* EFI item unlock handler on abort. Also, we have a new +* transaction so we should return committed=1 even though we're +* returning an error. +*/ +if (*committed) { +xfs_efi_release (efi); +xfs_force_shutdown ((*tp)->t_mountp, + (error == -EFSCORRUPTED ) ? +SHUTDOWN_CORRUPT_INCORE : +SHUTDOWN_META_IO_ERROR ); + }else { + *committed =1 ; + } +return error; + } efd =xfs_trans_get_efd (*tp, efi, flist->xbf_count);for (free = flist->xbf_first; free !=NULL ; free = next) { next = free->xbfi_next; -if ((error =xfs_free_extent (*tp, free->xbfi_startblock, - free->xbfi_blockcount))) { -/* -* The bmap free list will be cleaned up at a -* higher level. The EFI will be canceled when -* this transaction is aborted. -* Need to force shutdown here to make sure it -* happens, since this transaction may not be -* dirty yet. -*/ - mp = (*tp)->t_mountp; -if (!XFS_FORCED_SHUTDOWN (mp)) -xfs_force_shutdown (mp, - (error == -EFSCORRUPTED ) ? -SHUTDOWN_CORRUPT_INCORE : -SHUTDOWN_META_IO_ERROR ); -return error; - } + +/* +* Free the extent and log the EFD to dirty the transaction +* before handling errors. This ensures that the transaction is +* aborted, which: +* +* 1.) releases the EFI and frees the EFD +* 2.) shuts down the filesystem +* +* The bmap free list is cleaned up at a higher level. +*/ + error =xfs_free_extent (*tp, free->xbfi_startblock, + free->xbfi_blockcount);xfs_trans_log_efd_extent (*tp, efd, free->xbfi_startblock, - free->xbfi_blockcount); + free->xbfi_blockcount); +if (error) +return error; +xfs_bmap_del_free (flist,NULL , free); } +return 0 ; }
fs/xfs/xfs_extfree_item.c +41 -30
116 lines not on this page · raw message
fs/xfs/xfs_extfree_item.h +22 -3
@@ -39,9 +39,28 @@ struct kmem_zone;* "extent free done" log item described below. * * The EFI is reference counted so that it is not freed prior to both the EFI -* and EFD being committed and unpinned. This ensures that when the last -* reference goes away the EFI will always be in the AIL as it has been -* unpinned, regardless of whether the EFD is processed before or after the EFI. +* and EFD being committed and unpinned. This ensures the EFI is inserted into +* the AIL even in the event of out of order EFI/EFD processing. In other words, +* an EFI is born with two references: +* +* 1.) an EFI held reference to track EFI AIL insertion +* 2.) an EFD held reference to track EFD commit +* +* On allocation, both references are the responsibility of the caller. Once the +* EFI is added to and dirtied in a transaction, ownership of reference one +* transfers to the transaction. The reference is dropped once the EFI is +* inserted to the AIL or in the event of failure along the way (e.g., commit +* failure, log I/O error, etc.). Note that the caller remains responsible for +* the EFD reference under all circumstances to this point. The caller has no +* means to detect failure once the transaction is committed, however. +* Therefore, an EFD is required after this point, even in the event of +* unrelated failure. +* +* Once an EFD is allocated and dirtied in a transaction, reference two +* transfers to the transaction. The EFD reference is dropped once it reaches +* the unpin handler. Similar to the EFI, the reference also drops in the event +* of commit failure or log I/O errors. Note that the EFD is not inserted in the +* AIL, so at this point both the EFI and EFD are freed. */ typedef struct xfs_efi_log_item { xfs_log_item_t efi_item;
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 6/12 xfs: don't leave EFIs on AIL on mount failure
In reply to Brian FosterLog recovery occurs in two phases at mount time. In the first phase, EFIs and EFDs are processed and potentially cancelled out. EFIs without EFD objects are inserted into the AIL for processing and recovery in the second phase. xfs_mountfs() runs various other operations between the phases and is thus subject to failure. If failure occurs after the first phase but before the second, pending EFIs sit on the AIL, pin it and cause the mount to hang.
Update the mount sequence to ensure that pending EFIs are cancelled in the event of failure. Add a recovery cancellation mechanism to iterate the AIL and cancel all EFI items when requested. Plumb cancellation support through the log mount finish helper and update xfs_mountfs() to invoke cancellation in the event of failure after recovery has started.
--- fs/xfs/xfs_log.c | 30 ++++++++++++++++++----- fs/xfs/xfs_log.h | 1 + fs/xfs/xfs_log_priv.h | 2 ++ fs/xfs/xfs_log_recover.c | 63 +++++++++++++++++++++++++++++++++++++++++++++--- fs/xfs/xfs_mount.c | 26 +++++++++++--------- 5 files changed, 100 insertions(+), 22 deletions(-)
fs/xfs/xfs_log.c +24 -6
@@ -700,6 +700,7 @@ xfs_log_mount(if (error) {xfs_warn (mp,"log mount/recovery failed: error %d" , error); +xlog_recover_cancel (mp->m_log); goto out_destroy_ail; } }
@@ -740,18 +741,35 @@ out:* it. */ int -xfs_log_mount_finish (xfs_mount_t *mp) +xfs_log_mount_finish ( +struct xfs_mount *mp) {int error =0 ; -if (!(mp->m_flags &XFS_MOUNT_NORECOVERY )) { - error =xlog_recover_finish (mp->m_log); -if (!error) -xfs_log_work_queue (mp); - }else { +if (mp->m_flags &XFS_MOUNT_NORECOVERY ) {ASSERT (mp->m_flags &XFS_MOUNT_RDONLY ); +return 0 ; } + error =xlog_recover_finish (mp->m_log); +if (!error) +xfs_log_work_queue (mp); + +return error; +} + +/* +* The mount has failed. Cancel the recovery if it hasn't completed and destroy +* the log. +*/ +int +xfs_log_mount_cancel ( +struct xfs_mount *mp) +{ +int error; + + error =xlog_recover_cancel (mp->m_log); +xfs_log_unmount (mp);return error; }
fs/xfs/xfs_log.h +1 -0
@@ -147,6 +147,7 @@ int xfs_log_mount(struct xfs_mount *mp,xfs_daddr_t start_block, int num_bblocks);int xfs_log_mount_finish (struct xfs_mount *mp); +int xfs_log_mount_cancel (struct xfs_mount *);xfs_lsn_t xlog_assign_tail_lsn (struct xfs_mount *mp);xfs_lsn_t xlog_assign_tail_lsn_locked (struct xfs_mount *mp);void xfs_log_space_wake (struct xfs_mount *mp);
fs/xfs/xfs_log_priv.h +2 -0
@@ -426,6 +426,8 @@ xlog_recover(extern int xlog_recover_finish (struct xlog *log); +extern int +xlog_recover_cancel (struct xlog *);extern __le32 xlog_cksum (struct xlog *log,struct xlog_rec_header *rhead,char *dp,int size);
fs/xfs/xfs_log_recover.c +59 -4
88 lines not on this page · raw message
fs/xfs/xfs_mount.c +14 -12
@@ -615,14 +615,14 @@ xfs_default_resblks(xfs_mount_t *mp)*/ int xfs_mountfs ( -xfs_mount_t *mp) +struct xfs_mount *mp) { -xfs_sb_t *sbp = &(mp->m_sb); -xfs_inode_t *rip; -__uint64_t resblks; -uint quotamount =0 ; -uint quotaflags =0 ; -int error =0 ; +struct xfs_sb *sbp = &(mp->m_sb); +struct xfs_inode *rip; +__uint64_t resblks; +uint quotamount =0 ; +uint quotaflags =0 ; +int error =0 ;xfs_sb_mount_common (mp, sbp);
@@ -799,7 +799,9 @@ xfs_mountfs( }/* -* log's mount-time initialization. Perform 1st part recovery if needed +* Log's mount-time initialization. The first part of recovery can place +* some items on the AIL, to be handled when recovery is finished or +* cancelled. */ error = xfs_log_mount(mp, mp->m_logdev_targp, XFS_FSB_TO_DADDR(mp, sbp->sb_logstart),
@@ -910,9 +912,9 @@ xfs_mountfs( }/* -* Finish recovering the file system. This part needed to be -* delayed until after the root and real-time bitmap inodes -* were consistently read in. +* Finish recovering the file system. This part needed to be delayed +* until after the root and real-time bitmap inodes were consistently +* read in. */ error =xfs_log_mount_finish (mp);if (error) {
@@ -956,7 +958,7 @@ xfs_mountfs( out_rele_rip:IRELE (rip); out_log_dealloc: -xfs_log_unmount (mp); +xfs_log_mount_cancel (mp); out_fail_wait:if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)xfs_wait_buftarg (mp->m_logdev_targp);
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 8/12 xfs: fix broken icreate log item cancellation
In reply to Brian FosterInode cluster buffers are invalidated and cancelled when inode chunks are freed to notify log recovery that previous logged updates to the metadata buffer should be skipped. This ensures that log recovery does not overwrite buffers that might have already been reused.
On v4 filesystems, inode chunk allocation and inode updates are logged via the cluster buffers and thus cancellation is easily detected via buffer cancellation items. v5 filesystems use the new icreate transaction, which uses logical logging and ordered buffers to log a full inode chunk allocation at once. The resulting icreate item often spans multiple inode cluster buffers.
Log recovery checks for cancelled buffers when processing icreate log items, but it has a couple problems. First, it uses the full length of the inode chunk rather than the cluster size. Second, it uses the length in FSB units rather than BB units. Either of these problems prevent icreate recovery from identifying cancelled buffers and thus inode initialization proceeds unconditionally.
Update xlog_recover_do_icreate_pass2() to iterate the icreate range in cluster sized increments and check each increment for cancellation. Since icreate is currently only used for the minimum atomic inode chunk allocation, we expect that either all or none of the buffers will be cancelled. Cancel the icreate if at least one buffer is cancelled to avoid making a bad situation worse by initializing a partial inode chunk, but detect such anomalies and warn the user.
--- fs/xfs/xfs_log_recover.c | 49 ++++++++++++++++++++++++++++++++++++------------ 1 file changed, 37 insertions(+), 12 deletions(-)
fs/xfs/xfs_log_recover.c +37 -12
@@ -3037,6 +3037,11 @@ xlog_recover_do_icreate_pass2(unsigned int count;unsigned int isize;xfs_agblock_t length; +int blks_per_cluster; +int bb_per_cluster; +int cancel_count; +int nbufs; +int i; icl = (struct xfs_icreate_log *)item->ri_buf[0 ].i_addr;if (icl->icl_type !=XFS_LI_ICREATE ) {
@@ -3095,25 +3100,45 @@ xlog_recover_do_icreate_pass2( }/* -* Inode buffers can be freed. Do not replay the inode initialisation as -* we could be overwriting something written after this inode buffer was -* cancelled. +* The icreate transaction can cover multiple cluster buffers and these +* buffers could have been freed and reused. Check the individual +* buffers for cancellation so we don't overwrite anything written after +* a cancellation. +*/ + blks_per_cluster =xfs_icluster_size_fsb (mp); + bb_per_cluster =XFS_FSB_TO_BB (mp, blks_per_cluster); + nbufs = length / blks_per_cluster; +for (i =0 , cancel_count =0 ; i < nbufs; i++) { +xfs_daddr_t daddr; + + daddr =XFS_AGB_TO_DADDR (mp, agno, + agbno + i * blks_per_cluster); +if (xlog_check_buffer_cancelled (log, daddr, bb_per_cluster,0 )) + cancel_count++; + } + +/* +* We currently only use icreate for a single allocation at a time. This +* means we should expect either all or none of the buffers to be +* cancelled. Be conservative and skip replay if at least one buffer is +* cancelled, but warn the user that something is awry if the buffers +* are not consistent. * -* XXX: we need to iterate all buffers and only init those that are not -* cancelled. I think that a more fine grained factoring of -* xfs_ialloc_inode_init may be appropriate here to enable this to be -* done easily. +* XXX: This must be refined to only skip cancelled clusters once we use +* icreate for multiple chunk allocations. */ -if (xlog_check_buffer_cancelled (log, -XFS_AGB_TO_DADDR (mp, agno, agbno), length,0 )) { +ASSERT (!cancel_count || cancel_count == nbufs); +if (cancel_count) { +if (cancel_count != nbufs) +xfs_warn (mp, +"WARNING: partial inode chunk cancellation, skipped icreate." );trace_xfs_log_recover_icreate_cancel (log, icl);return 0 ; }trace_xfs_log_recover_icreate_recover (log, icl); -xfs_ialloc_inode_init (mp,NULL , buffer_list, count, agno, agbno, length, -be32_to_cpu (icl->icl_gen)); -return 0 ; +return xfs_ialloc_inode_init (mp,NULL , buffer_list, count, agno, agbno, + length,be32_to_cpu (icl->icl_gen)); }STATIC void
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 10/12 xfs: clean up root inode properly on mount failure
In reply to Brian FosterThe root inode is read as part of the xfs_mountfs() sequence and the reference is dropped in the event of failure after we grab the inode. The reference drop doesn't necessarily free the inode, however. It marks it for reclaim and potentially kicks off the reclaim workqueue. The workqueue is destroyed further up the error path, which means we are subject to crash if the workqueue job runs after this point or a memory leak which is identified if the xfs_inode_zone is destroyed (e.g., on module removal). Both of these outcomes are reproducible via manual instrumentation of a mount error after the root inode xfs_iget() call in xfs_mountfs().
Update the xfs_mountfs() error path to cancel any potential reclaim work items and to run a synchronous inode reclaim if the root inode is marked for reclaim. This ensures that no jobs remain on the queue before it is destroyed and that the root inode is freed before the reclaim mechanism is torn down.
--- fs/xfs/xfs_mount.c | 2 ++ 1 file changed, 2 insertions(+)
fs/xfs/xfs_mount.c +2 -0
@@ -957,6 +957,8 @@ xfs_mountfs(xfs_rtunmount_inodes (mp); out_rele_rip:IRELE (rip); +cancel_delayed_work_sync (&mp->m_reclaim_work); +xfs_reclaim_inodes (mp,SYNC_WAIT ); out_log_dealloc:xfs_log_mount_cancel (mp); out_fail_wait:
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 11/12 xfs: fix btree cursor error cleanups
In reply to Brian FosterThe btree cursor cleanup function takes an error parameter that affects how buffers are released from the cursor. All buffers are released in the event of error. Several callers do not specify the XFS_BTREE_ERROR flag in the event of error, however. This can cause buffers to hang around locked or with an elevated hold count and thus lead to umount hangs in the event of errors.
Fix up the xfs_btree_del_cursor() callers to pass XFS_BTREE_ERROR if the cursor is being torn down due to error.
--- fs/xfs/libxfs/xfs_ialloc.c | 2 +- fs/xfs/xfs_itable.c | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_ialloc.c +1 -1
@@ -2233,7 +2233,7 @@ xfs_imap_lookup( }xfs_trans_brelse (tp, agbp); -xfs_btree_del_cursor (cur,XFS_BTREE_NOERROR ); +xfs_btree_del_cursor (cur, error ?XFS_BTREE_ERROR :XFS_BTREE_NOERROR );if (error)return error;
fs/xfs/xfs_itable.c +2 -1
@@ -473,7 +473,8 @@ xfs_bulkstat(* pending error, then we are done. */ del_cursor: -xfs_btree_del_cursor (cur,XFS_BTREE_NOERROR ); +xfs_btree_del_cursor (cur, error ? +XFS_BTREE_ERROR :XFS_BTREE_NOERROR );xfs_buf_relse (agbp);if (error)break ;
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 5/12 xfs: use EFI refcount consistently in log recovery
In reply to Brian FosterThe EFI is initialized with a reference count of 2. One for the EFI to ensure the item makes it to the AIL and one for the subsequently created EFD to release the EFI once the EFD is committed. Log recovery uses the EFI in a similar manner, but implements a hack to remove both references in one call once the EFD is handled.
Update log recovery to use EFI reference counting in a manner consistent with the log. When an EFI is encountered during recovery, an EFI item is allocated and inserted to the AIL directly. Since the EFI reference is typically dropped when the EFI is unpinned and this is analogous with AIL insertion, drop the EFI reference at this point.
When a corresponding EFD is encountered in the log, this indicates that the extents were freed, no processing is required and the EFI can be dropped. Update xlog_recover_efd_pass2() to simply drop the EFD reference at this point rather than open code the AIL removal and EFI free.
Remaining EFIs (i.e., with no corresponding EFD) are processed in xlog_recover_finish(). An EFD transaction is allocated and the extents are freed, which transfers ownership of the EFI reference to the EFD item in the log.
--- fs/xfs/xfs_extfree_item.c | 57 +++++++++++++++++------------------------------ fs/xfs/xfs_log_recover.c | 43 ++++++++++++++++++----------------- 2 files changed, 43 insertions(+), 57 deletions(-)
fs/xfs/xfs_extfree_item.c +20 -37
@@ -47,34 +47,6 @@ xfs_efi_item_free( }/* -* Freeing the efi requires that we remove it from the AIL if it has already -* been placed there. However, the EFI may not yet have been placed in the AIL -* when called by xfs_efi_release() from EFD processing due to the ordering of -* committed vs unpin operations in bulk insert operations. Hence the reference -* count to ensure only the last caller frees the EFI. -*/ -STATIC void -__xfs_efi_release ( -struct xfs_efi_log_item *efip) -{ -struct xfs_ail *ailp = efip->efi_item.li_ailp; - -if (atomic_dec_and_test (&efip->efi_refcount)) { -spin_lock (&ailp->xa_lock); -/* -* We don't know whether the EFI made it to the AIL. Remove it -* if so. Note that xfs_trans_ail_delete() drops the AIL lock. -*/ -if (efip->efi_item.li_flags &XFS_LI_IN_AIL ) -xfs_trans_ail_delete (ailp, &efip->efi_item, -SHUTDOWN_LOG_IO_ERROR ); -else -spin_unlock (&ailp->xa_lock); -xfs_efi_item_free (efip); - } -} - -/* * This returns the number of iovecs needed to log the given efi item. * We only need 1 iovec for an efi item. It just logs the efi_log_format * structure.
@@ -304,20 +276,31 @@ xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt) }/* -* This is called by the efd item code below to release references to the given -* efi item. Each efd calls this with the number of extents that it has -* logged, and when the sum of these reaches the total number of extents logged -* by this efi item we can free the efi item. +* Freeing the efi requires that we remove it from the AIL if it has already +* been placed there. However, the EFI may not yet have been placed in the AIL +* when called by xfs_efi_release() from EFD processing due to the ordering of +* committed vs unpin operations in bulk insert operations. Hence the reference +* count to ensure only the last caller frees the EFI. */ void xfs_efi_release (struct xfs_efi_log_item *efip) { -/* recovery needs us to drop the EFI reference, too */ -if (test_bit (XFS_EFI_RECOVERED , &efip->efi_flags)) -__xfs_efi_release (efip); +struct xfs_ail *ailp = efip->efi_item.li_ailp; -__xfs_efi_release (efip); -/* efip may now have been freed, do not reference it again. */ +if (atomic_dec_and_test (&efip->efi_refcount)) { +spin_lock (&ailp->xa_lock); +/* +* We don't know whether the EFI made it to the AIL. Remove it +* if so. Note that xfs_trans_ail_delete() drops the AIL lock. +*/ +if (efip->efi_item.li_flags &XFS_LI_IN_AIL ) +xfs_trans_ail_delete (ailp, &efip->efi_item, +SHUTDOWN_LOG_IO_ERROR ); +else +spin_unlock (&ailp->xa_lock); + +xfs_efi_item_free (efip); + } }static inline struct xfs_efd_log_item *EFD_ITEM (struct xfs_log_item *lip)
fs/xfs/xfs_log_recover.c +23 -20
85 lines not on this page · raw message
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 12/12 xfs: add helper to conditionally remove items from the AIL
In reply to Brian FosterSeveral areas of code duplicate a pattern where we take the AIL lock, check whether an item is in the AIL and remove it if so. Create a new helper for this pattern and use it where appropriate.
--- fs/xfs/xfs_buf_item.c | 7 ++----- fs/xfs/xfs_dquot.c | 8 ++------ fs/xfs/xfs_extfree_item.c | 13 ++----------- fs/xfs/xfs_inode_item.c | 10 ++-------- fs/xfs/xfs_trans_priv.h | 14 ++++++++++++++ 5 files changed, 22 insertions(+), 30 deletions(-)
fs/xfs/xfs_buf_item.c +2 -5
@@ -647,11 +647,8 @@ xfs_buf_item_unlock(xfs_buf_item_relse (bp); else if (aborted) {ASSERT (XFS_FORCED_SHUTDOWN (lip->li_mountp)); -if (lip->li_flags &XFS_LI_IN_AIL ) { -spin_lock (&lip->li_ailp->xa_lock); -xfs_trans_ail_delete (lip->li_ailp, lip, -SHUTDOWN_LOG_IO_ERROR ); - } +xfs_trans_ail_remove (lip->li_ailp, lip, +SHUTDOWN_LOG_IO_ERROR );xfs_buf_item_relse (bp); } }
fs/xfs/xfs_dquot.c +2 -6
@@ -954,12 +954,8 @@ xfs_qm_dqflush(struct xfs_log_item *lip = &dqp->q_logitem.qli_item; dqp->dq_flags &= ~XFS_DQ_DIRTY ; -spin_lock (&mp->m_ail->xa_lock); -if (lip->li_flags &XFS_LI_IN_AIL ) -xfs_trans_ail_delete (mp->m_ail, lip, -SHUTDOWN_CORRUPT_INCORE ); -else -spin_unlock (&mp->m_ail->xa_lock); +xfs_trans_ail_remove (mp->m_ail, lip,SHUTDOWN_CORRUPT_INCORE ); + error = -EIO ; goto out_unlock; }
fs/xfs/xfs_extfree_item.c +2 -11
@@ -288,17 +288,8 @@ xfs_efi_release(struct xfs_efi_log_item *efip)struct xfs_ail *ailp = efip->efi_item.li_ailp;if (atomic_dec_and_test (&efip->efi_refcount)) { -spin_lock (&ailp->xa_lock); -/* -* We don't know whether the EFI made it to the AIL. Remove it -* if so. Note that xfs_trans_ail_delete() drops the AIL lock. -*/ -if (efip->efi_item.li_flags &XFS_LI_IN_AIL ) -xfs_trans_ail_delete (ailp, &efip->efi_item, -SHUTDOWN_LOG_IO_ERROR ); -else -spin_unlock (&ailp->xa_lock); - +xfs_trans_ail_remove (ailp, &efip->efi_item, +SHUTDOWN_LOG_IO_ERROR );xfs_efi_item_free (efip); } }
fs/xfs/xfs_inode_item.c +2 -8
@@ -705,15 +705,9 @@ xfs_iflush_abort(if (iip) {struct xfs_ail *ailp = iip->ili_item.li_ailp;if (iip->ili_item.li_flags &XFS_LI_IN_AIL ) { -spin_lock (&ailp->xa_lock); -if (iip->ili_item.li_flags &XFS_LI_IN_AIL ) { -/* xfs_trans_ail_delete() drops the AIL lock. */ -xfs_trans_ail_delete (ailp, &iip->ili_item, - stale ? -SHUTDOWN_LOG_IO_ERROR : +xfs_trans_ail_remove (ailp, &iip->ili_item, + stale ?SHUTDOWN_LOG_IO_ERROR :SHUTDOWN_CORRUPT_INCORE ); - }else -spin_unlock (&ailp->xa_lock); } iip->ili_logged =0 ;/*
fs/xfs/xfs_trans_priv.h +14 -0
@@ -119,6 +119,20 @@ xfs_trans_ail_delete(xfs_trans_ail_delete_bulk (ailp, &lip,1 , shutdown_type); } +static inline void +xfs_trans_ail_remove ( +struct xfs_ail *ailp, +struct xfs_log_item *lip, +int shutdown_type) +{ +spin_lock (&ailp->xa_lock); +/* xfs_trans_ail_delete() drops the AIL lock */ +if (lip->li_flags &XFS_LI_IN_AIL ) +xfs_trans_ail_delete (ailp, lip, shutdown_type); +else +spin_unlock (&ailp->xa_lock); +} +void xfs_ail_push (struct xfs_ail *,xfs_lsn_t );void xfs_ail_push_all (struct xfs_ail *);void xfs_ail_push_all_sync (struct xfs_ail *);
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 2/12 xfs: return committed status from xfs_trans_roll()
In reply to Brian FosterSome callers need to make error handling decisions based on whether the current transaction successfully committed or not. Rename xfs_trans_roll(), add a new parameter and provide a wrapper to preserve existing callers.
--- fs/xfs/xfs_trans.c | 15 +++++++++++++-- fs/xfs/xfs_trans.h | 1 + 2 files changed, 14 insertions(+), 2 deletions(-)
fs/xfs/xfs_trans.c +13 -2
@@ -1019,9 +1019,10 @@ xfs_trans_cancel(* chunk we've been working on and get a new transaction to continue. */ int -xfs_trans_roll ( +__xfs_trans_roll (struct xfs_trans **tpp, -struct xfs_inode *dp) +struct xfs_inode *dp, +int *committed) {struct xfs_trans *trans;struct xfs_trans_res tres;
@@ -1052,6 +1053,7 @@ xfs_trans_roll(if (error)return error; + *committed =1 ; trans = *tpp;/*
@@ -1074,3 +1076,12 @@ xfs_trans_roll(xfs_trans_ijoin (trans, dp,0 );return 0 ; } + +int +xfs_trans_roll ( +struct xfs_trans **tpp, +struct xfs_inode *dp) +{ +int committed =0 ; +return __xfs_trans_roll (tpp, dp, &committed); +}
fs/xfs/xfs_trans.h +1 -0
@@ -225,6 +225,7 @@ void xfs_trans_log_efd_extent(xfs_trans_t *, xfs_fsblock_t, xfs_extlen_t);int xfs_trans_commit (struct xfs_trans *); +int __xfs_trans_roll (struct xfs_trans **,struct xfs_inode *,int *);int xfs_trans_roll (struct xfs_trans **,struct xfs_inode *);void xfs_trans_cancel (xfs_trans_t *);int xfs_trans_ail_init (struct xfs_mount *);
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
v2 cover xfs: miscellaneous logging, recovery, umount fixes
Hi all,
Here's v2 of the EFI/EFD and miscellaneous log fixes series. Patch 12 is added based on a suggestion from Dave in the v1 comments. Otherwise, most of the changes are in patch 6 where the APIs for log recovery cancellation are shuffled around a bit. Note that I retained the xlog_recovery_finish() helper rather than replace it because there is another caller in this version that addresses a memory leak (plus it seems consistent with the xlog_recovery_finish() interface).
Brian
v2:
- Added new comment around EFI/EFD refcount rules.
- Appended patch 12 to clean up AIL item removal.
- Reworked log recovery EFI cancellation APIs.
- Invoke EFI cancellation within xfs_log_mount() on failure to prevent memory leak.
v1: http://oss.sgi.com/pipermail/xfs/2015-August/042877.html
- Updated EFI/EFD tracking semantics based on rfc comments.
- Added more cleanups/fixes to series.
rfc: http://oss.sgi.com/pipermail/xfs/2015-July/042617.html
Brian Foster (12):
xfs: disentagle EFI release from the extent count
xfs: return committed status from xfs_trans_roll()
xfs: fix efi/efd error handling to avoid fs shutdown hangs
xfs: ensure EFD trans aborts on log recovery extent free failure
xfs: use EFI refcount consistently in log recovery
xfs: don't leave EFIs on AIL on mount failure
xfs: icreate log item recovery and cancellation tracepoints
xfs: fix broken icreate log item cancellation
xfs: checksum log record ext headers based on record size
xfs: clean up root inode properly on mount failure
xfs: fix btree cursor error cleanups
xfs: add helper to conditionally remove items from the AIL
fs/xfs/libxfs/xfs_ialloc.c | 2 +- fs/xfs/xfs_bmap_util.c | 84 ++++++++++++---------- fs/xfs/xfs_buf_item.c | 7 +- fs/xfs/xfs_dquot.c | 8 +-- fs/xfs/xfs_extfree_item.c | 109 ++++++++++++----------------- fs/xfs/xfs_extfree_item.h | 26 ++++++- fs/xfs/xfs_inode_item.c | 10 +-- fs/xfs/xfs_itable.c | 3 +- fs/xfs/xfs_log.c | 37 ++++++++-- fs/xfs/xfs_log.h | 1 + fs/xfs/xfs_log_priv.h | 2 + fs/xfs/xfs_log_recover.c | 169 ++++++++++++++++++++++++++++++++++----------- fs/xfs/xfs_mount.c | 28 ++++---- fs/xfs/xfs_trace.h | 34 +++++++++ fs/xfs/xfs_trans.c | 15 +++- fs/xfs/xfs_trans.h | 2 +- fs/xfs/xfs_trans_priv.h | 14 ++++ 17 files changed, 367 insertions(+), 184 deletions(-)
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 1/12 xfs: disentagle EFI release from the extent count
Release of the EFI either occurs based on the reference count or the extent count. The extent count used is either the count tracked in the EFI or EFD, depending on the particular situation. In either case, the count is initialized to the final value and thus always matches the current efi_next_extent value once the EFI is completely constructed.
Given this along with the fact that the EFI is always completely constructed before error can occur, eliminate the unnecessary extent count manipulation and release the EFI directly based on reference count. The efi_next_extent counter remains because it is still used to track the slot to log the next extent to free.
--- fs/xfs/xfs_extfree_item.c | 20 ++++++++------------ fs/xfs/xfs_extfree_item.h | 1 + fs/xfs/xfs_log_recover.c | 2 +- fs/xfs/xfs_trans.h | 1 - 4 files changed, 10 insertions(+), 14 deletions(-)
fs/xfs/xfs_extfree_item.c +8 -12
@@ -149,7 +149,7 @@ xfs_efi_item_unpin(xfs_efi_item_free (efip);return ; } -__xfs_efi_release (efip); +xfs_efi_release (efip); }/*
@@ -307,18 +307,14 @@ xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt)* by this efi item we can free the efi item. */ void -xfs_efi_release (xfs_efi_log_item_t *efip, -uint nextents) +xfs_efi_release (struct xfs_efi_log_item *efip) { -ASSERT (atomic_read (&efip->efi_next_extent) >= nextents); -if (atomic_sub_and_test (nextents, &efip->efi_next_extent)) { -/* recovery needs us to drop the EFI reference, too */ -if (test_bit (XFS_EFI_RECOVERED , &efip->efi_flags)) -__xfs_efi_release (efip); - +/* recovery needs us to drop the EFI reference, too */ +if (test_bit (XFS_EFI_RECOVERED , &efip->efi_flags))__xfs_efi_release (efip); -/* efip may now have been freed, do not reference it again. */ - } + +__xfs_efi_release (efip); +/* efip may now have been freed, do not reference it again. */ }static inline struct xfs_efd_log_item *EFD_ITEM (struct xfs_log_item *lip)
@@ -442,7 +438,7 @@ xfs_efd_item_committed(* EFI got unpinned and freed before the EFD got aborted. */ if (!(lip->li_flags &XFS_LI_ABORTED )) -xfs_efi_release (efdp->efd_efip, efdp->efd_format.efd_nextents); +xfs_efi_release (efdp->efd_efip);xfs_efd_item_free (efdp);return (xfs_lsn_t)-1 ;
fs/xfs/xfs_extfree_item.h +1 -0
@@ -77,5 +77,6 @@ xfs_efd_log_item_t *xfs_efd_init(struct xfs_mount *, xfs_efi_log_item_t *,int xfs_efi_copy_format (xfs_log_iovec_t *buf,xfs_efi_log_format_t *dst_efi_fmt);void xfs_efi_item_free (xfs_efi_log_item_t *); +void xfs_efi_release (struct xfs_efi_log_item *);#endif /* __XFS_EXTFREE_ITEM_H__ */
fs/xfs/xfs_log_recover.c +1 -1
@@ -3766,7 +3766,7 @@ xlog_recover_process_efi(* free the memory associated with it. */ set_bit (XFS_EFI_RECOVERED , &efip->efi_flags); -xfs_efi_release (efip, efip->efi_format.efi_nextents); +xfs_efi_release (efip);return -EIO ; } }
fs/xfs/xfs_trans.h +0 -1
@@ -213,7 +213,6 @@ void xfs_trans_ijoin(struct xfs_trans *, struct xfs_inode *, uint);void xfs_trans_log_buf (xfs_trans_t *,struct xfs_buf *,uint ,uint );void xfs_trans_log_inode (xfs_trans_t *,struct xfs_inode *,uint );struct xfs_efi_log_item *xfs_trans_get_efi (xfs_trans_t *,uint ); -void xfs_efi_release (struct xfs_efi_log_item *,uint ); void xfs_trans_log_efi_extent(xfs_trans_t *, struct xfs_efi_log_item *, xfs_fsblock_t,
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 7/12 xfs: icreate log item recovery and cancellation tracepoints
In reply to Brian FosterVarious log items have recovery tracepoints to identify whether a particular log item is recovered or cancelled. Add the equivalent tracepoints for the icreate transaction.
--- fs/xfs/xfs_log_recover.c | 5 ++++- fs/xfs/xfs_trace.h | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 38 insertions(+), 1 deletion(-)
fs/xfs/xfs_log_recover.c +4 -1
@@ -3105,9 +3105,12 @@ xlog_recover_do_icreate_pass2(* done easily. */ if (xlog_check_buffer_cancelled (log, -XFS_AGB_TO_DADDR (mp, agno, agbno), length,0 )) +XFS_AGB_TO_DADDR (mp, agno, agbno), length,0 )) { +trace_xfs_log_recover_icreate_cancel (log, icl);return 0 ; + } +trace_xfs_log_recover_icreate_recover (log, icl);xfs_ialloc_inode_init (mp,NULL , buffer_list, count, agno, agbno, length,be32_to_cpu (icl->icl_gen));return 0 ;
fs/xfs/xfs_trace.h +34 -0
@@ -2089,6 +2089,40 @@ DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_recover);DEFINE_LOG_RECOVER_INO_ITEM (xfs_log_recover_inode_cancel);DEFINE_LOG_RECOVER_INO_ITEM (xfs_log_recover_inode_skip); +DECLARE_EVENT_CLASS (xfs_log_recover_icreate_item_class, + TP_PROTO(struct xlog *log, struct xfs_icreate_log *in_f), +TP_ARGS (log, in_f), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_agnumber_t, agno) + __field(xfs_agblock_t, agbno) + __field(unsigned int, count) + __field(unsigned int, isize) + __field(xfs_agblock_t, length) + __field(unsigned int, gen) + ), +TP_fast_assign ( + __entry->dev = log->l_mp->m_super->s_dev; + __entry->agno = be32_to_cpu(in_f->icl_ag); + __entry->agbno = be32_to_cpu(in_f->icl_agbno); + __entry->count = be32_to_cpu(in_f->icl_count); + __entry->isize = be32_to_cpu(in_f->icl_isize); + __entry->length = be32_to_cpu(in_f->icl_length); + __entry->gen = be32_to_cpu(in_f->icl_gen); + ), +TP_printk ("dev %d:%d agno %u agbno %u count %u isize %u length %u " +"gen %u" ,MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->agno, __entry->agbno, __entry->count, __entry->isize, + __entry->length, __entry->gen) +) +#define DEFINE_LOG_RECOVER_ICREATE_ITEM (name) \ +DEFINE_EVENT(xfs_log_recover_icreate_item_class, name, \ + TP_PROTO(struct xlog *log, struct xfs_icreate_log *in_f), \ + TP_ARGS(log, in_f)) + +DEFINE_LOG_RECOVER_ICREATE_ITEM (xfs_log_recover_icreate_cancel); +DEFINE_LOG_RECOVER_ICREATE_ITEM (xfs_log_recover_icreate_recover); + DECLARE_EVENT_CLASS(xfs_discard_class, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno, xfs_extlen_t len),
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 9/12 xfs: checksum log record ext headers based on record size
In reply to Brian FosterThe first 4 bytes of every basic block in the physical log is stamped with the current lsn. To support this mechanism, the log record header (first block of each new log record) contains space for the original first byte of each log record block before it is replaced with the lsn. The log record header has space for 32k worth of blocks. The version 2 log adds new extended record headers for each additional 32k worth of blocks beyond what is supported by the record header.
The log record checksum incorporates the log record header, the extended headers and the record payload. xlog_cksum() checksums the extended headers based on log->l_iclog_heads, which specifies the number of extended headers in a log record based on the log buffer size mount option. The log buffer size is variable, however, and thus means the checksum can be calculated differently based on how a filesystem is mounted. This is problematic if a filesystem crashes and recovery occurs on a subsequent mount using a different log buffer size. For example, crash an active filesystem that is mounted with the default (32k) logbsize, attempt remount/recovery using '-o logbsize=64k' and the mount fails on or warns about log checksum failures.
To avoid this problem, update xlog_cksum() to calculate the checksum based on the size of the log buffer according to the log record. The size is already included in the h_size field of the log record header and thus is available at log recovery time. Extended log record headers are also only written when the log record is large enough to require them. This makes checksum calculation of log records consistent with the extended record header mechanism as well as how on-disk records are checksummed with various log buffer size mount options.
--- fs/xfs/xfs_log.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
fs/xfs/xfs_log.c +6 -1
@@ -1672,8 +1672,13 @@ xlog_cksum(if (xfs_sb_version_haslogv2 (&log->l_mp->m_sb)) {union xlog_in_core2 *xhdr = (union xlog_in_core2 *)rhead;int i; +int xheads; -for (i =1 ; i < log->l_iclog_heads; i++) { + xheads = size /XLOG_HEADER_CYCLE_SIZE ; +if (size %XLOG_HEADER_CYCLE_SIZE ) + xheads++; + +for (i =1 ; i < xheads; i++) { crc =crc32c (crc, &xhdr[i].hic_xheader,sizeof (struct xlog_rec_ext_header )); }
Signature · 6 lines
2.1.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs