3 # Common support functions for testing scripts. If a script-config
4 # files is available it will be sourced so in-tree kernel modules and
5 # utilities will be used. If no script-config can be found then the
6 # installed kernel modules and utilities will be used.
8 basedir
="$(dirname $0)"
10 SCRIPT_CONFIG
=zfs-script-config.sh
11 if [ -f "${basedir}/../${SCRIPT_CONFIG}" ]; then
12 .
"${basedir}/../${SCRIPT_CONFIG}"
14 KERNEL_MODULES
=(zlib_deflate zlib_inflate
)
15 MODULES
=(spl splat zavl znvpair zunicode zcommon icp zfs
)
29 TESTS_RUN
=${TESTS_RUN:-'*'}
30 TESTS_SKIP
=${TESTS_SKIP:-}
34 pkgdatadir
=${prefix}/share
/zfs
35 bindir
=${exec_prefix}/bin
36 sbindir
=${exec_prefix}/sbin
40 sysconfdir
=${prefix}/etc
41 localstatedir
=${prefix}/var
43 ETCDIR
=${ETCDIR:-/etc}
44 DEVDIR
=${DEVDIR:-/dev/disk/by-vdev}
45 ZPOOLDIR
=${ZPOOLDIR:-${pkgdatadir}/zpool-config}
46 ZPIOSDIR
=${ZPIOSDIR:-${pkgdatadir}/zpios-test}
47 ZPIOSPROFILEDIR
=${ZPIOSPROFILEDIR:-${pkgdatadir}/zpios-profile}
48 TESTSDIR
=${TESTSDIR:-${pkgdatadir}/zfs-tests}
49 RUNFILEDIR
=${RUNFILEDIR:-${pkgdatadir}/runfiles}
51 ZDB
=${ZDB:-${sbindir}/zdb}
52 ZFS
=${ZFS:-${sbindir}/zfs}
53 ZINJECT
=${ZINJECT:-${sbindir}/zinject}
54 ZHACK
=${ZHACK:-${sbindir}/zhack}
55 ZPOOL
=${ZPOOL:-${sbindir}/zpool}
56 ZTEST
=${ZTEST:-${sbindir}/ztest}
57 ZPIOS
=${ZPIOS:-${sbindir}/zpios}
59 COMMON_SH
=${COMMON_SH:-${pkgdatadir}/common.sh}
60 ZFS_SH
=${ZFS_SH:-${pkgdatadir}/zfs.sh}
61 ZPOOL_CREATE_SH
=${ZPOOL_CREATE_SH:-${pkgdatadir}/zpool-create.sh}
62 ZPIOS_SH
=${ZPIOS_SH:-${pkgdatadir}/zpios.sh}
63 ZPIOS_SURVEY_SH
=${ZPIOS_SURVEY_SH:-${pkgdatadir}/zpios-survey.sh}
64 TEST_RUNNER
=${TEST_RUNNER:-${pkgdatadir}/test-runner/bin/test-runner.py}
65 STF_TOOLS
=${STF_TOOLS:-${pkgdatadir}/test-runner}
66 STF_SUITE
=${STF_SUITE:-${pkgdatadir}/zfs-tests}
68 LDMOD
=${LDMOD:-/sbin/modprobe}
69 LSMOD
=${LSMOD:-/sbin/lsmod}
70 RMMOD
=${RMMOD:-/sbin/rmmod}
71 INFOMOD
=${INFOMOD:-/sbin/modinfo}
72 LOSETUP
=${LOSETUP:-/sbin/losetup}
73 MDADM
=${MDADM:-/sbin/mdadm}
74 DMSETUP
=${DMSETUP:-/sbin/dmsetup}
75 PARTED
=${PARTED:-/sbin/parted}
76 BLOCKDEV
=${BLOCKDEV:-/sbin/blockdev}
77 LSSCSI
=${LSSCSI:-/usr/bin/lsscsi}
78 SCSIRESCAN
=${SCSIRESCAN:-/usr/bin/scsi-rescan}
79 SYSCTL
=${SYSCTL:-/sbin/sysctl}
80 UDEVADM
=${UDEVADM:-/sbin/udevadm}
81 AWK
=${AWK:-/usr/bin/awk}
82 GDB
=${GDB:-/usr/bin/gdb}
84 ZED_PIDFILE
=${ZED_PIDFILE:-${localstatedir}/run/zed.pid}
86 COLOR_BLACK
="\033[0;30m"
87 COLOR_DK_GRAY
="\033[1;30m"
88 COLOR_BLUE
="\033[0;34m"
89 COLOR_LT_BLUE
="\033[1;34m"
90 COLOR_GREEN
="\033[0;32m"
91 COLOR_LT_GREEN
="\033[1;32m"
92 COLOR_CYAN
="\033[0;36m"
93 COLOR_LT_CYAN
="\033[1;36m"
94 COLOR_RED
="\033[0;31m"
95 COLOR_LT_RED
="\033[1;31m"
96 COLOR_PURPLE
="\033[0;35m"
97 COLOR_LT_PURPLE
="\033[1;35m"
98 COLOR_BROWN
="\033[0;33m"
99 COLOR_YELLOW
="\033[1;33m"
100 COLOR_LT_GRAY
="\033[0;37m"
101 COLOR_WHITE
="\033[1;37m"
102 COLOR_RESET
="\033[0m"
105 echo -e "${PROG}: $1" >&2
110 if [ ${VERBOSE} ]; then
116 echo -e "${COLOR_GREEN}Pass${COLOR_RESET}"
120 echo -e "${COLOR_RED}Fail${COLOR_RESET} ($1)"
125 echo -e "${COLOR_BROWN}Skip${COLOR_RESET}"
130 local MAX_DIR_SIZE
=$2
131 local MAX_FILE_SIZE
=$3
133 mkdir
-p $ROOT/{a
,b
,c
,d
,e
,f
,g
}/{h
,i
}
137 COUNT
=$
(($RANDOM % $MAX_DIR_SIZE))
139 for i
in `seq $COUNT`; do
140 FILE
=`mktemp -p ${DIR}`
141 SIZE
=$
(($RANDOM % $MAX_FILE_SIZE))
142 dd if=/dev
/urandom of
=$FILE bs
=1k count
=$SIZE &>/dev
/null
150 # Create a random directory tree of files and sub-directories to
151 # to act as a copy source for the various regression tests.
152 SRC_DIR
=`mktemp -d -p /var/tmp/ zfs.src.XXXXXXXX`
153 trap "rm -Rf $SRC_DIR" INT TERM EXIT
154 populate
$SRC_DIR 10 100
158 local LOADED_MODULES
=()
159 local MISSING_MODULES
=()
161 for MOD
in ${MODULES[*]}; do
162 local NAME
=`basename $MOD .ko`
164 if ${LSMOD} |
egrep -q "^${NAME}"; then
165 LOADED_MODULES
=(${NAME} ${LOADED_MODULES[*]})
168 if [ ${INFOMOD} ${MOD} 2>/dev
/null
]; then
169 MISSING_MODULES
=("\t${MOD}\n" ${MISSING_MODULES[*]})
173 if [ ${#LOADED_MODULES[*]} -gt 0 ]; then
174 ERROR
="Unload these modules with '${PROG} -u':\n"
175 ERROR
="${ERROR}${LOADED_MODULES[*]}"
179 if [ ${#MISSING_MODULES[*]} -gt 0 ]; then
180 ERROR
="The following modules can not be found,"
181 ERROR
="${ERROR} ensure your source trees are built:\n"
182 ERROR
="${ERROR}${MISSING_MODULES[*]}"
190 local NAME
=`basename $1 .ko`
192 if [ ${VERBOSE} ]; then
193 echo "Loading ${NAME} ($@)"
196 ${LDMOD} $
* &>/dev
/null
197 if [ $?
-ne 0 ]; then
198 echo "Failed to load ${NAME} ($@)"
208 for MOD
in ${KERNEL_MODULES[*]}; do
209 load_module
${MOD} >/dev
/null
212 for MOD
in ${MODULES[*]}; do
213 local NAME
=`basename ${MOD} .ko`
217 OPT_NAME
=`echo ${OPT} | cut -f1 -d'='`
219 if [ ${NAME} = "${OPT_NAME}" ]; then
220 VALUE
=`echo ${OPT} | cut -f2- -d'='`
224 load_module
${MOD} ${VALUE} ||
return 1
227 if [ ${VERBOSE} ]; then
228 echo "Successfully loaded ZFS module stack"
235 local NAME
=`basename $1 .ko`
237 if [ ${VERBOSE} ]; then
238 echo "Unloading ${NAME} ($@)"
241 ${RMMOD} ${NAME} || ERROR="Failed to unload ${NAME}" return 1
247 local MODULES_REVERSE=( $(echo ${MODULES[@]} |
248 ${AWK} '{for (i=NF;i>=1;i--) printf $i" "} END{print ""}') )
250 for MOD in ${MODULES_REVERSE[*]}; do
251 local NAME=`basename ${MOD} .ko`
252 local USE_COUNT=`${LSMOD} |
253 egrep "^
${NAME} "| ${AWK} '{print $3}'`
255 if [ "${USE_COUNT}" = 0 ] ; then
256 unload_module ${MOD} || return 1
260 if [ ${VERBOSE} ]; then
261 echo "Successfully unloaded ZFS module stack"
268 # Check that the mdadm utilities are installed.
271 test -f ${LOSETUP} || die "${LOSETUP} utility must be installed"
276 # Find and return an unused loop device. A new /dev/loopN node will be
277 # created if required. The kernel loop driver will automatically register
278 # the minor as long as it's
less than
/sys
/module
/loop
/parameters
/max_loop.
280 unused_loop_device
() {
281 local DEVICE
=$
(${LOSETUP} -f)
282 local MAX_LOOP_PATH
="/sys/module/loop/parameters/max_loop"
285 # An existing /dev/loopN device was available.
286 if [ -n "${DEVICE}" ]; then
291 # Create a new /dev/loopN provided we are not at MAX_LOOP.
292 if [ -f "${MAX_LOOP_PATH}" ]; then
293 MAX_LOOP
=`cat /sys/module/loop/parameters/max_loop`
294 if [ ${MAX_LOOP} -eq 0 ]; then
298 for (( i
=0; i
<=${MAX_LOOP}; i
++ )); do
301 if [ -b "${DEVICE}" ]; then
304 mknod
-m660 "${DEVICE}" b
7 $i
305 chown root.disk
"${DEVICE}"
306 chmod 666 "${DEVICE}"
314 die
"Error: Unable to create new loopback device"
318 # This can be slightly dangerous because the loop devices we are
319 # cleaning up may not be ours. However, if the devices are currently
320 # in use we will not be able to remove them, and we only remove
321 # devices which include 'zpool' or 'deleted' in the name. So any
322 # damage we might do should be limited to other zfs related testing.
324 cleanup_loop_devices
() {
325 local TMP_FILE
=`mktemp`
327 ${LOSETUP} -a |
tr -d '()' >${TMP_FILE}
328 ${AWK} -F":" -v losetup
="$LOSETUP" \
329 '/zpool/ || /deleted/ { system("losetup -d "$1) }' ${TMP_FILE}
330 ${AWK} -F" " '/zpool/ || /deleted/ { system("rm -f "$3) }' ${TMP_FILE}
336 # Destroy the passed loopback devices, this is used when you know
337 # the names of the loopback devices.
339 destroy_loop_devices
() {
342 msg
"Destroying ${LODEVICES}"
343 ${LOSETUP} -d ${LODEVICES} || \
344 die
"Error $? destroying ${FILE} -> ${DEVICE} loopback"
351 # Create a device label taking care to briefly wait if udev needs to settle.
357 wait_udev
${DEVICE} 30 ||
return 1
358 ${PARTED} ${DEVICE} --script -- mklabel ${LABEL} ||
return 2
364 # Create a primary partition on a block device.
372 ${PARTED} --align optimal
${DEVICE} --script -- \
373 mkpart
${TYPE} ${START} ${END} ||
return 1
380 # Create a filesystem on the block device
386 # Force 4K blocksize, else mkfs.ext2 tries to use 8K, which
388 /sbin
/mkfs.
${FSTYPE} -b 4096 -F -q ${DEVICE} >/dev
/null ||
return 1
394 # Check that the mdadm utilities are installed.
397 test -f ${MDADM} || die
"${MDADM} utility must be installed"
398 test -f ${PARTED} || die
"${PARTED} utility must be installed"
401 check_md_partitionable
() {
402 local LOFILE
=`mktemp -p /tmp zpool-lo.XXXXXXXX`
403 local LODEVICE
=`unused_loop_device`
404 local MDDEVICE
=`unused_md_device`
410 dd if=/dev
/zero of
=${LOFILE} bs
=1M count
=0 seek
=16 \
411 &>/dev
/null ||
return ${RESULT}
413 msg
"Creating ${LODEVICE} using ${LOFILE}"
414 ${LOSETUP} ${LODEVICE} ${LOFILE}
415 if [ $?
-ne 0 ]; then
420 msg
"Creating ${MDDEVICE} using ${LODEVICE}"
421 ${MDADM} --build ${MDDEVICE} --level=faulty \
422 --raid-devices=1 ${LODEVICE} &>/dev
/null
423 if [ $?
-ne 0 ]; then
424 destroy_loop_devices
${LODEVICE}
428 wait_udev
${MDDEVICE} 30
430 ${BLOCKDEV} --rereadpt ${MDDEVICE} 2>/dev
/null
433 destroy_md_devices
${MDDEVICE}
434 destroy_loop_devices
${LODEVICE}
441 # Find and return an unused md device.
444 for (( i
=0; i
<32; i
++ )); do
447 # Skip active devicesudo in /proc/mdstat.
448 grep -q "${MDDEVICE} " /proc
/mdstat
&& continue
450 # Device doesn't exist, use it.
451 if [ ! -e $
/dev
/{MDDEVICE
} ]; then
452 echo /dev
/${MDDEVICE}
456 # Device exists but may not be in use.
457 if [ -b /dev
/${MDDEVICE} ]; then
458 ${MDADM} --detail /dev
/${MDDEVICE} &>/dev
/null
459 if [ $?
-eq 1 ]; then
460 echo /dev
/${MDDEVICE}
466 die
"Error: Unable to find unused md device"
470 # This can be slightly dangerous because it is possible the md devices
471 # we are cleaning up may not be ours. However, if the devices are
472 # currently in use we will not be able to remove them, and even if
473 # we remove devices which were not out we do not zero the super block
474 # so you should be able to reconstruct them.
476 cleanup_md_devices
() {
477 destroy_md_devices
"`ls /dev/md* 2>/dev/null | grep -v p`"
482 # Destroy the passed md devices, this is used when you know
483 # the names of the md devices.
485 destroy_md_devices
() {
488 msg
"Destroying ${MDDEVICES}"
489 for MDDEVICE
in ${MDDEVICES}; do
490 ${MDADM} --stop ${MDDEVICE} &>/dev
/null
491 ${MDADM} --remove ${MDDEVICE} &>/dev
/null
492 ${MDADM} --detail ${MDDEVICE} &>/dev
/null
499 # Check that the scsi utilities are installed.
502 ${INFOMOD} scsi_debug
&>/dev
/null || die
"scsi_debug module required"
503 test -f ${LSSCSI} || die
"${LSSCSI} utility must be installed"
507 # Rescan the scsi bus for scsi_debug devices. It is preferable to use the
508 # scsi-rescan tool if it is installed, but if it's not we can fall back to
509 # removing and readding the device manually. This rescan will only effect
510 # the first scsi_debug device if scsi-rescan is missing.
513 local AWK_SCRIPT
="/scsi_debug/ { print \$1; exit }"
515 if [ -f ${SCSIRESCAN} ]; then
516 ${SCSIRESCAN} --forcerescan --remove &>/dev
/null
518 local SCSIID
=`${LSSCSI} | ${AWK} "${AWK_SCRIPT}" | tr -d '[]'`
519 local SCSIHOST
=`echo ${SCSIID} | cut -f1 -d':'`
520 echo 1 >"/sys/class/scsi_device/${SCSIID}/device/delete"
522 echo "- - -" >/sys
/class
/scsi_host
/host${SCSIHOST}/scan
528 # Trigger udev and wait for it to settle.
531 if [ -f ${UDEVADM} ]; then
532 ${UDEVADM} trigger
--action=change
--subsystem-match=block
541 # The following udev helper functions assume that the provided
542 # udev rules file will create a /dev/disk/by-vdev/<CHANNEL><RANK>
543 # disk mapping. In this mapping each CHANNEL is represented by
544 # the letters a-z, and the RANK is represented by the numbers
545 # 1-n. A CHANNEL should identify a group of RANKS which are all
546 # attached to a single controller, each RANK represents a disk.
547 # This provides a simply mechanism to locate a specific drive
548 # given a known hardware configuration.
553 # When running in tree manually construct symlinks in tree to
554 # the proper devices. Symlinks are installed for all entries
555 # in the config file regardless of if that device actually
556 # exists. When installed as a package udev can be relied on for
557 # this and it will only create links for devices which exist.
558 if [ ${INTREE} ]; then
562 ${AWK} '!/^#/ && /./ { system( \
563 "ln -f -s /dev/disk/by-path/"$2" "$1";" \
564 "ln -f -s /dev/disk/by-path/"$2"-part1 "$1"p1;" \
565 "ln -f -s /dev/disk/by-path/"$2"-part9 "$1"p9;" \
569 DST_FILE
=`basename ${SRC_PATH} | cut -f1-2 -d'.'`
570 DST_PATH
=/etc
/zfs
/${DST_FILE}
572 if [ -e ${DST_PATH} ]; then
573 die
"Error: Config ${DST_PATH} already exists"
576 cp ${SRC_PATH} ${DST_PATH}
586 if [ ${INTREE} ]; then
589 ${AWK} '!/^#/ && /./ { system( \
590 "rm -f "$1" "$1"p1 "$1"p9") }' $SRC_PATH
598 local CHANNEL
=`echo "obase=16; $1+96" | bc`
601 printf "\x${CHANNEL}${RANK}"
610 for RANK
in `seq 1 ${RANKS}`; do
611 for CHANNEL
in `seq 1 ${CHANNELS}`; do
612 DISK
=`udev_cr2d ${CHANNEL} ${RANK}`
613 RAID0S
[${IDX}]="${DEVDIR}/${DISK}"
621 udev_raid10_setup() {
627 for RANK in `seq 1 ${RANKS}`; do
628 for CHANNEL1 in `seq 1 2 ${CHANNELS}`; do
629 let CHANNEL2=CHANNEL1+1
630 DISK1=`udev_cr2d ${CHANNEL1} ${RANK}`
631 DISK2=`udev_cr2d ${CHANNEL2} ${RANK}`
632 GROUP="${DEVDIR}/${DISK1} ${DEVDIR}/${DISK2}"
633 RAID10S[${IDX}]="mirror
${GROUP}"
646 for RANK in `seq 1 ${RANKS}`; do
649 for CHANNEL in `seq 1 ${CHANNELS}`; do
650 DISK=`udev_cr2d ${CHANNEL} ${RANK}`
651 RAIDZ[${CHANNEL}]="${DEVDIR}/${DISK}"
654 RAIDZS
[${RANK}]="${RAIDZ[*]}"
660 udev_raidz2_setup
() {
665 for RANK
in `seq 1 ${RANKS}`; do
668 for CHANNEL
in `seq 1 ${CHANNELS}`; do
669 DISK
=`udev_cr2d ${CHANNEL} ${RANK}`
670 RAIDZ2
[${CHANNEL}]="${DEVDIR}/${DISK}"
673 RAIDZ2S[${RANK}]="${RAIDZ2[*]}"
683 printf "%-4d %-34s " ${TEST_NUM} "${TEST_NAME}"
691 printf "%-4d %-34s " ${TEST_NUM} "${TEST_NAME}"
699 for i in ${TESTS_SKIP[@]}; do
700 if [[ $i == ${TEST_NUM} ]] ; then
701 skip_one_test ${TEST_NUM} "${TEST_NAME}"
706 if [ "${TESTS_RUN[0]}" = "*" ]; then
707 run_one_test ${TEST_NUM} "${TEST_NAME}"
709 for i in ${TESTS_RUN[@]}; do
710 if [[ $i == ${TEST_NUM} ]] ; then
711 run_one_test ${TEST_NUM} "${TEST_NAME}"
716 skip_one_test ${TEST_NUM} "${TEST_NAME}"
726 while [ ! -e ${DEVICE} ]; do
727 if [ ${COUNT} -gt ${DELAY} ]; then
739 local STACK_MAX_SIZE=/sys/kernel/debug/tracing/stack_max_size
740 local STACK_TRACER_ENABLED=/proc/sys/kernel/stack_tracer_enabled
742 if [ -e $STACK_MAX_SIZE ]; then
743 echo 1 >$STACK_TRACER_ENABLED
744 echo 0 >$STACK_MAX_SIZE
749 local STACK_MAX_SIZE=/sys/kernel/debug/tracing/stack_max_size
750 local STACK_TRACE=/sys/kernel/debug/tracing/stack_trace
751 local STACK_LIMIT=7000
753 if [ -e $STACK_MAX_SIZE ]; then
754 STACK_SIZE=`cat $STACK_MAX_SIZE`
756 if [ $STACK_SIZE -ge $STACK_LIMIT ]; then
758 echo "Warning
: max stack size
$STACK_SIZE bytes
"
765 if [ -f $ZED_PIDFILE ]; then
766 kill $(cat $ZED_PIDFILE)