1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
#! /bin/bash
# SPDX-License-Identifier: GPL-2.0
# Copyright (c) 2000-2003 Silicon Graphics, Inc. All Rights Reserved.
#
# FS QA Test No. 071
#
# Exercise IO at large file offsets.
seqfull=$0
. ./common/preamble
_begin_fstest rw auto
# Override the default cleanup function.
_cleanup()
{
cd /
rm -f $tmp.*
_scratch_unmount 2>/dev/null
}
# Import common functions.
. ./common/filter
bitsperlong=`$here/src/feature -w`
# link correct .out file
rm -f $seqfull.out
if [ "$bitsperlong" -eq 32 ]; then
ln -s $seq.out.32 $seqfull.out
else
ln -s $seq.out.64 $seqfull.out
fi
_filter_io()
{
sed -e "s/$dbsize/1FSB/g" -e '/.* ops; /d'
}
_filter_off()
{
sed -e "s/$1/<OFFSET>/g" | _filter_io
}
_filter_pwrite()
{
sed -e "s/pwrite.*: Invalid argument/pwrite: File too large/g"
}
_filter_pread()
{
sed -e "s/pread.*: Invalid argument/read 0\/$bytes bytes at offset <OFFSET>/g" | _filter_io
}
write_block()
{
location=$1
words=$2
offset=$3
bytes=$4
direct=$5
[ `$direct` ] && flags=-d
echo "Writing $bytes bytes, offset is $words (direct=$direct)" | _filter_io
echo "Writing $bytes bytes at $location $words (direct=$direct)" >>$seqres.full
$XFS_IO_PROG -c "pwrite $offset 512" $flags $SCRATCH_MNT/$seq \
2>&1 | _filter_off $offset | tee -a $seqres.full | _filter_pwrite
xfs_bmap -v $SCRATCH_MNT/$seq >>$seqres.full
echo "Reading $bytes bytes (direct=$direct)" | _filter_io
echo "Reading $bytes bytes at $location (direct=$direct)" >>$seqres.full
$XFS_IO_PROG -c "pread $offset $bytes" $flags $SCRATCH_MNT/$seq \
2>&1 | _filter_off $offset | tee -a $seqres.full | _filter_pread
$XFS_IO_PROG -c "pread -v $offset $bytes" $flags $SCRATCH_MNT/$seq >>$seqres.full 2>&1
echo | tee -a $seqres.full
}
# real QA test starts here
_supported_fs xfs
[ -n "$XFS_IO_PROG" ] || _notrun "xfs_io executable not found"
_require_scratch
_scratch_mkfs_xfs | _filter_mkfs 2>$tmp.mkfs
. $tmp.mkfs
echo
_scratch_mount
# Okay... filesize limit depends on blocksize, bits per long and
# also if large block device patch is enabled (can't dynamically
# check that, so use env var USE_LBD_PATCH to override default).
#
# Note:
# We check from 1Tb below our guessed limit to 1Tb above it, and
# see what happens for each 1Tb increment along the way (first
# half should succeed, second half should fail to create a file).
# So, number calculated here is not the actual limit, its a ways
# above that, hopefully.
if [ "$bitsperlong" -eq 32 ]; then
upperbound=`expr $dbsize / 512`
# which is 8(TB) for 4K, 4(TB) for 2k, ... etc.
[ "$USE_LBD_PATCH" = yes ] && upperbound=16
# limited by page cache index when LBD patch onboard.
else
upperbound=`echo 8 \* 1024 \* 1024 | bc`
# 8 exabytes (working in TBs below)
fi
# Step from (upperbound-1)(Tb) through (upperbound+1(Tb), &
# seeks/writes/reads on each boundary (using holey files) -
# 1byte back from the boundary, and 1FSB back from the same
# boundary (and stash xfs_bmap output), before moving onto
# each new test point.
$XFS_IO_PROG -c "truncate 0" -f $SCRATCH_MNT/$seq
oneTB=`echo 1024 \* 1024 \* 1024 \* 1024 | bc`
count=`expr $upperbound - 1`
upperbound=`expr $upperbound + 1`
while [ $count -le $upperbound ]
do
# buffered IO
offset=`echo $oneTB \* $count | bc`
write_block $count "+0" $offset 512 false
offset=`echo $oneTB \* $count \- 1 | bc`
write_block $count "minus 1 byte" $offset 512 false
offset=`echo $oneTB \* $count \- $dbsize | bc`
write_block $count "minus 1FSB" $offset 512 false
write_block $count "minus 1FSB" $offset 1 false
# direct IO
offset=`echo $oneTB \* $count | bc`
write_block $count "+0" $offset $dbsize true
offset=`echo $oneTB \* $count \- 1 | bc`
write_block $count "minus 1FSB" $offset $dbsize true
echo === Iterating, `expr $upperbound - $count` remains
echo
echo
let count=$count+1
done
# success, all done
status=0
exit
|
