ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

bdev/pmem: Removing bdev pmem - updated tests

Browse Source 
Removed tests associated with bdev pmem

Change-Id: Ibfb699eb5626242a7c1930be13eb1f5ded8d6392
Signed-off-by: Marcin Spiewak <marcin.spiewak@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/17003
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Community-CI: Mellanox Build Bot
Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
This commit is contained in:
Marcin Spiewak 2023-03-03 13:45:16 +00:00 committed by Tomasz Zawadzki
parent c5224a96ae
commit 8da5783b52
18 changed files with 1 additions and 1704 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
autotest.sh
View File

@ -305,12 +305,6 @@ if [ $SPDK_RUN_FUNCTIONAL_TEST -eq 1 ]; then
timing_exit vhost_initiator
fi
if [ $SPDK_TEST_PMDK -eq 1 ]; then
run_test "blockdev_pmem" $rootdir/test/bdev/blockdev.sh "pmem"
run_test "pmem" $rootdir/test/pmem/pmem.sh -x
run_test "spdkcli_pmem" $rootdir/test/spdkcli/pmem.sh
fi
if [ $SPDK_TEST_RBD -eq 1 ]; then
run_test "blockdev_rbd" $rootdir/test/bdev/blockdev.sh "rbd"
run_test "spdkcli_rbd" $rootdir/test/spdkcli/rbd.sh

1
scripts/vagrant/autorun-spdk.conf
View File

@ -23,7 +23,6 @@ SPDK_TEST_DAOS=0
# doesn't work on vm
SPDK_TEST_IOAT=0
SPDK_TEST_BLOBFS=0
SPDK_TEST_PMDK=0
SPDK_TEST_LVOL=0
SPDK_TEST_VBDEV_COMPRESS=0
SPDK_RUN_ASAN=1

14
test/bdev/blockdev.sh
View File

@ -25,7 +25,6 @@ nonarray_conf_file="$testdir/nonarray.json"
function cleanup() {
rm -f "$SPDK_TEST_STORAGE/aiofile"
rm -f "$SPDK_TEST_STORAGE/spdk-pmem-pool"
rm -f "$conf_file"
if [[ $test_type == rbd ]]; then
@ -255,16 +254,6 @@ function setup_crypto_mlx5_conf() {
RPC
}
function setup_pmem_conf() {
if hash pmempool; then
rm -f "$SPDK_TEST_STORAGE/spdk-pmem-pool"
pmempool create blk --size=32M 512 "$SPDK_TEST_STORAGE/spdk-pmem-pool"
"$rpc_py" bdev_pmem_create -n Pmem0 "$SPDK_TEST_STORAGE/spdk-pmem-pool"
else
return 1
fi
}
function setup_rbd_conf() {
timing_enter rbd_setup
rbd_setup 127.0.0.1
@ -678,9 +667,6 @@ case "$test_type" in
crypto_accel_mlx5)
setup_crypto_accel_mlx5_conf
;;
pmem)
setup_pmem_conf
;;
rbd)
setup_rbd_conf
;;

1
test/common/config/vm_setup.sh
View File

@ -191,7 +191,6 @@ SPDK_TEST_VFIOUSER=1
SPDK_TEST_RBD=1
SPDK_TEST_BLOCKDEV=1
SPDK_TEST_BLOBFS=1
SPDK_TEST_PMDK=1
SPDK_TEST_LVOL=1
SPDK_TEST_NVME_CUSE=1
SPDK_TEST_BLOBFS=1

1
test/common/skipped_tests.txt
View File

@ -64,7 +64,6 @@ build_shared_native_dpdk_rpm
build_shared_rpm_with_rpmed_dpdk
iscsi_tgt_digest
iscsi_tgt_data_digest
iscsi_tgt_pmem
iscsi_tgt_ext4test
iscsi_tgt_digests
iscsi_tgt_multiconnection

3
test/iscsi_tgt/iscsi_tgt.sh
View File

@ -39,9 +39,6 @@ run_test "iscsi_tgt_trace_record" $rootdir/test/iscsi_tgt/trace_record/trace_rec
run_test "iscsi_tgt_login_redirection" $rootdir/test/iscsi_tgt/login_redirection/login_redirection.sh
if [ $RUN_NIGHTLY -eq 1 ]; then
if [ $SPDK_TEST_PMDK -eq 1 ]; then
run_test "iscsi_tgt_pmem" $rootdir/test/iscsi_tgt/pmem/iscsi_pmem.sh 4096 10
fi
run_test "iscsi_tgt_ext4test" $rootdir/test/iscsi_tgt/ext4test/ext4test.sh
run_test "iscsi_tgt_digests" $rootdir/test/iscsi_tgt/digests/digests.sh
fi

76
test/iscsi_tgt/pmem/iscsi_pmem.sh
View File

@ -1,76 +0,0 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: BSD-3-Clause
# Copyright (C) 2017 Intel Corporation
# All rights reserved.
#
testdir=$(readlink -f $(dirname $0))
rootdir=$(readlink -f $testdir/../../..)
source $rootdir/test/common/autotest_common.sh
source $rootdir/test/iscsi_tgt/common.sh
BLOCKSIZE=$1
RUNTIME=$2
PMEM_BDEVS=""
PMEM_SIZE=128
PMEM_BLOCK_SIZE=512
TGT_NR=10
PMEM_PER_TGT=1
fio_py="$rootdir/scripts/fio-wrapper"
timing_enter start_iscsi_target
"${ISCSI_APP[@]}" -m $ISCSI_TEST_CORE_MASK --wait-for-rpc &
pid=$!
echo "Process pid: $pid"
trap 'iscsicleanup; killprocess $pid; rm -f /tmp/pool_file*; exit 1' SIGINT SIGTERM EXIT
waitforlisten $pid
$rpc_py iscsi_set_options -o 30 -a 16
$rpc_py framework_start_init
echo "iscsi_tgt is listening. Running tests..."
timing_exit start_iscsi_target
timing_enter setup
$rpc_py iscsi_create_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT
for i in $(seq 1 $TGT_NR); do
INITIATOR_TAG=$((i + 1))
$rpc_py iscsi_create_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
luns=""
for j in $(seq 1 $PMEM_PER_TGT); do
$rpc_py bdev_pmem_create_pool /tmp/pool_file${i}_${j} $PMEM_SIZE $PMEM_BLOCK_SIZE
bdevs_name="$($rpc_py bdev_pmem_create -n pmem${i}_${j} /tmp/pool_file${i}_${j})"
PMEM_BDEVS+="$bdevs_name "
luns+="$bdevs_name:$((j - 1)) "
done
$rpc_py iscsi_create_target_node Target$i Target${i}_alias "$luns" "1:$INITIATOR_TAG " 256 -d
done
timing_exit setup
sleep 1
timing_enter discovery
iscsiadm -m discovery -t sendtargets -p $TARGET_IP:$ISCSI_PORT
iscsiadm -m node --login -p $TARGET_IP:$ISCSI_PORT
timing_exit discovery
timing_enter fio_test
$fio_py -p iscsi -i $BLOCKSIZE -d 64 -t randwrite -r $RUNTIME -v
timing_exit fio_test
iscsicleanup
for pmem in $PMEM_BDEVS; do
$rpc_py bdev_pmem_delete $pmem
done
for i in $(seq 1 $TGT_NR); do
for c in $(seq 1 $PMEM_PER_TGT); do
$rpc_py bdev_pmem_delete_pool /tmp/pool_file${i}_${c}
done
done
trap - SIGINT SIGTERM EXIT
rm -f ./local-job*
rm -f /tmp/pool_file*
killprocess $pid

1
test/json_config/clear_config.py
View File

@ -37,7 +37,6 @@ def get_bdev_delete_method(bdev):
delete_method_map = {'bdev_malloc_create': "bdev_malloc_delete",
'bdev_null_create': "bdev_null_delete",
'bdev_rbd_create': "bdev_rbd_delete",
'bdev_pmem_create': "bdev_pmem_delete",
'bdev_aio_create': "bdev_aio_delete",
'bdev_error_create': "bdev_error_delete",
'bdev_split_create': "bdev_split_delete",

15
test/json_config/json_config.sh
View File

@ -22,7 +22,6 @@ if ((SPDK_TEST_BLOCKDEV + \
SPDK_TEST_NVMF + \
SPDK_TEST_VHOST + \
SPDK_TEST_VHOST_INIT + \
SPDK_TEST_PMDK + \
SPDK_TEST_RBD == 0)); then
echo "WARNING: No tests are enabled so not running JSON configuration tests"
exit 0
@ -225,14 +224,6 @@ function create_bdev_subsystem_config() {
)
fi
if [[ $SPDK_TEST_PMDK -eq 1 ]]; then
pmem_pool_file=$(mktemp /tmp/pool_file1.XXXXX)
rm -f $pmem_pool_file
tgt_rpc bdev_pmem_create_pool $pmem_pool_file 128 4096
tgt_rpc bdev_pmem_create -n pmem1 $pmem_pool_file
expected_notifications+=(bdev_register:pmem1)
fi
if [[ $SPDK_TEST_RBD -eq 1 ]]; then
rbd_setup 127.0.0.1
tgt_rpc bdev_rbd_create $RBD_POOL $RBD_NAME 4096
@ -258,12 +249,6 @@ function cleanup_bdev_subsystem_config() {
rm -f "$SPDK_TEST_STORAGE/sample_aio"
fi
if [[ $SPDK_TEST_PMDK -eq 1 && -n "$pmem_pool_file" && -f "$pmem_pool_file" ]]; then
tgt_rpc bdev_pmem_delete pmem1
tgt_rpc bdev_pmem_delete_pool $pmem_pool_file
rm -f $pmem_pool_file
fi
if [[ $SPDK_TEST_RBD -eq 1 ]]; then
rbd_cleanup
fi

96
test/pmem/common.sh
View File

@ -1,96 +0,0 @@
# SPDX-License-Identifier: BSD-3-Clause
# Copyright (C) 2017 Intel Corporation
# All rights reserved.
#
# Prints error message and return error code, closes vhost app and remove
# pmem pool file
# input: error message, error code
function error() {
local error_code=${2:-1}
echo "==========="
echo -e "ERROR: $1"
echo "error code: $error_code"
echo "==========="
vhost_kill 0
pmem_clean_pool_file
return $error_code
}
# check if there is pool file & remove it
# input: path to pool file
# default: $default_pool_file
function pmem_clean_pool_file() {
local pool_file=${1:-$default_pool_file}
if [ -f $pool_file ]; then
echo "Deleting old pool_file"
rm $pool_file
fi
}
# create new pmem file
# input: path to pool file, size in MB, block_size
# default: $default_pool_file 32 512
function pmem_create_pool_file() {
local pool_file=${1:-$default_pool_file}
local size=${2:-32}
local block_size=${3:-512}
pmem_clean_pool_file $pool_file
echo "Creating new pool file"
if ! $rpc_py bdev_pmem_create_pool $pool_file $size $block_size; then
error "Creating pool_file failed!"
fi
if [ ! -f $pool_file ]; then
error "Creating pool_file failed!"
fi
}
function pmem_unmount_ramspace() {
if [ -d "$testdir/ramspace" ]; then
if mount | grep -q "$testdir/ramspace"; then
umount $testdir/ramspace
fi
rm -rf $testdir/ramspace
fi
}
function pmem_print_tc_name() {
echo ""
echo "==============================================================="
echo "Now running: $1"
echo "==============================================================="
}
function vhost_start() {
local vhost_pid
$SPDK_BIN_DIR/vhost &
vhost_pid=$!
echo $vhost_pid > $testdir/vhost.pid
waitforlisten $vhost_pid
}
function vhost_kill() {
local vhost_pid_file="$testdir/vhost.pid"
local vhost_pid
vhost_pid="$(cat $vhost_pid_file)"
if [[ ! -f $vhost_pid_file ]]; then
echo -e "ERROR: No vhost pid file found!"
return 1
fi
if ! kill -s INT $vhost_pid; then
echo -e "ERROR: Failed to exit vhost / invalid pid!"
rm $vhost_pid_file
return 1
fi
sleep 1
rm $vhost_pid_file
}

686
test/pmem/pmem.sh
View File

@ -1,686 +0,0 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: BSD-3-Clause
# Copyright (C) 2017 Intel Corporation
# All rights reserved.
#
testdir=$(readlink -f $(dirname $0))
rootdir=$(readlink -f $testdir/../..)
source $rootdir/test/common/autotest_common.sh
source $rootdir/test/pmem/common.sh
rpc_py="$rootdir/scripts/rpc.py "
enable_script_debug=false
test_info=false
test_create=false
test_delete=false
test_construct_bdev=false
test_delete_bdev=false
test_all=true
test_all_get=false
default_pool_file="$testdir/pool_file"
obj_pool_file="$testdir/obj_pool_file"
bdev_name=pmem0
function usage() {
[[ -n $2 ]] && (
echo "$2"
echo ""
)
echo "Shortcut script for automated RPC tests for PMEM"
echo
echo "Usage: $(basename $1) [OPTIONS]"
echo
echo "-h, --help Print help and exit"
echo "-x set -x for script debug"
echo " --info Run test cases for bdev_pmem_get_pool_info"
echo " --create Run test cases for bdev_pmem_create_pool"
echo " --delete Run test cases for bdev_pmem_delete_pool"
echo " --construct_bdev Run test cases for constructing pmem bdevs"
echo " --delete_bdev Run test cases for deleting pmem bdevs"
echo " --all Run all test cases (default)"
exit 0
}
while getopts 'xh-:' optchar; do
case "$optchar" in
-)
case "$OPTARG" in
help) usage $0 ;;
info)
test_info=true
test_all=false
;;
create)
test_create=true
test_all=false
;;
delete)
test_delete=true
test_all=false
;;
construct_bdev)
test_construct_bdev=true
test_all=false
;;
delete_bdev)
test_delete_bdev=true
test_all=false
;;
all) test_all_get=true ;;
*) usage $0 "Invalid argument '$OPTARG'" ;;
esac
;;
h) usage $0 ;;
x) enable_script_debug=true ;;
*) usage $0 "Invalid argument '$OPTARG'" ;;
esac
done
if $test_all_get; then
test_all=true
fi
if [[ $EUID -ne 0 ]]; then
echo "Go away user come back as root"
exit 1
fi
#================================================
# bdev_pmem_get_pool_info tests
#================================================
function bdev_pmem_get_pool_info_tc1() {
pmem_print_tc_name ${FUNCNAME[0]}
if $rpc_py bdev_pmem_get_pool_info; then
error "bdev_pmem_get_pool_info passed with missing argument!"
fi
return 0
}
function bdev_pmem_get_pool_info_tc2() {
pmem_print_tc_name ${FUNCNAME[0]}
if $rpc_py bdev_pmem_get_pool_info $rootdir/non/existing/path/non_existent_file; then
error "bdev_pmem_get_pool_info passed with invalid path!"
fi
return 0
}
function bdev_pmem_get_pool_info_tc3() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file $obj_pool_file
echo "Creating new type OBJ pool file"
if hash pmempool; then
pmempool create -s 32000000 obj $obj_pool_file
else
echo "Warning: pmempool package not found! Creating stub file."
truncate -s "32M" $obj_pool_file
fi
if $rpc_py bdev_pmem_get_pool_info $obj_pool_file; then
pmem_clean_pool_file $obj_pool_file
error "Bdev_pmem_get_pool_info passed with invalid pool_file type!"
fi
pmem_clean_pool_file $obj_pool_file
return 0
}
function bdev_pmem_get_pool_info_tc4() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
pmem_create_pool_file
if ! $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "Failed to get bdev_pmem_get_pool_info!"
fi
pmem_clean_pool_file
return 0
}
#================================================
# bdev_pmem_create_pool tests
#================================================
function bdev_pmem_create_pool_tc1() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
if $rpc_py bdev_pmem_create_pool 32 512; then
error "Mem pool file created w/out given path!"
fi
if $rpc_py bdev_pmem_create_pool $default_pool_file; then
error "Mem pool file created w/out size & block size arguments!"
fi
if $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "bdev_pmem_create_pool created invalid pool file!"
fi
if $rpc_py bdev_pmem_create_pool $default_pool_file 32; then
error "Mem pool file created w/out block size argument!"
fi
if $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "bdev_pmem_create_pool created invalid pool file!"
fi
pmem_clean_pool_file
return 0
}
function bdev_pmem_create_pool_tc2() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
if $rpc_py bdev_pmem_create_pool $rootdir/non/existing/path/non_existent_file 32 512; then
error "Mem pool file created with incorrect path!"
fi
if $rpc_py bdev_pmem_get_pool_info $rootdir/non/existing/path/non_existent_file; then
error "bdev_pmem_create_pool created invalid pool file!"
fi
pmem_clean_pool_file
return 0
}
function bdev_pmem_create_pool_tc3() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
if ! $rpc_py bdev_pmem_create_pool $default_pool_file 256 512; then
error "Failed to create pmem pool!"
fi
if ! $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "Failed to get pmem info"
fi
if ! $rpc_py bdev_pmem_delete_pool $default_pool_file; then
error "Failed to delete pool file!"
fi
if $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "Got pmem file info but file should be deleted"
fi
if [ -f $default_pool_file ]; then
error "Failed to delete pmem file!"
fi
pmem_clean_pool_file
return 0
}
function bdev_pmem_create_pool_tc4() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_unmount_ramspace
mkdir $rootdir/test/pmem/ramspace
mount -t tmpfs -o size=300m tmpfs $rootdir/test/pmem/ramspace
if ! $rpc_py bdev_pmem_create_pool $rootdir/test/pmem/ramspace/pool_file 256 512; then
pmem_unmount_ramspace
error "Failed to create pmem pool!"
fi
if ! $rpc_py bdev_pmem_get_pool_info $rootdir/test/pmem/ramspace/pool_file; then
pmem_unmount_ramspace
error "Failed to get pmem info"
fi
if ! $rpc_py bdev_pmem_delete_pool $rootdir/test/pmem/ramspace/pool_file; then
pmem_unmount_ramspace
error "Failed to delete pool file!"
fi
if [ -f $rootdir/test/pmem/ramspace/pool_file ]; then
pmem_unmount_ramspace
error "Failed to delete pmem file / file still exists!"
fi
pmem_unmount_ramspace
return 0
}
function bdev_pmem_create_pool_tc5() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
local pmem_block_size
local pmem_num_block
if ! $rpc_py bdev_pmem_create_pool $default_pool_file 256 512; then
error "Failed to create pmem pool!"
fi
if $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
pmem_block_size=$($rpc_py bdev_pmem_get_pool_info $default_pool_file | jq -r '.[] .block_size')
pmem_num_block=$($rpc_py bdev_pmem_get_pool_info $default_pool_file | jq -r '.[] .num_blocks')
else
error "Failed to get pmem info!"
fi
if $rpc_py bdev_pmem_create_pool $default_pool_file 512 4096; then
error "Pmem pool with already occupied path has been created!"
fi
if $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
if [ $pmem_block_size != $($rpc_py bdev_pmem_get_pool_info $default_pool_file | jq -r '.[] .block_size') ]; then
error "Invalid block size of pmem pool!"
fi
if [ $pmem_num_block != $($rpc_py bdev_pmem_get_pool_info $default_pool_file | jq -r '.[] .num_blocks') ]; then
error "Invalid number of blocks of pmem pool!"
fi
else
error "Failed to get pmem info!"
fi
if ! $rpc_py bdev_pmem_delete_pool $default_pool_file; then
error "Failed to delete pmem file!"
fi
pmem_clean_pool_file
return 0
}
function bdev_pmem_create_pool_tc6() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
local created_pmem_block_size
for i in 511 512 1024 2048 4096 131072 262144; do
if ! $rpc_py bdev_pmem_create_pool $default_pool_file 256 $i; then
error "Failed to create pmem pool!"
fi
if ! created_pmem_block_size=$($rpc_py bdev_pmem_get_pool_info $default_pool_file | jq -r '.[] .block_size'); then
error "Failed to get pmem info!"
fi
if [ $i != $created_pmem_block_size ]; then
error "Invalid block size of pmem pool!"
fi
if ! $rpc_py bdev_pmem_delete_pool $default_pool_file; then
error "Failed to delete pmem file!"
fi
done
pmem_clean_pool_file
return 0
}
function bdev_pmem_create_pool_tc7() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
if $rpc_py bdev_pmem_create_pool $default_pool_file 15 512; then
error "Created pmem pool with invalid size!"
fi
if $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "Pmem file shouldn' exist!"
fi
pmem_clean_pool_file
return 0
}
function bdev_pmem_create_pool_tc8() {
pmem_print_tc_name "bdev_pmem_create_pool_tc8"
pmem_clean_pool_file
if $rpc_py bdev_pmem_create_pool $default_pool_file 32 65536; then
error "Created pmem pool with invalid block number!"
fi
if $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "Pmem file shouldn' exist!"
fi
pmem_clean_pool_file
return 0
}
function bdev_pmem_create_pool_tc9() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
if $rpc_py bdev_pmem_create_pool $default_pool_file 256 -1; then
error "Created pmem pool with negative block size number!"
fi
if $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "bdev_pmem_create_pool create invalid pool file!"
fi
if $rpc_py bdev_pmem_create_pool $default_pool_file -1 512; then
error "Created pmem pool with negative size number!"
fi
if $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "bdev_pmem_create_pool create invalid pool file!"
fi
pmem_clean_pool_file
return 0
}
#================================================
# bdev_pmem_delete_pool tests
#================================================
function bdev_pmem_delete_pool_tc1() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
if $rpc_py bdev_pmem_delete_pool $default_pool_file; then
error "bdev_pmem_delete_pool deleted nonexistent pool file!"
fi
return 0
}
function bdev_pmem_delete_pool_tc2() {
pmem_print_tc_name "bdev_pmem_delete_pool_tc2"
pmem_clean_pool_file $obj_pool_file
echo "Creating new type OBJ pool file"
if hash pmempool; then
pmempool create -s 32000000 obj $obj_pool_file
else
echo "Warning: pmempool package not found! Creating stub file."
truncate -s "32M" $obj_pool_file
fi
if $rpc_py bdev_pmem_delete_pool $obj_pool_file; then
pmem_clean_pool_file $obj_pool_file
error "bdev_pmem_delete_pool deleted invalid pmem pool type!"
fi
pmem_clean_pool_file $obj_pool_file
return 0
}
function bdev_pmem_delete_pool_tc3() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
pmem_create_pool_file
if ! $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "Failed to get info on pmem pool file!"
fi
if ! $rpc_py bdev_pmem_delete_pool $default_pool_file; then
error "Failed to delete pmem pool file!"
fi
if $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "Pmem pool file exists after using bdev_pmem_get_pool_info!"
fi
return 0
}
function bdev_pmem_delete_pool_tc4() {
pmem_print_tc_name ${FUNCNAME[0]}
bdev_pmem_delete_pool_tc3
if $rpc_py bdev_pmem_delete_pool $default_pool_file; then
error "Deleted pmem pool file that shouldn't exist!"
fi
return 0
}
#================================================
# bdev_pmem_create tests
#================================================
function bdev_pmem_create_tc1() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
pmem_create_pool_file
if $rpc_py bdev_pmem_create; then
error "bdev_pmem_create passed with missing argument!"
fi
pmem_clean_pool_file
return 0
}
function bdev_pmem_create_tc2() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
pmem_create_pool_file
if $rpc_py bdev_pmem_create -n $bdev_name $rootdir/non/existing/path/non_existent_file; then
error "Created pmem bdev w/out valid pool file!"
fi
if $rpc_py bdev_get_bdevs | jq -r '.[] .name' | grep -qi pmem; then
error "bdev_pmem_create passed with invalid argument!"
fi
pmem_clean_pool_file
return 0
}
function bdev_pmem_create_tc3() {
pmem_print_tc_name ${FUNCNAME[0]}
truncate -s 32M $rootdir/test/pmem/random_file
if $rpc_py bdev_pmem_create -n $bdev_name $rootdir/test/pmem/random_file; then
error "Created pmem bdev from random file!"
fi
if [ -f $rootdir/test/pmem/random_file ]; then
echo "Deleting previously created random file"
rm $rootdir/test/pmem/random_file
fi
return 0
}
function bdev_pmem_create_tc4() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file $obj_pool_file
echo "Creating new type OBJ pool file"
if hash pmempool; then
pmempool create -s 32000000 obj $obj_pool_file
else
echo "Warning: pmempool package not found! Creating stub file."
truncate -s "32M" $obj_pool_file
fi
if $rpc_py bdev_pmem_create -n $bdev_name $obj_pool_file; then
pmem_clean_pool_file $obj_pool_file
error "Created pmem bdev from obj type pmem file!"
fi
pmem_clean_pool_file $obj_pool_file
return 0
}
function bdev_pmem_create_tc5() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
pmem_create_pool_file
local pmem_bdev_name
if ! $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "Failed to get pmem info!"
fi
if ! pmem_bdev_name=$($rpc_py bdev_pmem_create -n $bdev_name $default_pool_file); then
error "Failed to create pmem bdev"
fi
if ! $rpc_py bdev_get_bdevs | jq -r '.[] .name' | grep -qi $pmem_bdev_name; then
error "Pmem bdev not found!"
fi
if ! $rpc_py bdev_pmem_delete $pmem_bdev_name; then
error "Failed to delete pmem bdev!"
fi
if ! $rpc_py bdev_pmem_delete_pool $default_pool_file; then
error "Failed to delete pmem pool file!"
fi
pmem_clean_pool_file
return 0
}
function bdev_pmem_create_tc6() {
pmem_print_tc_name ${FUNCNAME[0]}
local pmem_bdev_name
pmem_clean_pool_file
pmem_create_pool_file
if ! $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "Failed to get info on pmem pool file!"
fi
if ! pmem_bdev_name=$($rpc_py bdev_pmem_create -n $bdev_name $default_pool_file); then
error "Failed to create pmem bdev!"
fi
if ! $rpc_py bdev_get_bdevs | jq -r '.[] .name' | grep -qi $pmem_bdev_name; then
error "Pmem bdev not found!"
fi
if $rpc_py bdev_pmem_create -n $bdev_name $default_pool_file; then
error "Constructed pmem bdev with occupied path!"
fi
if ! $rpc_py bdev_pmem_delete $pmem_bdev_name; then
error "Failed to delete pmem bdev!"
fi
if ! $rpc_py bdev_pmem_delete_pool $default_pool_file; then
error "Failed to delete pmem pool file!"
fi
pmem_clean_pool_file
return 0
}
#================================================
# bdev_pmem_delete tests
#================================================
function delete_bdev_tc1() {
pmem_print_tc_name ${FUNCNAME[0]}
local pmem_bdev_name
local bdevs_names
pmem_clean_pool_file
pmem_create_pool_file $default_pool_file 256 512
if ! $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "Failed to get pmem info!"
fi
if ! pmem_bdev_name=$($rpc_py bdev_pmem_create -n $bdev_name $default_pool_file); then
error "Failed to create pmem bdev!"
fi
if ! $rpc_py bdev_get_bdevs | jq -r '.[] .name' | grep -qi $pmem_bdev_name; then
error "$pmem_bdev_name bdev not found!"
fi
if ! $rpc_py bdev_pmem_delete $pmem_bdev_name; then
error "Failed to delete $pmem_bdev_name bdev!"
fi
bdevs_names=$($rpc_py bdev_get_bdevs | jq -r '.[] .name')
if echo $bdevs_names | grep -qi $pmem_bdev_name; then
error "$pmem_bdev_name bdev is not deleted!"
fi
pmem_clean_pool_file
return 0
}
function delete_bdev_tc2() {
pmem_print_tc_name ${FUNCNAME[0]}
pmem_clean_pool_file
pmem_create_pool_file $default_pool_file 256 512
local pmem_bdev_name
if ! $rpc_py bdev_pmem_get_pool_info $default_pool_file; then
error "Failed to get pmem info!"
fi
if ! pmem_bdev_name=$($rpc_py bdev_pmem_create -n $bdev_name $default_pool_file); then
error "Failed to create pmem bdev"
fi
if ! $rpc_py bdev_get_bdevs | jq -r '.[] .name' | grep -qi $pmem_bdev_name; then
error "Pmem bdev not found!"
fi
if ! $rpc_py bdev_pmem_delete $pmem_bdev_name; then
error "Failed to delete pmem bdev!"
fi
if $rpc_py bdev_pmem_delete $pmem_bdev_name; then
error "bdev_pmem_delete deleted pmem bdev for second time!"
fi
pmem_clean_pool_file
return 0
}
vhost_start
if ! $enable_script_debug; then
set +x
fi
if $test_info || $test_all; then
bdev_pmem_get_pool_info_tc1
bdev_pmem_get_pool_info_tc2
bdev_pmem_get_pool_info_tc3
bdev_pmem_get_pool_info_tc4
fi
if $test_create || $test_all; then
bdev_pmem_create_pool_tc1
bdev_pmem_create_pool_tc2
bdev_pmem_create_pool_tc3
bdev_pmem_create_pool_tc4
bdev_pmem_create_pool_tc5
bdev_pmem_create_pool_tc6
bdev_pmem_create_pool_tc7
bdev_pmem_create_pool_tc8
bdev_pmem_create_pool_tc9
fi
if $test_delete || $test_all; then
bdev_pmem_delete_pool_tc1
bdev_pmem_delete_pool_tc2
bdev_pmem_delete_pool_tc3
bdev_pmem_delete_pool_tc4
fi
if $test_construct_bdev || $test_all; then
bdev_pmem_create_tc1
bdev_pmem_create_tc2
bdev_pmem_create_tc3
bdev_pmem_create_tc4
bdev_pmem_create_tc5
bdev_pmem_create_tc6
fi
if $test_delete_bdev || $test_all; then
delete_bdev_tc1
delete_bdev_tc2
fi
pmem_clean_pool_file
vhost_kill 0

2
test/spdkcli/common.sh
View File

@ -19,7 +19,7 @@ function cleanup() {
if [ -n "$vhost_tgt_pid" ]; then
killprocess $vhost_tgt_pid
fi
rm -f $testdir/${MATCH_FILE} $testdir/match_files/spdkcli_details_vhost.test /tmp/sample_aio /tmp/sample_pmem
rm -f $testdir/${MATCH_FILE} $testdir/match_files/spdkcli_details_vhost.test /tmp/sample_aio
}
function run_spdk_tgt() {

3
test/spdkcli/match_files/spdkcli_pmem.test.match
View File

@ -1,3 +0,0 @@
o- pmemblk .............................................................................................................. [Bdevs: 2]
o- pmem_bdev0 $(S) [Size=31.6M, Not claimed]
o- pmem_bdev1 $(S) [Size=31.6M, Not claimed]

50
test/spdkcli/pmem.sh
View File

@ -1,50 +0,0 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: BSD-3-Clause
# Copyright (C) 2018 Intel Corporation
# All rights reserved.
#
testdir=$(readlink -f $(dirname $0))
rootdir=$(readlink -f $testdir/../..)
source $rootdir/test/common/autotest_common.sh
source $rootdir/test/spdkcli/common.sh
MATCH_FILE="spdkcli_pmem.test"
SPDKCLI_BRANCH="/bdevs/pmemblk"
trap 'rm -f $testdir/match_files/spdkcli_pmem_info.test; cleanup' EXIT
timing_enter run_spdk_tgt
run_spdk_tgt
timing_exit run_spdk_tgt
timing_enter spdkcli_create_pmem_config
$spdkcli_job "'/bdevs/pmemblk bdev_pmem_create_pool /tmp/sample_pmem0 32 512' '' True
'/bdevs/pmemblk bdev_pmem_create_pool /tmp/sample_pmem1 32 512' '' True
"
# Saving pmem pool info before they get claimed by /bdevs/pmemblk create
$rootdir/scripts/spdkcli.py /bdevs/pmemblk bdev_pmem_get_pool_info /tmp/sample_pmem0 >> $testdir/match_files/spdkcli_pmem_info.test
$rootdir/scripts/spdkcli.py /bdevs/pmemblk bdev_pmem_get_pool_info /tmp/sample_pmem1 >> $testdir/match_files/spdkcli_pmem_info.test
$spdkcli_job "'/bdevs/pmemblk create /tmp/sample_pmem0 pmem_bdev0' 'pmem_bdev0' True
'/bdevs/pmemblk create /tmp/sample_pmem1 pmem_bdev1' 'pmem_bdev1' True
"
timing_exit spdkcli_create_pmem_config
timing_enter spdkcli_check_match
check_match
$rootdir/test/app/match/match -v $testdir/match_files/spdkcli_pmem_info.test.match
timing_exit spdkcli_check_match
timing_enter spdkcli_clear_pmem_config
$spdkcli_job "'/bdevs/pmemblk delete pmem_bdev0' 'pmem_bdev0'
'/bdevs/pmemblk bdev_pmem_delete_pool /tmp/sample_pmem0' ''
'/bdevs/pmemblk delete_all' 'pmem_bdev1'
'/bdevs/pmemblk bdev_pmem_delete_pool /tmp/sample_pmem1' ''
"
rm -f /tmp/sample_pmem
rm -f $testdir/match_files/spdkcli_pmem_info.test
timing_exit spdkcli_clear_pmem_config
killprocess $spdk_tgt_pid

2
test/unit/lib/bdev/Makefile
View File

@ -13,8 +13,6 @@ DIRS-$(CONFIG_CRYPTO) += crypto.c
# enable once new mocks are added for compressdev
DIRS-$(CONFIG_VBDEV_COMPRESS) += compress.c
DIRS-$(CONFIG_PMDK) += pmem
.PHONY: all clean $(DIRS-y)
all: $(DIRS-y)

10
test/unit/lib/bdev/pmem/Makefile
View File

@ -1,10 +0,0 @@
# SPDX-License-Identifier: BSD-3-Clause
# Copyright (C) 2016 Intel Corporation.
# All rights reserved.
#
SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../../..)
TEST_FILE = bdev_pmem_ut.c
include $(SPDK_ROOT_DIR)/mk/spdk.unittest.mk

734
test/unit/lib/bdev/pmem/bdev_pmem_ut.c
View File

@ -1,734 +0,0 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright (C) 2017 Intel Corporation.
* All rights reserved.
*/
#include "spdk_cunit.h"
#include "common/lib/ut_multithread.c"
#include "unit/lib/json_mock.c"
#include "bdev/pmem/bdev_pmem.c"
DEFINE_STUB_V(spdk_bdev_module_fini_done, (void));
static struct spdk_bdev_module *g_bdev_pmem_module;
static int g_bdev_module_cnt;
struct pmemblk {
const char *name;
bool is_open;
bool is_consistent;
size_t bsize;
long long nblock;
uint8_t *buffer;
};
static const char *g_bdev_name = "pmem0";
/* PMEMblkpool is a typedef of struct pmemblk */
static PMEMblkpool g_pool_ok = {
.name = "/pools/ok_pool",
.is_open = false,
.is_consistent = true,
.bsize = 4096,
.nblock = 150
};
static PMEMblkpool g_pool_nblock_0 = {
.name = "/pools/nblock_0",
.is_open = false,
.is_consistent = true,
.bsize = 4096,
.nblock = 0
};
static PMEMblkpool g_pool_bsize_0 = {
.name = "/pools/nblock_0",
.is_open = false,
.is_consistent = true,
.bsize = 0,
.nblock = 100
};
static PMEMblkpool g_pool_inconsistent = {
.name = "/pools/inconsistent",
.is_open = false,
.is_consistent = false,
.bsize = 512,
.nblock = 1
};
static int g_opened_pools;
static struct spdk_bdev *g_bdev;
static const char *g_check_version_msg;
static bool g_pmemblk_open_allow_open = true;
static PMEMblkpool *
find_pmemblk_pool(const char *path)
{
if (path == NULL) {
errno = EINVAL;
return NULL;
} else if (strcmp(g_pool_ok.name, path) == 0) {
return &g_pool_ok;
} else if (strcmp(g_pool_nblock_0.name, path) == 0) {
return &g_pool_nblock_0;
} else if (strcmp(g_pool_bsize_0.name, path) == 0) {
return &g_pool_bsize_0;
} else if (strcmp(g_pool_inconsistent.name, path) == 0) {
return &g_pool_inconsistent;
}
errno = ENOENT;
return NULL;
}
PMEMblkpool *
pmemblk_open(const char *path, size_t bsize)
{
PMEMblkpool *pool;
if (!g_pmemblk_open_allow_open) {
errno = EIO;
return NULL;
}
pool = find_pmemblk_pool(path);
if (!pool) {
errno = ENOENT;
return NULL;
}
CU_ASSERT_TRUE_FATAL(pool->is_consistent);
CU_ASSERT_FALSE(pool->is_open);
if (pool->is_open == false) {
pool->is_open = true;
g_opened_pools++;
} else {
errno = EBUSY;
pool = NULL;
}
return pool;
}
void
spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, uint64_t len)
{
cb(NULL, bdev_io, true);
}
static void
check_open_pool_fatal(PMEMblkpool *pool)
{
SPDK_CU_ASSERT_FATAL(pool != NULL);
SPDK_CU_ASSERT_FATAL(find_pmemblk_pool(pool->name) == pool);
SPDK_CU_ASSERT_FATAL(pool->is_open == true);
}
void
pmemblk_close(PMEMblkpool *pool)
{
check_open_pool_fatal(pool);
pool->is_open = false;
CU_ASSERT(g_opened_pools > 0);
g_opened_pools--;
}
size_t
pmemblk_bsize(PMEMblkpool *pool)
{
check_open_pool_fatal(pool);
return pool->bsize;
}
size_t
pmemblk_nblock(PMEMblkpool *pool)
{
check_open_pool_fatal(pool);
return pool->nblock;
}
int
pmemblk_read(PMEMblkpool *pool, void *buf, long long blockno)
{
check_open_pool_fatal(pool);
if (blockno >= pool->nblock) {
errno = EINVAL;
return -1;
}
memcpy(buf, &pool->buffer[blockno * pool->bsize], pool->bsize);
return 0;
}
int
pmemblk_write(PMEMblkpool *pool, const void *buf, long long blockno)
{
check_open_pool_fatal(pool);
if (blockno >= pool->nblock) {
errno = EINVAL;
return -1;
}
memcpy(&pool->buffer[blockno * pool->bsize], buf, pool->bsize);
return 0;
}
int
pmemblk_set_zero(PMEMblkpool *pool, long long blockno)
{
check_open_pool_fatal(pool);
if (blockno >= pool->nblock) {
errno = EINVAL;
return -1;
}
memset(&pool->buffer[blockno * pool->bsize], 0, pool->bsize);
return 0;
}
const char *
pmemblk_errormsg(void)
{
return strerror(errno);
}
const char *
pmemblk_check_version(unsigned major_required, unsigned minor_required)
{
return g_check_version_msg;
}
int
pmemblk_check(const char *path, size_t bsize)
{
PMEMblkpool *pool = find_pmemblk_pool(path);
if (!pool) {
errno = ENOENT;
return -1;
}
if (!pool->is_consistent) {
/* errno ? */
return 0;
}
if (bsize != 0 && pool->bsize != bsize) {
/* errno ? */
return 0;
}
return 1;
}
void
spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status)
{
bdev_io->internal.status = status;
}
int
spdk_bdev_register(struct spdk_bdev *bdev)
{
CU_ASSERT_PTR_NULL(g_bdev);
g_bdev = bdev;
return 0;
}
int
spdk_bdev_unregister_by_name(const char *name, struct spdk_bdev_module *module,
spdk_bdev_unregister_cb cb_fn, void *cb_arg)
{
return 0;
}
int
spdk_bdev_notify_blockcnt_change(struct spdk_bdev *bdev, uint64_t size)
{
bdev->blockcnt = size;
return 0;
}
static void
ut_bdev_pmem_destruct(struct spdk_bdev *bdev)
{
SPDK_CU_ASSERT_FATAL(g_bdev != NULL);
CU_ASSERT_EQUAL(bdev_pmem_destruct(bdev->ctxt), 0);
g_bdev = NULL;
}
void
spdk_bdev_module_list_add(struct spdk_bdev_module *bdev_module)
{
g_bdev_pmem_module = bdev_module;
g_bdev_module_cnt++;
}
static int
bdev_submit_request(struct spdk_bdev *bdev, int16_t io_type, uint64_t offset_blocks,
uint64_t num_blocks, struct iovec *iovs, size_t iov_cnt)
{
struct spdk_bdev_io bio = { 0 };
switch (io_type) {
case SPDK_BDEV_IO_TYPE_READ:
bio.u.bdev.iovs = iovs;
bio.u.bdev.iovcnt = iov_cnt;
bio.u.bdev.offset_blocks = offset_blocks;
bio.u.bdev.num_blocks = num_blocks;
break;
case SPDK_BDEV_IO_TYPE_WRITE:
bio.u.bdev.iovs = iovs;
bio.u.bdev.iovcnt = iov_cnt;
bio.u.bdev.offset_blocks = offset_blocks;
bio.u.bdev.num_blocks = num_blocks;
break;
case SPDK_BDEV_IO_TYPE_FLUSH:
bio.u.bdev.offset_blocks = offset_blocks;
bio.u.bdev.num_blocks = num_blocks;
break;
case SPDK_BDEV_IO_TYPE_RESET:
break;
case SPDK_BDEV_IO_TYPE_UNMAP:
bio.u.bdev.offset_blocks = offset_blocks;
bio.u.bdev.num_blocks = num_blocks;
break;
case SPDK_BDEV_IO_TYPE_WRITE_ZEROES:
bio.u.bdev.offset_blocks = offset_blocks;
bio.u.bdev.num_blocks = num_blocks;
break;
default:
CU_FAIL_FATAL("BUG:Unexpected IO type");
break;
}
/*
* Set status to value that shouldn't be returned
*/
bio.type = io_type;
bio.internal.status = SPDK_BDEV_IO_STATUS_PENDING;
bio.bdev = bdev;
bdev_pmem_submit_request(NULL, &bio);
return bio.internal.status;
}
static int
ut_pmem_blk_clean(void)
{
free(g_pool_ok.buffer);
g_pool_ok.buffer = NULL;
/* Unload module to free IO channel */
g_bdev_pmem_module->module_fini();
poll_threads();
free_threads();
return 0;
}
static int
ut_pmem_blk_init(void)
{
errno = 0;
allocate_threads(1);
set_thread(0);
g_pool_ok.buffer = calloc(g_pool_ok.nblock, g_pool_ok.bsize);
if (g_pool_ok.buffer == NULL) {
ut_pmem_blk_clean();
return -1;
}
return 0;
}
static void
ut_pmem_init(void)
{
SPDK_CU_ASSERT_FATAL(g_bdev_pmem_module != NULL);
CU_ASSERT_EQUAL(g_bdev_module_cnt, 1);
/* Make pmemblk_check_version fail with provided error message */
g_check_version_msg = "TEST FAIL MESSAGE";
CU_ASSERT_NOT_EQUAL(g_bdev_pmem_module->module_init(), 0);
/* This init must success */
g_check_version_msg = NULL;
CU_ASSERT_EQUAL(g_bdev_pmem_module->module_init(), 0);
}
static void
ut_pmem_open_close(void)
{
struct spdk_bdev *bdev = NULL;
int pools_cnt;
int rc;
pools_cnt = g_opened_pools;
/* Try opening with NULL name */
rc = create_pmem_disk(NULL, NULL, &bdev);
CU_ASSERT_PTR_NULL(bdev);
CU_ASSERT_EQUAL(pools_cnt, g_opened_pools);
CU_ASSERT_NOT_EQUAL(rc, 0);
/* Open non-existent pool */
rc = create_pmem_disk("non existent pool", NULL, &bdev);
CU_ASSERT_PTR_NULL(bdev);
CU_ASSERT_EQUAL(pools_cnt, g_opened_pools);
CU_ASSERT_NOT_EQUAL(rc, 0);
/* Open inconsistent pool */
rc = create_pmem_disk(g_pool_inconsistent.name, NULL, &bdev);
CU_ASSERT_PTR_NULL(bdev);
CU_ASSERT_EQUAL(pools_cnt, g_opened_pools);
CU_ASSERT_NOT_EQUAL(rc, 0);
/* Open consistent pool fail the open from unknown reason. */
g_pmemblk_open_allow_open = false;
rc = create_pmem_disk(g_pool_inconsistent.name, NULL, &bdev);
g_pmemblk_open_allow_open = true;
CU_ASSERT_PTR_NULL(bdev);
CU_ASSERT_EQUAL(pools_cnt, g_opened_pools);
CU_ASSERT_NOT_EQUAL(rc, 0);
/* Open pool with nblocks = 0 */
rc = create_pmem_disk(g_pool_nblock_0.name, NULL, &bdev);
CU_ASSERT_PTR_NULL(bdev);
CU_ASSERT_EQUAL(pools_cnt, g_opened_pools);
CU_ASSERT_NOT_EQUAL(rc, 0);
/* Open pool with bsize = 0 */
rc = create_pmem_disk(g_pool_bsize_0.name, NULL, &bdev);
CU_ASSERT_PTR_NULL(bdev);
CU_ASSERT_EQUAL(pools_cnt, g_opened_pools);
CU_ASSERT_NOT_EQUAL(rc, 0);
/* Open pool with NULL name */
rc = create_pmem_disk(g_pool_ok.name, NULL, &bdev);
CU_ASSERT_PTR_NULL(bdev);
CU_ASSERT_EQUAL(pools_cnt, g_opened_pools);
CU_ASSERT_NOT_EQUAL(rc, 0);
/* Open good pool */
rc = create_pmem_disk(g_pool_ok.name, g_bdev_name, &bdev);
SPDK_CU_ASSERT_FATAL(bdev != NULL);
CU_ASSERT_TRUE(g_pool_ok.is_open);
CU_ASSERT_EQUAL(pools_cnt + 1, g_opened_pools);
CU_ASSERT_EQUAL(rc, 0);
/* Now remove this bdev */
ut_bdev_pmem_destruct(bdev);
CU_ASSERT_FALSE(g_pool_ok.is_open);
CU_ASSERT_EQUAL(pools_cnt, g_opened_pools);
}
static void
ut_pmem_write_read(void)
{
uint8_t *write_buf, *read_buf;
struct spdk_bdev *bdev;
int rc;
size_t unaligned_aligned_size = 100;
size_t buf_size = g_pool_ok.bsize * g_pool_ok.nblock;
size_t i;
const uint64_t nblock_offset = 10;
uint64_t offset;
size_t io_size, nblock, total_io_size, bsize;
bsize = 4096;
struct iovec iov[] = {
{ 0, 2 * bsize },
{ 0, 3 * bsize },
{ 0, 4 * bsize },
};
rc = create_pmem_disk(g_pool_ok.name, g_bdev_name, &bdev);
CU_ASSERT_EQUAL(rc, 0);
SPDK_CU_ASSERT_FATAL(g_pool_ok.nblock > 40);
write_buf = calloc(1, buf_size);
read_buf = calloc(1, buf_size);
SPDK_CU_ASSERT_FATAL(bdev != NULL);
SPDK_CU_ASSERT_FATAL(write_buf != NULL);
SPDK_CU_ASSERT_FATAL(read_buf != NULL);
total_io_size = 0;
offset = nblock_offset * g_pool_ok.bsize;
for (i = 0; i < 3; i++) {
iov[i].iov_base = &write_buf[offset + total_io_size];
total_io_size += iov[i].iov_len;
}
for (i = 0; i < total_io_size + unaligned_aligned_size; i++) {
write_buf[offset + i] = 0x42 + i;
}
SPDK_CU_ASSERT_FATAL(total_io_size < buf_size);
/*
* Write outside pool.
*/
rc = bdev_submit_request(bdev, SPDK_BDEV_IO_TYPE_WRITE, g_pool_ok.nblock, 1, &iov[0], 2);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_FAILED);
/*
* Write with insufficient IOV buffers length.
*/
rc = bdev_submit_request(bdev, SPDK_BDEV_IO_TYPE_WRITE, 0, g_pool_ok.nblock, &iov[0], 2);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_FAILED);
/*
* Try to write two IOV with first one iov_len % bsize != 0.
*/
io_size = iov[0].iov_len + iov[1].iov_len;
nblock = io_size / g_pool_ok.bsize;
iov[0].iov_len += unaligned_aligned_size;
rc = bdev_submit_request(bdev, SPDK_BDEV_IO_TYPE_WRITE, 0, nblock, &iov[0], 2);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_FAILED);
iov[0].iov_len -= unaligned_aligned_size;
/*
* Try to write one IOV.
*/
nblock = iov[0].iov_len / g_pool_ok.bsize;
rc = bdev_submit_request(bdev, SPDK_BDEV_IO_TYPE_WRITE, nblock_offset, nblock, &iov[0], 1);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_SUCCESS);
/*
* Try to write 2 IOV.
* Sum of IOV length is larger than IO size and last IOV is larger and iov_len % bsize != 0
*/
offset = iov[0].iov_len / g_pool_ok.bsize;
io_size = iov[1].iov_len + iov[2].iov_len;
nblock = io_size / g_pool_ok.bsize;
iov[2].iov_len += unaligned_aligned_size;
rc = bdev_submit_request(bdev, SPDK_BDEV_IO_TYPE_WRITE, nblock_offset + offset, nblock,
&iov[1], 2);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_SUCCESS);
iov[2].iov_len -= unaligned_aligned_size;
/*
* Examine pool state:
* 1. Written area should have expected values.
* 2. Anything else should contain zeros.
*/
offset = nblock_offset * g_pool_ok.bsize + total_io_size;
rc = memcmp(&g_pool_ok.buffer[0], write_buf, offset);
CU_ASSERT_EQUAL(rc, 0);
for (i = offset; i < buf_size; i++) {
if (g_pool_ok.buffer[i] != 0) {
CU_ASSERT_EQUAL(g_pool_ok.buffer[i], 0);
break;
}
}
/* Setup IOV for reads */
memset(read_buf, 0xAB, buf_size);
offset = nblock_offset * g_pool_ok.bsize;
for (i = 0; i < 3; i++) {
iov[i].iov_base = &read_buf[offset];
offset += iov[i].iov_len;
}
/*
* Write outside pool.
*/
rc = bdev_submit_request(bdev, SPDK_BDEV_IO_TYPE_READ, g_pool_ok.nblock, 1, &iov[0], 2);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_FAILED);
/*
* Read with insufficient IOV buffers length.
*/
rc = bdev_submit_request(bdev, SPDK_BDEV_IO_TYPE_READ, 0, g_pool_ok.nblock, &iov[0], 2);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_FAILED);
/*
* Try to read two IOV with first one iov_len % bsize != 0.
*/
io_size = iov[0].iov_len + iov[1].iov_len;
nblock = io_size / g_pool_ok.bsize;
iov[0].iov_len += unaligned_aligned_size;
rc = bdev_submit_request(bdev, SPDK_BDEV_IO_TYPE_READ, 0, nblock, &iov[0], 2);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_FAILED);
iov[0].iov_len -= unaligned_aligned_size;
/*
* Try to write one IOV.
*/
nblock = iov[0].iov_len / g_pool_ok.bsize;
rc = bdev_submit_request(bdev, SPDK_BDEV_IO_TYPE_READ, nblock_offset, nblock, &iov[0], 1);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_SUCCESS);
/*
* Try to read 2 IOV.
* Sum of IOV length is larger than IO size and last IOV is larger and iov_len % bsize != 0
*/
offset = iov[0].iov_len / g_pool_ok.bsize;
io_size = iov[1].iov_len + iov[2].iov_len;
nblock = io_size / g_pool_ok.bsize;
iov[2].iov_len += unaligned_aligned_size;
rc = bdev_submit_request(bdev, SPDK_BDEV_IO_TYPE_READ, nblock_offset + offset, nblock,
&iov[1], 2);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_SUCCESS);
iov[2].iov_len -= unaligned_aligned_size;
/*
* Examine what we read state:
* 1. Written area should have expected values.
* 2. Anything else should contain zeros.
*/
offset = nblock_offset * g_pool_ok.bsize;
for (i = 0; i < offset; i++) {
if (read_buf[i] != 0xAB) {
CU_ASSERT_EQUAL(read_buf[i], 0xAB);
break;
}
}
rc = memcmp(&read_buf[offset], &write_buf[offset], total_io_size);
CU_ASSERT_EQUAL(rc, 0);
offset += total_io_size;
for (i = offset; i < buf_size; i++) {
if (read_buf[i] != 0xAB) {
CU_ASSERT_EQUAL(read_buf[i], 0xAB);
break;
}
}
memset(g_pool_ok.buffer, 0, g_pool_ok.bsize * g_pool_ok.nblock);
free(write_buf);
free(read_buf);
/* Now remove this bdev */
ut_bdev_pmem_destruct(bdev);
CU_ASSERT_FALSE(g_pool_ok.is_open);
CU_ASSERT_EQUAL(g_opened_pools, 0);
}
static void
ut_pmem_reset(void)
{
struct spdk_bdev *bdev;
int rc;
rc = create_pmem_disk(g_pool_ok.name, g_bdev_name, &bdev);
CU_ASSERT_EQUAL(rc, 0);
SPDK_CU_ASSERT_FATAL(bdev != NULL);
rc = bdev_submit_request(bdev, SPDK_BDEV_IO_TYPE_RESET, 0, 0, NULL, 0);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_SUCCESS);
ut_bdev_pmem_destruct(bdev);
}
static void
ut_pmem_unmap_write_zero(int16_t io_type)
{
struct spdk_bdev *bdev;
size_t buff_size = g_pool_ok.nblock * g_pool_ok.bsize;
size_t i;
uint8_t *buffer;
int rc;
CU_ASSERT(io_type == SPDK_BDEV_IO_TYPE_UNMAP || io_type == SPDK_BDEV_IO_TYPE_WRITE_ZEROES);
rc = create_pmem_disk(g_pool_ok.name, g_bdev_name, &bdev);
CU_ASSERT_EQUAL(rc, 0);
SPDK_CU_ASSERT_FATAL(bdev != NULL);
SPDK_CU_ASSERT_FATAL(g_pool_ok.nblock > 40);
buffer = calloc(1, buff_size);
SPDK_CU_ASSERT_FATAL(buffer != NULL);
for (i = 10 * g_pool_ok.bsize; i < 30 * g_pool_ok.bsize; i++) {
buffer[i] = 0x30 + io_type + i;
}
memcpy(g_pool_ok.buffer, buffer, buff_size);
/*
* Block outside of pool.
*/
rc = bdev_submit_request(bdev, io_type, g_pool_ok.nblock, 1, NULL, 0);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_FAILED);
rc = memcmp(buffer, g_pool_ok.buffer, buff_size);
CU_ASSERT_EQUAL(rc, 0);
/*
* Blocks 15 to 25
*/
memset(&buffer[15 * g_pool_ok.bsize], 0, 10 * g_pool_ok.bsize);
rc = bdev_submit_request(bdev, io_type, 15, 10, NULL, 0);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_SUCCESS);
rc = memcmp(buffer, g_pool_ok.buffer, buff_size);
CU_ASSERT_EQUAL(rc, 0);
/*
* All blocks.
*/
memset(buffer, 0, buff_size);
rc = bdev_submit_request(bdev, io_type, 0, g_pool_ok.nblock, NULL, 0);
CU_ASSERT_EQUAL(rc, SPDK_BDEV_IO_STATUS_SUCCESS);
rc = memcmp(buffer, g_pool_ok.buffer, buff_size);
CU_ASSERT_EQUAL(rc, 0);
/* Now remove this bdev */
ut_bdev_pmem_destruct(bdev);
CU_ASSERT_FALSE(g_pool_ok.is_open);
CU_ASSERT_EQUAL(g_opened_pools, 0);
free(buffer);
}
static void
ut_pmem_write_zero(void)
{
ut_pmem_unmap_write_zero(SPDK_BDEV_IO_TYPE_WRITE_ZEROES);
}
static void
ut_pmem_unmap(void)
{
ut_pmem_unmap_write_zero(SPDK_BDEV_IO_TYPE_UNMAP);
}
int
main(int argc, char **argv)
{
CU_pSuite suite = NULL;
unsigned int num_failures;
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("bdev_pmem", ut_pmem_blk_init, ut_pmem_blk_clean);
CU_ADD_TEST(suite, ut_pmem_init);
CU_ADD_TEST(suite, ut_pmem_open_close);
CU_ADD_TEST(suite, ut_pmem_write_read);
CU_ADD_TEST(suite, ut_pmem_reset);
CU_ADD_TEST(suite, ut_pmem_write_zero);
CU_ADD_TEST(suite, ut_pmem_unmap);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
num_failures = CU_get_number_of_failures();
CU_cleanup_registry();
return num_failures;
}

4
test/unit/unittest.sh
View File

@ -222,10 +222,6 @@ if grep -q '#define SPDK_CONFIG_DPDK_COMPRESSDEV 1' $rootdir/include/spdk/config
run_test "unittest_dpdk_compressdev" $valgrind $testdir/lib/accel/dpdk_compressdev.c/accel_dpdk_compressdev_ut
fi
if grep -q '#define SPDK_CONFIG_PMDK 1' $rootdir/include/spdk/config.h; then
run_test "unittest_bdev_pmem" $valgrind $testdir/lib/bdev/pmem/bdev_pmem_ut
fi
if grep -q '#define SPDK_CONFIG_RAID5F 1' $rootdir/include/spdk/config.h; then
run_test "unittest_bdev_raid5f" $valgrind $testdir/lib/bdev/raid/raid5f.c/raid5f_ut
fi