Archive-Team
/
zfs
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 103 Wiki Activity

ZTS: fallocate tests fail with hard coded values 

Currently, these two tests pass on disks with 512 byte sectors. In
environments where the backing store is different, the number of
blocks allocated to write the same file may differ. This change
modifies the reported size check to detect an expected change in the
reported number of blocks without specifying a particular number.

Reviewed-by: Ryan Moeller <ryan@iXsystems.com>
Reviewed-by: Tony Nguyen <tony.nguyen@delphix.com>
Signed-off-by: John Kennedy <john.kennedy@delphix.com>
Closes  #13931
This commit is contained in:
John Wren Kennedy 2022-09-22 16:42:34 -06:00 committed by GitHub
parent 505df8d133
commit ce55d6ae46
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 71 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
tests/zfs-tests/tests/functional/fallocate/fallocate_punch-hole.ksh
View File

@ -23,6 +23,7 @@
#
# Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
# Copyright (c) 2021 by The FreeBSD Foundation.
# Copyright (c) 2022 by Delphix. All rights reserved.
#
. $STF_SUITE/include/libtest.shlib
@ -35,6 +36,10 @@
# 1. Create a dense file
# 2. Punch an assortment of holes in the file and verify the result.
#
# Note: We can't compare exact block numbers as reported by du, because
# different backing stores may allocate different numbers of blocks for
# the same amount of data.
#
verify_runnable "global"
@ -60,27 +65,24 @@ function cleanup
[[ -e $TESTDIR ]] && log_must rm -f $FILE
}
function check_reported_size
function get_reported_size
{
typeset expected_size=$1
if ! [ -e "${FILE}" ]; then
if ! [ -e "$FILE" ]; then
log_fail "$FILE does not exist"
fi
reported_size=$(du "${FILE}" | awk '{print $1}')
if [ "$reported_size" != "$expected_size" ]; then
log_fail "Incorrect reported size: $reported_size != $expected_size"
fi
sync_pool $TESTPOOL >/dev/null 2>&1
du "$FILE" | awk '{print $1}'
}
function check_apparent_size
{
typeset expected_size=$1
apparent_size=$(stat_size "${FILE}")
apparent_size=$(stat_size "$FILE")
if [ "$apparent_size" != "$expected_size" ]; then
log_fail "Incorrect apparent size: $apparent_size != $expected_size"
log_fail \
"Incorrect apparent size: $apparent_size != $expected_size"
fi
}
@ -90,30 +92,36 @@ log_onexit cleanup
# Create a dense file and check it is the correct size.
log_must file_write -o create -f $FILE -b $BLKSZ -c 8
sync_pool $TESTPOOL
log_must check_reported_size 1027
full_size=$(get_reported_size)
# Punch a hole for the first full block.
# Punch a hole for the first full block. The reported size should decrease.
log_must punch_hole 0 $BLKSZ $FILE
sync_pool $TESTPOOL
log_must check_reported_size 899
one_hole=$(get_reported_size)
[[ $full_size -gt $one_hole ]] || log_fail \
"One hole failure: $full_size -> $one_hole"
# Partially punch a hole in the second block.
# Partially punch a hole in the second block. The reported size should
# remain constant.
log_must punch_hole $BLKSZ $((BLKSZ / 2)) $FILE
sync_pool $TESTPOOL
log_must check_reported_size 899
partial_hole=$(get_reported_size)
[[ $one_hole -eq $partial_hole ]] || log_fail \
"Partial hole failure: $one_hole -> $partial_hole"
# Punch a hole which overlaps the third and fourth block.
# Punch a hole which overlaps the third and fourth block. The reported size
# should remain constant.
log_must punch_hole $(((BLKSZ * 2) + (BLKSZ / 2))) $((BLKSZ)) $FILE
sync_pool $TESTPOOL
log_must check_reported_size 899
overlap_hole=$(get_reported_size)
[[ $one_hole -eq $overlap_hole ]] || log_fail \
"Overlap hole failure: $one_hole -> $overlap_hole"
# Punch a hole from the fifth block past the end of file. The apparent
# file size should not change since --keep-size is implied.
# Punch a hole from the fifth block past the end of file. The reported size
# should decrease, and the apparent file size should not change since
# --keep-size is implied.
apparent_size=$(stat_size $FILE)
log_must punch_hole $((BLKSZ * 4)) $((BLKSZ * 10)) $FILE
sync_pool $TESTPOOL
log_must check_reported_size 387
eof_hole=$(get_reported_size)
[[ $overlap_hole -gt $eof_hole ]] || log_fail \
"EOF hole failure: $overlap_hole -> $eof_hole"
log_must check_apparent_size $apparent_size
log_pass "Ensure holes can be punched in files making them sparse"

65
tests/zfs-tests/tests/functional/fallocate/fallocate_zero-range.ksh
View File

@ -23,6 +23,7 @@
#
# Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
# Copyright (c) 2021 by The FreeBSD Foundation.
# Copyright (c) 2022 by Delphix. All rights reserved.
#
. $STF_SUITE/include/libtest.shlib
@ -35,6 +36,10 @@
# 1. Create a dense file
# 2. Zero various ranges in the file and verify the result.
#
# Note: We can't compare exact block numbers as reported by du, because
# different backing stores may allocate different numbers of blocks for
# the same amount of data.
#
verify_runnable "global"
@ -50,28 +55,24 @@ function cleanup
[[ -e $TESTDIR ]] && log_must rm -f $FILE
}
# Helpfully, this function expects kilobytes, and check_apparent_size expects bytes.
function check_reported_size
function get_reported_size
{
typeset expected_size=$1
if ! [ -e "${FILE}" ]; then
if ! [ -e "$FILE" ]; then
log_fail "$FILE does not exist"
fi
reported_size=$(du "${FILE}" | awk '{print $1}')
if [ "$reported_size" != "$expected_size" ]; then
log_fail "Incorrect reported size: $reported_size != $expected_size"
fi
sync_pool $TESTPOOL >/dev/null 2>&1
du "$FILE" | awk '{print $1}'
}
function check_apparent_size
{
typeset expected_size=$1
apparent_size=$(stat_size "${FILE}")
apparent_size=$(stat_size "$FILE")
if [ "$apparent_size" != "$expected_size" ]; then
log_fail "Incorrect apparent size: $apparent_size != $expected_size"
log_fail \
"Incorrect apparent size: $apparent_size != $expected_size"
fi
}
@ -82,38 +83,46 @@ log_onexit cleanup
# Create a dense file and check it is the correct size.
log_must file_write -o create -f $FILE -b $BLKSZ -c 8
sync_pool $TESTPOOL
log_must check_reported_size 1027
full_size=$(get_reported_size)
# Zero a range covering the first full block.
# Zero a range covering the first full block. The reported size should decrease.
log_must zero_range 0 $BLKSZ $FILE
sync_pool $TESTPOOL
log_must check_reported_size 899
one_range=$(get_reported_size)
[[ $full_size -gt $one_range ]] || log_fail \
"One range failure: $full_size -> $one_range"
# Partially zero a range in the second block.
# Partially zero a range in the second block. The reported size should
# remain constant.
log_must zero_range $BLKSZ $((BLKSZ / 2)) $FILE
sync_pool $TESTPOOL
log_must check_reported_size 899
partial_range=$(get_reported_size)
[[ $one_range -eq $partial_range ]] || log_fail \
"Partial range failure: $one_range -> $partial_range"
# Zero range which overlaps the third and fourth block.
# Zero range which overlaps the third and fourth block. The reported size
# should remain constant.
log_must zero_range $(((BLKSZ * 2) + (BLKSZ / 2))) $((BLKSZ)) $FILE
sync_pool $TESTPOOL
log_must check_reported_size 899
overlap_range=$(get_reported_size)
[[ $one_range -eq $overlap_range ]] || log_fail \
"Overlap range failure: $one_range -> $overlap_range"
# Zero range from the fifth block past the end of file, with --keep-size.
# The apparent file size must not change, since we did specify --keep-size.
# The reported size should decrease, and the apparent file size must not
# change, since we did specify --keep-size.
apparent_size=$(stat_size $FILE)
log_must fallocate --keep-size --zero-range --offset $((BLKSZ * 4)) --length $((BLKSZ * 10)) "$FILE"
sync_pool $TESTPOOL
log_must check_reported_size 387
eof_range=$(get_reported_size)
[[ $overlap_range -gt $eof_range ]] || log_fail \
"EOF range failure: $overlap_range -> $eof_range"
log_must check_apparent_size $apparent_size
# Zero range from the fifth block past the end of file. The apparent
# file size should change since --keep-size is not implied, unlike
# with PUNCH_HOLE.
# with PUNCH_HOLE. The reported size should remain constant.
apparent_size=$(stat_size $FILE)
log_must zero_range $((BLKSZ * 4)) $((BLKSZ * 10)) $FILE
sync_pool $TESTPOOL
log_must check_reported_size 387
eof_range2=$(get_reported_size)
[[ $eof_range -eq $eof_range2 ]] || log_fail \
"Second EOF range failure: $eof_range -> $eof_range2"
log_must check_apparent_size $((BLKSZ * 14))
log_pass "Ensure ranges can be zeroed in files"