2018-06-06 05:42:14 +03:00
// SPDX-License-Identifier: GPL-2.0
2005-04-17 02:20:36 +04:00
/*
2006-06-09 08:56:16 +04:00
* Copyright ( c ) 2000 - 2006 Silicon Graphics , Inc .
2005-11-02 06:58:39 +03:00
* All Rights Reserved .
2005-04-17 02:20:36 +04:00
*/
# include "xfs.h"
2005-11-02 06:38:42 +03:00
# include "xfs_fs.h"
2013-10-23 03:36:05 +04:00
# include "xfs_shared.h"
2013-10-23 03:50:10 +04:00
# include "xfs_format.h"
# include "xfs_log_format.h"
# include "xfs_trans_resv.h"
2005-11-02 06:38:42 +03:00
# include "xfs_bit.h"
# include "xfs_sb.h"
2005-04-17 02:20:36 +04:00
# include "xfs_mount.h"
xfs: log recovery should replay deferred ops in order
As part of testing log recovery with dm_log_writes, Amir Goldstein
discovered an error in the deferred ops recovery that lead to corruption
of the filesystem metadata if a reflink+rmap filesystem happened to shut
down midway through a CoW remap:
"This is what happens [after failed log recovery]:
"Phase 1 - find and verify superblock...
"Phase 2 - using internal log
" - zero log...
" - scan filesystem freespace and inode maps...
" - found root inode chunk
"Phase 3 - for each AG...
" - scan (but don't clear) agi unlinked lists...
" - process known inodes and perform inode discovery...
" - agno = 0
"data fork in regular inode 134 claims CoW block 376
"correcting nextents for inode 134
"bad data fork in inode 134
"would have cleared inode 134"
Hou Tao dissected the log contents of exactly such a crash:
"According to the implementation of xfs_defer_finish(), these ops should
be completed in the following sequence:
"Have been done:
"(1) CUI: Oper (160)
"(2) BUI: Oper (161)
"(3) CUD: Oper (194), for CUI Oper (160)
"(4) RUI A: Oper (197), free rmap [0x155, 2, -9]
"Should be done:
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI A
"(8) RUD: for RUI B
"Actually be done by xlog_recover_process_intents()
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI B
"(8) RUD: for RUI A
"So the rmap entry [0x155, 2, -9] for COW should be freed firstly,
then a new rmap entry [0x155, 2, 137] will be added. However, as we can see
from the log record in post_mount.log (generated after umount) and the trace
print, the new rmap entry [0x155, 2, 137] are added firstly, then the rmap
entry [0x155, 2, -9] are freed."
When reconstructing the internal log state from the log items found on
disk, it's required that deferred ops replay in exactly the same order
that they would have had the filesystem not gone down. However,
replaying unfinished deferred ops can create /more/ deferred ops. These
new deferred ops are finished in the wrong order. This causes fs
corruption and replay crashes, so let's create a single defer_ops to
handle the subsequent ops created during replay, then use one single
transaction at the end of log recovery to ensure that everything is
replayed in the same order as they're supposed to be.
Reported-by: Amir Goldstein <amir73il@gmail.com>
Analyzed-by: Hou Tao <houtao1@huawei.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Tested-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2017-11-22 07:53:02 +03:00
# include "xfs_defer.h"
2005-04-17 02:20:36 +04:00
# include "xfs_inode.h"
2013-10-23 03:50:10 +04:00
# include "xfs_trans.h"
# include "xfs_log.h"
2005-04-17 02:20:36 +04:00
# include "xfs_log_priv.h"
# include "xfs_log_recover.h"
# include "xfs_trans_priv.h"
2013-10-23 03:51:50 +04:00
# include "xfs_alloc.h"
# include "xfs_ialloc.h"
2009-12-15 02:14:59 +03:00
# include "xfs_trace.h"
2012-10-08 14:56:11 +04:00
# include "xfs_icache.h"
2013-10-23 03:51:50 +04:00
# include "xfs_error.h"
xfs: update metadata LSN in buffers during log recovery
Log recovery is currently broken for v5 superblocks in that it never
updates the metadata LSN of buffers written out during recovery. The
metadata LSN is recorded in various bits of metadata to provide recovery
ordering criteria that prevents transient corruption states reported by
buffer write verifiers. Without such ordering logic, buffer updates can
be replayed out of order and lead to false positive transient corruption
states. This is generally not a corruption vector on its own, but
corruption detection shuts down the filesystem and ultimately prevents a
mount if it occurs during log recovery. This requires an xfs_repair run
that clears the log and potentially loses filesystem updates.
This problem is avoided in most cases as metadata writes during normal
filesystem operation update the metadata LSN appropriately. The problem
with log recovery not updating metadata LSNs manifests if the system
happens to crash shortly after log recovery itself. In this scenario, it
is possible for log recovery to complete all metadata I/O such that the
filesystem is consistent. If a crash occurs after that point but before
the log tail is pushed forward by subsequent operations, however, the
next mount performs the same log recovery over again. If a buffer is
updated multiple times in the dirty range of the log, an earlier update
in the log might not be valid based on the current state of the
associated buffer after all of the updates in the log had been replayed
(before the previous crash). If a verifier happens to detect such a
problem, the filesystem claims corruption and immediately shuts down.
This commonly manifests in practice as directory block verifier failures
such as the following, likely due to directory verifiers being
particularly detailed in their checks as compared to most others:
...
Mounting V5 Filesystem
XFS (dm-0): Starting recovery (logdev: internal)
XFS (dm-0): Internal error XFS_WANT_CORRUPTED_RETURN at line ... of \
file fs/xfs/libxfs/xfs_dir2_data.c. Caller xfs_dir3_data_verify ...
...
Update log recovery to update the metadata LSN of recovered buffers.
Since metadata LSNs are already updated by write verifer functions via
attached log items, attach a dummy log item to the buffer during
validation and explicitly set the LSN of the current transaction. This
ensures that the metadata LSN of a buffer is updated based on whether
the recovery I/O actually completes, and if so, that subsequent recovery
attempts identify that the buffer is already up to date with respect to
the current transaction.
Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-09-26 01:34:27 +03:00
# include "xfs_buf_item.h"
2005-04-17 02:20:36 +04:00
2013-08-12 14:49:22 +04:00
# define BLK_AVG(blk1, blk2) ((blk1+blk2) >> 1)
2012-06-14 18:22:16 +04:00
STATIC int
xlog_find_zeroed (
struct xlog * ,
xfs_daddr_t * ) ;
STATIC int
xlog_clear_stale_blocks (
struct xlog * ,
xfs_lsn_t ) ;
2005-04-17 02:20:36 +04:00
# if defined(DEBUG)
2012-06-14 18:22:16 +04:00
STATIC void
xlog_recover_check_summary (
struct xlog * ) ;
2005-04-17 02:20:36 +04:00
# else
# define xlog_recover_check_summary(log)
# endif
2016-01-04 23:40:16 +03:00
STATIC int
xlog_do_recovery_pass (
struct xlog * , xfs_daddr_t , xfs_daddr_t , int , xfs_daddr_t * ) ;
2005-04-17 02:20:36 +04:00
/*
* Sector aligned buffer routines for buffer create / read / write / access
*/
2010-04-13 09:22:58 +04:00
/*
2017-10-26 19:31:15 +03:00
* Verify the log - relative block number and length in basic blocks are valid for
* an operation involving the given XFS log buffer . Returns true if the fields
* are valid , false otherwise .
2010-04-13 09:22:58 +04:00
*/
2017-10-26 19:31:15 +03:00
static inline bool
2019-06-29 05:27:27 +03:00
xlog_verify_bno (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2017-10-26 19:31:15 +03:00
xfs_daddr_t blk_no ,
2010-04-13 09:22:58 +04:00
int bbcount )
{
2017-10-26 19:31:15 +03:00
if ( blk_no < 0 | | blk_no > = log - > l_logBBsize )
return false ;
if ( bbcount < = 0 | | ( blk_no + bbcount ) > log - > l_logBBsize )
return false ;
return true ;
2010-04-13 09:22:58 +04:00
}
2010-04-13 09:21:13 +04:00
/*
2019-06-29 05:27:26 +03:00
* Allocate a buffer to hold log data . The buffer needs to be able to map to
* a range of nbblks basic blocks at any valid offset within the log .
2010-04-13 09:21:13 +04:00
*/
2019-06-29 05:27:26 +03:00
static char *
2019-06-29 05:27:27 +03:00
xlog_alloc_buffer (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2009-01-22 07:37:47 +03:00
int nbblks )
2005-04-17 02:20:36 +04:00
{
xfs: add kmem_alloc_io()
Memory we use to submit for IO needs strict alignment to the
underlying driver contraints. Worst case, this is 512 bytes. Given
that all allocations for IO are always a power of 2 multiple of 512
bytes, the kernel heap provides natural alignment for objects of
these sizes and that suffices.
Until, of course, memory debugging of some kind is turned on (e.g.
red zones, poisoning, KASAN) and then the alignment of the heap
objects is thrown out the window. Then we get weird IO errors and
data corruption problems because drivers don't validate alignment
and do the wrong thing when passed unaligned memory buffers in bios.
TO fix this, introduce kmem_alloc_io(), which will guaranteeat least
512 byte alignment of buffers for IO, even if memory debugging
options are turned on. It is assumed that the minimum allocation
size will be 512 bytes, and that sizes will be power of 2 mulitples
of 512 bytes.
Use this everywhere we allocate buffers for IO.
This no longer fails with log recovery errors when KASAN is enabled
due to the brd driver not handling unaligned memory buffers:
# mkfs.xfs -f /dev/ram0 ; mount /dev/ram0 /mnt/test
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2019-08-26 22:08:39 +03:00
int align_mask = xfs_buftarg_dma_alignment ( log - > l_targ ) ;
2017-10-26 19:31:15 +03:00
/*
* Pass log block 0 since we don ' t have an addr yet , buffer will be
* verified on read .
*/
2019-11-11 23:53:22 +03:00
if ( XFS_IS_CORRUPT ( log - > l_mp , ! xlog_verify_bno ( log , 0 , nbblks ) ) ) {
2011-03-07 02:01:35 +03:00
xfs_warn ( log - > l_mp , " Invalid block length (0x%x) for buffer " ,
2010-04-13 09:22:58 +04:00
nbblks ) ;
2009-01-22 07:37:47 +03:00
return NULL ;
}
2005-04-17 02:20:36 +04:00
2010-04-13 09:21:13 +04:00
/*
2019-06-29 05:27:26 +03:00
* We do log I / O in units of log sectors ( a power - of - 2 multiple of the
* basic block size ) , so we round up the requested size to accommodate
* the basic blocks required for complete log sectors .
2010-04-13 09:21:13 +04:00
*
2019-06-29 05:27:26 +03:00
* In addition , the buffer may be used for a non - sector - aligned block
* offset , in which case an I / O of the requested size could extend
* beyond the end of the buffer . If the requested size is only 1 basic
* block it will never straddle a sector boundary , so this won ' t be an
* issue . Nor will this be a problem if the log I / O is done in basic
* blocks ( sector size 1 ) . But otherwise we extend the buffer by one
* extra log sector to ensure there ' s space to accommodate this
* possibility .
2010-04-13 09:21:13 +04:00
*/
2010-04-20 11:09:59 +04:00
if ( nbblks > 1 & & log - > l_sectBBsize > 1 )
nbblks + = log - > l_sectBBsize ;
nbblks = round_up ( nbblks , log - > l_sectBBsize ) ;
2019-10-05 02:38:44 +03:00
return kmem_alloc_io ( BBTOB ( nbblks ) , align_mask , KM_MAYFAIL | KM_ZERO ) ;
2005-04-17 02:20:36 +04:00
}
2010-04-20 11:10:21 +04:00
/*
* Return the address of the start of the given block number ' s data
* in a log buffer . The buffer covers a log sector - aligned region .
*/
2019-06-29 05:27:26 +03:00
static inline unsigned int
2009-03-16 10:24:13 +03:00
xlog_align (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2019-06-29 05:27:26 +03:00
xfs_daddr_t blk_no )
2009-03-16 10:24:13 +03:00
{
2019-06-29 05:27:26 +03:00
return BBTOB ( blk_no & ( ( xfs_daddr_t ) log - > l_sectBBsize - 1 ) ) ;
2009-03-16 10:24:13 +03:00
}
2019-06-29 05:27:26 +03:00
static int
xlog_do_io (
struct xlog * log ,
xfs_daddr_t blk_no ,
unsigned int nbblks ,
char * data ,
unsigned int op )
2005-04-17 02:20:36 +04:00
{
2019-06-29 05:27:26 +03:00
int error ;
2005-04-17 02:20:36 +04:00
2019-11-11 23:53:22 +03:00
if ( XFS_IS_CORRUPT ( log - > l_mp , ! xlog_verify_bno ( log , blk_no , nbblks ) ) ) {
2017-10-26 19:31:15 +03:00
xfs_warn ( log - > l_mp ,
" Invalid log block/length (0x%llx, 0x%x) for buffer " ,
blk_no , nbblks ) ;
2014-06-25 08:58:08 +04:00
return - EFSCORRUPTED ;
2009-01-22 07:37:47 +03:00
}
2010-04-20 11:09:59 +04:00
blk_no = round_down ( blk_no , log - > l_sectBBsize ) ;
nbblks = round_up ( nbblks , log - > l_sectBBsize ) ;
2005-04-17 02:20:36 +04:00
ASSERT ( nbblks > 0 ) ;
2019-06-29 05:27:26 +03:00
error = xfs_rw_bdev ( log - > l_targ - > bt_bdev , log - > l_logBBstart + blk_no ,
BBTOB ( nbblks ) , data , op ) ;
if ( error & & ! XFS_FORCED_SHUTDOWN ( log - > l_mp ) ) {
xfs_alert ( log - > l_mp ,
" log recovery %s I/O error at daddr 0x%llx len %d error %d " ,
op = = REQ_OP_WRITE ? " write " : " read " ,
blk_no , nbblks , error ) ;
}
2005-04-17 02:20:36 +04:00
return error ;
}
2009-03-16 10:24:13 +03:00
STATIC int
2019-06-29 05:27:26 +03:00
xlog_bread_noalign (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2009-03-16 10:24:13 +03:00
xfs_daddr_t blk_no ,
int nbblks ,
2019-06-29 05:27:26 +03:00
char * data )
2009-03-16 10:24:13 +03:00
{
2019-06-29 05:27:26 +03:00
return xlog_do_io ( log , blk_no , nbblks , data , REQ_OP_READ ) ;
2009-03-16 10:24:13 +03:00
}
2011-04-21 13:34:27 +04:00
STATIC int
2019-06-29 05:27:26 +03:00
xlog_bread (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2019-06-29 05:27:26 +03:00
xfs_daddr_t blk_no ,
int nbblks ,
char * data ,
char * * offset )
2011-04-21 13:34:27 +04:00
{
2019-06-29 05:27:26 +03:00
int error ;
2011-04-21 13:34:27 +04:00
2019-06-29 05:27:26 +03:00
error = xlog_do_io ( log , blk_no , nbblks , data , REQ_OP_READ ) ;
if ( ! error )
* offset = data + xlog_align ( log , blk_no ) ;
return error ;
2011-04-21 13:34:27 +04:00
}
2005-06-21 09:36:52 +04:00
STATIC int
2005-04-17 02:20:36 +04:00
xlog_bwrite (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2005-04-17 02:20:36 +04:00
xfs_daddr_t blk_no ,
int nbblks ,
2019-06-29 05:27:26 +03:00
char * data )
2005-04-17 02:20:36 +04:00
{
2019-06-29 05:27:26 +03:00
return xlog_do_io ( log , blk_no , nbblks , data , REQ_OP_WRITE ) ;
2005-04-17 02:20:36 +04:00
}
# ifdef DEBUG
/*
* dump debug superblock and log record information
*/
STATIC void
xlog_header_check_dump (
xfs_mount_t * mp ,
xlog_rec_header_t * head )
{
2013-10-12 05:59:05 +04:00
xfs_debug ( mp , " %s: SB : uuid = %pU, fmt = %d " ,
2009-12-15 05:01:10 +03:00
__func__ , & mp - > m_sb . sb_uuid , XLOG_FMT ) ;
2013-10-12 05:59:05 +04:00
xfs_debug ( mp , " log : uuid = %pU, fmt = %d " ,
2009-12-15 05:01:10 +03:00
& head - > h_fs_uuid , be32_to_cpu ( head - > h_fmt ) ) ;
2005-04-17 02:20:36 +04:00
}
# else
# define xlog_header_check_dump(mp, head)
# endif
/*
* check log record header for recovery
*/
STATIC int
xlog_header_check_recover (
xfs_mount_t * mp ,
xlog_rec_header_t * head )
{
2011-07-08 16:36:05 +04:00
ASSERT ( head - > h_magicno = = cpu_to_be32 ( XLOG_HEADER_MAGIC_NUM ) ) ;
2005-04-17 02:20:36 +04:00
/*
* IRIX doesn ' t write the h_fmt field and leaves it zeroed
* ( XLOG_FMT_UNKNOWN ) . This stops us from trying to recover
* a dirty log created in IRIX .
*/
2019-11-11 23:53:22 +03:00
if ( XFS_IS_CORRUPT ( mp , head - > h_fmt ! = cpu_to_be32 ( XLOG_FMT ) ) ) {
2011-03-07 02:01:35 +03:00
xfs_warn ( mp ,
" dirty log written in incompatible format - can't recover " ) ;
2005-04-17 02:20:36 +04:00
xlog_header_check_dump ( mp , head ) ;
2014-06-25 08:58:08 +04:00
return - EFSCORRUPTED ;
2019-11-11 23:53:22 +03:00
}
if ( XFS_IS_CORRUPT ( mp , ! uuid_equal ( & mp - > m_sb . sb_uuid ,
& head - > h_fs_uuid ) ) ) {
2011-03-07 02:01:35 +03:00
xfs_warn ( mp ,
" dirty log entry has mismatched uuid - can't recover " ) ;
2005-04-17 02:20:36 +04:00
xlog_header_check_dump ( mp , head ) ;
2014-06-25 08:58:08 +04:00
return - EFSCORRUPTED ;
2005-04-17 02:20:36 +04:00
}
return 0 ;
}
/*
* read the head block of the log and check the header
*/
STATIC int
xlog_header_check_mount (
xfs_mount_t * mp ,
xlog_rec_header_t * head )
{
2011-07-08 16:36:05 +04:00
ASSERT ( head - > h_magicno = = cpu_to_be32 ( XLOG_HEADER_MAGIC_NUM ) ) ;
2005-04-17 02:20:36 +04:00
2017-05-04 16:26:23 +03:00
if ( uuid_is_null ( & head - > h_fs_uuid ) ) {
2005-04-17 02:20:36 +04:00
/*
* IRIX doesn ' t write the h_fs_uuid or h_fmt fields . If
2017-05-04 16:26:23 +03:00
* h_fs_uuid is null , we assume this log was last mounted
2005-04-17 02:20:36 +04:00
* by IRIX and continue .
*/
2017-05-04 16:26:23 +03:00
xfs_warn ( mp , " null uuid in log - IRIX style log " ) ;
2019-11-11 23:53:22 +03:00
} else if ( XFS_IS_CORRUPT ( mp , ! uuid_equal ( & mp - > m_sb . sb_uuid ,
& head - > h_fs_uuid ) ) ) {
2011-03-07 02:01:35 +03:00
xfs_warn ( mp , " log has mismatched uuid - can't recover " ) ;
2005-04-17 02:20:36 +04:00
xlog_header_check_dump ( mp , head ) ;
2014-06-25 08:58:08 +04:00
return - EFSCORRUPTED ;
2005-04-17 02:20:36 +04:00
}
return 0 ;
}
/*
* This routine finds ( to an approximation ) the first block in the physical
* log which contains the given cycle . It uses a binary search algorithm .
* Note that the algorithm can not be perfect because the disk will not
* necessarily be perfect .
*/
2007-11-23 08:28:09 +03:00
STATIC int
2005-04-17 02:20:36 +04:00
xlog_find_cycle_start (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2019-06-29 05:27:27 +03:00
char * buffer ,
2005-04-17 02:20:36 +04:00
xfs_daddr_t first_blk ,
xfs_daddr_t * last_blk ,
uint cycle )
{
2015-06-22 02:45:10 +03:00
char * offset ;
2005-04-17 02:20:36 +04:00
xfs_daddr_t mid_blk ;
2010-04-15 22:17:30 +04:00
xfs_daddr_t end_blk ;
2005-04-17 02:20:36 +04:00
uint mid_cycle ;
int error ;
2010-04-15 22:17:30 +04:00
end_blk = * last_blk ;
mid_blk = BLK_AVG ( first_blk , end_blk ) ;
while ( mid_blk ! = first_blk & & mid_blk ! = end_blk ) {
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , mid_blk , 1 , buffer , & offset ) ;
2009-03-16 10:24:13 +03:00
if ( error )
2005-04-17 02:20:36 +04:00
return error ;
2007-10-12 04:58:05 +04:00
mid_cycle = xlog_get_cycle ( offset ) ;
2010-04-15 22:17:30 +04:00
if ( mid_cycle = = cycle )
end_blk = mid_blk ; /* last_half_cycle == mid_cycle */
else
first_blk = mid_blk ; /* first_half_cycle == mid_cycle */
mid_blk = BLK_AVG ( first_blk , end_blk ) ;
2005-04-17 02:20:36 +04:00
}
2010-04-15 22:17:30 +04:00
ASSERT ( ( mid_blk = = first_blk & & mid_blk + 1 = = end_blk ) | |
( mid_blk = = end_blk & & mid_blk - 1 = = first_blk ) ) ;
* last_blk = end_blk ;
2005-04-17 02:20:36 +04:00
return 0 ;
}
/*
2010-04-15 22:17:34 +04:00
* Check that a range of blocks does not contain stop_on_cycle_no .
* Fill in * new_blk with the block offset where such a block is
* found , or with - 1 ( an invalid block number ) if there is no such
* block in the range . The scan needs to occur from front to back
* and the pointer into the region must be updated since a later
* routine will need to perform another test .
2005-04-17 02:20:36 +04:00
*/
STATIC int
xlog_find_verify_cycle (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2005-04-17 02:20:36 +04:00
xfs_daddr_t start_blk ,
int nbblks ,
uint stop_on_cycle_no ,
xfs_daddr_t * new_blk )
{
xfs_daddr_t i , j ;
uint cycle ;
2019-06-29 05:27:27 +03:00
char * buffer ;
2005-04-17 02:20:36 +04:00
xfs_daddr_t bufblks ;
2015-06-22 02:45:10 +03:00
char * buf = NULL ;
2005-04-17 02:20:36 +04:00
int error = 0 ;
2010-04-13 09:22:29 +04:00
/*
* Greedily allocate a buffer big enough to handle the full
* range of basic blocks we ' ll be examining . If that fails ,
* try a smaller size . We need to be able to read at least
* a log sector , or we ' re out of luck .
*/
2005-04-17 02:20:36 +04:00
bufblks = 1 < < ffs ( nbblks ) ;
2012-04-27 13:45:22 +04:00
while ( bufblks > log - > l_logBBsize )
bufblks > > = 1 ;
2019-06-29 05:27:27 +03:00
while ( ! ( buffer = xlog_alloc_buffer ( log , bufblks ) ) ) {
2005-04-17 02:20:36 +04:00
bufblks > > = 1 ;
2010-04-20 11:09:59 +04:00
if ( bufblks < log - > l_sectBBsize )
2014-06-25 08:58:08 +04:00
return - ENOMEM ;
2005-04-17 02:20:36 +04:00
}
for ( i = start_blk ; i < start_blk + nbblks ; i + = bufblks ) {
int bcount ;
bcount = min ( bufblks , ( start_blk + nbblks - i ) ) ;
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , i , bcount , buffer , & buf ) ;
2009-03-16 10:24:13 +03:00
if ( error )
2005-04-17 02:20:36 +04:00
goto out ;
for ( j = 0 ; j < bcount ; j + + ) {
2007-10-12 04:58:05 +04:00
cycle = xlog_get_cycle ( buf ) ;
2005-04-17 02:20:36 +04:00
if ( cycle = = stop_on_cycle_no ) {
* new_blk = i + j ;
goto out ;
}
buf + = BBSIZE ;
}
}
* new_blk = - 1 ;
out :
2019-06-29 05:27:27 +03:00
kmem_free ( buffer ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
2020-09-22 19:41:06 +03:00
static inline int
xlog_logrec_hblks ( struct xlog * log , struct xlog_rec_header * rh )
{
if ( xfs_sb_version_haslogv2 ( & log - > l_mp - > m_sb ) ) {
int h_size = be32_to_cpu ( rh - > h_size ) ;
if ( ( be32_to_cpu ( rh - > h_version ) & XLOG_VERSION_2 ) & &
h_size > XLOG_HEADER_CYCLE_SIZE )
return DIV_ROUND_UP ( h_size , XLOG_HEADER_CYCLE_SIZE ) ;
}
return 1 ;
}
2005-04-17 02:20:36 +04:00
/*
* Potentially backup over partial log record write .
*
* In the typical case , last_blk is the number of the block directly after
* a good log record . Therefore , we subtract one to get the block number
* of the last block in the given buffer . extra_bblks contains the number
* of blocks we would have read on a previous read . This happens when the
* last log record is split over the end of the physical log .
*
* extra_bblks is the number of blocks potentially verified on a previous
* call to this routine .
*/
STATIC int
xlog_find_verify_log_record (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2005-04-17 02:20:36 +04:00
xfs_daddr_t start_blk ,
xfs_daddr_t * last_blk ,
int extra_bblks )
{
xfs_daddr_t i ;
2019-06-29 05:27:27 +03:00
char * buffer ;
2015-06-22 02:45:10 +03:00
char * offset = NULL ;
2005-04-17 02:20:36 +04:00
xlog_rec_header_t * head = NULL ;
int error = 0 ;
int smallmem = 0 ;
int num_blks = * last_blk - start_blk ;
int xhdrs ;
ASSERT ( start_blk ! = 0 | | * last_blk ! = start_blk ) ;
2019-06-29 05:27:27 +03:00
buffer = xlog_alloc_buffer ( log , num_blks ) ;
if ( ! buffer ) {
buffer = xlog_alloc_buffer ( log , 1 ) ;
if ( ! buffer )
2014-06-25 08:58:08 +04:00
return - ENOMEM ;
2005-04-17 02:20:36 +04:00
smallmem = 1 ;
} else {
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , start_blk , num_blks , buffer , & offset ) ;
2009-03-16 10:24:13 +03:00
if ( error )
2005-04-17 02:20:36 +04:00
goto out ;
offset + = ( ( num_blks - 1 ) < < BBSHIFT ) ;
}
for ( i = ( * last_blk ) - 1 ; i > = 0 ; i - - ) {
if ( i < start_blk ) {
/* valid log record not found */
2011-03-07 02:01:35 +03:00
xfs_warn ( log - > l_mp ,
" Log inconsistent (didn't find previous header) " ) ;
2005-04-17 02:20:36 +04:00
ASSERT ( 0 ) ;
2019-11-06 20:17:43 +03:00
error = - EFSCORRUPTED ;
2005-04-17 02:20:36 +04:00
goto out ;
}
if ( smallmem ) {
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , i , 1 , buffer , & offset ) ;
2009-03-16 10:24:13 +03:00
if ( error )
2005-04-17 02:20:36 +04:00
goto out ;
}
head = ( xlog_rec_header_t * ) offset ;
2011-07-08 16:36:05 +04:00
if ( head - > h_magicno = = cpu_to_be32 ( XLOG_HEADER_MAGIC_NUM ) )
2005-04-17 02:20:36 +04:00
break ;
if ( ! smallmem )
offset - = BBSIZE ;
}
/*
* We hit the beginning of the physical log & still no header . Return
* to caller . If caller can handle a return of - 1 , then this routine
* will be called again for the end of the physical log .
*/
if ( i = = - 1 ) {
2014-06-25 08:58:08 +04:00
error = 1 ;
2005-04-17 02:20:36 +04:00
goto out ;
}
/*
* We have the final block of the good log ( the first block
* of the log record _before_ the head . So we check the uuid .
*/
if ( ( error = xlog_header_check_mount ( log - > l_mp , head ) ) )
goto out ;
/*
* We may have found a log record header before we expected one .
* last_blk will be the 1 st block # with a given cycle # . We may end
* up reading an entire log record . In this case , we don ' t want to
* reset last_blk . Only when last_blk points in the middle of a log
* record do we update last_blk .
*/
2020-09-22 19:41:06 +03:00
xhdrs = xlog_logrec_hblks ( log , head ) ;
2005-04-17 02:20:36 +04:00
2007-10-12 04:59:34 +04:00
if ( * last_blk - i + extra_bblks ! =
BTOBB ( be32_to_cpu ( head - > h_len ) ) + xhdrs )
2005-04-17 02:20:36 +04:00
* last_blk = i ;
out :
2019-06-29 05:27:27 +03:00
kmem_free ( buffer ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
/*
* Head is defined to be the point of the log where the next log write
2013-08-07 14:11:08 +04:00
* could go . This means that incomplete LR writes at the end are
2005-04-17 02:20:36 +04:00
* eliminated when calculating the head . We aren ' t guaranteed that previous
* LR have complete transactions . We only know that a cycle number of
* current cycle number - 1 won ' t be present in the log if we start writing
* from our current block number .
*
* last_blk contains the block number of the first block with a given
* cycle number .
*
* Return : zero if normal , non - zero if error .
*/
2005-06-21 09:36:52 +04:00
STATIC int
2005-04-17 02:20:36 +04:00
xlog_find_head (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2005-04-17 02:20:36 +04:00
xfs_daddr_t * return_head_blk )
{
2019-06-29 05:27:27 +03:00
char * buffer ;
2015-06-22 02:45:10 +03:00
char * offset ;
2005-04-17 02:20:36 +04:00
xfs_daddr_t new_blk , first_blk , start_blk , last_blk , head_blk ;
int num_scan_bblks ;
uint first_half_cycle , last_half_cycle ;
uint stop_on_cycle ;
int error , log_bbnum = log - > l_logBBsize ;
/* Is the end of the log device zeroed? */
2014-06-25 08:58:08 +04:00
error = xlog_find_zeroed ( log , & first_blk ) ;
if ( error < 0 ) {
xfs_warn ( log - > l_mp , " empty log check failed " ) ;
return error ;
}
if ( error = = 1 ) {
2005-04-17 02:20:36 +04:00
* return_head_blk = first_blk ;
/* Is the whole lot zeroed? */
if ( ! first_blk ) {
/* Linux XFS shouldn't generate totally zeroed logs -
* mkfs etc write a dummy unmount record to a fresh
* log so we can store the uuid in there
*/
2011-03-07 02:01:35 +03:00
xfs_warn ( log - > l_mp , " totally zeroed log " ) ;
2005-04-17 02:20:36 +04:00
}
return 0 ;
}
first_blk = 0 ; /* get cycle # of 1st block */
2019-06-29 05:27:27 +03:00
buffer = xlog_alloc_buffer ( log , 1 ) ;
if ( ! buffer )
2014-06-25 08:58:08 +04:00
return - ENOMEM ;
2009-03-16 10:24:13 +03:00
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , 0 , 1 , buffer , & offset ) ;
2009-03-16 10:24:13 +03:00
if ( error )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2009-03-16 10:24:13 +03:00
2007-10-12 04:58:05 +04:00
first_half_cycle = xlog_get_cycle ( offset ) ;
2005-04-17 02:20:36 +04:00
last_blk = head_blk = log_bbnum - 1 ; /* get cycle # of last block */
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , last_blk , 1 , buffer , & offset ) ;
2009-03-16 10:24:13 +03:00
if ( error )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2009-03-16 10:24:13 +03:00
2007-10-12 04:58:05 +04:00
last_half_cycle = xlog_get_cycle ( offset ) ;
2005-04-17 02:20:36 +04:00
ASSERT ( last_half_cycle ! = 0 ) ;
/*
* If the 1 st half cycle number is equal to the last half cycle number ,
* then the entire log is stamped with the same cycle number . In this
* case , head_blk can ' t be set to zero ( which makes sense ) . The below
* math doesn ' t work out properly with head_blk equal to zero . Instead ,
* we set it to log_bbnum which is an invalid block number , but this
* value makes the math correct . If head_blk doesn ' t changed through
* all the tests below , * head_blk is set to zero at the very end rather
* than log_bbnum . In a sense , log_bbnum and zero are the same block
* in a circular file .
*/
if ( first_half_cycle = = last_half_cycle ) {
/*
* In this case we believe that the entire log should have
* cycle number last_half_cycle . We need to scan backwards
* from the end verifying that there are no holes still
* containing last_half_cycle - 1. If we find such a hole ,
* then the start of that hole will be the new head . The
* simple case looks like
* x | x . . . | x - 1 | x
* Another case that fits this picture would be
* x | x + 1 | x . . . | x
2006-03-29 02:55:14 +04:00
* In this case the head really is somewhere at the end of the
2005-04-17 02:20:36 +04:00
* log , as one of the latest writes at the beginning was
* incomplete .
* One more case is
* x | x + 1 | x . . . | x - 1 | x
* This is really the combination of the above two cases , and
* the head has to end up at the start of the x - 1 hole at the
* end of the log .
*
* In the 256 k log case , we will read from the beginning to the
* end of the log and search for cycle numbers equal to x - 1.
* We don ' t worry about the x + 1 blocks that we encounter ,
* because we know that they cannot be the head since the log
* started with x .
*/
head_blk = log_bbnum ;
stop_on_cycle = last_half_cycle - 1 ;
} else {
/*
* In this case we want to find the first block with cycle
* number matching last_half_cycle . We expect the log to be
* some variation on
2010-04-15 22:17:34 +04:00
* x + 1 . . . | x . . . | x
2005-04-17 02:20:36 +04:00
* The first block with cycle number x ( last_half_cycle ) will
* be where the new head belongs . First we do a binary search
* for the first occurrence of last_half_cycle . The binary
* search may not be totally accurate , so then we scan back
* from there looking for occurrences of last_half_cycle before
* us . If that backwards scan wraps around the beginning of
* the log , then we look for occurrences of last_half_cycle - 1
* at the end of the log . The cases we ' re looking for look
* like
2010-04-15 22:17:34 +04:00
* v binary search stopped here
* x + 1 . . . | x | x + 1 | x . . . | x
* ^ but we want to locate this spot
2005-04-17 02:20:36 +04:00
* or
* < - - - - - - - - - > less than scan distance
2010-04-15 22:17:34 +04:00
* x + 1 . . . | x . . . | x - 1 | x
* ^ we want to locate this spot
2005-04-17 02:20:36 +04:00
*/
stop_on_cycle = last_half_cycle ;
2019-06-29 05:27:27 +03:00
error = xlog_find_cycle_start ( log , buffer , first_blk , & head_blk ,
last_half_cycle ) ;
if ( error )
goto out_free_buffer ;
2005-04-17 02:20:36 +04:00
}
/*
* Now validate the answer . Scan back some number of maximum possible
* blocks and make sure each one has the expected cycle number . The
* maximum is determined by the total possible amount of buffering
* in the in - core log . The following number can be made tighter if
* we actually look at the block size of the filesystem .
*/
2017-10-26 19:31:16 +03:00
num_scan_bblks = min_t ( int , log_bbnum , XLOG_TOTAL_REC_SHIFT ( log ) ) ;
2005-04-17 02:20:36 +04:00
if ( head_blk > = num_scan_bblks ) {
/*
* We are guaranteed that the entire check can be performed
* in one buffer .
*/
start_blk = head_blk - num_scan_bblks ;
if ( ( error = xlog_find_verify_cycle ( log ,
start_blk , num_scan_bblks ,
stop_on_cycle , & new_blk ) ) )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2005-04-17 02:20:36 +04:00
if ( new_blk ! = - 1 )
head_blk = new_blk ;
} else { /* need to read 2 parts of log */
/*
* We are going to scan backwards in the log in two parts .
* First we scan the physical end of the log . In this part
* of the log , we are looking for blocks with cycle number
* last_half_cycle - 1.
* If we find one , then we know that the log starts there , as
* we ' ve found a hole that didn ' t get written in going around
* the end of the physical log . The simple case for this is
* x + 1 . . . | x . . . | x - 1 | x
* < - - - - - - - - - > less than scan distance
* If all of the blocks at the end of the log have cycle number
* last_half_cycle , then we check the blocks at the start of
* the log looking for occurrences of last_half_cycle . If we
* find one , then our current estimate for the location of the
* first occurrence of last_half_cycle is wrong and we move
* back to the hole we ' ve found . This case looks like
* x + 1 . . . | x | x + 1 | x . . .
* ^ binary search stopped here
* Another case we need to handle that only occurs in 256 k
* logs is
* x + 1 . . . | x . . . | x + 1 | x . . .
* ^ binary search stops here
* In a 256 k log , the scan at the end of the log will see the
* x + 1 blocks . We need to skip past those since that is
* certainly not the head of the log . By searching for
* last_half_cycle - 1 we accomplish that .
*/
ASSERT ( head_blk < = INT_MAX & &
2010-04-15 22:17:34 +04:00
( xfs_daddr_t ) num_scan_bblks > = head_blk ) ;
start_blk = log_bbnum - ( num_scan_bblks - head_blk ) ;
2005-04-17 02:20:36 +04:00
if ( ( error = xlog_find_verify_cycle ( log , start_blk ,
num_scan_bblks - ( int ) head_blk ,
( stop_on_cycle - 1 ) , & new_blk ) ) )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2005-04-17 02:20:36 +04:00
if ( new_blk ! = - 1 ) {
head_blk = new_blk ;
2010-04-15 22:17:26 +04:00
goto validate_head ;
2005-04-17 02:20:36 +04:00
}
/*
* Scan beginning of log now . The last part of the physical
* log is good . This scan needs to verify that it doesn ' t find
* the last_half_cycle .
*/
start_blk = 0 ;
ASSERT ( head_blk < = INT_MAX ) ;
if ( ( error = xlog_find_verify_cycle ( log ,
start_blk , ( int ) head_blk ,
stop_on_cycle , & new_blk ) ) )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2005-04-17 02:20:36 +04:00
if ( new_blk ! = - 1 )
head_blk = new_blk ;
}
2010-04-15 22:17:26 +04:00
validate_head :
2005-04-17 02:20:36 +04:00
/*
* Now we need to make sure head_blk is not pointing to a block in
* the middle of a log record .
*/
num_scan_bblks = XLOG_REC_SHIFT ( log ) ;
if ( head_blk > = num_scan_bblks ) {
start_blk = head_blk - num_scan_bblks ; /* don't read head_blk */
/* start ptr at last block ptr before head_blk */
2014-06-25 08:58:08 +04:00
error = xlog_find_verify_log_record ( log , start_blk , & head_blk , 0 ) ;
if ( error = = 1 )
error = - EIO ;
if ( error )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2005-04-17 02:20:36 +04:00
} else {
start_blk = 0 ;
ASSERT ( head_blk < = INT_MAX ) ;
2014-06-25 08:58:08 +04:00
error = xlog_find_verify_log_record ( log , start_blk , & head_blk , 0 ) ;
if ( error < 0 )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2014-06-25 08:58:08 +04:00
if ( error = = 1 ) {
2005-04-17 02:20:36 +04:00
/* We hit the beginning of the log during our search */
2010-04-15 22:17:34 +04:00
start_blk = log_bbnum - ( num_scan_bblks - head_blk ) ;
2005-04-17 02:20:36 +04:00
new_blk = log_bbnum ;
ASSERT ( start_blk < = INT_MAX & &
( xfs_daddr_t ) log_bbnum - start_blk > = 0 ) ;
ASSERT ( head_blk < = INT_MAX ) ;
2014-06-25 08:58:08 +04:00
error = xlog_find_verify_log_record ( log , start_blk ,
& new_blk , ( int ) head_blk ) ;
if ( error = = 1 )
error = - EIO ;
if ( error )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2005-04-17 02:20:36 +04:00
if ( new_blk ! = log_bbnum )
head_blk = new_blk ;
} else if ( error )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2005-04-17 02:20:36 +04:00
}
2019-06-29 05:27:27 +03:00
kmem_free ( buffer ) ;
2005-04-17 02:20:36 +04:00
if ( head_blk = = log_bbnum )
* return_head_blk = 0 ;
else
* return_head_blk = head_blk ;
/*
* When returning here , we have a good block number . Bad block
* means that during a previous crash , we didn ' t have a clean break
* from cycle number N to cycle number N - 1. In this case , we need
* to find the first block with cycle number N - 1.
*/
return 0 ;
2019-06-29 05:27:27 +03:00
out_free_buffer :
kmem_free ( buffer ) ;
2005-04-17 02:20:36 +04:00
if ( error )
2011-03-07 02:01:35 +03:00
xfs_warn ( log - > l_mp , " failed to find log head " ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
2016-01-04 07:55:10 +03:00
/*
* Seek backwards in the log for log record headers .
*
* Given a starting log block , walk backwards until we find the provided number
* of records or hit the provided tail block . The return value is the number of
* records encountered or a negative error code . The log block and buffer
* pointer of the last record seen are returned in rblk and rhead respectively .
*/
STATIC int
xlog_rseek_logrec_hdr (
struct xlog * log ,
xfs_daddr_t head_blk ,
xfs_daddr_t tail_blk ,
int count ,
2019-06-29 05:27:27 +03:00
char * buffer ,
2016-01-04 07:55:10 +03:00
xfs_daddr_t * rblk ,
struct xlog_rec_header * * rhead ,
bool * wrapped )
{
int i ;
int error ;
int found = 0 ;
char * offset = NULL ;
xfs_daddr_t end_blk ;
* wrapped = false ;
/*
* Walk backwards from the head block until we hit the tail or the first
* block in the log .
*/
end_blk = head_blk > tail_blk ? tail_blk : 0 ;
for ( i = ( int ) head_blk - 1 ; i > = end_blk ; i - - ) {
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , i , 1 , buffer , & offset ) ;
2016-01-04 07:55:10 +03:00
if ( error )
goto out_error ;
if ( * ( __be32 * ) offset = = cpu_to_be32 ( XLOG_HEADER_MAGIC_NUM ) ) {
* rblk = i ;
* rhead = ( struct xlog_rec_header * ) offset ;
if ( + + found = = count )
break ;
}
}
/*
* If we haven ' t hit the tail block or the log record header count ,
* start looking again from the end of the physical log . Note that
* callers can pass head = = tail if the tail is not yet known .
*/
if ( tail_blk > = head_blk & & found ! = count ) {
for ( i = log - > l_logBBsize - 1 ; i > = ( int ) tail_blk ; i - - ) {
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , i , 1 , buffer , & offset ) ;
2016-01-04 07:55:10 +03:00
if ( error )
goto out_error ;
if ( * ( __be32 * ) offset = =
cpu_to_be32 ( XLOG_HEADER_MAGIC_NUM ) ) {
* wrapped = true ;
* rblk = i ;
* rhead = ( struct xlog_rec_header * ) offset ;
if ( + + found = = count )
break ;
}
}
}
return found ;
out_error :
return error ;
}
2016-01-04 23:40:16 +03:00
/*
* Seek forward in the log for log record headers .
*
* Given head and tail blocks , walk forward from the tail block until we find
* the provided number of records or hit the head block . The return value is the
* number of records encountered or a negative error code . The log block and
* buffer pointer of the last record seen are returned in rblk and rhead
* respectively .
*/
STATIC int
xlog_seek_logrec_hdr (
struct xlog * log ,
xfs_daddr_t head_blk ,
xfs_daddr_t tail_blk ,
int count ,
2019-06-29 05:27:27 +03:00
char * buffer ,
2016-01-04 23:40:16 +03:00
xfs_daddr_t * rblk ,
struct xlog_rec_header * * rhead ,
bool * wrapped )
{
int i ;
int error ;
int found = 0 ;
char * offset = NULL ;
xfs_daddr_t end_blk ;
* wrapped = false ;
/*
* Walk forward from the tail block until we hit the head or the last
* block in the log .
*/
end_blk = head_blk > tail_blk ? head_blk : log - > l_logBBsize - 1 ;
for ( i = ( int ) tail_blk ; i < = end_blk ; i + + ) {
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , i , 1 , buffer , & offset ) ;
2016-01-04 23:40:16 +03:00
if ( error )
goto out_error ;
if ( * ( __be32 * ) offset = = cpu_to_be32 ( XLOG_HEADER_MAGIC_NUM ) ) {
* rblk = i ;
* rhead = ( struct xlog_rec_header * ) offset ;
if ( + + found = = count )
break ;
}
}
/*
* If we haven ' t hit the head block or the log record header count ,
* start looking again from the start of the physical log .
*/
if ( tail_blk > head_blk & & found ! = count ) {
for ( i = 0 ; i < ( int ) head_blk ; i + + ) {
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , i , 1 , buffer , & offset ) ;
2016-01-04 23:40:16 +03:00
if ( error )
goto out_error ;
if ( * ( __be32 * ) offset = =
cpu_to_be32 ( XLOG_HEADER_MAGIC_NUM ) ) {
* wrapped = true ;
* rblk = i ;
* rhead = ( struct xlog_rec_header * ) offset ;
if ( + + found = = count )
break ;
}
}
}
return found ;
out_error :
return error ;
}
/*
2017-08-09 04:21:52 +03:00
* Calculate distance from head to tail ( i . e . , unused space in the log ) .
*/
static inline int
xlog_tail_distance (
struct xlog * log ,
xfs_daddr_t head_blk ,
xfs_daddr_t tail_blk )
{
if ( head_blk < tail_blk )
return tail_blk - head_blk ;
return tail_blk + ( log - > l_logBBsize - head_blk ) ;
}
/*
* Verify the log tail . This is particularly important when torn or incomplete
* writes have been detected near the front of the log and the head has been
* walked back accordingly .
*
* We also have to handle the case where the tail was pinned and the head
* blocked behind the tail right before a crash . If the tail had been pushed
* immediately prior to the crash and the subsequent checkpoint was only
* partially written , it ' s possible it overwrote the last referenced tail in the
* log with garbage . This is not a coherency problem because the tail must have
* been pushed before it can be overwritten , but appears as log corruption to
* recovery because we have no way to know the tail was updated if the
* subsequent checkpoint didn ' t write successfully .
2016-01-04 23:40:16 +03:00
*
2017-08-09 04:21:52 +03:00
* Therefore , CRC check the log from tail to head . If a failure occurs and the
* offending record is within max iclog bufs from the head , walk the tail
* forward and retry until a valid tail is found or corruption is detected out
* of the range of a possible overwrite .
2016-01-04 23:40:16 +03:00
*/
STATIC int
xlog_verify_tail (
struct xlog * log ,
xfs_daddr_t head_blk ,
2017-08-09 04:21:52 +03:00
xfs_daddr_t * tail_blk ,
int hsize )
2016-01-04 23:40:16 +03:00
{
struct xlog_rec_header * thead ;
2019-06-29 05:27:27 +03:00
char * buffer ;
2016-01-04 23:40:16 +03:00
xfs_daddr_t first_bad ;
int error = 0 ;
bool wrapped ;
2017-08-09 04:21:52 +03:00
xfs_daddr_t tmp_tail ;
xfs_daddr_t orig_tail = * tail_blk ;
2016-01-04 23:40:16 +03:00
2019-06-29 05:27:27 +03:00
buffer = xlog_alloc_buffer ( log , 1 ) ;
if ( ! buffer )
2016-01-04 23:40:16 +03:00
return - ENOMEM ;
/*
2017-08-09 04:21:52 +03:00
* Make sure the tail points to a record ( returns positive count on
* success ) .
2016-01-04 23:40:16 +03:00
*/
2019-06-29 05:27:27 +03:00
error = xlog_seek_logrec_hdr ( log , head_blk , * tail_blk , 1 , buffer ,
2017-08-09 04:21:52 +03:00
& tmp_tail , & thead , & wrapped ) ;
if ( error < 0 )
2016-01-04 23:40:16 +03:00
goto out ;
2017-08-09 04:21:52 +03:00
if ( * tail_blk ! = tmp_tail )
* tail_blk = tmp_tail ;
2016-01-04 23:40:16 +03:00
/*
2017-08-09 04:21:52 +03:00
* Run a CRC check from the tail to the head . We can ' t just check
* MAX_ICLOGS records past the tail because the tail may point to stale
* blocks cleared during the search for the head / tail . These blocks are
* overwritten with zero - length records and thus record count is not a
* reliable indicator of the iclog state before a crash .
2016-01-04 23:40:16 +03:00
*/
2017-08-09 04:21:52 +03:00
first_bad = 0 ;
error = xlog_do_recovery_pass ( log , head_blk , * tail_blk ,
2016-01-04 23:40:16 +03:00
XLOG_RECOVER_CRCPASS , & first_bad ) ;
2017-08-09 04:21:53 +03:00
while ( ( error = = - EFSBADCRC | | error = = - EFSCORRUPTED ) & & first_bad ) {
2017-08-09 04:21:52 +03:00
int tail_distance ;
/*
* Is corruption within range of the head ? If so , retry from
* the next record . Otherwise return an error .
*/
tail_distance = xlog_tail_distance ( log , head_blk , first_bad ) ;
if ( tail_distance > BTOBB ( XLOG_MAX_ICLOGS * hsize ) )
break ;
2016-01-04 23:40:16 +03:00
2017-08-09 04:21:52 +03:00
/* skip to the next record; returns positive count on success */
2019-06-29 05:27:27 +03:00
error = xlog_seek_logrec_hdr ( log , head_blk , first_bad , 2 ,
buffer , & tmp_tail , & thead , & wrapped ) ;
2017-08-09 04:21:52 +03:00
if ( error < 0 )
goto out ;
* tail_blk = tmp_tail ;
first_bad = 0 ;
error = xlog_do_recovery_pass ( log , head_blk , * tail_blk ,
XLOG_RECOVER_CRCPASS , & first_bad ) ;
}
if ( ! error & & * tail_blk ! = orig_tail )
xfs_warn ( log - > l_mp ,
" Tail block (0x%llx) overwrite detected. Updated to 0x%llx " ,
orig_tail , * tail_blk ) ;
2016-01-04 23:40:16 +03:00
out :
2019-06-29 05:27:27 +03:00
kmem_free ( buffer ) ;
2016-01-04 23:40:16 +03:00
return error ;
}
/*
* Detect and trim torn writes from the head of the log .
*
* Storage without sector atomicity guarantees can result in torn writes in the
* log in the event of a crash . Our only means to detect this scenario is via
* CRC verification . While we can ' t always be certain that CRC verification
* failure is due to a torn write vs . an unrelated corruption , we do know that
* only a certain number ( XLOG_MAX_ICLOGS ) of log records can be written out at
* one time . Therefore , CRC verify up to XLOG_MAX_ICLOGS records at the head of
* the log and treat failures in this range as torn writes as a matter of
* policy . In the event of CRC failure , the head is walked back to the last good
* record in the log and the tail is updated from that record and verified .
*/
STATIC int
xlog_verify_head (
struct xlog * log ,
xfs_daddr_t * head_blk , /* in/out: unverified head */
xfs_daddr_t * tail_blk , /* out: tail block */
2019-06-29 05:27:27 +03:00
char * buffer ,
2016-01-04 23:40:16 +03:00
xfs_daddr_t * rhead_blk , /* start blk of last record */
struct xlog_rec_header * * rhead , /* ptr to last record */
bool * wrapped ) /* last rec. wraps phys. log */
{
struct xlog_rec_header * tmp_rhead ;
2019-06-29 05:27:27 +03:00
char * tmp_buffer ;
2016-01-04 23:40:16 +03:00
xfs_daddr_t first_bad ;
xfs_daddr_t tmp_rhead_blk ;
int found ;
int error ;
bool tmp_wrapped ;
/*
2016-03-07 00:22:22 +03:00
* Check the head of the log for torn writes . Search backwards from the
* head until we hit the tail or the maximum number of log record I / Os
* that could have been in flight at one time . Use a temporary buffer so
2019-06-29 05:27:27 +03:00
* we don ' t trash the rhead / buffer pointers from the caller .
2016-01-04 23:40:16 +03:00
*/
2019-06-29 05:27:27 +03:00
tmp_buffer = xlog_alloc_buffer ( log , 1 ) ;
if ( ! tmp_buffer )
2016-01-04 23:40:16 +03:00
return - ENOMEM ;
error = xlog_rseek_logrec_hdr ( log , * head_blk , * tail_blk ,
2019-06-29 05:27:27 +03:00
XLOG_MAX_ICLOGS , tmp_buffer ,
& tmp_rhead_blk , & tmp_rhead , & tmp_wrapped ) ;
kmem_free ( tmp_buffer ) ;
2016-01-04 23:40:16 +03:00
if ( error < 0 )
return error ;
/*
* Now run a CRC verification pass over the records starting at the
* block found above to the current head . If a CRC failure occurs , the
* log block of the first bad record is saved in first_bad .
*/
error = xlog_do_recovery_pass ( log , * head_blk , tmp_rhead_blk ,
XLOG_RECOVER_CRCPASS , & first_bad ) ;
2017-08-09 04:21:53 +03:00
if ( ( error = = - EFSBADCRC | | error = = - EFSCORRUPTED ) & & first_bad ) {
2016-01-04 23:40:16 +03:00
/*
* We ' ve hit a potential torn write . Reset the error and warn
* about it .
*/
error = 0 ;
xfs_warn ( log - > l_mp ,
" Torn write (CRC failure) detected at log block 0x%llx. Truncating head block from 0x%llx. " ,
first_bad , * head_blk ) ;
/*
* Get the header block and buffer pointer for the last good
* record before the bad record .
*
* Note that xlog_find_tail ( ) clears the blocks at the new head
* ( i . e . , the records with invalid CRC ) if the cycle number
2020-08-05 18:49:58 +03:00
* matches the current cycle .
2016-01-04 23:40:16 +03:00
*/
2019-06-29 05:27:27 +03:00
found = xlog_rseek_logrec_hdr ( log , first_bad , * tail_blk , 1 ,
buffer , rhead_blk , rhead , wrapped ) ;
2016-01-04 23:40:16 +03:00
if ( found < 0 )
return found ;
if ( found = = 0 ) /* XXX: right thing to do here? */
return - EIO ;
/*
* Reset the head block to the starting block of the first bad
* log record and set the tail block based on the last good
* record .
*
* Bail out if the updated head / tail match as this indicates
* possible corruption outside of the acceptable
* ( XLOG_MAX_ICLOGS ) range . This is a job for xfs_repair . . .
*/
* head_blk = first_bad ;
* tail_blk = BLOCK_LSN ( be64_to_cpu ( ( * rhead ) - > h_tail_lsn ) ) ;
if ( * head_blk = = * tail_blk ) {
ASSERT ( 0 ) ;
return 0 ;
}
}
2017-08-09 04:21:51 +03:00
if ( error )
return error ;
2016-01-04 23:40:16 +03:00
2017-08-09 04:21:52 +03:00
return xlog_verify_tail ( log , * head_blk , tail_blk ,
be32_to_cpu ( ( * rhead ) - > h_size ) ) ;
2016-01-04 23:40:16 +03:00
}
2018-06-08 19:54:22 +03:00
/*
* We need to make sure we handle log wrapping properly , so we can ' t use the
* calculated logbno directly . Make sure it wraps to the correct bno inside the
* log .
*
* The log is limited to 32 bit sizes , so we use the appropriate modulus
* operation here and cast it back to a 64 bit daddr on return .
*/
static inline xfs_daddr_t
xlog_wrap_logbno (
struct xlog * log ,
xfs_daddr_t bno )
{
int mod ;
div_s64_rem ( bno , log - > l_logBBsize , & mod ) ;
return mod ;
}
2016-03-07 00:22:22 +03:00
/*
* Check whether the head of the log points to an unmount record . In other
* words , determine whether the log is clean . If so , update the in - core state
* appropriately .
*/
static int
xlog_check_unmount_rec (
struct xlog * log ,
xfs_daddr_t * head_blk ,
xfs_daddr_t * tail_blk ,
struct xlog_rec_header * rhead ,
xfs_daddr_t rhead_blk ,
2019-06-29 05:27:27 +03:00
char * buffer ,
2016-03-07 00:22:22 +03:00
bool * clean )
{
struct xlog_op_header * op_head ;
xfs_daddr_t umount_data_blk ;
xfs_daddr_t after_umount_blk ;
int hblks ;
int error ;
char * offset ;
* clean = false ;
/*
* Look for unmount record . If we find it , then we know there was a
* clean unmount . Since ' i ' could be the last block in the physical
* log , we convert to a log block before comparing to the head_blk .
*
* Save the current tail lsn to use to pass to xlog_clear_stale_blocks ( )
* below . We won ' t want to clear the unmount record if there is one , so
* we pass the lsn of the unmount record rather than the block after it .
*/
2020-09-22 19:41:06 +03:00
hblks = xlog_logrec_hblks ( log , rhead ) ;
2018-06-08 19:54:22 +03:00
after_umount_blk = xlog_wrap_logbno ( log ,
rhead_blk + hblks + BTOBB ( be32_to_cpu ( rhead - > h_len ) ) ) ;
2016-03-07 00:22:22 +03:00
if ( * head_blk = = after_umount_blk & &
be32_to_cpu ( rhead - > h_num_logops ) = = 1 ) {
2018-06-08 19:54:22 +03:00
umount_data_blk = xlog_wrap_logbno ( log , rhead_blk + hblks ) ;
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , umount_data_blk , 1 , buffer , & offset ) ;
2016-03-07 00:22:22 +03:00
if ( error )
return error ;
op_head = ( struct xlog_op_header * ) offset ;
if ( op_head - > oh_flags & XLOG_UNMOUNT_TRANS ) {
/*
* Set tail and last sync so that newly written log
* records will point recovery to after the current
* unmount record .
*/
xlog_assign_atomic_lsn ( & log - > l_tail_lsn ,
log - > l_curr_cycle , after_umount_blk ) ;
xlog_assign_atomic_lsn ( & log - > l_last_sync_lsn ,
log - > l_curr_cycle , after_umount_blk ) ;
* tail_blk = after_umount_blk ;
* clean = true ;
}
}
return 0 ;
}
2016-03-07 00:22:22 +03:00
static void
xlog_set_state (
struct xlog * log ,
xfs_daddr_t head_blk ,
struct xlog_rec_header * rhead ,
xfs_daddr_t rhead_blk ,
bool bump_cycle )
{
/*
* Reset log values according to the state of the log when we
* crashed . In the case where head_blk = = 0 , we bump curr_cycle
* one because the next write starts a new cycle rather than
* continuing the cycle of the last good log record . At this
* point we have guaranteed that all partial log records have been
* accounted for . Therefore , we know that the last good log record
* written was complete and ended exactly on the end boundary
* of the physical log .
*/
log - > l_prev_block = rhead_blk ;
log - > l_curr_block = ( int ) head_blk ;
log - > l_curr_cycle = be32_to_cpu ( rhead - > h_cycle ) ;
if ( bump_cycle )
log - > l_curr_cycle + + ;
atomic64_set ( & log - > l_tail_lsn , be64_to_cpu ( rhead - > h_tail_lsn ) ) ;
atomic64_set ( & log - > l_last_sync_lsn , be64_to_cpu ( rhead - > h_lsn ) ) ;
xlog_assign_grant_head ( & log - > l_reserve_head . grant , log - > l_curr_cycle ,
BBTOB ( log - > l_curr_block ) ) ;
xlog_assign_grant_head ( & log - > l_write_head . grant , log - > l_curr_cycle ,
BBTOB ( log - > l_curr_block ) ) ;
}
2005-04-17 02:20:36 +04:00
/*
* Find the sync block number or the tail of the log .
*
* This will be the block number of the last record to have its
* associated buffers synced to disk . Every log record header has
* a sync lsn embedded in it . LSNs hold block numbers , so it is easy
* to get a sync block number . The only concern is to figure out which
* log record header to believe .
*
* The following algorithm uses the log record header with the largest
* lsn . The entire log record does not need to be valid . We only care
* that the header is valid .
*
* We could speed up search by using current head_blk buffer , but it is not
* available .
*/
2009-11-19 18:52:00 +03:00
STATIC int
2005-04-17 02:20:36 +04:00
xlog_find_tail (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2005-04-17 02:20:36 +04:00
xfs_daddr_t * head_blk ,
2006-01-11 07:34:19 +03:00
xfs_daddr_t * tail_blk )
2005-04-17 02:20:36 +04:00
{
xlog_rec_header_t * rhead ;
2015-06-22 02:45:10 +03:00
char * offset = NULL ;
2019-06-29 05:27:27 +03:00
char * buffer ;
2016-01-04 23:40:16 +03:00
int error ;
xfs_daddr_t rhead_blk ;
2005-04-17 02:20:36 +04:00
xfs_lsn_t tail_lsn ;
2016-01-04 07:55:10 +03:00
bool wrapped = false ;
2016-03-07 00:22:22 +03:00
bool clean = false ;
2005-04-17 02:20:36 +04:00
/*
* Find previous log record
*/
if ( ( error = xlog_find_head ( log , head_blk ) ) )
return error ;
2016-03-07 00:22:22 +03:00
ASSERT ( * head_blk < INT_MAX ) ;
2005-04-17 02:20:36 +04:00
2019-06-29 05:27:27 +03:00
buffer = xlog_alloc_buffer ( log , 1 ) ;
if ( ! buffer )
2014-06-25 08:58:08 +04:00
return - ENOMEM ;
2005-04-17 02:20:36 +04:00
if ( * head_blk = = 0 ) { /* special case */
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , 0 , 1 , buffer , & offset ) ;
2009-03-16 10:24:13 +03:00
if ( error )
2010-04-15 22:17:26 +04:00
goto done ;
2009-03-16 10:24:13 +03:00
2007-10-12 04:58:05 +04:00
if ( xlog_get_cycle ( offset ) = = 0 ) {
2005-04-17 02:20:36 +04:00
* tail_blk = 0 ;
/* leave all other log inited values alone */
2010-04-15 22:17:26 +04:00
goto done ;
2005-04-17 02:20:36 +04:00
}
}
/*
2016-03-07 00:22:22 +03:00
* Search backwards through the log looking for the log record header
* block . This wraps all the way back around to the head so something is
* seriously wrong if we can ' t find it .
2005-04-17 02:20:36 +04:00
*/
2019-06-29 05:27:27 +03:00
error = xlog_rseek_logrec_hdr ( log , * head_blk , * head_blk , 1 , buffer ,
2016-03-07 00:22:22 +03:00
& rhead_blk , & rhead , & wrapped ) ;
if ( error < 0 )
2019-11-14 23:51:34 +03:00
goto done ;
2016-03-07 00:22:22 +03:00
if ( ! error ) {
xfs_warn ( log - > l_mp , " %s: couldn't find sync record " , __func__ ) ;
2019-11-14 23:51:34 +03:00
error = - EFSCORRUPTED ;
goto done ;
2016-03-07 00:22:22 +03:00
}
* tail_blk = BLOCK_LSN ( be64_to_cpu ( rhead - > h_tail_lsn ) ) ;
2005-04-17 02:20:36 +04:00
/*
2016-03-07 00:22:22 +03:00
* Set the log state based on the current head record .
2005-04-17 02:20:36 +04:00
*/
2016-03-07 00:22:22 +03:00
xlog_set_state ( log , * head_blk , rhead , rhead_blk , wrapped ) ;
2016-03-07 00:22:22 +03:00
tail_lsn = atomic64_read ( & log - > l_tail_lsn ) ;
2005-04-17 02:20:36 +04:00
/*
2016-03-07 00:22:22 +03:00
* Look for an unmount record at the head of the log . This sets the log
* state to determine whether recovery is necessary .
2005-04-17 02:20:36 +04:00
*/
2016-03-07 00:22:22 +03:00
error = xlog_check_unmount_rec ( log , head_blk , tail_blk , rhead ,
2019-06-29 05:27:27 +03:00
rhead_blk , buffer , & clean ) ;
2016-03-07 00:22:22 +03:00
if ( error )
goto done ;
2005-04-17 02:20:36 +04:00
/*
2016-03-07 00:22:22 +03:00
* Verify the log head if the log is not clean ( e . g . , we have anything
* but an unmount record at the head ) . This uses CRC verification to
* detect and trim torn writes . If discovered , CRC failures are
* considered torn writes and the log head is trimmed accordingly .
2005-04-17 02:20:36 +04:00
*
2016-03-07 00:22:22 +03:00
* Note that we can only run CRC verification when the log is dirty
* because there ' s no guarantee that the log data behind an unmount
* record is compatible with the current architecture .
2005-04-17 02:20:36 +04:00
*/
2016-03-07 00:22:22 +03:00
if ( ! clean ) {
xfs_daddr_t orig_head = * head_blk ;
2005-04-17 02:20:36 +04:00
2019-06-29 05:27:27 +03:00
error = xlog_verify_head ( log , head_blk , tail_blk , buffer ,
2016-03-07 00:22:22 +03:00
& rhead_blk , & rhead , & wrapped ) ;
2009-03-16 10:24:13 +03:00
if ( error )
2010-04-15 22:17:26 +04:00
goto done ;
2009-03-16 10:24:13 +03:00
2016-03-07 00:22:22 +03:00
/* update in-core state again if the head changed */
if ( * head_blk ! = orig_head ) {
xlog_set_state ( log , * head_blk , rhead , rhead_blk ,
wrapped ) ;
tail_lsn = atomic64_read ( & log - > l_tail_lsn ) ;
error = xlog_check_unmount_rec ( log , head_blk , tail_blk ,
2019-06-29 05:27:27 +03:00
rhead , rhead_blk , buffer ,
2016-03-07 00:22:22 +03:00
& clean ) ;
if ( error )
goto done ;
2005-04-17 02:20:36 +04:00
}
}
2016-03-07 00:22:22 +03:00
/*
* Note that the unmount was clean . If the unmount was not clean , we
* need to know this to rebuild the superblock counters from the perag
* headers if we have a filesystem using non - persistent counters .
*/
if ( clean )
log - > l_mp - > m_flags | = XFS_MOUNT_WAS_CLEAN ;
2005-04-17 02:20:36 +04:00
/*
* Make sure that there are no blocks in front of the head
* with the same cycle number as the head . This can happen
* because we allow multiple outstanding log writes concurrently ,
* and the later writes might make it out before earlier ones .
*
* We use the lsn from before modifying it so that we ' ll never
* overwrite the unmount record after a clean unmount .
*
* Do this only if we are going to recover the filesystem
*
* NOTE : This used to say " if (!readonly) "
* However on Linux , we can & do recover a read - only filesystem .
* We only skip recovery if NORECOVERY is specified on mount ,
* in which case we would not be here .
*
* But . . . if the - device - itself is readonly , just skip this .
* We can ' t recover this device anyway , so it won ' t matter .
*/
2019-06-29 05:27:24 +03:00
if ( ! xfs_readonly_buftarg ( log - > l_targ ) )
2005-04-17 02:20:36 +04:00
error = xlog_clear_stale_blocks ( log , tail_lsn ) ;
2010-04-15 22:17:26 +04:00
done :
2019-06-29 05:27:27 +03:00
kmem_free ( buffer ) ;
2005-04-17 02:20:36 +04:00
if ( error )
2011-03-07 02:01:35 +03:00
xfs_warn ( log - > l_mp , " failed to locate log tail " ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
/*
* Is the log zeroed at all ?
*
* The last binary search should be changed to perform an X block read
* once X becomes small enough . You can then search linearly through
* the X blocks . This will cut down on the number of reads we need to do .
*
* If the log is partially zeroed , this routine will pass back the blkno
* of the first block with cycle number 0. It won ' t have a complete LR
* preceding it .
*
* Return :
* 0 = > the log is completely written to
2014-06-25 08:58:08 +04:00
* 1 = > use * blk_no as the first block of the log
* < 0 = > error has occurred
2005-04-17 02:20:36 +04:00
*/
2007-11-23 08:28:09 +03:00
STATIC int
2005-04-17 02:20:36 +04:00
xlog_find_zeroed (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2005-04-17 02:20:36 +04:00
xfs_daddr_t * blk_no )
{
2019-06-29 05:27:27 +03:00
char * buffer ;
2015-06-22 02:45:10 +03:00
char * offset ;
2005-04-17 02:20:36 +04:00
uint first_cycle , last_cycle ;
xfs_daddr_t new_blk , last_blk , start_blk ;
xfs_daddr_t num_scan_bblks ;
int error , log_bbnum = log - > l_logBBsize ;
2006-06-28 04:13:52 +04:00
* blk_no = 0 ;
2005-04-17 02:20:36 +04:00
/* check totally zeroed log */
2019-06-29 05:27:27 +03:00
buffer = xlog_alloc_buffer ( log , 1 ) ;
if ( ! buffer )
2014-06-25 08:58:08 +04:00
return - ENOMEM ;
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , 0 , 1 , buffer , & offset ) ;
2009-03-16 10:24:13 +03:00
if ( error )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2009-03-16 10:24:13 +03:00
2007-10-12 04:58:05 +04:00
first_cycle = xlog_get_cycle ( offset ) ;
2005-04-17 02:20:36 +04:00
if ( first_cycle = = 0 ) { /* completely zeroed log */
* blk_no = 0 ;
2019-06-29 05:27:27 +03:00
kmem_free ( buffer ) ;
2014-06-25 08:58:08 +04:00
return 1 ;
2005-04-17 02:20:36 +04:00
}
/* check partially zeroed log */
2019-06-29 05:27:27 +03:00
error = xlog_bread ( log , log_bbnum - 1 , 1 , buffer , & offset ) ;
2009-03-16 10:24:13 +03:00
if ( error )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2009-03-16 10:24:13 +03:00
2007-10-12 04:58:05 +04:00
last_cycle = xlog_get_cycle ( offset ) ;
2005-04-17 02:20:36 +04:00
if ( last_cycle ! = 0 ) { /* log completely written to */
2019-06-29 05:27:27 +03:00
kmem_free ( buffer ) ;
2005-04-17 02:20:36 +04:00
return 0 ;
}
/* we have a partially zeroed log */
last_blk = log_bbnum - 1 ;
2019-06-29 05:27:27 +03:00
error = xlog_find_cycle_start ( log , buffer , 0 , & last_blk , 0 ) ;
if ( error )
goto out_free_buffer ;
2005-04-17 02:20:36 +04:00
/*
* Validate the answer . Because there is no way to guarantee that
* the entire log is made up of log records which are the same size ,
* we scan over the defined maximum blocks . At this point , the maximum
* is not chosen to mean anything special . XXXmiken
*/
num_scan_bblks = XLOG_TOTAL_REC_SHIFT ( log ) ;
ASSERT ( num_scan_bblks < = INT_MAX ) ;
if ( last_blk < num_scan_bblks )
num_scan_bblks = last_blk ;
start_blk = last_blk - num_scan_bblks ;
/*
* We search for any instances of cycle number 0 that occur before
* our current estimate of the head . What we ' re trying to detect is
* 1 . . . | 0 | 1 | 0. . .
* ^ binary search ends here
*/
if ( ( error = xlog_find_verify_cycle ( log , start_blk ,
( int ) num_scan_bblks , 0 , & new_blk ) ) )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2005-04-17 02:20:36 +04:00
if ( new_blk ! = - 1 )
last_blk = new_blk ;
/*
* Potentially backup over partial log record write . We don ' t need
* to search the end of the log because we know it is zero .
*/
2014-06-25 08:58:08 +04:00
error = xlog_find_verify_log_record ( log , start_blk , & last_blk , 0 ) ;
if ( error = = 1 )
error = - EIO ;
if ( error )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2005-04-17 02:20:36 +04:00
* blk_no = last_blk ;
2019-06-29 05:27:27 +03:00
out_free_buffer :
kmem_free ( buffer ) ;
2005-04-17 02:20:36 +04:00
if ( error )
return error ;
2014-06-25 08:58:08 +04:00
return 1 ;
2005-04-17 02:20:36 +04:00
}
/*
* These are simple subroutines used by xlog_clear_stale_blocks ( ) below
* to initialize a buffer full of empty log record headers and write
* them into the log .
*/
STATIC void
xlog_add_record (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2015-06-22 02:45:10 +03:00
char * buf ,
2005-04-17 02:20:36 +04:00
int cycle ,
int block ,
int tail_cycle ,
int tail_block )
{
xlog_rec_header_t * recp = ( xlog_rec_header_t * ) buf ;
memset ( buf , 0 , BBSIZE ) ;
2007-10-12 04:59:34 +04:00
recp - > h_magicno = cpu_to_be32 ( XLOG_HEADER_MAGIC_NUM ) ;
recp - > h_cycle = cpu_to_be32 ( cycle ) ;
recp - > h_version = cpu_to_be32 (
2008-03-06 05:44:28 +03:00
xfs_sb_version_haslogv2 ( & log - > l_mp - > m_sb ) ? 2 : 1 ) ;
2007-10-12 04:59:34 +04:00
recp - > h_lsn = cpu_to_be64 ( xlog_assign_lsn ( cycle , block ) ) ;
recp - > h_tail_lsn = cpu_to_be64 ( xlog_assign_lsn ( tail_cycle , tail_block ) ) ;
recp - > h_fmt = cpu_to_be32 ( XLOG_FMT ) ;
2005-04-17 02:20:36 +04:00
memcpy ( & recp - > h_fs_uuid , & log - > l_mp - > m_sb . sb_uuid , sizeof ( uuid_t ) ) ;
}
STATIC int
xlog_write_log_records (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2005-04-17 02:20:36 +04:00
int cycle ,
int start_block ,
int blocks ,
int tail_cycle ,
int tail_block )
{
2015-06-22 02:45:10 +03:00
char * offset ;
2019-06-29 05:27:27 +03:00
char * buffer ;
2005-04-17 02:20:36 +04:00
int balign , ealign ;
2010-04-20 11:09:59 +04:00
int sectbb = log - > l_sectBBsize ;
2005-04-17 02:20:36 +04:00
int end_block = start_block + blocks ;
int bufblks ;
int error = 0 ;
int i , j = 0 ;
2010-04-13 09:22:29 +04:00
/*
* Greedily allocate a buffer big enough to handle the full
* range of basic blocks to be written . If that fails , try
* a smaller size . We need to be able to write at least a
* log sector , or we ' re out of luck .
*/
2005-04-17 02:20:36 +04:00
bufblks = 1 < < ffs ( blocks ) ;
2012-04-27 13:45:22 +04:00
while ( bufblks > log - > l_logBBsize )
bufblks > > = 1 ;
2019-06-29 05:27:27 +03:00
while ( ! ( buffer = xlog_alloc_buffer ( log , bufblks ) ) ) {
2005-04-17 02:20:36 +04:00
bufblks > > = 1 ;
2010-04-20 11:09:59 +04:00
if ( bufblks < sectbb )
2014-06-25 08:58:08 +04:00
return - ENOMEM ;
2005-04-17 02:20:36 +04:00
}
/* We may need to do a read at the start to fill in part of
* the buffer in the starting sector not covered by the first
* write below .
*/
2010-04-13 09:22:48 +04:00
balign = round_down ( start_block , sectbb ) ;
2005-04-17 02:20:36 +04:00
if ( balign ! = start_block ) {
2019-06-29 05:27:27 +03:00
error = xlog_bread_noalign ( log , start_block , 1 , buffer ) ;
2009-03-16 10:24:13 +03:00
if ( error )
2019-06-29 05:27:27 +03:00
goto out_free_buffer ;
2009-03-16 10:24:13 +03:00
2005-04-17 02:20:36 +04:00
j = start_block - balign ;
}
for ( i = start_block ; i < end_block ; i + = bufblks ) {
int bcount , endcount ;
bcount = min ( bufblks , end_block - start_block ) ;
endcount = bcount - j ;
/* We may need to do a read at the end to fill in part of
* the buffer in the final sector not covered by the write .
* If this is the same sector as the above read , skip it .
*/
2010-04-13 09:22:48 +04:00
ealign = round_down ( end_block , sectbb ) ;
2005-04-17 02:20:36 +04:00
if ( j = = 0 & & ( start_block + endcount > ealign ) ) {
2019-06-29 05:27:26 +03:00
error = xlog_bread_noalign ( log , ealign , sectbb ,
2019-06-29 05:27:27 +03:00
buffer + BBTOB ( ealign - start_block ) ) ;
2009-03-16 10:24:13 +03:00
if ( error )
break ;
2005-04-17 02:20:36 +04:00
}
2019-06-29 05:27:27 +03:00
offset = buffer + xlog_align ( log , start_block ) ;
2005-04-17 02:20:36 +04:00
for ( ; j < endcount ; j + + ) {
xlog_add_record ( log , offset , cycle , i + j ,
tail_cycle , tail_block ) ;
offset + = BBSIZE ;
}
2019-06-29 05:27:27 +03:00
error = xlog_bwrite ( log , start_block , endcount , buffer ) ;
2005-04-17 02:20:36 +04:00
if ( error )
break ;
start_block + = endcount ;
j = 0 ;
}
2009-03-16 10:24:13 +03:00
2019-06-29 05:27:27 +03:00
out_free_buffer :
kmem_free ( buffer ) ;
2005-04-17 02:20:36 +04:00
return error ;
}
/*
* This routine is called to blow away any incomplete log writes out
* in front of the log head . We do this so that we won ' t become confused
* if we come up , write only a little bit more , and then crash again .
* If we leave the partial log records out there , this situation could
* cause us to think those partial writes are valid blocks since they
* have the current cycle number . We get rid of them by overwriting them
* with empty log records with the old cycle number rather than the
* current one .
*
* The tail lsn is passed in rather than taken from
* the log so that we will not write over the unmount record after a
* clean unmount in a 512 block log . Doing so would leave the log without
* any valid log records in it until a new one was written . If we crashed
* during that time we would not be able to recover .
*/
STATIC int
xlog_clear_stale_blocks (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2005-04-17 02:20:36 +04:00
xfs_lsn_t tail_lsn )
{
int tail_cycle , head_cycle ;
int tail_block , head_block ;
int tail_distance , max_distance ;
int distance ;
int error ;
tail_cycle = CYCLE_LSN ( tail_lsn ) ;
tail_block = BLOCK_LSN ( tail_lsn ) ;
head_cycle = log - > l_curr_cycle ;
head_block = log - > l_curr_block ;
/*
* Figure out the distance between the new head of the log
* and the tail . We want to write over any blocks beyond the
* head that we may have written just before the crash , but
* we don ' t want to overwrite the tail of the log .
*/
if ( head_cycle = = tail_cycle ) {
/*
* The tail is behind the head in the physical log ,
* so the distance from the head to the tail is the
* distance from the head to the end of the log plus
* the distance from the beginning of the log to the
* tail .
*/
2019-11-11 23:53:22 +03:00
if ( XFS_IS_CORRUPT ( log - > l_mp ,
head_block < tail_block | |
head_block > = log - > l_logBBsize ) )
2014-06-25 08:58:08 +04:00
return - EFSCORRUPTED ;
2005-04-17 02:20:36 +04:00
tail_distance = tail_block + ( log - > l_logBBsize - head_block ) ;
} else {
/*
* The head is behind the tail in the physical log ,
* so the distance from the head to the tail is just
* the tail block minus the head block .
*/
2019-11-11 23:53:22 +03:00
if ( XFS_IS_CORRUPT ( log - > l_mp ,
head_block > = tail_block | |
head_cycle ! = tail_cycle + 1 ) )
2014-06-25 08:58:08 +04:00
return - EFSCORRUPTED ;
2005-04-17 02:20:36 +04:00
tail_distance = tail_block - head_block ;
}
/*
* If the head is right up against the tail , we can ' t clear
* anything .
*/
if ( tail_distance < = 0 ) {
ASSERT ( tail_distance = = 0 ) ;
return 0 ;
}
max_distance = XLOG_TOTAL_REC_SHIFT ( log ) ;
/*
* Take the smaller of the maximum amount of outstanding I / O
* we could have and the distance to the tail to clear out .
* We take the smaller so that we don ' t overwrite the tail and
* we don ' t waste all day writing from the head to the tail
* for no reason .
*/
2018-06-07 17:54:02 +03:00
max_distance = min ( max_distance , tail_distance ) ;
2005-04-17 02:20:36 +04:00
if ( ( head_block + max_distance ) < = log - > l_logBBsize ) {
/*
* We can stomp all the blocks we need to without
* wrapping around the end of the log . Just do it
* in a single write . Use the cycle number of the
* current cycle minus one so that the log will look like :
* n . . . | n - 1 . . .
*/
error = xlog_write_log_records ( log , ( head_cycle - 1 ) ,
head_block , max_distance , tail_cycle ,
tail_block ) ;
if ( error )
return error ;
} else {
/*
* We need to wrap around the end of the physical log in
* order to clear all the blocks . Do it in two separate
* I / Os . The first write should be from the head to the
* end of the physical log , and it should use the current
* cycle number minus one just like above .
*/
distance = log - > l_logBBsize - head_block ;
error = xlog_write_log_records ( log , ( head_cycle - 1 ) ,
head_block , distance , tail_cycle ,
tail_block ) ;
if ( error )
return error ;
/*
* Now write the blocks at the start of the physical log .
* This writes the remainder of the blocks we want to clear .
* It uses the current cycle number since we ' re now on the
* same cycle as the head so that we get :
* n . . . n . . . | n - 1 . . .
* ^ ^ ^ ^ ^ blocks we ' re writing
*/
distance = max_distance - ( log - > l_logBBsize - head_block ) ;
error = xlog_write_log_records ( log , head_cycle , 0 , distance ,
tail_cycle , tail_block ) ;
if ( error )
return error ;
}
return 0 ;
}
2020-05-02 02:00:54 +03:00
/*
* Release the recovered intent item in the AIL that matches the given intent
* type and intent id .
*/
void
xlog_recover_release_intent (
struct xlog * log ,
unsigned short intent_type ,
uint64_t intent_id )
{
struct xfs_ail_cursor cur ;
struct xfs_log_item * lip ;
struct xfs_ail * ailp = log - > l_ailp ;
spin_lock ( & ailp - > ail_lock ) ;
for ( lip = xfs_trans_ail_cursor_first ( ailp , & cur , 0 ) ; lip ! = NULL ;
lip = xfs_trans_ail_cursor_next ( ailp , & cur ) ) {
if ( lip - > li_type ! = intent_type )
continue ;
if ( ! lip - > li_ops - > iop_match ( lip , intent_id ) )
continue ;
spin_unlock ( & ailp - > ail_lock ) ;
lip - > li_ops - > iop_release ( lip ) ;
spin_lock ( & ailp - > ail_lock ) ;
break ;
}
xfs_trans_ail_cursor_done ( & cur ) ;
spin_unlock ( & ailp - > ail_lock ) ;
}
2005-04-17 02:20:36 +04:00
/******************************************************************************
*
* Log recover routines
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
2020-05-02 02:00:45 +03:00
static const struct xlog_recover_item_ops * xlog_recover_item_ops [ ] = {
& xlog_buf_item_ops ,
& xlog_inode_item_ops ,
& xlog_dquot_item_ops ,
& xlog_quotaoff_item_ops ,
& xlog_icreate_item_ops ,
& xlog_efi_item_ops ,
& xlog_efd_item_ops ,
& xlog_rui_item_ops ,
& xlog_rud_item_ops ,
& xlog_cui_item_ops ,
& xlog_cud_item_ops ,
& xlog_bui_item_ops ,
& xlog_bud_item_ops ,
} ;
static const struct xlog_recover_item_ops *
xlog_find_item_ops (
struct xlog_recover_item * item )
{
unsigned int i ;
for ( i = 0 ; i < ARRAY_SIZE ( xlog_recover_item_ops ) ; i + + )
if ( ITEM_TYPE ( item ) = = xlog_recover_item_ops [ i ] - > item_type )
return xlog_recover_item_ops [ i ] ;
return NULL ;
}
2005-04-17 02:20:36 +04:00
2010-01-11 14:49:57 +03:00
/*
2013-06-05 06:09:07 +04:00
* Sort the log items in the transaction .
*
* The ordering constraints are defined by the inode allocation and unlink
* behaviour . The rules are :
*
* 1. Every item is only logged once in a given transaction . Hence it
* represents the last logged state of the item . Hence ordering is
* dependent on the order in which operations need to be performed so
* required initial conditions are always met .
*
* 2. Cancelled buffers are recorded in pass 1 in a separate table and
* there ' s nothing to replay from them so we can simply cull them
* from the transaction . However , we can ' t do that until after we ' ve
* replayed all the other items because they may be dependent on the
* cancelled buffer and replaying the cancelled buffer can remove it
* form the cancelled buffer table . Hence they have tobe done last .
*
* 3. Inode allocation buffers must be replayed before inode items that
2013-06-27 10:04:55 +04:00
* read the buffer and replay changes into it . For filesystems using the
* ICREATE transactions , this means XFS_LI_ICREATE objects need to get
* treated the same as inode allocation buffers as they create and
* initialise the buffers directly .
2013-06-05 06:09:07 +04:00
*
* 4. Inode unlink buffers must be replayed after inode items are replayed .
* This ensures that inodes are completely flushed to the inode buffer
* in a " free " state before we remove the unlinked inode list pointer .
*
* Hence the ordering needs to be inode allocation buffers first , inode items
* second , inode unlink buffers third and cancelled buffers last .
*
* But there ' s a problem with that - we can ' t tell an inode allocation buffer
* apart from a regular buffer , so we can ' t separate them . We can , however ,
* tell an inode unlink buffer from the others , and so we can separate them out
* from all the other buffers and move them to last .
*
* Hence , 4 lists , in order from head to tail :
2013-06-27 10:04:55 +04:00
* - buffer_list for all buffers except cancelled / inode unlink buffers
* - item_list for all non - buffer items
* - inode_buffer_list for inode unlink buffers
* - cancel_list for the cancelled buffers
*
* Note that we add objects to the tail of the lists so that first - to - last
* ordering is preserved within the lists . Adding objects to the head of the
* list means when we traverse from the head we walk them in last - to - first
* order . For cancelled buffers and inode unlink buffers this doesn ' t matter ,
* but for all other items there may be specific ordering that we need to
* preserve .
2010-01-11 14:49:57 +03:00
*/
2005-04-17 02:20:36 +04:00
STATIC int
xlog_recover_reorder_trans (
2012-06-14 18:22:15 +04:00
struct xlog * log ,
struct xlog_recover * trans ,
2010-04-13 09:06:46 +04:00
int pass )
2005-04-17 02:20:36 +04:00
{
2020-04-30 20:45:41 +03:00
struct xlog_recover_item * item , * n ;
2013-10-02 16:51:12 +04:00
int error = 0 ;
2010-01-11 14:49:57 +03:00
LIST_HEAD ( sort_list ) ;
2013-06-05 06:09:07 +04:00
LIST_HEAD ( cancel_list ) ;
LIST_HEAD ( buffer_list ) ;
LIST_HEAD ( inode_buffer_list ) ;
2020-04-27 21:14:59 +03:00
LIST_HEAD ( item_list ) ;
2010-01-11 14:49:57 +03:00
list_splice_init ( & trans - > r_itemq , & sort_list ) ;
list_for_each_entry_safe ( item , n , & sort_list , ri_list ) {
2020-05-02 02:00:45 +03:00
enum xlog_recover_reorder fate = XLOG_REORDER_ITEM_LIST ;
2005-04-17 02:20:36 +04:00
2020-05-02 02:00:45 +03:00
item - > ri_ops = xlog_find_item_ops ( item ) ;
if ( ! item - > ri_ops ) {
2011-03-07 02:01:35 +03:00
xfs_warn ( log - > l_mp ,
2020-04-22 00:16:52 +03:00
" %s: unrecognized type of log operation (%d) " ,
__func__ , ITEM_TYPE ( item ) ) ;
2005-04-17 02:20:36 +04:00
ASSERT ( 0 ) ;
2013-10-02 16:51:12 +04:00
/*
* return the remaining items back to the transaction
* item list so they can be freed in caller .
*/
if ( ! list_empty ( & sort_list ) )
list_splice_init ( & sort_list , & trans - > r_itemq ) ;
2020-05-02 02:00:45 +03:00
error = - EFSCORRUPTED ;
break ;
}
if ( item - > ri_ops - > reorder )
fate = item - > ri_ops - > reorder ( item ) ;
switch ( fate ) {
case XLOG_REORDER_BUFFER_LIST :
list_move_tail ( & item - > ri_list , & buffer_list ) ;
break ;
case XLOG_REORDER_CANCEL_LIST :
trace_xfs_log_recover_item_reorder_head ( log ,
trans , item , pass ) ;
list_move ( & item - > ri_list , & cancel_list ) ;
break ;
case XLOG_REORDER_INODE_BUFFER_LIST :
list_move ( & item - > ri_list , & inode_buffer_list ) ;
break ;
case XLOG_REORDER_ITEM_LIST :
trace_xfs_log_recover_item_reorder_tail ( log ,
trans , item , pass ) ;
list_move_tail ( & item - > ri_list , & item_list ) ;
break ;
2005-04-17 02:20:36 +04:00
}
2010-01-11 14:49:57 +03:00
}
2020-05-02 02:00:45 +03:00
2010-01-11 14:49:57 +03:00
ASSERT ( list_empty ( & sort_list ) ) ;
2013-06-05 06:09:07 +04:00
if ( ! list_empty ( & buffer_list ) )
list_splice ( & buffer_list , & trans - > r_itemq ) ;
2020-04-27 21:14:59 +03:00
if ( ! list_empty ( & item_list ) )
list_splice_tail ( & item_list , & trans - > r_itemq ) ;
2013-06-05 06:09:07 +04:00
if ( ! list_empty ( & inode_buffer_list ) )
list_splice_tail ( & inode_buffer_list , & trans - > r_itemq ) ;
if ( ! list_empty ( & cancel_list ) )
list_splice_tail ( & cancel_list , & trans - > r_itemq ) ;
2013-10-02 16:51:12 +04:00
return error ;
2005-04-17 02:20:36 +04:00
}
2020-05-02 02:00:46 +03:00
void
2020-04-28 04:23:17 +03:00
xlog_buf_readahead (
struct xlog * log ,
xfs_daddr_t blkno ,
uint len ,
const struct xfs_buf_ops * ops )
{
if ( ! xlog_is_buffer_cancelled ( log , blkno , len ) )
xfs_buf_readahead ( log - > l_mp - > m_ddev_targp , blkno , len , ops ) ;
}
2013-08-14 11:16:03 +04:00
STATIC int
xlog_recover_items_pass2 (
struct xlog * log ,
struct xlog_recover * trans ,
struct list_head * buffer_list ,
struct list_head * item_list )
{
struct xlog_recover_item * item ;
int error = 0 ;
list_for_each_entry ( item , item_list , ri_list ) {
2020-05-02 02:00:50 +03:00
trace_xfs_log_recover_item_recover ( log , trans , item ,
XLOG_RECOVER_PASS2 ) ;
if ( item - > ri_ops - > commit_pass2 )
error = item - > ri_ops - > commit_pass2 ( log , buffer_list ,
item , trans - > r_lsn ) ;
2013-08-14 11:16:03 +04:00
if ( error )
return error ;
}
return error ;
}
2010-12-02 01:06:23 +03:00
/*
* Perform the transaction .
*
* If the transaction modifies a buffer or inode , do it now . Otherwise ,
* EFIs and EFDs get queued up by adding entries into the AIL for them .
*/
2005-04-17 02:20:36 +04:00
STATIC int
xlog_recover_commit_trans (
2012-06-14 18:22:15 +04:00
struct xlog * log ,
2010-12-02 01:06:23 +03:00
struct xlog_recover * trans ,
2016-09-26 01:22:16 +03:00
int pass ,
struct list_head * buffer_list )
2005-04-17 02:20:36 +04:00
{
2013-08-14 11:16:03 +04:00
int error = 0 ;
int items_queued = 0 ;
struct xlog_recover_item * item ;
struct xlog_recover_item * next ;
LIST_HEAD ( ra_list ) ;
LIST_HEAD ( done_list ) ;
# define XLOG_RECOVER_COMMIT_QUEUE_MAX 100
2005-04-17 02:20:36 +04:00
2017-06-24 20:11:41 +03:00
hlist_del_init ( & trans - > r_list ) ;
2010-12-02 01:06:23 +03:00
error = xlog_recover_reorder_trans ( log , trans , pass ) ;
if ( error )
2005-04-17 02:20:36 +04:00
return error ;
2010-12-02 01:06:23 +03:00
2013-08-14 11:16:03 +04:00
list_for_each_entry_safe ( item , next , & trans - > r_itemq , ri_list ) {
2020-05-02 02:00:46 +03:00
trace_xfs_log_recover_item_recover ( log , trans , item , pass ) ;
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-23 09:58:39 +04:00
switch ( pass ) {
case XLOG_RECOVER_PASS1 :
2020-05-02 02:00:46 +03:00
if ( item - > ri_ops - > commit_pass1 )
error = item - > ri_ops - > commit_pass1 ( log , item ) ;
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-23 09:58:39 +04:00
break ;
case XLOG_RECOVER_PASS2 :
2020-05-02 02:00:46 +03:00
if ( item - > ri_ops - > ra_pass2 )
item - > ri_ops - > ra_pass2 ( log , item ) ;
2013-08-14 11:16:03 +04:00
list_move_tail ( & item - > ri_list , & ra_list ) ;
items_queued + + ;
if ( items_queued > = XLOG_RECOVER_COMMIT_QUEUE_MAX ) {
error = xlog_recover_items_pass2 ( log , trans ,
2016-09-26 01:22:16 +03:00
buffer_list , & ra_list ) ;
2013-08-14 11:16:03 +04:00
list_splice_tail_init ( & ra_list , & done_list ) ;
items_queued = 0 ;
}
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-23 09:58:39 +04:00
break ;
default :
ASSERT ( 0 ) ;
}
2010-12-02 01:06:23 +03:00
if ( error )
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-23 09:58:39 +04:00
goto out ;
2010-12-02 01:06:23 +03:00
}
2013-08-14 11:16:03 +04:00
out :
if ( ! list_empty ( & ra_list ) ) {
if ( ! error )
error = xlog_recover_items_pass2 ( log , trans ,
2016-09-26 01:22:16 +03:00
buffer_list , & ra_list ) ;
2013-08-14 11:16:03 +04:00
list_splice_tail_init ( & ra_list , & done_list ) ;
}
if ( ! list_empty ( & done_list ) )
list_splice_init ( & done_list , & trans - > r_itemq ) ;
2016-09-26 01:22:16 +03:00
return error ;
2005-04-17 02:20:36 +04:00
}
2014-09-29 03:45:42 +04:00
STATIC void
xlog_recover_add_item (
struct list_head * head )
{
2020-04-30 20:45:41 +03:00
struct xlog_recover_item * item ;
2014-09-29 03:45:42 +04:00
2020-04-30 20:45:41 +03:00
item = kmem_zalloc ( sizeof ( struct xlog_recover_item ) , 0 ) ;
2014-09-29 03:45:42 +04:00
INIT_LIST_HEAD ( & item - > ri_list ) ;
list_add_tail ( & item - > ri_list , head ) ;
}
2005-04-17 02:20:36 +04:00
STATIC int
2014-09-29 03:45:42 +04:00
xlog_recover_add_to_cont_trans (
struct xlog * log ,
struct xlog_recover * trans ,
2015-06-22 02:45:10 +03:00
char * dp ,
2014-09-29 03:45:42 +04:00
int len )
2005-04-17 02:20:36 +04:00
{
2020-04-30 20:45:41 +03:00
struct xlog_recover_item * item ;
2015-06-22 02:45:10 +03:00
char * ptr , * old_ptr ;
2014-09-29 03:45:42 +04:00
int old_len ;
2015-07-29 04:51:10 +03:00
/*
* If the transaction is empty , the header was split across this and the
* previous record . Copy the rest of the header .
*/
2014-09-29 03:45:42 +04:00
if ( list_empty ( & trans - > r_itemq ) ) {
2015-11-10 02:10:33 +03:00
ASSERT ( len < = sizeof ( struct xfs_trans_header ) ) ;
2015-07-29 04:51:10 +03:00
if ( len > sizeof ( struct xfs_trans_header ) ) {
xfs_warn ( log - > l_mp , " %s: bad header length " , __func__ ) ;
2019-11-06 20:17:43 +03:00
return - EFSCORRUPTED ;
2015-07-29 04:51:10 +03:00
}
2014-09-29 03:45:42 +04:00
xlog_recover_add_item ( & trans - > r_itemq ) ;
2015-06-22 02:45:10 +03:00
ptr = ( char * ) & trans - > r_theader +
2015-07-29 04:51:10 +03:00
sizeof ( struct xfs_trans_header ) - len ;
2014-09-29 03:45:42 +04:00
memcpy ( ptr , dp , len ) ;
return 0 ;
}
2015-07-29 04:51:10 +03:00
2014-09-29 03:45:42 +04:00
/* take the tail entry */
2020-04-30 20:45:41 +03:00
item = list_entry ( trans - > r_itemq . prev , struct xlog_recover_item ,
ri_list ) ;
2014-09-29 03:45:42 +04:00
old_ptr = item - > ri_buf [ item - > ri_cnt - 1 ] . i_addr ;
old_len = item - > ri_buf [ item - > ri_cnt - 1 ] . i_len ;
2020-08-27 00:05:56 +03:00
ptr = krealloc ( old_ptr , len + old_len , GFP_KERNEL | __GFP_NOFAIL ) ;
2014-09-29 03:45:42 +04:00
memcpy ( & ptr [ old_len ] , dp , len ) ;
item - > ri_buf [ item - > ri_cnt - 1 ] . i_len + = len ;
item - > ri_buf [ item - > ri_cnt - 1 ] . i_addr = ptr ;
trace_xfs_log_recover_item_add_cont ( log , trans , item , 0 ) ;
2005-04-17 02:20:36 +04:00
return 0 ;
}
2014-09-29 03:45:42 +04:00
/*
* The next region to add is the start of a new region . It could be
* a whole region or it could be the first part of a new region . Because
* of this , the assumption here is that the type and size fields of all
* format structures fit into the first 32 bits of the structure .
*
* This works because all regions must be 32 bit aligned . Therefore , we
* either have both fields or we have neither field . In the case we have
* neither field , the data part of the region is zero length . We only have
* a log_op_header and can throw away the header since a new one will appear
* later . If we have at least 4 bytes , then we can determine how many regions
* will appear in the current log item .
*/
STATIC int
xlog_recover_add_to_trans (
struct xlog * log ,
struct xlog_recover * trans ,
2015-06-22 02:45:10 +03:00
char * dp ,
2014-09-29 03:45:42 +04:00
int len )
{
2017-10-31 22:04:24 +03:00
struct xfs_inode_log_format * in_f ; /* any will do */
2020-04-30 20:45:41 +03:00
struct xlog_recover_item * item ;
2015-06-22 02:45:10 +03:00
char * ptr ;
2014-09-29 03:45:42 +04:00
if ( ! len )
return 0 ;
if ( list_empty ( & trans - > r_itemq ) ) {
/* we need to catch log corruptions here */
if ( * ( uint * ) dp ! = XFS_TRANS_HEADER_MAGIC ) {
xfs_warn ( log - > l_mp , " %s: bad header magic number " ,
__func__ ) ;
ASSERT ( 0 ) ;
2019-11-06 20:17:43 +03:00
return - EFSCORRUPTED ;
2014-09-29 03:45:42 +04:00
}
2015-07-29 04:51:10 +03:00
if ( len > sizeof ( struct xfs_trans_header ) ) {
xfs_warn ( log - > l_mp , " %s: bad header length " , __func__ ) ;
ASSERT ( 0 ) ;
2019-11-06 20:17:43 +03:00
return - EFSCORRUPTED ;
2015-07-29 04:51:10 +03:00
}
/*
* The transaction header can be arbitrarily split across op
* records . If we don ' t have the whole thing here , copy what we
* do have and handle the rest in the next record .
*/
if ( len = = sizeof ( struct xfs_trans_header ) )
2014-09-29 03:45:42 +04:00
xlog_recover_add_item ( & trans - > r_itemq ) ;
memcpy ( & trans - > r_theader , dp , len ) ;
return 0 ;
}
2019-08-26 22:06:22 +03:00
ptr = kmem_alloc ( len , 0 ) ;
2014-09-29 03:45:42 +04:00
memcpy ( ptr , dp , len ) ;
2017-10-31 22:04:24 +03:00
in_f = ( struct xfs_inode_log_format * ) ptr ;
2014-09-29 03:45:42 +04:00
/* take the tail entry */
2020-04-30 20:45:41 +03:00
item = list_entry ( trans - > r_itemq . prev , struct xlog_recover_item ,
ri_list ) ;
2014-09-29 03:45:42 +04:00
if ( item - > ri_total ! = 0 & &
item - > ri_total = = item - > ri_cnt ) {
/* tail item is in use, get a new one */
xlog_recover_add_item ( & trans - > r_itemq ) ;
item = list_entry ( trans - > r_itemq . prev ,
2020-04-30 20:45:41 +03:00
struct xlog_recover_item , ri_list ) ;
2014-09-29 03:45:42 +04:00
}
if ( item - > ri_total = = 0 ) { /* first region to be added */
if ( in_f - > ilf_size = = 0 | |
in_f - > ilf_size > XLOG_MAX_REGIONS_IN_ITEM ) {
xfs_warn ( log - > l_mp ,
" bad number of regions (%d) in inode log format " ,
in_f - > ilf_size ) ;
ASSERT ( 0 ) ;
kmem_free ( ptr ) ;
2019-11-06 20:17:43 +03:00
return - EFSCORRUPTED ;
2014-09-29 03:45:42 +04:00
}
item - > ri_total = in_f - > ilf_size ;
item - > ri_buf =
kmem_zalloc ( item - > ri_total * sizeof ( xfs_log_iovec_t ) ,
2019-08-26 22:06:22 +03:00
0 ) ;
2014-09-29 03:45:42 +04:00
}
2019-11-06 20:11:23 +03:00
if ( item - > ri_total < = item - > ri_cnt ) {
xfs_warn ( log - > l_mp ,
" log item region count (%d) overflowed size (%d) " ,
item - > ri_cnt , item - > ri_total ) ;
ASSERT ( 0 ) ;
kmem_free ( ptr ) ;
return - EFSCORRUPTED ;
}
2014-09-29 03:45:42 +04:00
/* Description region is ri_buf[0] */
item - > ri_buf [ item - > ri_cnt ] . i_addr = ptr ;
item - > ri_buf [ item - > ri_cnt ] . i_len = len ;
item - > ri_cnt + + ;
trace_xfs_log_recover_item_add ( log , trans , item , 0 ) ;
return 0 ;
}
2014-09-29 03:45:54 +04:00
2014-09-29 03:45:42 +04:00
/*
* Free up any resources allocated by the transaction
*
* Remember that EFIs , EFDs , and IUNLINKs are handled later .
*/
STATIC void
xlog_recover_free_trans (
struct xlog_recover * trans )
{
2020-04-30 20:45:41 +03:00
struct xlog_recover_item * item , * n ;
2014-09-29 03:45:42 +04:00
int i ;
2017-06-24 20:11:41 +03:00
hlist_del_init ( & trans - > r_list ) ;
2014-09-29 03:45:42 +04:00
list_for_each_entry_safe ( item , n , & trans - > r_itemq , ri_list ) {
/* Free the regions in the item. */
list_del ( & item - > ri_list ) ;
for ( i = 0 ; i < item - > ri_cnt ; i + + )
kmem_free ( item - > ri_buf [ i ] . i_addr ) ;
/* Free the item itself */
kmem_free ( item - > ri_buf ) ;
kmem_free ( item ) ;
}
/* Free the transaction recover structure */
kmem_free ( trans ) ;
}
2014-09-29 03:45:18 +04:00
/*
* On error or completion , trans is freed .
*/
2005-04-17 02:20:36 +04:00
STATIC int
2014-09-29 03:45:03 +04:00
xlog_recovery_process_trans (
struct xlog * log ,
struct xlog_recover * trans ,
2015-06-22 02:45:10 +03:00
char * dp ,
2014-09-29 03:45:03 +04:00
unsigned int len ,
unsigned int flags ,
2016-09-26 01:22:16 +03:00
int pass ,
struct list_head * buffer_list )
2005-04-17 02:20:36 +04:00
{
2014-09-29 03:45:18 +04:00
int error = 0 ;
bool freeit = false ;
2014-09-29 03:45:03 +04:00
/* mask off ophdr transaction container flags */
flags & = ~ XLOG_END_TRANS ;
if ( flags & XLOG_WAS_CONT_TRANS )
flags & = ~ XLOG_CONTINUE_TRANS ;
2014-09-29 03:45:32 +04:00
/*
* Callees must not free the trans structure . We ' ll decide if we need to
* free it or not based on the operation being done and it ' s result .
*/
2014-09-29 03:45:03 +04:00
switch ( flags ) {
/* expected flag values */
case 0 :
case XLOG_CONTINUE_TRANS :
error = xlog_recover_add_to_trans ( log , trans , dp , len ) ;
break ;
case XLOG_WAS_CONT_TRANS :
error = xlog_recover_add_to_cont_trans ( log , trans , dp , len ) ;
break ;
case XLOG_COMMIT_TRANS :
2016-09-26 01:22:16 +03:00
error = xlog_recover_commit_trans ( log , trans , pass ,
buffer_list ) ;
2014-09-29 03:45:32 +04:00
/* success or fail, we are now done with this transaction. */
freeit = true ;
2014-09-29 03:45:03 +04:00
break ;
/* unexpected flag values */
case XLOG_UNMOUNT_TRANS :
2014-09-29 03:45:18 +04:00
/* just skip trans */
2014-09-29 03:45:03 +04:00
xfs_warn ( log - > l_mp , " %s: Unmount LR " , __func__ ) ;
2014-09-29 03:45:18 +04:00
freeit = true ;
2014-09-29 03:45:03 +04:00
break ;
case XLOG_START_TRANS :
default :
xfs_warn ( log - > l_mp , " %s: bad flag 0x%x " , __func__ , flags ) ;
ASSERT ( 0 ) ;
2019-11-06 20:17:43 +03:00
error = - EFSCORRUPTED ;
2014-09-29 03:45:03 +04:00
break ;
}
2014-09-29 03:45:18 +04:00
if ( error | | freeit )
xlog_recover_free_trans ( trans ) ;
2014-09-29 03:45:03 +04:00
return error ;
}
2014-09-29 03:45:54 +04:00
/*
* Lookup the transaction recovery structure associated with the ID in the
* current ophdr . If the transaction doesn ' t exist and the start flag is set in
* the ophdr , then allocate a new transaction for future ID matches to find .
* Either way , return what we found during the lookup - an existing transaction
* or nothing .
*/
2014-09-29 03:45:03 +04:00
STATIC struct xlog_recover *
xlog_recover_ophdr_to_trans (
struct hlist_head rhash [ ] ,
struct xlog_rec_header * rhead ,
struct xlog_op_header * ohead )
{
struct xlog_recover * trans ;
xlog_tid_t tid ;
struct hlist_head * rhp ;
tid = be32_to_cpu ( ohead - > oh_tid ) ;
rhp = & rhash [ XLOG_RHASH ( tid ) ] ;
2014-09-29 03:45:54 +04:00
hlist_for_each_entry ( trans , rhp , r_list ) {
if ( trans - > r_log_tid = = tid )
return trans ;
}
2014-09-29 03:45:03 +04:00
/*
2014-09-29 03:45:54 +04:00
* skip over non - start transaction headers - we could be
* processing slack space before the next transaction starts
*/
if ( ! ( ohead - > oh_flags & XLOG_START_TRANS ) )
return NULL ;
ASSERT ( be32_to_cpu ( ohead - > oh_len ) = = 0 ) ;
/*
* This is a new transaction so allocate a new recovery container to
* hold the recovery ops that will follow .
*/
2019-08-26 22:06:22 +03:00
trans = kmem_zalloc ( sizeof ( struct xlog_recover ) , 0 ) ;
2014-09-29 03:45:54 +04:00
trans - > r_log_tid = tid ;
trans - > r_lsn = be64_to_cpu ( rhead - > h_lsn ) ;
INIT_LIST_HEAD ( & trans - > r_itemq ) ;
INIT_HLIST_NODE ( & trans - > r_list ) ;
hlist_add_head ( & trans - > r_list , rhp ) ;
/*
* Nothing more to do for this ophdr . Items to be added to this new
* transaction will be in subsequent ophdr containers .
2014-09-29 03:45:03 +04:00
*/
return NULL ;
}
STATIC int
xlog_recover_process_ophdr (
struct xlog * log ,
struct hlist_head rhash [ ] ,
struct xlog_rec_header * rhead ,
struct xlog_op_header * ohead ,
2015-06-22 02:45:10 +03:00
char * dp ,
char * end ,
2016-09-26 01:22:16 +03:00
int pass ,
struct list_head * buffer_list )
2014-09-29 03:45:03 +04:00
{
struct xlog_recover * trans ;
unsigned int len ;
2016-09-26 01:22:16 +03:00
int error ;
2014-09-29 03:45:03 +04:00
/* Do we understand who wrote this op? */
if ( ohead - > oh_clientid ! = XFS_TRANSACTION & &
ohead - > oh_clientid ! = XFS_LOG ) {
xfs_warn ( log - > l_mp , " %s: bad clientid 0x%x " ,
__func__ , ohead - > oh_clientid ) ;
ASSERT ( 0 ) ;
2019-11-06 20:17:43 +03:00
return - EFSCORRUPTED ;
2014-09-29 03:45:03 +04:00
}
/*
* Check the ophdr contains all the data it is supposed to contain .
*/
len = be32_to_cpu ( ohead - > oh_len ) ;
if ( dp + len > end ) {
xfs_warn ( log - > l_mp , " %s: bad length 0x%x " , __func__ , len ) ;
WARN_ON ( 1 ) ;
2019-11-06 20:17:43 +03:00
return - EFSCORRUPTED ;
2014-09-29 03:45:03 +04:00
}
trans = xlog_recover_ophdr_to_trans ( rhash , rhead , ohead ) ;
if ( ! trans ) {
/* nothing to do, so skip over this ophdr */
return 0 ;
}
2016-09-26 01:22:16 +03:00
/*
* The recovered buffer queue is drained only once we know that all
* recovery items for the current LSN have been processed . This is
* required because :
*
* - Buffer write submission updates the metadata LSN of the buffer .
* - Log recovery skips items with a metadata LSN > = the current LSN of
* the recovery item .
* - Separate recovery items against the same metadata buffer can share
* a current LSN . I . e . , consider that the LSN of a recovery item is
* defined as the starting LSN of the first record in which its
* transaction appears , that a record can hold multiple transactions ,
* and / or that a transaction can span multiple records .
*
* In other words , we are allowed to submit a buffer from log recovery
* once per current LSN . Otherwise , we may incorrectly skip recovery
* items and cause corruption .
*
* We don ' t know up front whether buffers are updated multiple times per
* LSN . Therefore , track the current LSN of each commit log record as it
* is processed and drain the queue when it changes . Use commit records
* because they are ordered correctly by the logging code .
*/
if ( log - > l_recovery_lsn ! = trans - > r_lsn & &
ohead - > oh_flags & XLOG_COMMIT_TRANS ) {
error = xfs_buf_delwri_submit ( buffer_list ) ;
if ( error )
return error ;
log - > l_recovery_lsn = trans - > r_lsn ;
}
2014-09-29 03:45:18 +04:00
return xlog_recovery_process_trans ( log , trans , dp , len ,
2016-09-26 01:22:16 +03:00
ohead - > oh_flags , pass , buffer_list ) ;
2005-04-17 02:20:36 +04:00
}
/*
* There are two valid states of the r_state field . 0 indicates that the
* transaction structure is in a normal state . We have either seen the
* start of the transaction or the last operation we added was not a partial
* operation . If the last operation we added to the transaction was a
* partial operation , we need to mark r_state with XLOG_WAS_CONT_TRANS .
*
* NOTE : skip LRs with 0 data length .
*/
STATIC int
xlog_recover_process_data (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2010-01-11 14:49:57 +03:00
struct hlist_head rhash [ ] ,
2012-06-14 18:22:16 +04:00
struct xlog_rec_header * rhead ,
2015-06-22 02:45:10 +03:00
char * dp ,
2016-09-26 01:22:16 +03:00
int pass ,
struct list_head * buffer_list )
2005-04-17 02:20:36 +04:00
{
2014-09-29 03:45:03 +04:00
struct xlog_op_header * ohead ;
2015-06-22 02:45:10 +03:00
char * end ;
2005-04-17 02:20:36 +04:00
int num_logops ;
int error ;
2014-09-29 03:45:03 +04:00
end = dp + be32_to_cpu ( rhead - > h_len ) ;
2007-10-12 04:59:34 +04:00
num_logops = be32_to_cpu ( rhead - > h_num_logops ) ;
2005-04-17 02:20:36 +04:00
/* check the log format matches our own - else we can't recover */
if ( xlog_header_check_recover ( log - > l_mp , rhead ) )
2014-06-25 08:58:08 +04:00
return - EIO ;
2005-04-17 02:20:36 +04:00
2016-09-26 01:34:52 +03:00
trace_xfs_log_recover_record ( log , rhead , pass ) ;
2014-09-29 03:45:03 +04:00
while ( ( dp < end ) & & num_logops ) {
ohead = ( struct xlog_op_header * ) dp ;
dp + = sizeof ( * ohead ) ;
ASSERT ( dp < = end ) ;
/* errors will abort recovery */
error = xlog_recover_process_ophdr ( log , rhash , rhead , ohead ,
2016-09-26 01:22:16 +03:00
dp , end , pass , buffer_list ) ;
2014-09-29 03:45:03 +04:00
if ( error )
return error ;
2007-10-12 04:58:59 +04:00
dp + = be32_to_cpu ( ohead - > oh_len ) ;
2005-04-17 02:20:36 +04:00
num_logops - - ;
}
return 0 ;
}
xfs: log recovery should replay deferred ops in order
As part of testing log recovery with dm_log_writes, Amir Goldstein
discovered an error in the deferred ops recovery that lead to corruption
of the filesystem metadata if a reflink+rmap filesystem happened to shut
down midway through a CoW remap:
"This is what happens [after failed log recovery]:
"Phase 1 - find and verify superblock...
"Phase 2 - using internal log
" - zero log...
" - scan filesystem freespace and inode maps...
" - found root inode chunk
"Phase 3 - for each AG...
" - scan (but don't clear) agi unlinked lists...
" - process known inodes and perform inode discovery...
" - agno = 0
"data fork in regular inode 134 claims CoW block 376
"correcting nextents for inode 134
"bad data fork in inode 134
"would have cleared inode 134"
Hou Tao dissected the log contents of exactly such a crash:
"According to the implementation of xfs_defer_finish(), these ops should
be completed in the following sequence:
"Have been done:
"(1) CUI: Oper (160)
"(2) BUI: Oper (161)
"(3) CUD: Oper (194), for CUI Oper (160)
"(4) RUI A: Oper (197), free rmap [0x155, 2, -9]
"Should be done:
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI A
"(8) RUD: for RUI B
"Actually be done by xlog_recover_process_intents()
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI B
"(8) RUD: for RUI A
"So the rmap entry [0x155, 2, -9] for COW should be freed firstly,
then a new rmap entry [0x155, 2, 137] will be added. However, as we can see
from the log record in post_mount.log (generated after umount) and the trace
print, the new rmap entry [0x155, 2, 137] are added firstly, then the rmap
entry [0x155, 2, -9] are freed."
When reconstructing the internal log state from the log items found on
disk, it's required that deferred ops replay in exactly the same order
that they would have had the filesystem not gone down. However,
replaying unfinished deferred ops can create /more/ deferred ops. These
new deferred ops are finished in the wrong order. This causes fs
corruption and replay crashes, so let's create a single defer_ops to
handle the subsequent ops created during replay, then use one single
transaction at the end of log recovery to ensure that everything is
replayed in the same order as they're supposed to be.
Reported-by: Amir Goldstein <amir73il@gmail.com>
Analyzed-by: Hou Tao <houtao1@huawei.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Tested-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2017-11-22 07:53:02 +03:00
/* Take all the collected deferred ops and finish them in order. */
static int
xlog_finish_defer_ops (
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
struct xfs_mount * mp ,
struct list_head * capture_list )
xfs: log recovery should replay deferred ops in order
As part of testing log recovery with dm_log_writes, Amir Goldstein
discovered an error in the deferred ops recovery that lead to corruption
of the filesystem metadata if a reflink+rmap filesystem happened to shut
down midway through a CoW remap:
"This is what happens [after failed log recovery]:
"Phase 1 - find and verify superblock...
"Phase 2 - using internal log
" - zero log...
" - scan filesystem freespace and inode maps...
" - found root inode chunk
"Phase 3 - for each AG...
" - scan (but don't clear) agi unlinked lists...
" - process known inodes and perform inode discovery...
" - agno = 0
"data fork in regular inode 134 claims CoW block 376
"correcting nextents for inode 134
"bad data fork in inode 134
"would have cleared inode 134"
Hou Tao dissected the log contents of exactly such a crash:
"According to the implementation of xfs_defer_finish(), these ops should
be completed in the following sequence:
"Have been done:
"(1) CUI: Oper (160)
"(2) BUI: Oper (161)
"(3) CUD: Oper (194), for CUI Oper (160)
"(4) RUI A: Oper (197), free rmap [0x155, 2, -9]
"Should be done:
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI A
"(8) RUD: for RUI B
"Actually be done by xlog_recover_process_intents()
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI B
"(8) RUD: for RUI A
"So the rmap entry [0x155, 2, -9] for COW should be freed firstly,
then a new rmap entry [0x155, 2, 137] will be added. However, as we can see
from the log record in post_mount.log (generated after umount) and the trace
print, the new rmap entry [0x155, 2, 137] are added firstly, then the rmap
entry [0x155, 2, -9] are freed."
When reconstructing the internal log state from the log items found on
disk, it's required that deferred ops replay in exactly the same order
that they would have had the filesystem not gone down. However,
replaying unfinished deferred ops can create /more/ deferred ops. These
new deferred ops are finished in the wrong order. This causes fs
corruption and replay crashes, so let's create a single defer_ops to
handle the subsequent ops created during replay, then use one single
transaction at the end of log recovery to ensure that everything is
replayed in the same order as they're supposed to be.
Reported-by: Amir Goldstein <amir73il@gmail.com>
Analyzed-by: Hou Tao <houtao1@huawei.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Tested-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2017-11-22 07:53:02 +03:00
{
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
struct xfs_defer_capture * dfc , * next ;
xfs: log recovery should replay deferred ops in order
As part of testing log recovery with dm_log_writes, Amir Goldstein
discovered an error in the deferred ops recovery that lead to corruption
of the filesystem metadata if a reflink+rmap filesystem happened to shut
down midway through a CoW remap:
"This is what happens [after failed log recovery]:
"Phase 1 - find and verify superblock...
"Phase 2 - using internal log
" - zero log...
" - scan filesystem freespace and inode maps...
" - found root inode chunk
"Phase 3 - for each AG...
" - scan (but don't clear) agi unlinked lists...
" - process known inodes and perform inode discovery...
" - agno = 0
"data fork in regular inode 134 claims CoW block 376
"correcting nextents for inode 134
"bad data fork in inode 134
"would have cleared inode 134"
Hou Tao dissected the log contents of exactly such a crash:
"According to the implementation of xfs_defer_finish(), these ops should
be completed in the following sequence:
"Have been done:
"(1) CUI: Oper (160)
"(2) BUI: Oper (161)
"(3) CUD: Oper (194), for CUI Oper (160)
"(4) RUI A: Oper (197), free rmap [0x155, 2, -9]
"Should be done:
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI A
"(8) RUD: for RUI B
"Actually be done by xlog_recover_process_intents()
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI B
"(8) RUD: for RUI A
"So the rmap entry [0x155, 2, -9] for COW should be freed firstly,
then a new rmap entry [0x155, 2, 137] will be added. However, as we can see
from the log record in post_mount.log (generated after umount) and the trace
print, the new rmap entry [0x155, 2, 137] are added firstly, then the rmap
entry [0x155, 2, -9] are freed."
When reconstructing the internal log state from the log items found on
disk, it's required that deferred ops replay in exactly the same order
that they would have had the filesystem not gone down. However,
replaying unfinished deferred ops can create /more/ deferred ops. These
new deferred ops are finished in the wrong order. This causes fs
corruption and replay crashes, so let's create a single defer_ops to
handle the subsequent ops created during replay, then use one single
transaction at the end of log recovery to ensure that everything is
replayed in the same order as they're supposed to be.
Reported-by: Amir Goldstein <amir73il@gmail.com>
Analyzed-by: Hou Tao <houtao1@huawei.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Tested-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2017-11-22 07:53:02 +03:00
struct xfs_trans * tp ;
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
int error = 0 ;
xfs: log recovery should replay deferred ops in order
As part of testing log recovery with dm_log_writes, Amir Goldstein
discovered an error in the deferred ops recovery that lead to corruption
of the filesystem metadata if a reflink+rmap filesystem happened to shut
down midway through a CoW remap:
"This is what happens [after failed log recovery]:
"Phase 1 - find and verify superblock...
"Phase 2 - using internal log
" - zero log...
" - scan filesystem freespace and inode maps...
" - found root inode chunk
"Phase 3 - for each AG...
" - scan (but don't clear) agi unlinked lists...
" - process known inodes and perform inode discovery...
" - agno = 0
"data fork in regular inode 134 claims CoW block 376
"correcting nextents for inode 134
"bad data fork in inode 134
"would have cleared inode 134"
Hou Tao dissected the log contents of exactly such a crash:
"According to the implementation of xfs_defer_finish(), these ops should
be completed in the following sequence:
"Have been done:
"(1) CUI: Oper (160)
"(2) BUI: Oper (161)
"(3) CUD: Oper (194), for CUI Oper (160)
"(4) RUI A: Oper (197), free rmap [0x155, 2, -9]
"Should be done:
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI A
"(8) RUD: for RUI B
"Actually be done by xlog_recover_process_intents()
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI B
"(8) RUD: for RUI A
"So the rmap entry [0x155, 2, -9] for COW should be freed firstly,
then a new rmap entry [0x155, 2, 137] will be added. However, as we can see
from the log record in post_mount.log (generated after umount) and the trace
print, the new rmap entry [0x155, 2, 137] are added firstly, then the rmap
entry [0x155, 2, -9] are freed."
When reconstructing the internal log state from the log items found on
disk, it's required that deferred ops replay in exactly the same order
that they would have had the filesystem not gone down. However,
replaying unfinished deferred ops can create /more/ deferred ops. These
new deferred ops are finished in the wrong order. This causes fs
corruption and replay crashes, so let's create a single defer_ops to
handle the subsequent ops created during replay, then use one single
transaction at the end of log recovery to ensure that everything is
replayed in the same order as they're supposed to be.
Reported-by: Amir Goldstein <amir73il@gmail.com>
Analyzed-by: Hou Tao <houtao1@huawei.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Tested-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2017-11-22 07:53:02 +03:00
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
list_for_each_entry_safe ( dfc , next , capture_list , dfc_list ) {
2020-09-26 03:39:49 +03:00
error = xfs_trans_alloc ( mp , & M_RES ( mp ) - > tr_itruncate ,
dfc - > dfc_blkres , dfc - > dfc_rtxres ,
XFS_TRANS_RESERVE , & tp ) ;
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
if ( error )
return error ;
xfs: log recovery should replay deferred ops in order
As part of testing log recovery with dm_log_writes, Amir Goldstein
discovered an error in the deferred ops recovery that lead to corruption
of the filesystem metadata if a reflink+rmap filesystem happened to shut
down midway through a CoW remap:
"This is what happens [after failed log recovery]:
"Phase 1 - find and verify superblock...
"Phase 2 - using internal log
" - zero log...
" - scan filesystem freespace and inode maps...
" - found root inode chunk
"Phase 3 - for each AG...
" - scan (but don't clear) agi unlinked lists...
" - process known inodes and perform inode discovery...
" - agno = 0
"data fork in regular inode 134 claims CoW block 376
"correcting nextents for inode 134
"bad data fork in inode 134
"would have cleared inode 134"
Hou Tao dissected the log contents of exactly such a crash:
"According to the implementation of xfs_defer_finish(), these ops should
be completed in the following sequence:
"Have been done:
"(1) CUI: Oper (160)
"(2) BUI: Oper (161)
"(3) CUD: Oper (194), for CUI Oper (160)
"(4) RUI A: Oper (197), free rmap [0x155, 2, -9]
"Should be done:
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI A
"(8) RUD: for RUI B
"Actually be done by xlog_recover_process_intents()
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI B
"(8) RUD: for RUI A
"So the rmap entry [0x155, 2, -9] for COW should be freed firstly,
then a new rmap entry [0x155, 2, 137] will be added. However, as we can see
from the log record in post_mount.log (generated after umount) and the trace
print, the new rmap entry [0x155, 2, 137] are added firstly, then the rmap
entry [0x155, 2, -9] are freed."
When reconstructing the internal log state from the log items found on
disk, it's required that deferred ops replay in exactly the same order
that they would have had the filesystem not gone down. However,
replaying unfinished deferred ops can create /more/ deferred ops. These
new deferred ops are finished in the wrong order. This causes fs
corruption and replay crashes, so let's create a single defer_ops to
handle the subsequent ops created during replay, then use one single
transaction at the end of log recovery to ensure that everything is
replayed in the same order as they're supposed to be.
Reported-by: Amir Goldstein <amir73il@gmail.com>
Analyzed-by: Hou Tao <houtao1@huawei.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Tested-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2017-11-22 07:53:02 +03:00
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
/*
* Transfer to this new transaction all the dfops we captured
* from recovering a single intent item .
*/
list_del_init ( & dfc - > dfc_list ) ;
xfs_defer_ops_continue ( dfc , tp ) ;
error = xfs_trans_commit ( tp ) ;
if ( error )
return error ;
}
ASSERT ( list_empty ( capture_list ) ) ;
return 0 ;
xfs: log recovery should replay deferred ops in order
As part of testing log recovery with dm_log_writes, Amir Goldstein
discovered an error in the deferred ops recovery that lead to corruption
of the filesystem metadata if a reflink+rmap filesystem happened to shut
down midway through a CoW remap:
"This is what happens [after failed log recovery]:
"Phase 1 - find and verify superblock...
"Phase 2 - using internal log
" - zero log...
" - scan filesystem freespace and inode maps...
" - found root inode chunk
"Phase 3 - for each AG...
" - scan (but don't clear) agi unlinked lists...
" - process known inodes and perform inode discovery...
" - agno = 0
"data fork in regular inode 134 claims CoW block 376
"correcting nextents for inode 134
"bad data fork in inode 134
"would have cleared inode 134"
Hou Tao dissected the log contents of exactly such a crash:
"According to the implementation of xfs_defer_finish(), these ops should
be completed in the following sequence:
"Have been done:
"(1) CUI: Oper (160)
"(2) BUI: Oper (161)
"(3) CUD: Oper (194), for CUI Oper (160)
"(4) RUI A: Oper (197), free rmap [0x155, 2, -9]
"Should be done:
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI A
"(8) RUD: for RUI B
"Actually be done by xlog_recover_process_intents()
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI B
"(8) RUD: for RUI A
"So the rmap entry [0x155, 2, -9] for COW should be freed firstly,
then a new rmap entry [0x155, 2, 137] will be added. However, as we can see
from the log record in post_mount.log (generated after umount) and the trace
print, the new rmap entry [0x155, 2, 137] are added firstly, then the rmap
entry [0x155, 2, -9] are freed."
When reconstructing the internal log state from the log items found on
disk, it's required that deferred ops replay in exactly the same order
that they would have had the filesystem not gone down. However,
replaying unfinished deferred ops can create /more/ deferred ops. These
new deferred ops are finished in the wrong order. This causes fs
corruption and replay crashes, so let's create a single defer_ops to
handle the subsequent ops created during replay, then use one single
transaction at the end of log recovery to ensure that everything is
replayed in the same order as they're supposed to be.
Reported-by: Amir Goldstein <amir73il@gmail.com>
Analyzed-by: Hou Tao <houtao1@huawei.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Tested-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2017-11-22 07:53:02 +03:00
}
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
/* Release all the captured defer ops and capture structures in this list. */
static void
xlog_abort_defer_ops (
struct xfs_mount * mp ,
struct list_head * capture_list )
{
struct xfs_defer_capture * dfc ;
struct xfs_defer_capture * next ;
list_for_each_entry_safe ( dfc , next , capture_list , dfc_list ) {
list_del_init ( & dfc - > dfc_list ) ;
xfs_defer_ops_release ( mp , dfc ) ;
}
}
2005-04-17 02:20:36 +04:00
/*
2016-08-03 04:23:49 +03:00
* When this is called , all of the log intent items which did not have
* corresponding log done items should be in the AIL . What we do now
* is update the data structures associated with each one .
2005-04-17 02:20:36 +04:00
*
2016-08-03 04:23:49 +03:00
* Since we process the log intent items in normal transactions , they
* will be removed at some point after the commit . This prevents us
* from just walking down the list processing each one . We ' ll use a
* flag in the intent item to skip those that we ' ve already processed
* and use the AIL iteration mechanism ' s generation count to try to
* speed this up at least a bit .
2005-04-17 02:20:36 +04:00
*
2016-08-03 04:23:49 +03:00
* When we start , we know that the intents are the only things in the
* AIL . As we process them , however , other items are added to the
* AIL .
2005-04-17 02:20:36 +04:00
*/
2008-04-10 06:21:11 +04:00
STATIC int
2016-08-03 04:23:49 +03:00
xlog_recover_process_intents (
2015-08-19 02:58:36 +03:00
struct xlog * log )
2005-04-17 02:20:36 +04:00
{
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
LIST_HEAD ( capture_list ) ;
2008-10-30 09:38:39 +03:00
struct xfs_ail_cursor cur ;
xfs: log recovery should replay deferred ops in order
As part of testing log recovery with dm_log_writes, Amir Goldstein
discovered an error in the deferred ops recovery that lead to corruption
of the filesystem metadata if a reflink+rmap filesystem happened to shut
down midway through a CoW remap:
"This is what happens [after failed log recovery]:
"Phase 1 - find and verify superblock...
"Phase 2 - using internal log
" - zero log...
" - scan filesystem freespace and inode maps...
" - found root inode chunk
"Phase 3 - for each AG...
" - scan (but don't clear) agi unlinked lists...
" - process known inodes and perform inode discovery...
" - agno = 0
"data fork in regular inode 134 claims CoW block 376
"correcting nextents for inode 134
"bad data fork in inode 134
"would have cleared inode 134"
Hou Tao dissected the log contents of exactly such a crash:
"According to the implementation of xfs_defer_finish(), these ops should
be completed in the following sequence:
"Have been done:
"(1) CUI: Oper (160)
"(2) BUI: Oper (161)
"(3) CUD: Oper (194), for CUI Oper (160)
"(4) RUI A: Oper (197), free rmap [0x155, 2, -9]
"Should be done:
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI A
"(8) RUD: for RUI B
"Actually be done by xlog_recover_process_intents()
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI B
"(8) RUD: for RUI A
"So the rmap entry [0x155, 2, -9] for COW should be freed firstly,
then a new rmap entry [0x155, 2, 137] will be added. However, as we can see
from the log record in post_mount.log (generated after umount) and the trace
print, the new rmap entry [0x155, 2, 137] are added firstly, then the rmap
entry [0x155, 2, -9] are freed."
When reconstructing the internal log state from the log items found on
disk, it's required that deferred ops replay in exactly the same order
that they would have had the filesystem not gone down. However,
replaying unfinished deferred ops can create /more/ deferred ops. These
new deferred ops are finished in the wrong order. This causes fs
corruption and replay crashes, so let's create a single defer_ops to
handle the subsequent ops created during replay, then use one single
transaction at the end of log recovery to ensure that everything is
replayed in the same order as they're supposed to be.
Reported-by: Amir Goldstein <amir73il@gmail.com>
Analyzed-by: Hou Tao <houtao1@huawei.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Tested-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2017-11-22 07:53:02 +03:00
struct xfs_log_item * lip ;
2008-10-30 09:39:35 +03:00
struct xfs_ail * ailp ;
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
int error = 0 ;
2017-09-01 01:11:06 +03:00
# if defined(DEBUG) || defined(XFS_WARN)
2016-08-03 04:23:49 +03:00
xfs_lsn_t last_lsn ;
2017-09-01 01:11:06 +03:00
# endif
2005-04-17 02:20:36 +04:00
2008-10-30 09:39:35 +03:00
ailp = log - > l_ailp ;
2018-03-08 01:59:39 +03:00
spin_lock ( & ailp - > ail_lock ) ;
2017-09-01 01:11:06 +03:00
# if defined(DEBUG) || defined(XFS_WARN)
2016-08-03 04:23:49 +03:00
last_lsn = xlog_assign_lsn ( log - > l_curr_cycle , log - > l_curr_block ) ;
2017-09-01 01:11:06 +03:00
# endif
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
for ( lip = xfs_trans_ail_cursor_first ( ailp , & cur , 0 ) ;
lip ! = NULL ;
lip = xfs_trans_ail_cursor_next ( ailp , & cur ) ) {
2005-04-17 02:20:36 +04:00
/*
2016-08-03 04:23:49 +03:00
* We ' re done when we see something other than an intent .
* There should be no intents left in the AIL now .
2005-04-17 02:20:36 +04:00
*/
2016-08-03 04:23:49 +03:00
if ( ! xlog_item_is_intent ( lip ) ) {
2008-10-30 09:38:39 +03:00
# ifdef DEBUG
2008-10-30 09:39:35 +03:00
for ( ; lip ; lip = xfs_trans_ail_cursor_next ( ailp , & cur ) )
2016-08-03 04:23:49 +03:00
ASSERT ( ! xlog_item_is_intent ( lip ) ) ;
2008-10-30 09:38:39 +03:00
# endif
2005-04-17 02:20:36 +04:00
break ;
}
/*
2016-08-03 04:23:49 +03:00
* We should never see a redo item with a LSN higher than
* the last transaction we found in the log at the start
* of recovery .
2005-04-17 02:20:36 +04:00
*/
2016-08-03 04:23:49 +03:00
ASSERT ( XFS_LSN_CMP ( last_lsn , lip - > li_lsn ) > = 0 ) ;
2005-04-17 02:20:36 +04:00
xfs: log recovery should replay deferred ops in order
As part of testing log recovery with dm_log_writes, Amir Goldstein
discovered an error in the deferred ops recovery that lead to corruption
of the filesystem metadata if a reflink+rmap filesystem happened to shut
down midway through a CoW remap:
"This is what happens [after failed log recovery]:
"Phase 1 - find and verify superblock...
"Phase 2 - using internal log
" - zero log...
" - scan filesystem freespace and inode maps...
" - found root inode chunk
"Phase 3 - for each AG...
" - scan (but don't clear) agi unlinked lists...
" - process known inodes and perform inode discovery...
" - agno = 0
"data fork in regular inode 134 claims CoW block 376
"correcting nextents for inode 134
"bad data fork in inode 134
"would have cleared inode 134"
Hou Tao dissected the log contents of exactly such a crash:
"According to the implementation of xfs_defer_finish(), these ops should
be completed in the following sequence:
"Have been done:
"(1) CUI: Oper (160)
"(2) BUI: Oper (161)
"(3) CUD: Oper (194), for CUI Oper (160)
"(4) RUI A: Oper (197), free rmap [0x155, 2, -9]
"Should be done:
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI A
"(8) RUD: for RUI B
"Actually be done by xlog_recover_process_intents()
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI B
"(8) RUD: for RUI A
"So the rmap entry [0x155, 2, -9] for COW should be freed firstly,
then a new rmap entry [0x155, 2, 137] will be added. However, as we can see
from the log record in post_mount.log (generated after umount) and the trace
print, the new rmap entry [0x155, 2, 137] are added firstly, then the rmap
entry [0x155, 2, -9] are freed."
When reconstructing the internal log state from the log items found on
disk, it's required that deferred ops replay in exactly the same order
that they would have had the filesystem not gone down. However,
replaying unfinished deferred ops can create /more/ deferred ops. These
new deferred ops are finished in the wrong order. This causes fs
corruption and replay crashes, so let's create a single defer_ops to
handle the subsequent ops created during replay, then use one single
transaction at the end of log recovery to ensure that everything is
replayed in the same order as they're supposed to be.
Reported-by: Amir Goldstein <amir73il@gmail.com>
Analyzed-by: Hou Tao <houtao1@huawei.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Tested-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2017-11-22 07:53:02 +03:00
/*
* NOTE : If your intent processing routine can create more
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
* deferred ops , you / must / attach them to the capture list in
* the recover routine or else those subsequent intents will be
xfs: log recovery should replay deferred ops in order
As part of testing log recovery with dm_log_writes, Amir Goldstein
discovered an error in the deferred ops recovery that lead to corruption
of the filesystem metadata if a reflink+rmap filesystem happened to shut
down midway through a CoW remap:
"This is what happens [after failed log recovery]:
"Phase 1 - find and verify superblock...
"Phase 2 - using internal log
" - zero log...
" - scan filesystem freespace and inode maps...
" - found root inode chunk
"Phase 3 - for each AG...
" - scan (but don't clear) agi unlinked lists...
" - process known inodes and perform inode discovery...
" - agno = 0
"data fork in regular inode 134 claims CoW block 376
"correcting nextents for inode 134
"bad data fork in inode 134
"would have cleared inode 134"
Hou Tao dissected the log contents of exactly such a crash:
"According to the implementation of xfs_defer_finish(), these ops should
be completed in the following sequence:
"Have been done:
"(1) CUI: Oper (160)
"(2) BUI: Oper (161)
"(3) CUD: Oper (194), for CUI Oper (160)
"(4) RUI A: Oper (197), free rmap [0x155, 2, -9]
"Should be done:
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI A
"(8) RUD: for RUI B
"Actually be done by xlog_recover_process_intents()
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI B
"(8) RUD: for RUI A
"So the rmap entry [0x155, 2, -9] for COW should be freed firstly,
then a new rmap entry [0x155, 2, 137] will be added. However, as we can see
from the log record in post_mount.log (generated after umount) and the trace
print, the new rmap entry [0x155, 2, 137] are added firstly, then the rmap
entry [0x155, 2, -9] are freed."
When reconstructing the internal log state from the log items found on
disk, it's required that deferred ops replay in exactly the same order
that they would have had the filesystem not gone down. However,
replaying unfinished deferred ops can create /more/ deferred ops. These
new deferred ops are finished in the wrong order. This causes fs
corruption and replay crashes, so let's create a single defer_ops to
handle the subsequent ops created during replay, then use one single
transaction at the end of log recovery to ensure that everything is
replayed in the same order as they're supposed to be.
Reported-by: Amir Goldstein <amir73il@gmail.com>
Analyzed-by: Hou Tao <houtao1@huawei.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Tested-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2017-11-22 07:53:02 +03:00
* replayed in the wrong order !
*/
2020-09-28 21:01:45 +03:00
spin_unlock ( & ailp - > ail_lock ) ;
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
error = lip - > li_ops - > iop_recover ( lip , & capture_list ) ;
2020-09-28 21:01:45 +03:00
spin_lock ( & ailp - > ail_lock ) ;
2008-10-30 09:38:39 +03:00
if ( error )
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
break ;
2005-04-17 02:20:36 +04:00
}
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
2014-04-14 13:06:05 +04:00
xfs_trans_ail_cursor_done ( & cur ) ;
2018-03-08 01:59:39 +03:00
spin_unlock ( & ailp - > ail_lock ) ;
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
if ( error )
goto err ;
xfs: log recovery should replay deferred ops in order
As part of testing log recovery with dm_log_writes, Amir Goldstein
discovered an error in the deferred ops recovery that lead to corruption
of the filesystem metadata if a reflink+rmap filesystem happened to shut
down midway through a CoW remap:
"This is what happens [after failed log recovery]:
"Phase 1 - find and verify superblock...
"Phase 2 - using internal log
" - zero log...
" - scan filesystem freespace and inode maps...
" - found root inode chunk
"Phase 3 - for each AG...
" - scan (but don't clear) agi unlinked lists...
" - process known inodes and perform inode discovery...
" - agno = 0
"data fork in regular inode 134 claims CoW block 376
"correcting nextents for inode 134
"bad data fork in inode 134
"would have cleared inode 134"
Hou Tao dissected the log contents of exactly such a crash:
"According to the implementation of xfs_defer_finish(), these ops should
be completed in the following sequence:
"Have been done:
"(1) CUI: Oper (160)
"(2) BUI: Oper (161)
"(3) CUD: Oper (194), for CUI Oper (160)
"(4) RUI A: Oper (197), free rmap [0x155, 2, -9]
"Should be done:
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI A
"(8) RUD: for RUI B
"Actually be done by xlog_recover_process_intents()
"(5) BUD: for BUI Oper (161)
"(6) RUI B: add rmap [0x155, 2, 137]
"(7) RUD: for RUI B
"(8) RUD: for RUI A
"So the rmap entry [0x155, 2, -9] for COW should be freed firstly,
then a new rmap entry [0x155, 2, 137] will be added. However, as we can see
from the log record in post_mount.log (generated after umount) and the trace
print, the new rmap entry [0x155, 2, 137] are added firstly, then the rmap
entry [0x155, 2, -9] are freed."
When reconstructing the internal log state from the log items found on
disk, it's required that deferred ops replay in exactly the same order
that they would have had the filesystem not gone down. However,
replaying unfinished deferred ops can create /more/ deferred ops. These
new deferred ops are finished in the wrong order. This causes fs
corruption and replay crashes, so let's create a single defer_ops to
handle the subsequent ops created during replay, then use one single
transaction at the end of log recovery to ensure that everything is
replayed in the same order as they're supposed to be.
Reported-by: Amir Goldstein <amir73il@gmail.com>
Analyzed-by: Hou Tao <houtao1@huawei.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Tested-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2017-11-22 07:53:02 +03:00
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 03:39:37 +03:00
error = xlog_finish_defer_ops ( log - > l_mp , & capture_list ) ;
if ( error )
goto err ;
return 0 ;
err :
xlog_abort_defer_ops ( log - > l_mp , & capture_list ) ;
2008-04-10 06:21:11 +04:00
return error ;
2005-04-17 02:20:36 +04:00
}
2015-08-19 02:58:36 +03:00
/*
2016-08-03 04:23:49 +03:00
* A cancel occurs when the mount has failed and we ' re bailing out .
* Release all pending log intent items so they don ' t pin the AIL .
2015-08-19 02:58:36 +03:00
*/
2019-07-03 17:34:18 +03:00
STATIC void
2016-08-03 04:23:49 +03:00
xlog_recover_cancel_intents (
2015-08-19 02:58:36 +03:00
struct xlog * log )
{
struct xfs_log_item * lip ;
struct xfs_ail_cursor cur ;
struct xfs_ail * ailp ;
ailp = log - > l_ailp ;
2018-03-08 01:59:39 +03:00
spin_lock ( & ailp - > ail_lock ) ;
2015-08-19 02:58:36 +03:00
lip = xfs_trans_ail_cursor_first ( ailp , & cur , 0 ) ;
while ( lip ! = NULL ) {
/*
2016-08-03 04:23:49 +03:00
* We ' re done when we see something other than an intent .
* There should be no intents left in the AIL now .
2015-08-19 02:58:36 +03:00
*/
2016-08-03 04:23:49 +03:00
if ( ! xlog_item_is_intent ( lip ) ) {
2015-08-19 02:58:36 +03:00
# ifdef DEBUG
for ( ; lip ; lip = xfs_trans_ail_cursor_next ( ailp , & cur ) )
2016-08-03 04:23:49 +03:00
ASSERT ( ! xlog_item_is_intent ( lip ) ) ;
2015-08-19 02:58:36 +03:00
# endif
break ;
}
2020-05-02 02:00:52 +03:00
spin_unlock ( & ailp - > ail_lock ) ;
lip - > li_ops - > iop_release ( lip ) ;
spin_lock ( & ailp - > ail_lock ) ;
2015-08-19 02:58:36 +03:00
lip = xfs_trans_ail_cursor_next ( ailp , & cur ) ;
}
xfs_trans_ail_cursor_done ( & cur ) ;
2018-03-08 01:59:39 +03:00
spin_unlock ( & ailp - > ail_lock ) ;
2015-08-19 02:58:36 +03:00
}
2005-04-17 02:20:36 +04:00
/*
* This routine performs a transaction to null out a bad inode pointer
* in an agi unlinked inode hash bucket .
*/
STATIC void
xlog_recover_clear_agi_bucket (
xfs_mount_t * mp ,
xfs_agnumber_t agno ,
int bucket )
{
xfs_trans_t * tp ;
xfs_agi_t * agi ;
xfs_buf_t * agibp ;
int offset ;
int error ;
2016-04-06 02:19:55 +03:00
error = xfs_trans_alloc ( mp , & M_RES ( mp ) - > tr_clearagi , 0 , 0 , 0 , & tp ) ;
2008-04-10 06:21:18 +04:00
if ( error )
2016-04-06 02:19:55 +03:00
goto out_error ;
2005-04-17 02:20:36 +04:00
2008-11-28 06:23:37 +03:00
error = xfs_read_agi ( mp , tp , agno , & agibp ) ;
if ( error )
2008-04-10 06:21:18 +04:00
goto out_abort ;
2005-04-17 02:20:36 +04:00
2020-03-10 18:57:29 +03:00
agi = agibp - > b_addr ;
2005-11-02 07:11:25 +03:00
agi - > agi_unlinked [ bucket ] = cpu_to_be32 ( NULLAGINO ) ;
2005-04-17 02:20:36 +04:00
offset = offsetof ( xfs_agi_t , agi_unlinked ) +
( sizeof ( xfs_agino_t ) * bucket ) ;
xfs_trans_log_buf ( tp , agibp , offset ,
( offset + sizeof ( xfs_agino_t ) - 1 ) ) ;
2015-06-04 06:48:08 +03:00
error = xfs_trans_commit ( tp ) ;
2008-04-10 06:21:18 +04:00
if ( error )
goto out_error ;
return ;
out_abort :
2015-06-04 06:47:56 +03:00
xfs_trans_cancel ( tp ) ;
2008-04-10 06:21:18 +04:00
out_error :
2011-03-07 02:01:35 +03:00
xfs_warn ( mp , " %s: failed to clear agi %d. Continuing. " , __func__ , agno ) ;
2008-04-10 06:21:18 +04:00
return ;
2005-04-17 02:20:36 +04:00
}
2008-11-28 06:23:40 +03:00
STATIC xfs_agino_t
xlog_recover_process_one_iunlink (
struct xfs_mount * mp ,
xfs_agnumber_t agno ,
xfs_agino_t agino ,
int bucket )
{
struct xfs_buf * ibp ;
struct xfs_dinode * dip ;
struct xfs_inode * ip ;
xfs_ino_t ino ;
int error ;
ino = XFS_AGINO_TO_INO ( mp , agno , agino ) ;
2010-06-24 05:35:17 +04:00
error = xfs_iget ( mp , NULL , ino , 0 , 0 , & ip ) ;
2008-11-28 06:23:40 +03:00
if ( error )
goto fail ;
/*
* Get the on disk inode to find the next inode in the bucket .
*/
2020-05-06 23:29:20 +03:00
error = xfs_imap_to_bp ( mp , NULL , & ip - > i_imap , & dip , & ibp , 0 ) ;
2008-11-28 06:23:40 +03:00
if ( error )
2008-11-28 06:23:42 +03:00
goto fail_iput ;
2008-11-28 06:23:40 +03:00
2016-10-03 19:11:29 +03:00
xfs_iflags_clear ( ip , XFS_IRECOVERY ) ;
2016-02-09 08:54:58 +03:00
ASSERT ( VFS_I ( ip ) - > i_nlink = = 0 ) ;
2016-02-09 08:54:58 +03:00
ASSERT ( VFS_I ( ip ) - > i_mode ! = 0 ) ;
2008-11-28 06:23:40 +03:00
/* setup for the next pass */
agino = be32_to_cpu ( dip - > di_next_unlinked ) ;
xfs_buf_relse ( ibp ) ;
/*
* Prevent any DMAPI event from being sent when the reference on
* the inode is dropped .
*/
ip - > i_d . di_dmevmask = 0 ;
2018-07-25 22:52:32 +03:00
xfs_irele ( ip ) ;
2008-11-28 06:23:40 +03:00
return agino ;
2008-11-28 06:23:42 +03:00
fail_iput :
2018-07-25 22:52:32 +03:00
xfs_irele ( ip ) ;
2008-11-28 06:23:40 +03:00
fail :
/*
* We can ' t read in the inode this bucket points to , or this inode
* is messed up . Just ditch this bucket of inodes . We will lose
* some inodes and space , but at least we won ' t hang .
*
* Call xlog_recover_clear_agi_bucket ( ) to perform a transaction to
* clear the inode pointer in the bucket .
*/
xlog_recover_clear_agi_bucket ( mp , agno , bucket ) ;
return NULLAGINO ;
}
2005-04-17 02:20:36 +04:00
/*
xfs: prevent CIL push holdoff in log recovery
generic/530 on a machine with enough ram and a non-preemptible
kernel can run the AGI processing phase of log recovery enitrely out
of cache. This means it never blocks on locks, never waits for IO
and runs entirely through the unlinked lists until it either
completes or blocks and hangs because it has run out of log space.
It runs out of log space because the background CIL push is
scheduled but never runs. queue_work() queues the CIL work on the
current CPU that is busy, and the workqueue code will not run it on
any other CPU. Hence if the unlinked list processing never yields
the CPU voluntarily, the push work is delayed indefinitely. This
results in the CIL aggregating changes until all the log space is
consumed.
When the log recoveyr processing evenutally blocks, the CIL flushes
but because the last iclog isn't submitted for IO because it isn't
full, the CIL flush never completes and nothing ever moves the log
head forwards, or indeed inserts anything into the tail of the log,
and hence nothing is able to get the log moving again and recovery
hangs.
There are several problems here, but the two obvious ones from
the trace are that:
a) log recovery does not yield the CPU for over 4 seconds,
b) binding CIL pushes to a single CPU is a really bad idea.
This patch addresses just these two aspects of the problem, and are
suitable for backporting to work around any issues in older kernels.
The more fundamental problem of preventing the CIL from consuming
more than 50% of the log without committing will take more invasive
and complex work, so will be done as followup work.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2019-09-06 07:35:39 +03:00
* Recover AGI unlinked lists
2005-04-17 02:20:36 +04:00
*
xfs: prevent CIL push holdoff in log recovery
generic/530 on a machine with enough ram and a non-preemptible
kernel can run the AGI processing phase of log recovery enitrely out
of cache. This means it never blocks on locks, never waits for IO
and runs entirely through the unlinked lists until it either
completes or blocks and hangs because it has run out of log space.
It runs out of log space because the background CIL push is
scheduled but never runs. queue_work() queues the CIL work on the
current CPU that is busy, and the workqueue code will not run it on
any other CPU. Hence if the unlinked list processing never yields
the CPU voluntarily, the push work is delayed indefinitely. This
results in the CIL aggregating changes until all the log space is
consumed.
When the log recoveyr processing evenutally blocks, the CIL flushes
but because the last iclog isn't submitted for IO because it isn't
full, the CIL flush never completes and nothing ever moves the log
head forwards, or indeed inserts anything into the tail of the log,
and hence nothing is able to get the log moving again and recovery
hangs.
There are several problems here, but the two obvious ones from
the trace are that:
a) log recovery does not yield the CPU for over 4 seconds,
b) binding CIL pushes to a single CPU is a really bad idea.
This patch addresses just these two aspects of the problem, and are
suitable for backporting to work around any issues in older kernels.
The more fundamental problem of preventing the CIL from consuming
more than 50% of the log without committing will take more invasive
and complex work, so will be done as followup work.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2019-09-06 07:35:39 +03:00
* This is called during recovery to process any inodes which we unlinked but
* not freed when the system crashed . These inodes will be on the lists in the
* AGI blocks . What we do here is scan all the AGIs and fully truncate and free
* any inodes found on the lists . Each inode is removed from the lists when it
* has been fully truncated and is freed . The freeing of the inode and its
* removal from the list must be atomic .
*
* If everything we touch in the agi processing loop is already in memory , this
* loop can hold the cpu for a long time . It runs without lock contention ,
* memory allocation contention , the need wait for IO , etc , and so will run
* until we either run out of inodes to process , run low on memory or we run out
* of log space .
*
* This behaviour is bad for latency on single CPU and non - preemptible kernels ,
* and can prevent other filesytem work ( such as CIL pushes ) from running . This
* can lead to deadlocks if the recovery process runs out of log reservation
* space . Hence we need to yield the CPU when there is other kernel work
* scheduled on this CPU to ensure other scheduled work can run without undue
* latency .
2005-04-17 02:20:36 +04:00
*/
2009-07-02 09:09:33 +04:00
STATIC void
2005-04-17 02:20:36 +04:00
xlog_recover_process_iunlinks (
2012-06-14 18:22:16 +04:00
struct xlog * log )
2005-04-17 02:20:36 +04:00
{
xfs_mount_t * mp ;
xfs_agnumber_t agno ;
xfs_agi_t * agi ;
xfs_buf_t * agibp ;
xfs_agino_t agino ;
int bucket ;
int error ;
mp = log - > l_mp ;
for ( agno = 0 ; agno < mp - > m_sb . sb_agcount ; agno + + ) {
/*
* Find the agi for this ag .
*/
2008-11-28 06:23:37 +03:00
error = xfs_read_agi ( mp , NULL , agno , & agibp ) ;
if ( error ) {
/*
* AGI is b0rked . Don ' t process it .
*
* We should probably mark the filesystem as corrupt
* after we ' ve recovered all the ag ' s we can . . . .
*/
continue ;
2005-04-17 02:20:36 +04:00
}
2012-03-15 13:34:02 +04:00
/*
* Unlock the buffer so that it can be acquired in the normal
* course of the transaction to truncate and free each inode .
* Because we are not racing with anyone else here for the AGI
* buffer , we don ' t even need to hold it locked to read the
* initial unlinked bucket entries out of the buffer . We keep
* buffer reference though , so that it stays pinned in memory
* while we need the buffer .
*/
2020-03-10 18:57:29 +03:00
agi = agibp - > b_addr ;
2012-03-15 13:34:02 +04:00
xfs_buf_unlock ( agibp ) ;
2005-04-17 02:20:36 +04:00
for ( bucket = 0 ; bucket < XFS_AGI_UNLINKED_BUCKETS ; bucket + + ) {
2005-11-02 07:11:25 +03:00
agino = be32_to_cpu ( agi - > agi_unlinked [ bucket ] ) ;
2005-04-17 02:20:36 +04:00
while ( agino ! = NULLAGINO ) {
2008-11-28 06:23:40 +03:00
agino = xlog_recover_process_one_iunlink ( mp ,
agno , agino , bucket ) ;
xfs: prevent CIL push holdoff in log recovery
generic/530 on a machine with enough ram and a non-preemptible
kernel can run the AGI processing phase of log recovery enitrely out
of cache. This means it never blocks on locks, never waits for IO
and runs entirely through the unlinked lists until it either
completes or blocks and hangs because it has run out of log space.
It runs out of log space because the background CIL push is
scheduled but never runs. queue_work() queues the CIL work on the
current CPU that is busy, and the workqueue code will not run it on
any other CPU. Hence if the unlinked list processing never yields
the CPU voluntarily, the push work is delayed indefinitely. This
results in the CIL aggregating changes until all the log space is
consumed.
When the log recoveyr processing evenutally blocks, the CIL flushes
but because the last iclog isn't submitted for IO because it isn't
full, the CIL flush never completes and nothing ever moves the log
head forwards, or indeed inserts anything into the tail of the log,
and hence nothing is able to get the log moving again and recovery
hangs.
There are several problems here, but the two obvious ones from
the trace are that:
a) log recovery does not yield the CPU for over 4 seconds,
b) binding CIL pushes to a single CPU is a really bad idea.
This patch addresses just these two aspects of the problem, and are
suitable for backporting to work around any issues in older kernels.
The more fundamental problem of preventing the CIL from consuming
more than 50% of the log without committing will take more invasive
and complex work, so will be done as followup work.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2019-09-06 07:35:39 +03:00
cond_resched ( ) ;
2005-04-17 02:20:36 +04:00
}
}
2012-03-15 13:34:02 +04:00
xfs_buf_rele ( agibp ) ;
2005-04-17 02:20:36 +04:00
}
}
2019-05-02 06:26:30 +03:00
STATIC void
2005-04-17 02:20:36 +04:00
xlog_unpack_data (
2012-06-14 18:22:16 +04:00
struct xlog_rec_header * rhead ,
2015-06-22 02:45:10 +03:00
char * dp ,
2012-06-14 18:22:16 +04:00
struct xlog * log )
2005-04-17 02:20:36 +04:00
{
int i , j , k ;
2007-10-12 04:59:34 +04:00
for ( i = 0 ; i < BTOBB ( be32_to_cpu ( rhead - > h_len ) ) & &
2005-04-17 02:20:36 +04:00
i < ( XLOG_HEADER_CYCLE_SIZE / BBSIZE ) ; i + + ) {
2007-10-12 04:59:34 +04:00
* ( __be32 * ) dp = * ( __be32 * ) & rhead - > h_cycle_data [ i ] ;
2005-04-17 02:20:36 +04:00
dp + = BBSIZE ;
}
2008-03-06 05:44:28 +03:00
if ( xfs_sb_version_haslogv2 ( & log - > l_mp - > m_sb ) ) {
2008-11-28 06:23:38 +03:00
xlog_in_core_2_t * xhdr = ( xlog_in_core_2_t * ) rhead ;
2007-10-12 04:59:34 +04:00
for ( ; i < BTOBB ( be32_to_cpu ( rhead - > h_len ) ) ; i + + ) {
2005-04-17 02:20:36 +04:00
j = i / ( XLOG_HEADER_CYCLE_SIZE / BBSIZE ) ;
k = i % ( XLOG_HEADER_CYCLE_SIZE / BBSIZE ) ;
2007-10-12 04:59:34 +04:00
* ( __be32 * ) dp = xhdr [ j ] . hic_xheader . xh_cycle_data [ k ] ;
2005-04-17 02:20:36 +04:00
dp + = BBSIZE ;
}
}
}
2016-01-04 07:55:10 +03:00
/*
2016-01-04 07:55:10 +03:00
* CRC check , unpack and process a log record .
2016-01-04 07:55:10 +03:00
*/
STATIC int
xlog_recover_process (
struct xlog * log ,
struct hlist_head rhash [ ] ,
struct xlog_rec_header * rhead ,
char * dp ,
2016-09-26 01:22:16 +03:00
int pass ,
struct list_head * buffer_list )
2016-01-04 07:55:10 +03:00
{
2016-12-05 06:40:32 +03:00
__le32 old_crc = rhead - > h_crc ;
2016-01-04 07:55:10 +03:00
__le32 crc ;
2016-01-04 07:55:10 +03:00
crc = xlog_cksum ( log , rhead , dp , be32_to_cpu ( rhead - > h_len ) ) ;
2016-01-04 07:55:10 +03:00
/*
2016-01-04 07:55:10 +03:00
* Nothing else to do if this is a CRC verification pass . Just return
* if this a record with a non - zero crc . Unfortunately , mkfs always
2016-12-05 06:40:32 +03:00
* sets old_crc to 0 so we must consider this valid even on v5 supers .
2016-01-04 07:55:10 +03:00
* Otherwise , return EFSBADCRC on failure so the callers up the stack
* know precisely what failed .
*/
if ( pass = = XLOG_RECOVER_CRCPASS ) {
2016-12-05 06:40:32 +03:00
if ( old_crc & & crc ! = old_crc )
2016-01-04 07:55:10 +03:00
return - EFSBADCRC ;
return 0 ;
}
/*
* We ' re in the normal recovery path . Issue a warning if and only if the
* CRC in the header is non - zero . This is an advisory warning and the
* zero CRC check prevents warnings from being emitted when upgrading
* the kernel from one that does not add CRCs by default .
2016-01-04 07:55:10 +03:00
*/
2016-12-05 06:40:32 +03:00
if ( crc ! = old_crc ) {
if ( old_crc | | xfs_sb_version_hascrc ( & log - > l_mp - > m_sb ) ) {
2016-01-04 07:55:10 +03:00
xfs_alert ( log - > l_mp ,
" log record CRC mismatch: found 0x%x, expected 0x%x. " ,
2016-12-05 06:40:32 +03:00
le32_to_cpu ( old_crc ) ,
2016-01-04 07:55:10 +03:00
le32_to_cpu ( crc ) ) ;
xfs_hex_dump ( dp , 32 ) ;
}
/*
* If the filesystem is CRC enabled , this mismatch becomes a
* fatal log corruption failure .
*/
2019-11-02 19:40:53 +03:00
if ( xfs_sb_version_hascrc ( & log - > l_mp - > m_sb ) ) {
XFS_ERROR_REPORT ( __func__ , XFS_ERRLEVEL_LOW , log - > l_mp ) ;
2016-01-04 07:55:10 +03:00
return - EFSCORRUPTED ;
2019-11-02 19:40:53 +03:00
}
2016-01-04 07:55:10 +03:00
}
2016-01-04 07:55:10 +03:00
2019-05-02 06:26:30 +03:00
xlog_unpack_data ( rhead , dp , log ) ;
2016-01-04 07:55:10 +03:00
2016-09-26 01:22:16 +03:00
return xlog_recover_process_data ( log , rhash , rhead , dp , pass ,
buffer_list ) ;
2016-01-04 07:55:10 +03:00
}
2005-04-17 02:20:36 +04:00
STATIC int
xlog_valid_rec_header (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
struct xlog_rec_header * rhead ,
2020-09-22 19:41:06 +03:00
xfs_daddr_t blkno ,
int bufsize )
2005-04-17 02:20:36 +04:00
{
int hlen ;
2019-11-11 23:53:22 +03:00
if ( XFS_IS_CORRUPT ( log - > l_mp ,
rhead - > h_magicno ! = cpu_to_be32 ( XLOG_HEADER_MAGIC_NUM ) ) )
2014-06-25 08:58:08 +04:00
return - EFSCORRUPTED ;
2019-11-11 23:53:22 +03:00
if ( XFS_IS_CORRUPT ( log - > l_mp ,
( ! rhead - > h_version | |
( be32_to_cpu ( rhead - > h_version ) &
( ~ XLOG_VERSION_OKBITS ) ) ) ) ) {
2011-03-07 02:01:35 +03:00
xfs_warn ( log - > l_mp , " %s: unrecognised log version (%d). " ,
2008-04-10 06:19:21 +04:00
__func__ , be32_to_cpu ( rhead - > h_version ) ) ;
2019-11-06 20:17:43 +03:00
return - EFSCORRUPTED ;
2005-04-17 02:20:36 +04:00
}
2020-09-22 19:41:06 +03:00
/*
* LR body must have data ( or it wouldn ' t have been written )
* and h_len must not be greater than LR buffer size .
*/
2007-10-12 04:59:34 +04:00
hlen = be32_to_cpu ( rhead - > h_len ) ;
2020-09-22 19:41:06 +03:00
if ( XFS_IS_CORRUPT ( log - > l_mp , hlen < = 0 | | hlen > bufsize ) )
2014-06-25 08:58:08 +04:00
return - EFSCORRUPTED ;
2020-09-22 19:41:06 +03:00
2019-11-11 23:53:22 +03:00
if ( XFS_IS_CORRUPT ( log - > l_mp ,
blkno > log - > l_logBBsize | | blkno > INT_MAX ) )
2014-06-25 08:58:08 +04:00
return - EFSCORRUPTED ;
2005-04-17 02:20:36 +04:00
return 0 ;
}
/*
* Read the log from tail to head and process the log records found .
* Handle the two cases where the tail and head are in the same cycle
* and where the active portion of the log wraps around the end of
* the physical log separately . The pass parameter is passed through
* to the routines called to process the data and is not looked at
* here .
*/
STATIC int
xlog_do_recovery_pass (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2005-04-17 02:20:36 +04:00
xfs_daddr_t head_blk ,
xfs_daddr_t tail_blk ,
2016-01-04 07:55:10 +03:00
int pass ,
xfs_daddr_t * first_bad ) /* out: first bad log rec */
2005-04-17 02:20:36 +04:00
{
xlog_rec_header_t * rhead ;
2017-08-09 04:21:51 +03:00
xfs_daddr_t blk_no , rblk_no ;
2016-01-04 07:55:10 +03:00
xfs_daddr_t rhead_blk ;
2015-06-22 02:45:10 +03:00
char * offset ;
2019-06-29 05:27:26 +03:00
char * hbp , * dbp ;
2016-01-04 07:55:10 +03:00
int error = 0 , h_size , h_len ;
2016-09-26 01:22:16 +03:00
int error2 = 0 ;
2005-04-17 02:20:36 +04:00
int bblks , split_bblks ;
int hblks , split_hblks , wrapped_hblks ;
2017-06-24 20:11:41 +03:00
int i ;
2010-01-11 14:49:57 +03:00
struct hlist_head rhash [ XLOG_RHASH_SIZE ] ;
2016-09-26 01:22:16 +03:00
LIST_HEAD ( buffer_list ) ;
2005-04-17 02:20:36 +04:00
ASSERT ( head_blk ! = tail_blk ) ;
2017-08-09 04:21:53 +03:00
blk_no = rhead_blk = tail_blk ;
2005-04-17 02:20:36 +04:00
2017-06-24 20:11:41 +03:00
for ( i = 0 ; i < XLOG_RHASH_SIZE ; i + + )
INIT_HLIST_HEAD ( & rhash [ i ] ) ;
2005-04-17 02:20:36 +04:00
/*
* Read the header of the tail block and get the iclog buffer size from
* h_size . Use this to tell how many sectors make up the log header .
*/
2008-03-06 05:44:28 +03:00
if ( xfs_sb_version_haslogv2 ( & log - > l_mp - > m_sb ) ) {
2005-04-17 02:20:36 +04:00
/*
* When using variable length iclogs , read first sector of
* iclog header and extract the header size from it . Get a
* new hbp that is the correct size .
*/
2019-06-29 05:27:27 +03:00
hbp = xlog_alloc_buffer ( log , 1 ) ;
2005-04-17 02:20:36 +04:00
if ( ! hbp )
2014-06-25 08:58:08 +04:00
return - ENOMEM ;
2009-03-16 10:24:13 +03:00
error = xlog_bread ( log , tail_blk , 1 , hbp , & offset ) ;
if ( error )
2005-04-17 02:20:36 +04:00
goto bread_err1 ;
2009-03-16 10:24:13 +03:00
2005-04-17 02:20:36 +04:00
rhead = ( xlog_rec_header_t * ) offset ;
2016-01-04 07:55:10 +03:00
/*
* xfsprogs has a bug where record length is based on lsunit but
* h_size ( iclog size ) is hardcoded to 32 k . Now that we
* unconditionally CRC verify the unmount record , this means the
* log buffer can be too small for the record and cause an
* overrun .
*
* Detect this condition here . Use lsunit for the buffer size as
* long as this looks like the mkfs case . Otherwise , return an
* error to avoid a buffer overrun .
*/
2007-10-12 04:59:34 +04:00
h_size = be32_to_cpu ( rhead - > h_size ) ;
2016-01-04 07:55:10 +03:00
h_len = be32_to_cpu ( rhead - > h_len ) ;
2020-09-22 19:41:06 +03:00
if ( h_len > h_size & & h_len < = log - > l_mp - > m_logbsize & &
rhead - > h_num_logops = = cpu_to_be32 ( 1 ) ) {
xfs_warn ( log - > l_mp ,
2016-01-04 07:55:10 +03:00
" invalid iclog size (%d bytes), using lsunit (%d bytes) " ,
2020-09-22 19:41:06 +03:00
h_size , log - > l_mp - > m_logbsize ) ;
h_size = log - > l_mp - > m_logbsize ;
2016-01-04 07:55:10 +03:00
}
2020-09-22 19:41:06 +03:00
error = xlog_valid_rec_header ( log , rhead , tail_blk , h_size ) ;
if ( error )
goto bread_err1 ;
2020-09-22 19:41:06 +03:00
hblks = xlog_logrec_hblks ( log , rhead ) ;
if ( hblks ! = 1 ) {
2019-06-29 05:27:26 +03:00
kmem_free ( hbp ) ;
2019-06-29 05:27:27 +03:00
hbp = xlog_alloc_buffer ( log , hblks ) ;
2005-04-17 02:20:36 +04:00
}
} else {
2010-04-20 11:09:59 +04:00
ASSERT ( log - > l_sectBBsize = = 1 ) ;
2005-04-17 02:20:36 +04:00
hblks = 1 ;
2019-06-29 05:27:27 +03:00
hbp = xlog_alloc_buffer ( log , 1 ) ;
2005-04-17 02:20:36 +04:00
h_size = XLOG_BIG_RECORD_BSIZE ;
}
if ( ! hbp )
2014-06-25 08:58:08 +04:00
return - ENOMEM ;
2019-06-29 05:27:27 +03:00
dbp = xlog_alloc_buffer ( log , BTOBB ( h_size ) ) ;
2005-04-17 02:20:36 +04:00
if ( ! dbp ) {
2019-06-29 05:27:26 +03:00
kmem_free ( hbp ) ;
2014-06-25 08:58:08 +04:00
return - ENOMEM ;
2005-04-17 02:20:36 +04:00
}
memset ( rhash , 0 , sizeof ( rhash ) ) ;
2014-09-09 05:57:29 +04:00
if ( tail_blk > head_blk ) {
2005-04-17 02:20:36 +04:00
/*
* Perform recovery around the end of the physical log .
* When the head is not on the same cycle number as the tail ,
2014-09-09 05:57:29 +04:00
* we can ' t do a sequential recovery .
2005-04-17 02:20:36 +04:00
*/
while ( blk_no < log - > l_logBBsize ) {
/*
* Check for header wrapping around physical end - of - log
*/
2019-06-29 05:27:26 +03:00
offset = hbp ;
2005-04-17 02:20:36 +04:00
split_hblks = 0 ;
wrapped_hblks = 0 ;
if ( blk_no + hblks < = log - > l_logBBsize ) {
/* Read header in one read */
2009-03-16 10:24:13 +03:00
error = xlog_bread ( log , blk_no , hblks , hbp ,
& offset ) ;
2005-04-17 02:20:36 +04:00
if ( error )
goto bread_err2 ;
} else {
/* This LR is split across physical log end */
if ( blk_no ! = log - > l_logBBsize ) {
/* some data before physical log end */
ASSERT ( blk_no < = INT_MAX ) ;
split_hblks = log - > l_logBBsize - ( int ) blk_no ;
ASSERT ( split_hblks > 0 ) ;
2009-03-16 10:24:13 +03:00
error = xlog_bread ( log , blk_no ,
split_hblks , hbp ,
& offset ) ;
if ( error )
2005-04-17 02:20:36 +04:00
goto bread_err2 ;
}
2009-03-16 10:24:13 +03:00
2005-04-17 02:20:36 +04:00
/*
* Note : this black magic still works with
* large sector sizes ( non - 512 ) only because :
* - we increased the buffer size originally
* by 1 sector giving us enough extra space
* for the second read ;
* - the log start is guaranteed to be sector
* aligned ;
* - we read the log end ( LR header start )
* _first_ , then the log start ( LR header end )
* - order is important .
*/
2008-04-10 06:24:24 +04:00
wrapped_hblks = hblks - split_hblks ;
2019-06-29 05:27:26 +03:00
error = xlog_bread_noalign ( log , 0 ,
wrapped_hblks ,
2011-04-21 13:34:27 +04:00
offset + BBTOB ( split_hblks ) ) ;
2005-04-17 02:20:36 +04:00
if ( error )
goto bread_err2 ;
}
rhead = ( xlog_rec_header_t * ) offset ;
error = xlog_valid_rec_header ( log , rhead ,
2020-09-22 19:41:06 +03:00
split_hblks ? blk_no : 0 , h_size ) ;
2005-04-17 02:20:36 +04:00
if ( error )
goto bread_err2 ;
2007-10-12 04:59:34 +04:00
bblks = ( int ) BTOBB ( be32_to_cpu ( rhead - > h_len ) ) ;
2005-04-17 02:20:36 +04:00
blk_no + = hblks ;
2017-08-09 04:21:51 +03:00
/*
* Read the log record data in multiple reads if it
* wraps around the end of the log . Note that if the
* header already wrapped , blk_no could point past the
* end of the log . The record data is contiguous in
* that case .
*/
if ( blk_no + bblks < = log - > l_logBBsize | |
blk_no > = log - > l_logBBsize ) {
2018-06-08 19:54:22 +03:00
rblk_no = xlog_wrap_logbno ( log , blk_no ) ;
2017-08-09 04:21:51 +03:00
error = xlog_bread ( log , rblk_no , bblks , dbp ,
2009-03-16 10:24:13 +03:00
& offset ) ;
2005-04-17 02:20:36 +04:00
if ( error )
goto bread_err2 ;
} else {
/* This log record is split across the
* physical end of log */
2019-06-29 05:27:26 +03:00
offset = dbp ;
2005-04-17 02:20:36 +04:00
split_bblks = 0 ;
if ( blk_no ! = log - > l_logBBsize ) {
/* some data is before the physical
* end of log */
ASSERT ( ! wrapped_hblks ) ;
ASSERT ( blk_no < = INT_MAX ) ;
split_bblks =
log - > l_logBBsize - ( int ) blk_no ;
ASSERT ( split_bblks > 0 ) ;
2009-03-16 10:24:13 +03:00
error = xlog_bread ( log , blk_no ,
split_bblks , dbp ,
& offset ) ;
if ( error )
2005-04-17 02:20:36 +04:00
goto bread_err2 ;
}
2009-03-16 10:24:13 +03:00
2005-04-17 02:20:36 +04:00
/*
* Note : this black magic still works with
* large sector sizes ( non - 512 ) only because :
* - we increased the buffer size originally
* by 1 sector giving us enough extra space
* for the second read ;
* - the log start is guaranteed to be sector
* aligned ;
* - we read the log end ( LR header start )
* _first_ , then the log start ( LR header end )
* - order is important .
*/
2019-06-29 05:27:26 +03:00
error = xlog_bread_noalign ( log , 0 ,
bblks - split_bblks ,
2011-04-21 13:34:27 +04:00
offset + BBTOB ( split_bblks ) ) ;
2009-03-16 10:24:13 +03:00
if ( error )
goto bread_err2 ;
2005-04-17 02:20:36 +04:00
}
xfs: add CRC checks to the log
Implement CRCs for the log buffers. We re-use a field in
struct xlog_rec_header that was used for a weak checksum of the
log buffer payload in debug builds before.
The new checksumming uses the crc32c checksum we will use elsewhere
in XFS, and also protects the record header and addition cycle data.
Due to this there are some interesting changes in xlog_sync, as we
need to do the cycle wrapping for the split buffer case much earlier,
as we would touch the buffer after generating the checksum otherwise.
The CRC calculation is always enabled, even for non-CRC filesystems,
as adding this CRC does not change the log format. On non-CRC
filesystems, only issue an alert if a CRC mismatch is found and
allow recovery to continue - this will act as an indicator that
log recovery problems are a result of log corruption. On CRC enabled
filesystems, however, log recovery will fail.
Note that existing debug kernels will write a simple checksum value
to the log, so the first time this is run on a filesystem taht was
last used on a debug kernel it will through CRC mismatch warning
errors. These can be ignored.
Initially based on a patch from Dave Chinner, then modified
significantly by Christoph Hellwig. Modified again by Dave Chinner
to get to this version.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-11-12 15:54:24 +04:00
2016-01-04 07:55:10 +03:00
error = xlog_recover_process ( log , rhash , rhead , offset ,
2016-09-26 01:22:16 +03:00
pass , & buffer_list ) ;
xfs: add CRC checks to the log
Implement CRCs for the log buffers. We re-use a field in
struct xlog_rec_header that was used for a weak checksum of the
log buffer payload in debug builds before.
The new checksumming uses the crc32c checksum we will use elsewhere
in XFS, and also protects the record header and addition cycle data.
Due to this there are some interesting changes in xlog_sync, as we
need to do the cycle wrapping for the split buffer case much earlier,
as we would touch the buffer after generating the checksum otherwise.
The CRC calculation is always enabled, even for non-CRC filesystems,
as adding this CRC does not change the log format. On non-CRC
filesystems, only issue an alert if a CRC mismatch is found and
allow recovery to continue - this will act as an indicator that
log recovery problems are a result of log corruption. On CRC enabled
filesystems, however, log recovery will fail.
Note that existing debug kernels will write a simple checksum value
to the log, so the first time this is run on a filesystem taht was
last used on a debug kernel it will through CRC mismatch warning
errors. These can be ignored.
Initially based on a patch from Dave Chinner, then modified
significantly by Christoph Hellwig. Modified again by Dave Chinner
to get to this version.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-11-12 15:54:24 +04:00
if ( error )
2005-04-17 02:20:36 +04:00
goto bread_err2 ;
2016-01-04 07:55:10 +03:00
2005-04-17 02:20:36 +04:00
blk_no + = bblks ;
2016-01-04 07:55:10 +03:00
rhead_blk = blk_no ;
2005-04-17 02:20:36 +04:00
}
ASSERT ( blk_no > = log - > l_logBBsize ) ;
blk_no - = log - > l_logBBsize ;
2016-01-04 07:55:10 +03:00
rhead_blk = blk_no ;
2014-09-09 05:57:29 +04:00
}
2005-04-17 02:20:36 +04:00
2014-09-09 05:57:29 +04:00
/* read first part of physical log */
while ( blk_no < head_blk ) {
error = xlog_bread ( log , blk_no , hblks , hbp , & offset ) ;
if ( error )
goto bread_err2 ;
2009-03-16 10:24:13 +03:00
2014-09-09 05:57:29 +04:00
rhead = ( xlog_rec_header_t * ) offset ;
2020-09-22 19:41:06 +03:00
error = xlog_valid_rec_header ( log , rhead , blk_no , h_size ) ;
2014-09-09 05:57:29 +04:00
if ( error )
goto bread_err2 ;
2009-03-16 10:24:13 +03:00
2014-09-09 05:57:29 +04:00
/* blocks in data section */
bblks = ( int ) BTOBB ( be32_to_cpu ( rhead - > h_len ) ) ;
error = xlog_bread ( log , blk_no + hblks , bblks , dbp ,
& offset ) ;
if ( error )
goto bread_err2 ;
2009-03-16 10:24:13 +03:00
2016-09-26 01:22:16 +03:00
error = xlog_recover_process ( log , rhash , rhead , offset , pass ,
& buffer_list ) ;
2014-09-09 05:57:29 +04:00
if ( error )
goto bread_err2 ;
2016-01-04 07:55:10 +03:00
2014-09-09 05:57:29 +04:00
blk_no + = bblks + hblks ;
2016-01-04 07:55:10 +03:00
rhead_blk = blk_no ;
2005-04-17 02:20:36 +04:00
}
bread_err2 :
2019-06-29 05:27:26 +03:00
kmem_free ( dbp ) ;
2005-04-17 02:20:36 +04:00
bread_err1 :
2019-06-29 05:27:26 +03:00
kmem_free ( hbp ) ;
2016-01-04 07:55:10 +03:00
2016-09-26 01:22:16 +03:00
/*
* Submit buffers that have been added from the last record processed ,
* regardless of error status .
*/
if ( ! list_empty ( & buffer_list ) )
error2 = xfs_buf_delwri_submit ( & buffer_list ) ;
2016-01-04 07:55:10 +03:00
if ( error & & first_bad )
* first_bad = rhead_blk ;
2017-06-24 20:11:41 +03:00
/*
* Transactions are freed at commit time but transactions without commit
* records on disk are never committed . Free any that may be left in the
* hash table .
*/
for ( i = 0 ; i < XLOG_RHASH_SIZE ; i + + ) {
struct hlist_node * tmp ;
struct xlog_recover * trans ;
hlist_for_each_entry_safe ( trans , tmp , & rhash [ i ] , r_list )
xlog_recover_free_trans ( trans ) ;
}
2016-09-26 01:22:16 +03:00
return error ? error : error2 ;
2005-04-17 02:20:36 +04:00
}
/*
* Do the recovery of the log . We actually do this in two phases .
* The two passes are necessary in order to implement the function
* of cancelling a record written into the log . The first pass
* determines those things which have been cancelled , and the
* second pass replays log items normally except for those which
* have been cancelled . The handling of the replay and cancellations
* takes place in the log item type specific routines .
*
* The table of items which have cancel records in the log is allocated
* and freed at this level , since only here do we know when all of
* the log recovery has been completed .
*/
STATIC int
xlog_do_log_recovery (
2012-06-14 18:22:16 +04:00
struct xlog * log ,
2005-04-17 02:20:36 +04:00
xfs_daddr_t head_blk ,
xfs_daddr_t tail_blk )
{
2010-12-02 01:06:22 +03:00
int error , i ;
2005-04-17 02:20:36 +04:00
ASSERT ( head_blk ! = tail_blk ) ;
/*
* First do a pass to find all of the cancelled buf log items .
* Store them in the buf_cancel_table for use in the second pass .
*/
2010-12-02 01:06:22 +03:00
log - > l_buf_cancel_table = kmem_zalloc ( XLOG_BC_TABLE_SIZE *
sizeof ( struct list_head ) ,
2019-08-26 22:06:22 +03:00
0 ) ;
2010-12-02 01:06:22 +03:00
for ( i = 0 ; i < XLOG_BC_TABLE_SIZE ; i + + )
INIT_LIST_HEAD ( & log - > l_buf_cancel_table [ i ] ) ;
2005-04-17 02:20:36 +04:00
error = xlog_do_recovery_pass ( log , head_blk , tail_blk ,
2016-01-04 07:55:10 +03:00
XLOG_RECOVER_PASS1 , NULL ) ;
2005-04-17 02:20:36 +04:00
if ( error ! = 0 ) {
2008-05-19 10:31:57 +04:00
kmem_free ( log - > l_buf_cancel_table ) ;
2005-04-17 02:20:36 +04:00
log - > l_buf_cancel_table = NULL ;
return error ;
}
/*
* Then do a second pass to actually recover the items in the log .
* When it is complete free the table of buf cancel items .
*/
error = xlog_do_recovery_pass ( log , head_blk , tail_blk ,
2016-01-04 07:55:10 +03:00
XLOG_RECOVER_PASS2 , NULL ) ;
2005-04-17 02:20:36 +04:00
# ifdef DEBUG
2006-06-09 08:55:38 +04:00
if ( ! error ) {
2005-04-17 02:20:36 +04:00
int i ;
for ( i = 0 ; i < XLOG_BC_TABLE_SIZE ; i + + )
2010-12-02 01:06:22 +03:00
ASSERT ( list_empty ( & log - > l_buf_cancel_table [ i ] ) ) ;
2005-04-17 02:20:36 +04:00
}
# endif /* DEBUG */
2008-05-19 10:31:57 +04:00
kmem_free ( log - > l_buf_cancel_table ) ;
2005-04-17 02:20:36 +04:00
log - > l_buf_cancel_table = NULL ;
return error ;
}
/*
* Do the actual recovery
*/
STATIC int
xlog_do_recover (
2020-09-01 20:55:47 +03:00
struct xlog * log ,
xfs_daddr_t head_blk ,
xfs_daddr_t tail_blk )
2005-04-17 02:20:36 +04:00
{
2020-09-01 20:55:47 +03:00
struct xfs_mount * mp = log - > l_mp ;
struct xfs_buf * bp = mp - > m_sb_bp ;
struct xfs_sb * sbp = & mp - > m_sb ;
int error ;
2005-04-17 02:20:36 +04:00
2017-08-09 04:21:53 +03:00
trace_xfs_log_recover ( log , head_blk , tail_blk ) ;
2005-04-17 02:20:36 +04:00
/*
* First replay the images in the log .
*/
error = xlog_do_log_recovery ( log , head_blk , tail_blk ) ;
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-23 09:58:39 +04:00
if ( error )
2005-04-17 02:20:36 +04:00
return error ;
/*
* If IO errors happened during recovery , bail out .
*/
2020-09-01 20:55:47 +03:00
if ( XFS_FORCED_SHUTDOWN ( mp ) )
2014-06-25 08:58:08 +04:00
return - EIO ;
2005-04-17 02:20:36 +04:00
/*
* We now update the tail_lsn since much of the recovery has completed
* and there may be space available to use . If there were no extent
* or iunlinks , we can free up the entire log and set the tail_lsn to
* be the last_sync_lsn . This was set in xlog_find_tail to be the
* lsn of the last known good LR on disk . If there are extent frees
* or iunlinks they will have some entries in the AIL ; so we look at
* the AIL to determine how to set the tail_lsn .
*/
2016-03-07 00:39:36 +03:00
xlog_assign_tail_lsn ( mp ) ;
2005-04-17 02:20:36 +04:00
/*
2020-09-01 20:55:47 +03:00
* Now that we ' ve finished replaying all buffer and inode updates ,
* re - read the superblock and reverify it .
2005-04-17 02:20:36 +04:00
*/
2020-09-01 20:55:47 +03:00
xfs_buf_lock ( bp ) ;
xfs_buf_hold ( bp ) ;
2020-09-01 20:55:47 +03:00
error = _xfs_buf_read ( bp , XBF_READ ) ;
2008-04-10 06:22:17 +04:00
if ( error ) {
2016-03-07 00:39:36 +03:00
if ( ! XFS_FORCED_SHUTDOWN ( mp ) ) {
2020-01-24 04:01:20 +03:00
xfs_buf_ioerror_alert ( bp , __this_address ) ;
2014-10-02 03:05:14 +04:00
ASSERT ( 0 ) ;
}
2005-04-17 02:20:36 +04:00
xfs_buf_relse ( bp ) ;
return error ;
}
/* Convert superblock from on-disk format */
2020-03-10 18:57:30 +03:00
xfs_sb_from_disk ( sbp , bp - > b_addr ) ;
2005-04-17 02:20:36 +04:00
xfs_buf_relse ( bp ) ;
2016-03-07 00:39:36 +03:00
/* re-initialise in-core superblock and geometry structures */
xfs_reinit_percpu_counters ( mp ) ;
error = xfs_initialize_perag ( mp , sbp - > sb_agcount , & mp - > m_maxagi ) ;
if ( error ) {
xfs_warn ( mp , " Failed post-recovery per-ag init: %d " , error ) ;
return error ;
}
2016-08-03 04:38:24 +03:00
mp - > m_alloc_set_aside = xfs_alloc_set_aside ( mp ) ;
2007-02-10 10:36:29 +03:00
2005-04-17 02:20:36 +04:00
xlog_recover_check_summary ( log ) ;
/* Normal transactions can now occur */
log - > l_flags & = ~ XLOG_ACTIVE_RECOVERY ;
return 0 ;
}
/*
* Perform recovery and re - initialize some log variables in xlog_find_tail .
*
* Return error or zero .
*/
int
xlog_recover (
2012-06-14 18:22:16 +04:00
struct xlog * log )
2005-04-17 02:20:36 +04:00
{
xfs_daddr_t head_blk , tail_blk ;
int error ;
/* find the tail of the log */
2015-10-12 07:59:25 +03:00
error = xlog_find_tail ( log , & head_blk , & tail_blk ) ;
if ( error )
2005-04-17 02:20:36 +04:00
return error ;
2015-10-12 07:59:25 +03:00
/*
* The superblock was read before the log was available and thus the LSN
* could not be verified . Check the superblock LSN against the current
* LSN now that it ' s known .
*/
if ( xfs_sb_version_hascrc ( & log - > l_mp - > m_sb ) & &
! xfs_log_check_lsn ( log - > l_mp , log - > l_mp - > m_sb . sb_lsn ) )
return - EINVAL ;
2005-04-17 02:20:36 +04:00
if ( tail_blk ! = head_blk ) {
/* There used to be a comment here:
*
* disallow recovery on read - only mounts . note - - mount
* checks for ENOSPC and turns it into an intelligent
* error message .
* . . . but this is no longer true . Now , unless you specify
* NORECOVERY ( in which case this function would never be
* called ) , we just go ahead and recover . We do this all
* under the vfs layer , so we can get away with it unless
* the device itself is read - only , in which case we fail .
*/
2007-05-08 07:50:06 +04:00
if ( ( error = xfs_dev_is_read_only ( log - > l_mp , " recovery " ) ) ) {
2005-04-17 02:20:36 +04:00
return error ;
}
2013-04-03 09:11:32 +04:00
/*
* Version 5 superblock log feature mask validation . We know the
* log is dirty so check if there are any unknown log features
* in what we need to recover . If there are unknown features
* ( e . g . unsupported transactions , then simply reject the
* attempt at recovery before touching anything .
*/
if ( XFS_SB_VERSION_NUM ( & log - > l_mp - > m_sb ) = = XFS_SB_VERSION_5 & &
xfs_sb_has_incompat_log_feature ( & log - > l_mp - > m_sb ,
XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN ) ) {
xfs_warn ( log - > l_mp ,
2015-07-29 04:52:04 +03:00
" Superblock has unknown incompatible log features (0x%x) enabled. " ,
2013-04-03 09:11:32 +04:00
( log - > l_mp - > m_sb . sb_features_log_incompat &
XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN ) ) ;
2015-07-29 04:52:04 +03:00
xfs_warn ( log - > l_mp ,
" The log can not be fully and/or safely recovered by this kernel. " ) ;
xfs_warn ( log - > l_mp ,
" Please recover the log on a kernel that supports the unknown features. " ) ;
2014-06-25 08:58:08 +04:00
return - EINVAL ;
2013-04-03 09:11:32 +04:00
}
2014-09-09 05:56:13 +04:00
/*
* Delay log recovery if the debug hook is set . This is debug
* instrumention to coordinate simulation of I / O failures with
* log recovery .
*/
if ( xfs_globals . log_recovery_delay ) {
xfs_notice ( log - > l_mp ,
" Delaying log recovery for %d seconds. " ,
xfs_globals . log_recovery_delay ) ;
msleep ( xfs_globals . log_recovery_delay * 1000 ) ;
}
2011-03-07 02:01:35 +03:00
xfs_notice ( log - > l_mp , " Starting recovery (logdev: %s) " ,
log - > l_mp - > m_logname ? log - > l_mp - > m_logname
: " internal " ) ;
2005-04-17 02:20:36 +04:00
error = xlog_do_recover ( log , head_blk , tail_blk ) ;
log - > l_flags | = XLOG_RECOVERY_NEEDED ;
}
return error ;
}
/*
* In the first part of recovery we replay inodes and buffers and build
* up the list of extent free items which need to be processed . Here
* we process the extent free items and clean up the on disk unlinked
* inode lists . This is separated from the first part of recovery so
* that the root and real - time bitmap inodes can be read in from disk in
* between the two stages . This is necessary so that we can free space
* in the real - time portion of the file system .
*/
int
xlog_recover_finish (
2012-06-14 18:22:16 +04:00
struct xlog * log )
2005-04-17 02:20:36 +04:00
{
/*
* Now we ' re ready to do the transactions needed for the
* rest of recovery . Start with completing all the extent
* free intent records and then process the unlinked inode
* lists . At this point , we essentially run in normal mode
* except that we ' re still performing recovery actions
* rather than accepting new requests .
*/
if ( log - > l_flags & XLOG_RECOVERY_NEEDED ) {
2008-04-10 06:21:11 +04:00
int error ;
2016-08-03 04:23:49 +03:00
error = xlog_recover_process_intents ( log ) ;
2008-04-10 06:21:11 +04:00
if ( error ) {
2016-08-03 04:23:49 +03:00
xfs_alert ( log - > l_mp , " Failed to recover intents " ) ;
2008-04-10 06:21:11 +04:00
return error ;
}
2016-08-03 05:09:48 +03:00
2005-04-17 02:20:36 +04:00
/*
2016-08-03 04:23:49 +03:00
* Sync the log to get all the intents out of the AIL .
2005-04-17 02:20:36 +04:00
* This isn ' t absolutely necessary , but it helps in
* case the unlink transactions would have problems
2016-08-03 04:23:49 +03:00
* pushing the intents out of the way .
2005-04-17 02:20:36 +04:00
*/
2010-01-19 12:56:46 +03:00
xfs_log_force ( log - > l_mp , XFS_LOG_SYNC ) ;
2005-04-17 02:20:36 +04:00
2008-08-13 10:49:32 +04:00
xlog_recover_process_iunlinks ( log ) ;
2005-04-17 02:20:36 +04:00
xlog_recover_check_summary ( log ) ;
2011-03-07 02:01:35 +03:00
xfs_notice ( log - > l_mp , " Ending recovery (logdev: %s) " ,
log - > l_mp - > m_logname ? log - > l_mp - > m_logname
: " internal " ) ;
2005-04-17 02:20:36 +04:00
log - > l_flags & = ~ XLOG_RECOVERY_NEEDED ;
} else {
2011-03-07 02:01:35 +03:00
xfs_info ( log - > l_mp , " Ending clean mount " ) ;
2005-04-17 02:20:36 +04:00
}
return 0 ;
}
2019-07-03 17:34:18 +03:00
void
2015-08-19 02:58:36 +03:00
xlog_recover_cancel (
struct xlog * log )
{
if ( log - > l_flags & XLOG_RECOVERY_NEEDED )
2019-07-03 17:34:18 +03:00
xlog_recover_cancel_intents ( log ) ;
2015-08-19 02:58:36 +03:00
}
2005-04-17 02:20:36 +04:00
# if defined(DEBUG)
/*
* Read all of the agf and agi counters and check that they
* are consistent with the superblock counters .
*/
2017-11-06 22:54:01 +03:00
STATIC void
2005-04-17 02:20:36 +04:00
xlog_recover_check_summary (
2012-06-14 18:22:16 +04:00
struct xlog * log )
2005-04-17 02:20:36 +04:00
{
xfs_mount_t * mp ;
xfs_buf_t * agfbp ;
xfs_buf_t * agibp ;
xfs_agnumber_t agno ;
2017-06-16 21:00:05 +03:00
uint64_t freeblks ;
uint64_t itotal ;
uint64_t ifree ;
2008-11-28 06:23:37 +03:00
int error ;
2005-04-17 02:20:36 +04:00
mp = log - > l_mp ;
freeblks = 0LL ;
itotal = 0LL ;
ifree = 0LL ;
for ( agno = 0 ; agno < mp - > m_sb . sb_agcount ; agno + + ) {
2008-11-28 06:23:38 +03:00
error = xfs_read_agf ( mp , NULL , agno , 0 , & agfbp ) ;
if ( error ) {
2011-03-07 02:01:35 +03:00
xfs_alert ( mp , " %s agf read failed agno %d error %d " ,
__func__ , agno , error ) ;
2008-11-28 06:23:38 +03:00
} else {
2020-03-10 18:57:29 +03:00
struct xfs_agf * agfp = agfbp - > b_addr ;
2008-11-28 06:23:38 +03:00
freeblks + = be32_to_cpu ( agfp - > agf_freeblks ) +
be32_to_cpu ( agfp - > agf_flcount ) ;
xfs_buf_relse ( agfbp ) ;
2005-04-17 02:20:36 +04:00
}
2008-11-28 06:23:37 +03:00
error = xfs_read_agi ( mp , NULL , agno , & agibp ) ;
2011-03-07 02:01:35 +03:00
if ( error ) {
xfs_alert ( mp , " %s agi read failed agno %d error %d " ,
__func__ , agno , error ) ;
} else {
2020-03-10 18:57:29 +03:00
struct xfs_agi * agi = agibp - > b_addr ;
2005-11-02 07:11:25 +03:00
2008-11-28 06:23:37 +03:00
itotal + = be32_to_cpu ( agi - > agi_count ) ;
ifree + = be32_to_cpu ( agi - > agi_freecount ) ;
xfs_buf_relse ( agibp ) ;
}
2005-04-17 02:20:36 +04:00
}
}
# endif /* DEBUG */