0d9a56b4f0
according to recent changes Signed-off-by: Slawomir Jankowski <slawomir.jankowski@intel.com>
541 lines
13 KiB
Bash
541 lines
13 KiB
Bash
#!/bin/bash
|
|
|
|
#
|
|
# Copyright(c) 2012-2020 Intel Corporation
|
|
# SPDX-License-Identifier: BSD-3-Clause-Clear
|
|
#
|
|
|
|
export NAME=`basename $0`
|
|
|
|
export RESTORE='\033[0m'
|
|
export RED='\033[00;31m'
|
|
export GREEN='\033[00;32m'
|
|
export YELLOW='\033[00;33m'
|
|
|
|
if [ -z $TESTS_DIR ] ; then
|
|
export TESTS_DIR="$(dirname $0)"
|
|
fi
|
|
|
|
export LOGS_FOLDER="$TESTS_DIR/logs"
|
|
|
|
if [ -z "$TEST_LOG_DIR" ] ; then
|
|
export TEST_LOG_DIR="$TESTS_DIR/logs"
|
|
fi
|
|
export TEST_TIME=""
|
|
|
|
check_if_root_or_exit() {
|
|
if [[ $EUID -ne 0 ]] ; then
|
|
echo "You need to have root privileges to launch DVT tests"
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
resolve_path() {
|
|
local BY_ID_DIR="/dev/disk/by-id"
|
|
local BY_ID_LINKS=$(ls $BY_ID_DIR)
|
|
|
|
for BY_ID_PATH in $BY_ID_LINKS
|
|
do
|
|
FULL_PATH="${BY_ID_DIR}/${BY_ID_PATH}"
|
|
if [[ "$(realpath $FULL_PATH)" -ef "$(realpath $DEVICE)" ]]
|
|
then
|
|
DEVICE=$FULL_PATH
|
|
break
|
|
fi
|
|
done
|
|
}
|
|
|
|
parse_args() {
|
|
while [ -n "$1" ] ; do
|
|
|
|
case $1 in
|
|
-a | --all ) export TEST_MODE="all"
|
|
;;
|
|
-x | --dir ) shift
|
|
export TEST_MODE="dir"
|
|
TEST_MODE_DIR="$1"
|
|
;;
|
|
-b | --bvt ) export TEST_MODE="bvt"
|
|
;;
|
|
-f | --atomic ) export TEST_MODE="atomic"
|
|
;;
|
|
-n | --nightly ) export TEST_MODE="nightly"
|
|
;;
|
|
-s | --sanity ) export TEST_MODE="sanity"
|
|
;;
|
|
-i | --ignore ) export IGNORE_WARNINGS="1"
|
|
;;
|
|
-c | --cache ) shift
|
|
DEVICE="$1"
|
|
resolve_path
|
|
CACHE_DEVICE=$DEVICE
|
|
;;
|
|
-d | --core ) shift
|
|
DEVICE="$1"
|
|
resolve_path
|
|
CORE_DEVICE=$DEVICE
|
|
;;
|
|
* ) echo "Unrecognized option"
|
|
usage
|
|
exit 1
|
|
esac
|
|
shift
|
|
done
|
|
}
|
|
|
|
usage() {
|
|
echo "example: ./${NAME} -b"
|
|
echo " -a | --all - run all TESTS"
|
|
echo " -b | --bvt - run BVT"
|
|
echo " -n | --nightly - run nightly"
|
|
echo " -s | --sanity - sanity check"
|
|
echo " -i | --ignore - ignore config warnings"
|
|
echo " -c | --cache - override cache device from settings file"
|
|
echo " -d | --core - override core device from settings file"
|
|
echo " -x | --dir <dir> - performs tests for specified directory (e.g. --dir basic)"
|
|
}
|
|
|
|
load_cas_lib() {
|
|
if [ -z $CAS_CONFIGURATION_LOADED ] ; then
|
|
. $TESTS_DIR/cas_config
|
|
fi
|
|
if [ -z $CAS_FUNCTIONS_LOADED ] ; then
|
|
. $TESTS_DIR/cas_functions
|
|
fi
|
|
if [ -z $CAS_OPTIONS_LOADED ] ; then
|
|
. $TESTS_DIR/cas_options
|
|
fi
|
|
if [ -f ~/cas_local_config ] ; then
|
|
. ~/cas_local_config
|
|
echo "--- Using home config file ---"
|
|
elif [ -f $TESTS_DIR/cas_local_config ] ; then
|
|
. $TESTS_DIR/cas_local_config
|
|
echo "--- Using local config file ---"
|
|
fi
|
|
}
|
|
|
|
start_test() {
|
|
if [ -z $LOG_FILE ] ; then
|
|
load_cas_lib
|
|
else
|
|
load_cas_lib >> $LOG_FILE
|
|
fi
|
|
parse_args $*
|
|
check_config
|
|
|
|
if [ -z $DESCRIPTION ]
|
|
then
|
|
DESCRIPTION=$(cat $0 | grep "# DESCRIPTION" | sed 's/# DESCRIPTION //g')
|
|
export DESCRIPTION="$DESCRIPTION"
|
|
fi
|
|
|
|
STORE_CONFIG_OPTION=1 clear_config
|
|
|
|
clear_options
|
|
echo "*** Starting test $0 - $DESCRIPTION ***"
|
|
TEST_TIME="$(date +%s)"
|
|
}
|
|
|
|
end_test() {
|
|
TEST_TIME="$(($(date +%s) - TEST_TIME))"
|
|
echo "*** Finished test $NAME ***"
|
|
echo "*** The test took $TEST_TIME seconds ***"
|
|
echo "result : $1"
|
|
|
|
restore_config
|
|
|
|
if [ $1 -ne 0 ] ; then
|
|
# Try to cleanup in case of failure - it might not always work, but could help to
|
|
# execute remaining tests
|
|
umount ${CORE_DEVICE}* &>/dev/null
|
|
remove_caches
|
|
test_log_stop
|
|
fi
|
|
# Delete all temporary files
|
|
rm -rf $TMP_DIR/*
|
|
# Delete created symlinks for NVMes
|
|
if [[ $CACHE_DEVICE != "/dev/nvme"* ]] ; then
|
|
exit $1
|
|
fi
|
|
|
|
local L_NVME_SYM_LINKS=`ls /dev/ | grep -E -w "${CACHE_DEVICE:5}[1-9][1-9]?"`
|
|
|
|
for SYM_LINK in $L_NVME_SYM_LINKS
|
|
do
|
|
if [ -L "/dev/${SYM_LINK}" ]
|
|
then
|
|
rm -f "/dev/${SYM_LINK}"
|
|
fi
|
|
done
|
|
|
|
exit $1
|
|
}
|
|
|
|
echo_green() {
|
|
echo -e "${GREEN}$*${RESTORE}"
|
|
}
|
|
|
|
echo_red() {
|
|
echo -e "${RED}$*${RESTORE}"
|
|
}
|
|
|
|
echo_yellow() {
|
|
echo -e "${YELLOW}$*${RESTORE}"
|
|
}
|
|
|
|
echo_green_n() {
|
|
echo -ne "${GREEN}$*${RESTORE}"
|
|
}
|
|
|
|
echo_red_n() {
|
|
echo -ne "${RED}$*${RESTORE}"
|
|
}
|
|
|
|
echo_yellow_n() {
|
|
echo -ne "${YELLOW}$*${RESTORE}"
|
|
}
|
|
|
|
success() {
|
|
echo -n "$*"
|
|
echo_green "[OK]"
|
|
}
|
|
|
|
error() {
|
|
echo -n "$*"
|
|
echo_red "[ERROR]"
|
|
}
|
|
|
|
not_run() {
|
|
echo -n "$*"
|
|
echo_yellow "[NOT RUN]"
|
|
}
|
|
|
|
warning() {
|
|
echo -n "$*"
|
|
echo_yellow "[WARNING]"
|
|
}
|
|
|
|
# This function should be used by all API wrappers and may be also used
|
|
# directly in tests. It runs the command passed to it and checks the return
|
|
# code against NEGATIVE_TEST_OPTION. If the NEGATIVE_TEST_OPTION is set, then
|
|
# we assume the command should fail - otherwise the command should succeed.
|
|
# If the output is correct, the command is printed and the test continues;
|
|
# if not, we print an error message and end the test immediately.
|
|
run_cmd() {
|
|
export RUN_CMD_OUTPUT=""
|
|
local L_RUN_CMD_START=$SECONDS
|
|
if [ -z "$SILENT_COMMAND_OPTION" ] ; then
|
|
echo -n "$(date +%Y-%m-%d_%H:%M:%S) "
|
|
echo -n "Running $* "
|
|
fi
|
|
OUTPUT=$(eval "$*" 2>&1)
|
|
STATUS=$?
|
|
export RUN_CMD_OUTPUT="${OUTPUT}"
|
|
export RUN_CMD_TIME=$(( $SECONDS - $L_RUN_CMD_START ))
|
|
if [ -z "$SILENT_COMMAND_OPTION" ] ; then
|
|
if [ -n "$NEGATIVE_TEST_OPTION" ] && [ "$NEGATIVE_TEST_OPTION" -ne 0 ] ; then
|
|
echo -n "(negative test) "
|
|
if [ $STATUS -ne 0 ] ; then
|
|
success
|
|
else
|
|
error
|
|
echo "--- Command output:"
|
|
echo "$OUTPUT"
|
|
if [ -z $DONT_FAIL_ON_ERROR_OPTION ]; then
|
|
end_test 1
|
|
fi
|
|
return 1
|
|
fi
|
|
else
|
|
if [ $STATUS -eq 0 ] ; then
|
|
success
|
|
else
|
|
error
|
|
echo "--- Command output:"
|
|
echo "$OUTPUT"
|
|
if [ -z $DONT_FAIL_ON_ERROR_OPTION ]; then
|
|
end_test 1
|
|
fi
|
|
return 1
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# This function converts size to bytes amount. It takes one parameter and
|
|
# the format of it is: [0-9][b|kB|kiB|k|M|MiB|MB|G|GiB|GB|T|TiB|TB]
|
|
#
|
|
# example of usage: BYTES=$(get_bytes 128kB)
|
|
# return : 128*1024 = 131,072
|
|
#
|
|
get_bytes () {
|
|
local PARAM
|
|
local FACTOR
|
|
local BYTES
|
|
|
|
if [[ $1 =~ ^([0-9]*)$ ]] ; then
|
|
PARAM=${BASH_REMATCH[1]}
|
|
FACTOR=1
|
|
elif [[ $1 =~ ^(b)$ ]] ; then
|
|
PARAM=1
|
|
FACTOR=512
|
|
elif [[ $1 =~ ^([0-9]*)(b)$ ]] ; then
|
|
PARAM=${BASH_REMATCH[1]}
|
|
FACTOR=512
|
|
elif [[ $1 =~ ^(kB)$ ]] ; then
|
|
PARAM=1
|
|
FACTOR=1000
|
|
elif [[ $1 =~ ^(k|kiB)$ ]] ; then
|
|
PARAM=1
|
|
FACTOR=1024
|
|
elif [[ $1 =~ ^([0-9]*)(kB)$ ]] ; then
|
|
PARAM=${BASH_REMATCH[1]}
|
|
FACTOR=1000
|
|
elif [[ $1 =~ ^([0-9]*)(k|kiB)$ ]] ; then
|
|
PARAM=${BASH_REMATCH[1]}
|
|
FACTOR=1024
|
|
elif [[ $1 =~ ^(MB)$ ]] ; then
|
|
PARAM=1
|
|
FACTOR=1000*1000
|
|
elif [[ $1 =~ ^(M|MiB)$ ]] ; then
|
|
PARAM=1
|
|
FACTOR=1024*1024
|
|
elif [[ $1 =~ ^([0-9]*)(MB)$ ]] ; then
|
|
PARAM=${BASH_REMATCH[1]}
|
|
FACTOR=1000*1000
|
|
elif [[ $1 =~ ^([0-9]*)(M|MiB)$ ]] ; then
|
|
PARAM=${BASH_REMATCH[1]}
|
|
FACTOR=1024*1024
|
|
elif [[ $1 =~ ^(GB)$ ]] ; then
|
|
PARAM=1
|
|
FACTOR=1000*1000*1000
|
|
elif [[ $1 =~ ^(G|GiB)$ ]] ; then
|
|
PARAM=1
|
|
FACTOR=1024*1024*1024
|
|
elif [[ $1 =~ ^([0-9]*)(GB)$ ]] ; then
|
|
PARAM=${BASH_REMATCH[1]}
|
|
FACTOR=1000*1000*1000
|
|
elif [[ $1 =~ ^([0-9]*)(G|GiB)$ ]] ; then
|
|
PARAM=${BASH_REMATCH[1]}
|
|
FACTOR=1024*1024*1024
|
|
elif [[ $1 =~ ^(T|TiB)$ ]] ; then
|
|
PARAM=1
|
|
FACTOR=1024*1024*1024*1024
|
|
elif [[ $1 =~ ^(TB)$ ]] ; then
|
|
PARAM=1
|
|
FACTOR=1000*1000*1000*1000
|
|
elif [[ $1 =~ ^([0-9]*)(T|TiB)$ ]] ; then
|
|
PARAM=${BASH_REMATCH[1]}
|
|
FACTOR=1024*1024*1024*1024
|
|
elif [[ $1 =~ ^([0-9]*)(TB)$ ]] ; then
|
|
PARAM=${BASH_REMATCH[1]}
|
|
FACTOR=1000*1000*1000*1000
|
|
else
|
|
echo "Input parameter error, ($1) is not [0-9](b|kB|kiB|k|M|MiB|MB|G|GiB|GB|T|TiB|TB)"
|
|
exit 1
|
|
fi
|
|
|
|
let BYTES=$PARAM*$FACTOR
|
|
|
|
echo $BYTES
|
|
}
|
|
|
|
# This function returns pages amount for specified byte size. It takes
|
|
# folowing parameters:
|
|
# size - size that will be computed to number of pages
|
|
# [page_size] - optional, if ommited then page size is 4k
|
|
#
|
|
# example of usage: PAGES=$(get_bytes 128kB [$PAGE_SIZE=4k])
|
|
# return : 128kB / $PAGE_SIZE = 32
|
|
#
|
|
get_pages () {
|
|
local PAGES
|
|
local PAGE_SIZE
|
|
local BYTES
|
|
|
|
if [ -z "$2" ]
|
|
then
|
|
PAGE_SIZE=4096
|
|
else
|
|
PAGE_SIZE=$2
|
|
fi
|
|
|
|
PAGE_SIZE=$(get_bytes $PAGE_SIZE)
|
|
BYTES=$(get_bytes $1)
|
|
|
|
let PAGES=$BYTES/$PAGE_SIZE
|
|
|
|
echo $PAGES
|
|
}
|
|
|
|
TEST_LOG_PID="${TEST_LOG_DIR}/.test_log_pid"
|
|
|
|
# Start print log to the STD
|
|
#
|
|
# usage:
|
|
# test_log_tail <log file>
|
|
test_log_tail () {
|
|
#
|
|
# Check if traicing in progress
|
|
#
|
|
if [ -f $TEST_LOG_PID ]
|
|
then
|
|
local L_PID=$(ps | grep tail | grep $(cat $TEST_LOG_PID))
|
|
if [ "" != "$L_PID" ]
|
|
then
|
|
return 0
|
|
fi
|
|
fi
|
|
|
|
tail -f $1 &
|
|
echo $! > $TEST_LOG_PID
|
|
return 0
|
|
}
|
|
|
|
# Test Log Utils Function
|
|
# It shall be used in following order
|
|
# test_log_start()
|
|
#
|
|
#
|
|
# test_log_trace() # Do tracing
|
|
#
|
|
#
|
|
# test_log_stop()
|
|
#
|
|
# Start trace loging. Function takes following parameters:
|
|
# [TEST_LOG_FILE_NAME] File where log will be captured. If omitted log file name
|
|
# id "cas_test_log"
|
|
#
|
|
# example of usage: test_log_start [$TEST_LOG_FILE_NAME]
|
|
#
|
|
test_log_start() {
|
|
if [ -n "$1" ]
|
|
then
|
|
export TEST_LOG="${TEST_LOG_DIR}/$1"
|
|
else
|
|
export TEST_LOG="${TEST_LOG_DIR}/cas_test_log_ext"
|
|
fi
|
|
|
|
if [ ! -d $TEST_LOG_DIR ] ; then
|
|
mkdir -p $TEST_LOG_DIR
|
|
fi
|
|
echo >> $TEST_LOG
|
|
echo "********************************************************" >> $TEST_LOG
|
|
echo "* Test log start : $(date)" >> $TEST_LOG
|
|
echo "* $DESCRIPTION - $TEST_LOG" >> $TEST_LOG
|
|
echo "********************************************************" >> $TEST_LOG
|
|
|
|
if [ -z $DISABLE_EXTERNAL_LOGGING ]
|
|
then
|
|
test_log_tail $TEST_LOG
|
|
fi
|
|
}
|
|
|
|
# Stop trace loging
|
|
test_log_stop() {
|
|
|
|
if [ -n "${TEST_LOG}" ]; then
|
|
echo "########################################################" >> $TEST_LOG
|
|
echo "* $DESCRIPTION - $TEST_LOG" >> $TEST_LOG
|
|
echo "# Test log stop : $(date)" >> $TEST_LOG
|
|
echo "########################################################" >> $TEST_LOG
|
|
echo >> $TEST_LOG
|
|
sleep 1
|
|
fi
|
|
|
|
if [ -f $TEST_LOG_PID ]
|
|
then
|
|
local L_PID=$(ps | grep tail | grep $(cat $TEST_LOG_PID))
|
|
if [ "" != "$L_PID" ]
|
|
then
|
|
kill $(cat $TEST_LOG_PID)
|
|
rm -f $TEST_LOG_PID
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#
|
|
# Trace log message.
|
|
#
|
|
# example of usage: test_log_trace "Some message to store in file"
|
|
#
|
|
test_log_trace() {
|
|
if [[ ! -z $1 ]]
|
|
then
|
|
echo "$DESCRIPTION : $1" >> $TEST_LOG
|
|
fi
|
|
}
|
|
|
|
set_categories() {
|
|
if [ "" != "$TEST_MODE_DIR" ]
|
|
then
|
|
export CATEGORIES=$TEST_MODE_DIR
|
|
return 0
|
|
fi
|
|
|
|
local TMP_CATEGORIES="$(find $TESTS_DIR -type d | grep -v old | grep -v logs | grep -v ^.$)"
|
|
for CATEGORY in $TMP_CATEGORIES ; do
|
|
CATEGORIES="$(basename $CATEGORY) $CATEGORIES"
|
|
done
|
|
export CATEGORIES=$(echo $CATEGORIES | tr ' ' '\n' | sort | tr '\n' ' ' && echo)
|
|
}
|
|
|
|
#
|
|
# Warmup device
|
|
#
|
|
#param1 - Input
|
|
#param2 - Output
|
|
#param3 - Block Size
|
|
#param4 - Count
|
|
#param5 - Seek
|
|
#param6 - Skip
|
|
warmup() {
|
|
local L_IF=$1
|
|
local L_OF=$2
|
|
local L_BS=$3
|
|
local L_COUNT=$4
|
|
local L_SEEK=$5
|
|
local L_SKIP=$6
|
|
local I_SEEK
|
|
local I_SKIP
|
|
|
|
if [ "$L_OF" = "/dev/null" ] ; then
|
|
DD_CONF='if=${L_IF} of=${L_OF} count=1 bs=${L_BS} skip=$I_SKIP iflag=direct'
|
|
else
|
|
DD_CONF='if=${L_IF} of=${L_OF} count=1 bs=${L_BS} seek=$I_SEEK skip=$I_SKIP oflag=direct iflag=direct conv=notrunc'
|
|
fi
|
|
|
|
for (( I=0; I<$L_COUNT; I=I+2 ))
|
|
do
|
|
let I_SEEK=${L_SEEK}+${I}
|
|
let I_SKIP=${L_SKIP}+${I}
|
|
|
|
eval "dd $DD_CONF &>/dev/null"
|
|
if [ $? != 0 ]
|
|
then
|
|
return 1
|
|
fi
|
|
done
|
|
|
|
for (( I=1; I<$L_COUNT; I=I+2 ))
|
|
do
|
|
let I_SEEK=${L_SEEK}+${I}
|
|
let I_SKIP=${L_SKIP}+${I}
|
|
|
|
eval "dd $DD_CONF &>/dev/null"
|
|
if [ $? != 0 ]
|
|
then
|
|
return 1
|
|
fi
|
|
done
|
|
|
|
return 0
|
|
}
|
|
|
|
cas_version () {
|
|
local L_CAS_VERSION=$(LANG=1 casadm -V -o csv 2>/dev/null | grep "CLI" | cut -d ',' -f2)
|
|
echo $L_CAS_VERSION
|
|
}
|
|
|
|
check_if_root_or_exit
|