scripts/common.sh.in

   1 #!/bin/bash
   2 #
   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.
   7
   8 basedir="$(dirname $0)"
   9
  10 SCRIPT_CONFIG=zfs-script-config.sh
  11 if [ -f "${basedir}/../${SCRIPT_CONFIG}" ]; then
  12 . "${basedir}/../${SCRIPT_CONFIG}"
  13 else
  14 KERNEL_MODULES=(zlib_deflate zlib_inflate)
  15 MODULES=(spl splat zavl znvpair zunicode zcommon zfs)
  16 fi
  17
  18 PROG="<define PROG>"
  19 CLEANUP=
  20 VERBOSE=
  21 VERBOSE_FLAG=
  22 FORCE=
  23 FORCE_FLAG=
  24 DUMP_LOG=
  25 ERROR=
  26 RAID0S=()
  27 RAID10S=()
  28 RAIDZS=()
  29 RAIDZ2S=()
  30 TESTS_RUN=${TESTS_RUN:-'*'}
  31 TESTS_SKIP=${TESTS_SKIP:-}
  32
  33 prefix=@prefix@
  34 exec_prefix=@exec_prefix@
  35 pkgdatadir=@datarootdir@/@PACKAGE@
  36 bindir=@bindir@
  37 sbindir=@sbindir@
  38 udevdir=@udevdir@
  39 udevruledir=@udevruledir@
  40 sysconfdir=@sysconfdir@
  41 localstatedir=@localstatedir@
  42
  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}
  50
  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}
  58
  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}
  67
  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}
  83
  84 ZED_PIDFILE=${ZED_PIDFILE:-${localstatedir}/run/zed.pid}
  85
  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"
 103
 104 die() {
 105         echo -e "${PROG}: $1" >&2
 106         exit 1
 107 }
 108
 109 msg() {
 110         if [ ${VERBOSE} ]; then
 111                 echo "$@"
 112         fi
 113 }
 114
 115 pass() {
 116         echo -e "${COLOR_GREEN}Pass${COLOR_RESET}"
 117 }
 118
 119 fail() {
 120         echo -e "${COLOR_RED}Fail${COLOR_RESET} ($1)"
 121         exit $1
 122 }
 123
 124 skip() {
 125         echo -e "${COLOR_BROWN}Skip${COLOR_RESET}"
 126 }
 127
 128 populate() {
 129         local ROOT=$1
 130         local MAX_DIR_SIZE=$2
 131         local MAX_FILE_SIZE=$3
 132
 133         mkdir -p $ROOT/{a,b,c,d,e,f,g}/{h,i}
 134         DIRS=`find $ROOT`
 135
 136         for DIR in $DIRS; do
 137                 COUNT=$(($RANDOM % $MAX_DIR_SIZE))
 138
 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
 143                 done
 144         done
 145
 146         return 0
 147 }
 148
 149 init() {
 150         # Disable the udev rule 90-zfs.rules to prevent the zfs module
 151         # stack from being loaded due to the detection of a zfs device.
 152         # This is important because the test scripts require full control
 153         # over when and how the modules are loaded/unloaded.  A trap is
 154         # set to ensure the udev rule is correctly replaced on exit.
 155         local RULE=${udevruledir}/90-zfs.rules
 156         if test -e  ${RULE}; then
 157                 trap "mv ${RULE}.disabled ${RULE}" INT TERM EXIT
 158                 mv ${RULE} ${RULE}.disabled
 159         fi
 160
 161         # Create a random directory tree of files and sub-directories to
 162         # to act as a copy source for the various regression tests.
 163         SRC_DIR=`mktemp -d -p /var/tmp/ zfs.src.XXXXXXXX`
 164         trap "rm -Rf $SRC_DIR" INT TERM EXIT
 165         populate $SRC_DIR 10 100
 166 }
 167
 168 spl_dump_log() {
 169         ${SYSCTL} -w kernel.spl.debug.dump=1 &>/dev/null
 170         local NAME=`dmesg | tail -n 1 | cut -f5 -d' '`
 171         ${SPLBUILD}/cmd/spl ${NAME} >${NAME}.log
 172         echo
 173         echo "Dumped debug log: ${NAME}.log"
 174         tail -n1 ${NAME}.log
 175         echo
 176         return 0
 177 }
 178
 179 check_modules() {
 180         local LOADED_MODULES=()
 181         local MISSING_MODULES=()
 182
 183         for MOD in ${MODULES[*]}; do
 184                 local NAME=`basename $MOD .ko`
 185
 186                 if ${LSMOD} | egrep -q "^${NAME}"; then
 187                         LOADED_MODULES=(${NAME} ${LOADED_MODULES[*]})
 188                 fi
 189
 190                 if [ ${INFOMOD} ${MOD} 2>/dev/null ]; then
 191                         MISSING_MODULES=("\t${MOD}\n" ${MISSING_MODULES[*]})
 192                 fi
 193         done
 194
 195         if [ ${#LOADED_MODULES[*]} -gt 0 ]; then
 196                 ERROR="Unload these modules with '${PROG} -u':\n"
 197                 ERROR="${ERROR}${LOADED_MODULES[*]}"
 198                 return 1
 199         fi
 200
 201         if [ ${#MISSING_MODULES[*]} -gt 0 ]; then
 202                 ERROR="The following modules can not be found,"
 203                 ERROR="${ERROR} ensure your source trees are built:\n"
 204                 ERROR="${ERROR}${MISSING_MODULES[*]}"
 205                 return 1
 206         fi
 207
 208         return 0
 209 }
 210
 211 load_module() {
 212         local NAME=`basename $1 .ko`
 213
 214         if [ ${VERBOSE} ]; then
 215                 echo "Loading ${NAME} ($@)"
 216         fi
 217
 218         ${LDMOD} $* &>/dev/null
 219         if [ $? -ne 0 ]; then
 220                 echo "Failed to load ${NAME} ($@)"
 221                 return 1
 222         fi
 223
 224         return 0
 225 }
 226
 227 load_modules() {
 228         mkdir -p /etc/zfs
 229
 230         for MOD in ${KERNEL_MODULES[*]}; do
 231                 load_module ${MOD} >/dev/null
 232         done
 233
 234         for MOD in ${MODULES[*]}; do
 235                 local NAME=`basename ${MOD} .ko`
 236                 local VALUE=
 237
 238                 for OPT in "$@"; do
 239                         OPT_NAME=`echo ${OPT} | cut -f1 -d'='`
 240
 241                         if [ ${NAME} = "${OPT_NAME}" ]; then
 242                                 VALUE=`echo ${OPT} | cut -f2- -d'='`
 243                         fi
 244                 done
 245
 246                 load_module ${MOD} ${VALUE} || return 1
 247         done
 248
 249         if [ ${VERBOSE} ]; then
 250                 echo "Successfully loaded ZFS module stack"
 251         fi
 252
 253         return 0
 254 }
 255
 256 unload_module() {
 257         local NAME=`basename $1 .ko`
 258
 259         if [ ${VERBOSE} ]; then
 260                 echo "Unloading ${NAME} ($@)"
 261         fi
 262
 263         ${RMMOD} ${NAME} || ERROR="Failed to unload ${NAME}" return 1
 264
 265         return 0
 266 }
 267
 268 unload_modules() {
 269         local MODULES_REVERSE=( $(echo ${MODULES[@]} |
 270                 ${AWK} '{for (i=NF;i>=1;i--) printf $i" "} END{print ""}') )
 271
 272         for MOD in ${MODULES_REVERSE[*]}; do
 273                 local NAME=`basename ${MOD} .ko`
 274                 local USE_COUNT=`${LSMOD} |
 275                                 egrep "^${NAME} "| ${AWK} '{print $3}'`
 276
 277                 if [ "${USE_COUNT}" = 0 ] ; then
 278
 279                         if [ "${DUMP_LOG}" -a ${NAME} = "spl" ]; then
 280                                 spl_dump_log
 281                         fi
 282
 283                         unload_module ${MOD} || return 1
 284                 fi
 285         done
 286
 287         if [ ${VERBOSE} ]; then
 288                 echo "Successfully unloaded ZFS module stack"
 289         fi
 290
 291         return 0
 292 }
 293
 294 #
 295 # Check that the mdadm utilities are installed.
 296 #
 297 check_loop_utils() {
 298         test -f ${LOSETUP} || die "${LOSETUP} utility must be installed"
 299 }
 300
 301
 302 #
 303 # Find and return an unused loop device.  A new /dev/loopN node will be
 304 # created if required.  The kernel loop driver will automatically register
 305 # the minor as long as it's less than /sys/module/loop/parameters/max_loop.
 306 #
 307 unused_loop_device() {
 308         local DEVICE=$(${LOSETUP} -f)
 309         local MAX_LOOP_PATH="/sys/module/loop/parameters/max_loop"
 310         local MAX_LOOP;
 311
 312         # An existing /dev/loopN device was available.
 313         if [ -n "${DEVICE}" ]; then
 314                 echo "${DEVICE}"
 315                 return 0
 316         fi
 317
 318         # Create a new /dev/loopN provided we are not at MAX_LOOP.
 319         if [ -f "${MAX_LOOP_PATH}" ]; then
 320                 MAX_LOOP=`cat /sys/module/loop/parameters/max_loop`
 321                 if [ ${MAX_LOOP} -eq 0 ]; then
 322                         MAX_LOOP=255
 323                 fi
 324
 325                 for (( i=0; i<=${MAX_LOOP}; i++ )); do
 326                         DEVICE="/dev/loop$i"
 327
 328                         if [ -b "${DEVICE}" ]; then
 329                                 continue
 330                         else
 331                                 mknod -m660 "${DEVICE}" b 7 $i
 332                                 chown root.disk "${DEVICE}"
 333                                 chmod 666 "${DEVICE}"
 334
 335                                 echo "${DEVICE}"
 336                                 return 0
 337                         fi
 338                 done
 339         fi
 340
 341         die "Error: Unable to create new loopback device"
 342 }
 343
 344 #
 345 # This can be slightly dangerous because the loop devices we are
 346 # cleaning up may not be ours.  However, if the devices are currently
 347 # in use we will not be able to remove them, and we only remove
 348 # devices which include 'zpool' or 'deleted' in the name.  So any
 349 # damage we might do should be limited to other zfs related testing.
 350 #
 351 cleanup_loop_devices() {
 352         local TMP_FILE=`mktemp`
 353
 354         ${LOSETUP} -a | tr -d '()' >${TMP_FILE}
 355         ${AWK} -F":" -v losetup="$LOSETUP" \
 356             '/zpool/ || /deleted/ { system("losetup -d "$1) }' ${TMP_FILE}
 357         ${AWK} -F" " '/zpool/ || /deleted/ { system("rm -f "$3) }' ${TMP_FILE}
 358
 359         rm -f ${TMP_FILE}
 360 }
 361
 362 #
 363 # Destroy the passed loopback devices, this is used when you know
 364 # the names of the loopback devices.
 365 #
 366 destroy_loop_devices() {
 367         local LODEVICES="$1"
 368
 369         msg "Destroying ${LODEVICES}"
 370         ${LOSETUP} -d ${LODEVICES} || \
 371                 die "Error $? destroying ${FILE} -> ${DEVICE} loopback"
 372
 373         rm -f ${FILES}
 374         return 0
 375 }
 376
 377 #
 378 # Create a device label taking care to briefly wait if udev needs to settle.
 379 #
 380 label() {
 381         local DEVICE=$1
 382         local LABEL=$2
 383
 384         wait_udev ${DEVICE} 30 || return 1
 385         ${PARTED} ${DEVICE} --script -- mklabel ${LABEL} || return 2
 386
 387         return 0
 388 }
 389
 390 #
 391 # Create a primary partition on a block device.
 392 #
 393 partition() {
 394         local DEVICE=$1
 395         local TYPE=$2
 396         local START=$3
 397         local END=$4
 398
 399         ${PARTED} --align optimal ${DEVICE} --script -- \
 400             mkpart ${TYPE} ${START} ${END} || return 1
 401         udev_trigger
 402
 403         return 0
 404 }
 405
 406 #
 407 # Create a filesystem on the block device
 408 #
 409 format() {
 410         local DEVICE=$1
 411         local FSTYPE=$2
 412
 413         # Force 4K blocksize, else mkfs.ext2 tries to use 8K, which
 414         # won't mount
 415         /sbin/mkfs.${FSTYPE} -b 4096 -F -q ${DEVICE} >/dev/null || return 1
 416
 417         return 0
 418 }
 419
 420 #
 421 # Check that the mdadm utilities are installed.
 422 #
 423 check_md_utils() {
 424         test -f ${MDADM} || die "${MDADM} utility must be installed"
 425         test -f ${PARTED} || die "${PARTED} utility must be installed"
 426 }
 427
 428 check_md_partitionable() {
 429         local LOFILE=`mktemp -p /tmp zpool-lo.XXXXXXXX`
 430         local LODEVICE=`unused_loop_device`
 431         local MDDEVICE=`unused_md_device`
 432         local RESULT=1
 433
 434         check_md_utils
 435
 436         rm -f ${LOFILE}
 437         dd if=/dev/zero of=${LOFILE} bs=1M count=0 seek=16 \
 438                 &>/dev/null || return ${RESULT}
 439
 440         msg "Creating ${LODEVICE} using ${LOFILE}"
 441         ${LOSETUP} ${LODEVICE} ${LOFILE}
 442         if [ $? -ne 0 ]; then
 443                 rm -f ${LOFILE}
 444                 return ${RESULT}
 445         fi
 446
 447         msg "Creating ${MDDEVICE} using ${LODEVICE}"
 448         ${MDADM} --build ${MDDEVICE} --level=faulty \
 449                 --raid-devices=1 ${LODEVICE} &>/dev/null
 450         if [ $? -ne 0 ]; then
 451                 destroy_loop_devices ${LODEVICE}
 452                 rm -f ${LOFILE}
 453                 return ${RESULT}
 454         fi
 455         wait_udev ${MDDEVICE} 30
 456
 457         ${BLOCKDEV} --rereadpt ${MDDEVICE} 2>/dev/null
 458         RESULT=$?
 459
 460         destroy_md_devices ${MDDEVICE}
 461         destroy_loop_devices ${LODEVICE}
 462         rm -f ${LOFILE}
 463
 464         return ${RESULT}
 465 }
 466
 467 #
 468 # Find and return an unused md device.
 469 #
 470 unused_md_device() {
 471         for (( i=0; i<32; i++ )); do
 472                 MDDEVICE=md${i}
 473
 474                 # Skip active devicesudo in /proc/mdstat.
 475                 grep -q "${MDDEVICE} " /proc/mdstat && continue
 476
 477                 # Device doesn't exist, use it.
 478                 if [ ! -e $/dev/{MDDEVICE} ]; then
 479                         echo /dev/${MDDEVICE}
 480                         return
 481                 fi
 482
 483                 # Device exists but may not be in use.
 484                 if [ -b /dev/${MDDEVICE} ]; then
 485                         ${MDADM} --detail /dev/${MDDEVICE} &>/dev/null
 486                         if [ $? -eq 1 ]; then
 487                                 echo /dev/${MDDEVICE}
 488                                 return
 489                         fi
 490                 fi
 491         done
 492
 493         die "Error: Unable to find unused md device"
 494 }
 495
 496 #
 497 # This can be slightly dangerous because it is possible the md devices
 498 # we are cleaning up may not be ours.  However, if the devices are
 499 # currently in use we will not be able to remove them, and even if
 500 # we remove devices which were not out we do not zero the super block
 501 # so you should be able to reconstruct them.
 502 #
 503 cleanup_md_devices() {
 504         destroy_md_devices "`ls /dev/md* 2>/dev/null | grep -v p`"
 505         udev_trigger
 506 }
 507
 508 #
 509 # Destroy the passed md devices, this is used when you know
 510 # the names of the md devices.
 511 #
 512 destroy_md_devices() {
 513         local MDDEVICES="$1"
 514
 515         msg "Destroying ${MDDEVICES}"
 516         for MDDEVICE in ${MDDEVICES}; do
 517                 ${MDADM} --stop ${MDDEVICE} &>/dev/null
 518                 ${MDADM} --remove ${MDDEVICE} &>/dev/null
 519                 ${MDADM} --detail ${MDDEVICE} &>/dev/null
 520         done
 521
 522         return 0
 523 }
 524
 525 #
 526 # Check that the scsi utilities are installed.
 527 #
 528 check_sd_utils() {
 529         ${INFOMOD} scsi_debug &>/dev/null || die "scsi_debug module required"
 530         test -f ${LSSCSI} || die "${LSSCSI} utility must be installed"
 531 }
 532
 533 #
 534 # Rescan the scsi bus for scsi_debug devices.  It is preferable to use the
 535 # scsi-rescan tool if it is installed, but if it's not we can fall back to
 536 # removing and readding the device manually.  This rescan will only effect
 537 # the first scsi_debug device if scsi-rescan is missing.
 538 #
 539 scsi_rescan() {
 540         local AWK_SCRIPT="/scsi_debug/ { print \$1; exit }"
 541
 542         if [ -f ${SCSIRESCAN} ]; then
 543                 ${SCSIRESCAN} --forcerescan --remove &>/dev/null
 544         else
 545                 local SCSIID=`${LSSCSI} | ${AWK} "${AWK_SCRIPT}" | tr -d '[]'`
 546                 local SCSIHOST=`echo ${SCSIID} | cut -f1 -d':'`
 547                 echo 1 >"/sys/class/scsi_device/${SCSIID}/device/delete"
 548                 udev_trigger
 549                 echo "- - -" >/sys/class/scsi_host/host${SCSIHOST}/scan
 550                 udev_trigger
 551         fi
 552 }
 553
 554 #
 555 # Trigger udev and wait for it to settle.
 556 #
 557 udev_trigger() {
 558         if [ -f ${UDEVADM} ]; then
 559                 ${UDEVADM} trigger --action=change --subsystem-match=block
 560                 ${UDEVADM} settle
 561         else
 562                 /sbin/udevtrigger
 563                 /sbin/udevsettle
 564         fi
 565 }
 566
 567 #
 568 # The following udev helper functions assume that the provided
 569 # udev rules file will create a /dev/disk/by-vdev/<CHANNEL><RANK>
 570 # disk mapping.  In this mapping each CHANNEL is represented by
 571 # the letters a-z, and the RANK is represented by the numbers
 572 # 1-n.  A CHANNEL should identify a group of RANKS which are all
 573 # attached to a single controller, each RANK represents a disk.
 574 # This provides a simply mechanism to locate a specific drive
 575 # given a known hardware configuration.
 576 #
 577 udev_setup() {
 578         local SRC_PATH=$1
 579
 580         # When running in tree manually contruct symlinks in tree to
 581         # the proper devices.  Symlinks are installed for all entires
 582         # in the config file regardless of if that device actually
 583         # exists.  When installed as a package udev can be relied on for
 584         # this and it will only create links for devices which exist.
 585         if [ ${INTREE} ]; then
 586                 PWD=`pwd`
 587                 mkdir -p ${DEVDIR}/
 588                 cd ${DEVDIR}/
 589                 ${AWK} '!/^#/ && /./ { system( \
 590                         "ln -f -s /dev/disk/by-path/"$2" "$1";" \
 591                         "ln -f -s /dev/disk/by-path/"$2"-part1 "$1"p1;" \
 592                         "ln -f -s /dev/disk/by-path/"$2"-part9 "$1"p9;" \
 593                         ) }' $SRC_PATH
 594                 cd ${PWD}
 595         else
 596                 DST_FILE=`basename ${SRC_PATH} | cut -f1-2 -d'.'`
 597                 DST_PATH=/etc/zfs/${DST_FILE}
 598
 599                 if [ -e ${DST_PATH} ]; then
 600                         die "Error: Config ${DST_PATH} already exists"
 601                 fi
 602
 603                 cp ${SRC_PATH} ${DST_PATH}
 604                 udev_trigger
 605         fi
 606
 607         return 0
 608 }
 609
 610 udev_cleanup() {
 611         local SRC_PATH=$1
 612
 613         if [ ${INTREE} ]; then
 614                 PWD=`pwd`
 615                 cd ${DEVDIR}/
 616                 ${AWK} '!/^#/ && /./ { system( \
 617                         "rm -f "$1" "$1"p1 "$1"p9") }' $SRC_PATH
 618                 cd ${PWD}
 619         fi
 620
 621         return 0
 622 }
 623
 624 udev_cr2d() {
 625         local CHANNEL=`echo "obase=16; $1+96" | bc`
 626         local RANK=$2
 627
 628         printf "\x${CHANNEL}${RANK}"
 629 }
 630
 631 udev_raid0_setup() {
 632         local RANKS=$1
 633         local CHANNELS=$2
 634         local IDX=0
 635
 636         RAID0S=()
 637         for RANK in `seq 1 ${RANKS}`; do
 638                 for CHANNEL in `seq 1 ${CHANNELS}`; do
 639                         DISK=`udev_cr2d ${CHANNEL} ${RANK}`
 640                         RAID0S[${IDX}]="${DEVDIR}/${DISK}"
 641                         let IDX=IDX+1
 642                 done
 643         done
 644
 645         return 0
 646 }
 647
 648 udev_raid10_setup() {
 649         local RANKS=$1
 650         local CHANNELS=$2
 651         local IDX=0
 652
 653         RAID10S=()
 654         for RANK in `seq 1 ${RANKS}`; do
 655                 for CHANNEL1 in `seq 1 2 ${CHANNELS}`; do
 656                         let CHANNEL2=CHANNEL1+1
 657                         DISK1=`udev_cr2d ${CHANNEL1} ${RANK}`
 658                         DISK2=`udev_cr2d ${CHANNEL2} ${RANK}`
 659                         GROUP="${DEVDIR}/${DISK1} ${DEVDIR}/${DISK2}"
 660                         RAID10S[${IDX}]="mirror ${GROUP}"
 661                         let IDX=IDX+1
 662                 done
 663         done
 664
 665         return 0
 666 }
 667
 668 udev_raidz_setup() {
 669         local RANKS=$1
 670         local CHANNELS=$2
 671
 672         RAIDZS=()
 673         for RANK in `seq 1 ${RANKS}`; do
 674                 RAIDZ=("raidz")
 675
 676                 for CHANNEL in `seq 1 ${CHANNELS}`; do
 677                         DISK=`udev_cr2d ${CHANNEL} ${RANK}`
 678                         RAIDZ[${CHANNEL}]="${DEVDIR}/${DISK}"
 679                 done
 680
 681                 RAIDZS[${RANK}]="${RAIDZ[*]}"
 682         done
 683
 684         return 0
 685 }
 686
 687 udev_raidz2_setup() {
 688         local RANKS=$1
 689         local CHANNELS=$2
 690
 691         RAIDZ2S=()
 692         for RANK in `seq 1 ${RANKS}`; do
 693                 RAIDZ2=("raidz2")
 694
 695                 for CHANNEL in `seq 1 ${CHANNELS}`; do
 696                         DISK=`udev_cr2d ${CHANNEL} ${RANK}`
 697                         RAIDZ2[${CHANNEL}]="${DEVDIR}/${DISK}"
 698                 done
 699
 700                 RAIDZ2S[${RANK}]="${RAIDZ2[*]}"
 701         done
 702
 703         return 0
 704 }
 705
 706 run_one_test() {
 707         local TEST_NUM=$1
 708         local TEST_NAME=$2
 709
 710         printf "%-4d %-34s " ${TEST_NUM} "${TEST_NAME}"
 711         test_${TEST_NUM}
 712 }
 713
 714 skip_one_test() {
 715         local TEST_NUM=$1
 716         local TEST_NAME=$2
 717
 718         printf "%-4d %-34s " ${TEST_NUM} "${TEST_NAME}"
 719         skip
 720 }
 721
 722 run_test() {
 723         local TEST_NUM=$1
 724         local TEST_NAME=$2
 725
 726         for i in ${TESTS_SKIP[@]}; do
 727                 if [[ $i == ${TEST_NUM} ]] ; then
 728                         skip_one_test ${TEST_NUM} "${TEST_NAME}"
 729                         return 0
 730                 fi
 731         done
 732
 733         if [ "${TESTS_RUN[0]}" = "*" ]; then
 734                 run_one_test ${TEST_NUM} "${TEST_NAME}"
 735         else
 736                 for i in ${TESTS_RUN[@]}; do
 737                         if [[ $i == ${TEST_NUM} ]] ; then
 738                                 run_one_test ${TEST_NUM} "${TEST_NAME}"
 739                                 return 0
 740                         fi
 741                 done
 742
 743                 skip_one_test ${TEST_NUM} "${TEST_NAME}"
 744         fi
 745 }
 746
 747 wait_udev() {
 748         local DEVICE=$1
 749         local DELAY=$2
 750         local COUNT=0
 751
 752         udev_trigger
 753         while [ ! -e ${DEVICE} ]; do
 754                 if [ ${COUNT} -gt ${DELAY} ]; then
 755                         return 1
 756                 fi
 757
 758                 let COUNT=${COUNT}+1
 759                 sleep 1
 760         done
 761
 762         return 0
 763 }
 764
 765 stack_clear() {
 766         local STACK_MAX_SIZE=/sys/kernel/debug/tracing/stack_max_size
 767         local STACK_TRACER_ENABLED=/proc/sys/kernel/stack_tracer_enabled
 768
 769         if [ -e $STACK_MAX_SIZE ]; then
 770                 echo 1 >$STACK_TRACER_ENABLED
 771                 echo 0 >$STACK_MAX_SIZE
 772         fi
 773 }
 774
 775 stack_check() {
 776         local STACK_MAX_SIZE=/sys/kernel/debug/tracing/stack_max_size
 777         local STACK_TRACE=/sys/kernel/debug/tracing/stack_trace
 778         local STACK_LIMIT=7000
 779
 780         if [ -e $STACK_MAX_SIZE ]; then
 781                 STACK_SIZE=`cat $STACK_MAX_SIZE`
 782
 783                 if [ $STACK_SIZE -ge $STACK_LIMIT ]; then
 784                         echo
 785                         echo "Warning: max stack size $STACK_SIZE bytes"
 786                         cat $STACK_TRACE
 787                 fi
 788         fi
 789 }
 790
 791 kill_zed() {
 792         if [ -f $ZED_PIDFILE ]; then
 793                 kill $(cat $ZED_PIDFILE)
 794         fi
 795 }