mirror of
https://github.com/linux-apfs/apfstests.git
synced 2026-05-01 15:01:44 -07:00
Niv Sardi
c77cdc9151
Update test 082 for new filtred output
Update test 081 for new filtred output
Update test 018 for new filtred output
xfstests: filter out logprint inode version (and format)
Merge of master-melb:xfs-cmds:30583a by kenmcd.
459 lines
12 KiB
Plaintext
459 lines
12 KiB
Plaintext
##/bin/sh
|
|
#
|
|
# Copyright (c) 2000-2002 Silicon Graphics, Inc. All Rights Reserved.
|
|
#
|
|
# common routines for log testing
|
|
# Created by dxm@sgi.com & tes@sgi.com
|
|
#
|
|
|
|
fulldir=$seq.fulldir
|
|
rm -rf $fulldir
|
|
|
|
_cleanup_logfiles()
|
|
{
|
|
if [ $status -eq 0 ]; then
|
|
# don't keep these files around unless something went wrong
|
|
rm -rf $fulldir
|
|
fi
|
|
}
|
|
|
|
_full()
|
|
{
|
|
echo "" >>$seq.full
|
|
echo "*** $* ***" >>$seq.full
|
|
echo "" >>$seq.full
|
|
}
|
|
|
|
_echofull()
|
|
{
|
|
echo "" | tee -a $seq.full
|
|
echo "*** $* ***" | tee -a $seq.full
|
|
echo "" | tee -a $seq.full
|
|
}
|
|
|
|
# Handle the operations which get split over Log Record
|
|
# boundaries.
|
|
# Oper (379)..... flags: CONTINUE
|
|
# ...
|
|
# Oper (0)....... flags: WAS_CONT END
|
|
#
|
|
# or
|
|
#
|
|
# Oper (379)..... flags: none
|
|
# ...
|
|
# Oper (0)....... flags: none
|
|
#
|
|
_filter_opnum()
|
|
{
|
|
$AWK_PROG '
|
|
BEGIN {
|
|
debug = 0
|
|
}
|
|
/^Oper/ && debug {
|
|
printf "line = %s\n", $0
|
|
}
|
|
/^Oper/ {
|
|
was_cont = 0
|
|
}
|
|
/^Oper/ && /flags: CONTINUE/ {
|
|
# this will be the first op of split region
|
|
$9 = "none" # overwrite CONTINUE flags
|
|
print
|
|
print "Not printing rest"
|
|
was_cont = 1
|
|
next
|
|
}
|
|
/^Oper/ && /flags: WAS_CONT END/ {
|
|
# this will be the last op of split region
|
|
# skip over was-continued op
|
|
# we assume there can be only 1
|
|
was_cont = 1
|
|
next
|
|
}
|
|
(was_cont == 1) {
|
|
# skip over any continued op stuff
|
|
next
|
|
}
|
|
{print}
|
|
'
|
|
}
|
|
|
|
#
|
|
# Filter out things that can change
|
|
# We have complexities which change when log is sync'ed at different
|
|
# times.
|
|
# Example1: DATA FORK EXTENTS
|
|
# These will not show up if inode is sync'ed sooner
|
|
# /DATA FORK EXTENTS/d;
|
|
# /INODE:/s/flags:0x5/flags:0x1/g;
|
|
# define XFS_ILOG_CORE 0x001 /* log standard inode fields */
|
|
# define XFS_ILOG_DEXT 0x004 /* log i_df.if_extents */
|
|
#
|
|
#
|
|
|
|
_filter_logprint()
|
|
{
|
|
_fix_malloc |\
|
|
sed '
|
|
s/ver:[0-9]/ver:<VERS>/;
|
|
s/version [0-9] format [0-9]/version <VERS> format <FORMAT>/;
|
|
s/data device: 0x[0-9a-f][0-9a-f]*/data device: <DEVICE>/;
|
|
s/log device: 0x[0-9a-f][0-9a-f]*/log device: <DEVICE>/;
|
|
s/log file: \".*\"/log device: <DEVICE>/;
|
|
s/daddr: [0-9][0-9]*/daddr: <DADDR>/;
|
|
s/length: [0-9][0-9]*/length: <LENGTH>/;
|
|
s/length: [0-9][0-9]*/length: <LENGTH>/;
|
|
s/^cycle num overwrites: .*$/cycle num overwrites: <TIDS>/;
|
|
s/tid: [0-9a-f][0-9a-f]*/tid: <TID>/;
|
|
s/tid:0x[0-9a-f][0-9a-f]*/tid:<TID>/;
|
|
s/q:0x[0-9a-f][0-9a-f]*/q:<Q>/;
|
|
s/a:0x[0-9a-f][0-9a-f]*/a:<A>/g;
|
|
s/blkno:0x[0-9a-f][0-9a-f]*/blkno:<BLKNO>/g;
|
|
s/blkno: *[0-9][0-9]* (0x[0-9a-f]*)/blkno: <BLKNO> (<BLKNO>)/g;
|
|
s/blkno: *[0-9][0-9]*/blkno: <BLKNO>/g;
|
|
s/boff: [0-9][0-9]*/boff: <BOFF>/g;
|
|
s/len: *[0-9][0-9]*/len:<LEN>/g;
|
|
/BUF:/s/[ ]*flags:.*$//;
|
|
/zeroed blocks/s/[0-9][0-9]*/<COUNT>/g;
|
|
/cleared blocks/d;
|
|
/log tail/s/[0-9][0-9]*/<COUNT>/g;
|
|
s/atime:[0-9a-fx]* *mtime:[0-9a-fx]* *ctime:[0-9a-fx]*/atime:<TIME> mtime:<TIME> ctime:<TIME>/;
|
|
s/atime 0x[0-9a-f]* mtime 0x[0-9a-f]* ctime 0x[0-9a-f]*/atime <TIME> mtime <TIME> ctime <TIME>/;
|
|
s/block [0-9][0-9]*/block <BLOCK>/;
|
|
s/icount: *[0-9][0-9]* *ifree: *[0-9][0-9]* *fdblks: *[0-9][0-9]* *frext: *[0-9][0-9]*/icount:<COUNT> ifree:<FREE> fdblks:<BLOCKS> frext:<COUNT>/;
|
|
s/sunit: *[0-9][0-9]* *swidth: *[0-9][0-9]*/sunit:<SUNIT> swidth:<SWIDTH>/;
|
|
s/1st: *[0-9][0-9]* *last: *[0-9][0-9]* *cnt: *[0-9][0-9]* *freeblks: *[0-9][0-9]* *longest: *[0-9][0-9]*/1st:<NUM> last:<NUM> cnt:<COUNT> freeblks:<COUNT> longest:<NUM>/;
|
|
s/^uuid: *[0-9a-f-][0-9a-f-]* *format: *.*$/uuid: <UUID> format: <FORMAT>/;
|
|
/flushiter:/d;
|
|
/version:/,/h_size:/d;
|
|
/override tail/s/[0-9][0-9]*/<TAIL_BLK>/;
|
|
/^---*/d;
|
|
/^===*/d;
|
|
/^~~~*/d;
|
|
/extended-header/d;
|
|
/LOG REC AT LSN/d;
|
|
/DATA FORK EXTENTS/d;
|
|
s/BUF: cnt:[1-9][0-9]* total:[1-9][0-9]*.*/BUF: cnt:C total:T/;
|
|
s/INO: cnt:[1-9][0-9]* total:[1-9][0-9]*.*/INO: cnt:C total:T/;
|
|
s/#regs: *[1-9][0-9]*/#regs:R/;
|
|
/INODE:/s/flags:0x5/flags:0x1/g;
|
|
s/Oper ([0-9][0-9]*)/Oper (OPNUM)/;
|
|
/^[ ]*$/d;
|
|
s/ */ /g;
|
|
s/ $//;
|
|
s/newino: 0x[0-9a-f]*$/newino: <INO>/g
|
|
s/newino:0x[0-9a-f]*$/newino:<INO>/g
|
|
s/ino: 0x[0-9a-f]* flags:/ino: <INO> flags:/g
|
|
s/ino:0x[0-9a-f]* flags:/ino:<INO> flags:/g
|
|
'|\
|
|
awk '
|
|
# collapse BUF DATA group into 1 line
|
|
# for Oper data this can be over separate operations...ughh
|
|
/BUF DATA/ {
|
|
if (!buf_data) { # 1st one
|
|
if (oper) {
|
|
print oper
|
|
oper = 0
|
|
}
|
|
print
|
|
}
|
|
buf_data = 1
|
|
oper = 0 # wont need it now
|
|
next
|
|
}
|
|
/^Oper/ {
|
|
# store it as we dont know if 2nd BUF DATA is to follow
|
|
if (oper) {
|
|
print oper
|
|
}
|
|
oper = $0
|
|
next
|
|
}
|
|
/^TRANS/ && dummy_rec == 1 {
|
|
# start printing again - dummy transaction over
|
|
dummy_rec = 0
|
|
}
|
|
/DUMMY1/ {
|
|
# filter out dummy transactions
|
|
dummy_rec = 1
|
|
next
|
|
}
|
|
{
|
|
if (dummy_rec) {
|
|
next
|
|
}
|
|
buf_data = 0
|
|
if (oper) { # now we can print out oper
|
|
print oper
|
|
oper = 0
|
|
}
|
|
print
|
|
}
|
|
'
|
|
}
|
|
|
|
_check_log()
|
|
{
|
|
_full "clean_log : xfs_logprint"
|
|
_scratch_xfs_logprint -t | tee -a $seq.full \
|
|
| head | grep -q "<CLEAN>" || _fail "DIRTY LOG"
|
|
}
|
|
|
|
_print_logstate()
|
|
{
|
|
_scratch_xfs_logprint -t | tee -a $seq.full >$tmp.logprint
|
|
if grep -q "<DIRTY>" $tmp.logprint; then
|
|
echo "dirty log"
|
|
fi
|
|
if grep -q "<CLEAN>" $tmp.logprint; then
|
|
echo "clean log"
|
|
fi
|
|
}
|
|
|
|
_print_operation()
|
|
{
|
|
mkdir $fulldir >/dev/null 2>&1
|
|
mntopt=`echo $MOUNT_OPTIONS | sed 's/ //g'`
|
|
mkfsopt=`echo $MKFS_OPTIONS | sed 's/ //g'`
|
|
raw=$fulldir/op.mnt$mntopt.mkfs$mkfsopt$sync_suffix.raw
|
|
filtered=$fulldir/op.mnt$mntopt.mkfs$mkfsopt$sync_suffix.filtered
|
|
|
|
echo "### xfs_logprint output ###" | tee $raw >$filtered
|
|
_scratch_xfs_logprint -c 2>&1 \
|
|
| tee -a $raw \
|
|
| _filter_logprint \
|
|
| _filter_opnum \
|
|
>>$filtered
|
|
}
|
|
|
|
# start at rec#2 "-s 2" so we skip over UMOUNT record which will always
|
|
# be a 512b single header at mkfs time
|
|
# and may not match with the FS mounted at a different LR size
|
|
# => xlog_do_recovery_pass() can not handle the different hdr sizes
|
|
# it assumes them all to be the same between the start..finish
|
|
# NB: On IRIX there is no UMOUNT record and so we could start from -s 0.
|
|
|
|
_print_transaction_inode()
|
|
{
|
|
_start=$1
|
|
mkdir $fulldir >/dev/null 2>&1
|
|
mntopt=`echo $MOUNT_OPTIONS | sed 's/ //g'`
|
|
mkfsopt=`echo $MKFS_OPTIONS | sed 's/ //g'`
|
|
raw=$fulldir/trans_inode.mnt$mntopt.mkfs$mkfsopt$sync_suffix.raw
|
|
filtered=$fulldir/trans_inode.mnt$mntopt.mkfs$mkfsopt$sync_suffix.filtered
|
|
|
|
echo "### xfs_logprint -t -i -s START output ###" | tee $raw >$filtered
|
|
_scratch_xfs_logprint -t -i -s $_start 2>&1 \
|
|
| tee -a $raw \
|
|
| _filter_logprint \
|
|
>>$filtered
|
|
}
|
|
|
|
_print_transaction_buf()
|
|
{
|
|
_start=$1
|
|
mkdir $fulldir >/dev/null 2>&1
|
|
mntopt=`echo $MOUNT_OPTIONS | sed 's/ //g'`
|
|
mkfsopt=`echo $MKFS_OPTIONS | sed 's/ //g'`
|
|
raw=$fulldir/trans_buf.mnt$mntopt.mkfs$mkfsopt$sync_suffix.raw
|
|
filtered=$fulldir/trans_buf.mnt$mntopt.mkfs$mkfsopt$sync_suffix.filtered
|
|
|
|
echo "### xfs_logprint -t -b -s START output ###" | tee $raw >$filtered
|
|
_scratch_xfs_logprint -t -b -s $_start 2>&1 \
|
|
| tee -a $raw \
|
|
| _filter_logprint \
|
|
>>$filtered
|
|
}
|
|
|
|
_mkfs_log()
|
|
{
|
|
# create the FS
|
|
# mkfs options to append to log size otion can be specified ($*)
|
|
export MKFS_OPTIONS="-l size=2000b $*"
|
|
_full "mkfs"
|
|
_scratch_mkfs_xfs >>$seq.full 2>&1
|
|
if [ $? -ne 0 ] ; then
|
|
_echofull "Cannot mkfs for this test using option specified: $MKFS_OPTIONS"
|
|
return 1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
|
|
#
|
|
# mount fs and create some log traffic
|
|
#
|
|
_create_log()
|
|
{
|
|
# mount the FS
|
|
_full "mount"
|
|
_scratch_mount >>$seq.full 2>&1
|
|
if [ $? -ne 0 ] ; then
|
|
_echofull "mount failed: $MOUNT_OPTIONS"
|
|
return 1
|
|
fi
|
|
|
|
# generate some log traffic - but not too much - life gets a little
|
|
# more complicated if the log wraps around. This traffic is
|
|
# pretty much arbitary, but could probably be made better than this.
|
|
touch $SCRATCH_MNT/{0,1,2,3,4,5,6,7,8,9}{0,1,2,3,4,5,6,7,8,9}
|
|
|
|
# unmount the FS
|
|
_full "umount"
|
|
umount $SCRATCH_DEV >>$seq.full 2>&1
|
|
if [ $? -ne 0 ] ; then
|
|
_echofull "umount failed"
|
|
return 1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
#
|
|
# mount fs and create some log traffic with sync'ing
|
|
#
|
|
_create_log_sync()
|
|
{
|
|
# mount the FS
|
|
_full " mount"
|
|
_scratch_mount >>$seq.full 2>&1
|
|
if [ $? -ne 0 ] ; then
|
|
_echofull "mount failed: $MOUNT_OPTIONS"
|
|
return 1
|
|
fi
|
|
|
|
# generate some log traffic - but not too much
|
|
# add some syncs to get the log flushed to disk
|
|
for file in $SCRATCH_MNT/{0,1,2,3,4,5,6,7,8,9}{0,1,2,3,4,5,6,7,8,9}; do
|
|
touch $file
|
|
sync
|
|
done
|
|
|
|
# unmount the FS
|
|
_full "umount"
|
|
umount $SCRATCH_DEV >>$seq.full 2>&1
|
|
if [ $? -ne 0 ] ; then
|
|
_echofull "umount failed"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
_cmp_output()
|
|
{
|
|
echo "*** compare logprint: $1 with $2"
|
|
if ! diff $1 $2 >/dev/null; then
|
|
_fail "logprint output $1 differs to $2"
|
|
fi
|
|
}
|
|
|
|
#
|
|
# Op data of different Log Record sizes will mean that data is
|
|
# split at different points and in op printing it will not
|
|
# try and decode the data which has been split up.
|
|
# So we do a special diff processing to complain of differences
|
|
# if no split is involved.
|
|
#
|
|
# Example diff with forms of:
|
|
# "Left over region from split log item"
|
|
# "Not printing rest of data"
|
|
#
|
|
# 2149c2149
|
|
# < Left over region from split log item
|
|
# ---
|
|
# > BUF DATA
|
|
# 2888c2888,2889
|
|
# < INODE: #regs: 3 Not printing rest of data
|
|
# ---
|
|
# > INODE: #regs: 3 ino: 0x80 flags: 0x5 dsize: 16
|
|
# > blkno: <BLKNO> len:<LEN> boff: <BOFF>
|
|
#
|
|
_process_op_diff()
|
|
{
|
|
$AWK_PROG <$1 '
|
|
BEGIN { num_splits = 1; max_splits = 50 }
|
|
/^[0-9]/ {
|
|
|
|
# ensure a split happened in previous difference
|
|
if (num_splits < 1 || num_splits > max_splits) {
|
|
print num_splits, " split(s) found prior to diff cmd: ", $0
|
|
num_splits = 1 # shut-up end condition
|
|
exit 1
|
|
}
|
|
num_splits = 0
|
|
|
|
next
|
|
}
|
|
/Left over region/ || /Not printing rest/ {
|
|
num_splits++
|
|
next
|
|
}
|
|
{ next }
|
|
END {
|
|
if (num_splits < 1 || num_splits > max_splits) {
|
|
print num_splits, " split(s) found prior to diff end"
|
|
exit 1
|
|
}
|
|
}
|
|
'
|
|
return $?
|
|
}
|
|
|
|
_cmp_op_output()
|
|
{
|
|
echo "*** compare logprint: $1 with $2"
|
|
|
|
diff $1 $2 >$filtered.diff
|
|
if ! _process_op_diff $filtered.diff
|
|
then
|
|
_fail "logprint output $1 differs to $2 considering splits"
|
|
fi
|
|
}
|
|
|
|
# return xfs log version of device
|
|
# e.g.
|
|
# _log_version /dev/dsk/dks0d1s4
|
|
#
|
|
_log_version()
|
|
{
|
|
_dev=$1
|
|
vers=`xfs_db -c 'sb 0' -c 'p versionnum' -r $_dev | $AWK_PROG '{print $3}'`
|
|
logver=`echo $vers | sed -e 's/0x[0-9a-f]\([0-9a-f]\)[0-9a-f][0-9a-f]/\1/'`
|
|
if [ $logver = 4 -o $logver = 5 -o $logver = 6 -o $logver = 7 -o \
|
|
$logver = c -o $logver = d -o $logver = e -o $logver = f ]; then
|
|
echo 2
|
|
else
|
|
echo 1
|
|
fi
|
|
}
|
|
|
|
_require_v2log()
|
|
{
|
|
# test out mkfs to see if it supports "-l version=2"
|
|
export MKFS_OPTIONS="-l version=2"
|
|
if ! _scratch_mkfs_xfs >>$seq.full 2>&1; then
|
|
_notrun "mkfs does not support v2 logs"
|
|
fi
|
|
|
|
# test out mount to see if it mounts a v2 log fs
|
|
export MOUNT_OPTIONS="-o logbsize=32k"
|
|
if ! _scratch_mount >>$seq.full 2>&1; then
|
|
_notrun "mount/kernel does not support v2 logs"
|
|
fi
|
|
|
|
# check after unmount to see if it is clean
|
|
# i.e. it is not a 6.5.25 buggy version checking kernel
|
|
touch $SCRATCH_MNT/file
|
|
umount $SCRATCH_DEV >>$seq.full 2>&1
|
|
if _scratch_xfs_logprint -t | tee -a $seq.full \
|
|
| head | grep -q "<DIRTY>"; then
|
|
_notrun "kernel does not support v2 logs"
|
|
fi
|
|
|
|
# otherwise presume it does support v2 logs...:)
|
|
}
|
|
|
|
|
|
# make sure this script returns success
|
|
/bin/true
|