lustre/tests/test-framework.sh

   1 #!/bin/bash
   2
   3 trap 'print_summary && print_stack_trace | tee $TF_FAIL && \
   4     echo "$TESTSUITE: FAIL: test-framework exiting on error"' ERR
   5 set -e
   6
   7 export LANG=en_US
   8 export REFORMAT=${REFORMAT:-""}
   9 export WRITECONF=${WRITECONF:-""}
  10 export VERBOSE=${VERBOSE:-false}
  11 export GSS=${GSS:-false}
  12 export GSS_SK=${GSS_SK:-false}
  13 export GSS_KRB5=false
  14 export GSS_PIPEFS=false
  15 export SHARED_KEY=${SHARED_KEY:-false}
  16 export SK_PATH=${SK_PATH:-/tmp/test-framework-keys}
  17 export SK_OM_PATH=$SK_PATH'/tmp-request-mount'
  18 export SK_MOUNTED=${SK_MOUNTED:-false}
  19 export SK_FLAVOR=${SK_FLAVOR:-ski}
  20 export SK_NO_KEY=${SK_NO_KEY:-true}
  21 export SK_UNIQUE_NM=${SK_UNIQUE_NM:-false}
  22 export SK_S2S=${SK_S2S:-false}
  23 export SK_S2SNM=${SK_S2SNM:-TestFrameNM}
  24 export SK_S2SNMCLI=${SK_S2SNMCLI:-TestFrameNMCli}
  25 export SK_SKIPFIRST=${SK_SKIPFIRST:-true}
  26 export IDENTITY_UPCALL=default
  27 export QUOTA_AUTO=1
  28 export FLAKEY=${FLAKEY:-true}
  29 # specify environment variable containing batch job name for server statistics
  30 export JOBID_VAR=${JOBID_VAR:-"procname_uid"}  # or "existing" or "disable"
  31
  32 #export PDSH="pdsh -S -Rssh -w"
  33 export MOUNT_CMD=${MOUNT_CMD:-"mount -t lustre"}
  34 export UMOUNT=${UMOUNT:-"umount -d"}
  35
  36 export LSNAPSHOT_CONF="/etc/ldev.conf"
  37 export LSNAPSHOT_LOG="/var/log/lsnapshot.log"
  38
  39 # sles12 umount has a issue with -d option
  40 [ -e /etc/SuSE-release ] && grep -w VERSION /etc/SuSE-release | grep -wq 12 && {
  41         export UMOUNT="umount"
  42 }
  43
  44 # function used by scripts run on remote nodes
  45 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
  46 . $LUSTRE/tests/functions.sh
  47 . $LUSTRE/tests/yaml.sh
  48
  49 export LD_LIBRARY_PATH=${LUSTRE}/utils/.libs:${LUSTRE}/utils:${LD_LIBRARY_PATH}
  50
  51 LUSTRE_TESTS_CFG_DIR=${LUSTRE_TESTS_CFG_DIR:-${LUSTRE}/tests/cfg}
  52
  53 EXCEPT_LIST_FILE=${EXCEPT_LIST_FILE:-${LUSTRE_TESTS_CFG_DIR}/tests-to-skip.sh}
  54
  55 if [ -f "$EXCEPT_LIST_FILE" ]; then
  56     echo "Reading test skip list from $EXCEPT_LIST_FILE"
  57     cat $EXCEPT_LIST_FILE
  58     . $EXCEPT_LIST_FILE
  59 fi
  60
  61 # check config files for options in decreasing order of preference
  62 [ -z "$MODPROBECONF" -a -f /etc/modprobe.d/lustre.conf ] &&
  63     MODPROBECONF=/etc/modprobe.d/lustre.conf
  64 [ -z "$MODPROBECONF" -a -f /etc/modprobe.d/Lustre ] &&
  65     MODPROBECONF=/etc/modprobe.d/Lustre
  66 [ -z "$MODPROBECONF" -a -f /etc/modprobe.conf ] &&
  67     MODPROBECONF=/etc/modprobe.conf
  68
  69 sanitize_parameters() {
  70         for i in DIR DIR1 DIR2 MOUNT MOUNT1 MOUNT2
  71         do
  72                 local path=${!i}
  73                 if [ -d "$path" ]; then
  74                         eval export $i=$(echo $path | sed -r 's/\/+$//g')
  75                 fi
  76         done
  77 }
  78 assert_DIR () {
  79         local failed=""
  80         [[ $DIR/ = $MOUNT/* ]] ||
  81                 { failed=1 && echo "DIR=$DIR not in $MOUNT. Aborting."; }
  82         [[ $DIR1/ = $MOUNT1/* ]] ||
  83                 { failed=1 && echo "DIR1=$DIR1 not in $MOUNT1. Aborting."; }
  84         [[ $DIR2/ = $MOUNT2/* ]] ||
  85                 { failed=1 && echo "DIR2=$DIR2 not in $MOUNT2. Aborting"; }
  86
  87         [ -n "$failed" ] && exit 99 || true
  88 }
  89
  90 usage() {
  91     echo "usage: $0 [-r] [-f cfgfile]"
  92     echo "       -r: reformat"
  93
  94     exit
  95 }
  96
  97 print_summary () {
  98     trap 0
  99         [ -z "$DEFAULT_SUITES"] && return 0
 100     [ -n "$ONLY" ] && echo "WARNING: ONLY is set to $(echo $ONLY)"
 101     local details
 102     local form="%-13s %-17s %-9s %s %s\n"
 103     printf "$form" "status" "script" "Total(sec)" "E(xcluded) S(low)"
 104     echo "------------------------------------------------------------------------------------"
 105     for O in $DEFAULT_SUITES; do
 106         O=$(echo $O  | tr "-" "_" | tr "[:lower:]" "[:upper:]")
 107         [ "${!O}" = "no" ] && continue || true
 108         local o=$(echo $O  | tr "[:upper:]_" "[:lower:]-")
 109         local log=${TMP}/${o}.log
 110         if is_sanity_benchmark $o; then
 111             log=${TMP}/sanity-benchmark.log
 112         fi
 113         local slow=
 114         local skipped=
 115         local total=
 116         local status=Unfinished
 117         if [ -f $log ]; then
 118                 skipped=$(grep excluded $log | awk '{ printf " %s", $3 }' |
 119                         sed 's/test_//g')
 120                 slow=$(egrep "^PASS|^FAIL" $log | tr -d "("| sed s/s\)$//g |
 121                         sort -nr -k 3  | head -n5 |  awk '{ print $2":"$3"s" }')
 122                 total=$(grep duration $log | awk '{ print $2 }')
 123                 if [ "${!O}" = "done" ]; then
 124                         status=Done
 125                 fi
 126                 if $DDETAILS; then
 127                         local durations=$(egrep "^PASS|^FAIL" $log |
 128                                 tr -d "("| sed s/s\)$//g |
 129                                 awk '{ print $2":"$3"|" }')
 130                         details=$(printf "%s\n%s %s %s\n" "$details" \
 131                                 "DDETAILS" "$O" "$(echo $durations)")
 132                 fi
 133         fi
 134         printf "$form" $status "$O" "${total}" "E=$skipped"
 135         printf "$form" "-" "-" "-" "S=$(echo $slow)"
 136     done
 137
 138     for O in $DEFAULT_SUITES; do
 139         O=$(echo $O  | tr "-" "_" | tr "[:lower:]" "[:upper:]")
 140         if [ "${!O}" = "no" ]; then
 141             printf "$form" "Skipped" "$O" ""
 142         fi
 143     done
 144
 145     # print the detailed tests durations if DDETAILS=true
 146     if $DDETAILS; then
 147         echo "$details"
 148     fi
 149 }
 150
 151 # Get information about the Lustre environment. The information collected
 152 # will be used in Lustre tests.
 153 # usage: get_lustre_env
 154 # input: No required or optional arguments
 155 # output: No return values, environment variables are exported
 156
 157 get_lustre_env() {
 158
 159         export mds1_FSTYPE=${mds1_FSTYPE:-$(facet_fstype mds1)}
 160         export ost1_FSTYPE=${ost1_FSTYPE:-$(facet_fstype ost1)}
 161
 162         export MGS_VERSION=$(lustre_version_code mgs)
 163         export MDS1_VERSION=$(lustre_version_code mds1)
 164         export OST1_VERSION=$(lustre_version_code ost1)
 165         export CLIENT_VERSION=$(lustre_version_code client)
 166 }
 167
 168 init_test_env() {
 169         export LUSTRE=$(absolute_path $LUSTRE)
 170         export TESTSUITE=$(basename $0 .sh)
 171         export TEST_FAILED=false
 172         export FAIL_ON_SKIP_ENV=${FAIL_ON_SKIP_ENV:-false}
 173         export RPC_MODE=${RPC_MODE:-false}
 174         export DO_CLEANUP=${DO_CLEANUP:-true}
 175         export KEEP_ZPOOL=${KEEP_ZPOOL:-false}
 176         export CLEANUP_DM_DEV=false
 177         export PAGE_SIZE=$(get_page_size client)
 178
 179         export MKE2FS=$MKE2FS
 180         if [ -z "$MKE2FS" ]; then
 181                 if which mkfs.ldiskfs >/dev/null 2>&1; then
 182                         export MKE2FS=mkfs.ldiskfs
 183                 else
 184                         export MKE2FS=mke2fs
 185                 fi
 186         fi
 187
 188         export DEBUGFS=$DEBUGFS
 189         if [ -z "$DEBUGFS" ]; then
 190                 if which debugfs.ldiskfs >/dev/null 2>&1; then
 191                         export DEBUGFS=debugfs.ldiskfs
 192                 else
 193                         export DEBUGFS=debugfs
 194                 fi
 195         fi
 196
 197         export TUNE2FS=$TUNE2FS
 198         if [ -z "$TUNE2FS" ]; then
 199                 if which tunefs.ldiskfs >/dev/null 2>&1; then
 200                         export TUNE2FS=tunefs.ldiskfs
 201                 else
 202                         export TUNE2FS=tune2fs
 203                 fi
 204         fi
 205
 206         export E2LABEL=$E2LABEL
 207         if [ -z "$E2LABEL" ]; then
 208                 if which label.ldiskfs >/dev/null 2>&1; then
 209                         export E2LABEL=label.ldiskfs
 210                 else
 211                         export E2LABEL=e2label
 212                 fi
 213         fi
 214
 215         export DUMPE2FS=$DUMPE2FS
 216         if [ -z "$DUMPE2FS" ]; then
 217                 if which dumpfs.ldiskfs >/dev/null 2>&1; then
 218                         export DUMPE2FS=dumpfs.ldiskfs
 219                 else
 220                         export DUMPE2FS=dumpe2fs
 221                 fi
 222         fi
 223
 224         export E2FSCK=$E2FSCK
 225         if [ -z "$E2FSCK" ]; then
 226                 if which fsck.ldiskfs >/dev/null 2>&1; then
 227                         export E2FSCK=fsck.ldiskfs
 228                 else
 229                          export E2FSCK=e2fsck
 230                 fi
 231         fi
 232
 233         export RESIZE2FS=$RESIZE2FS
 234         if [ -z "$RESIZE2FS" ]; then
 235                 if which resizefs.ldiskfs >/dev/null 2>&1; then
 236                         export RESIZE2FS=resizefs.ldiskfs
 237                 else
 238                         export RESIZE2FS=resize2fs
 239                 fi
 240         fi
 241
 242         export LFSCK_ALWAYS=${LFSCK_ALWAYS:-"no"} # check fs after test suite
 243         export FSCK_MAX_ERR=4   # File system errors left uncorrected
 244
 245         export ZFS=${ZFS:-zfs}
 246         export ZPOOL=${ZPOOL:-zpool}
 247         export ZDB=${ZDB:-zdb}
 248         export PARTPROBE=${PARTPROBE:-partprobe}
 249
 250         #[ -d /r ] && export ROOT=${ROOT:-/r}
 251         export TMP=${TMP:-$ROOT/tmp}
 252         export TESTSUITELOG=${TMP}/${TESTSUITE}.log
 253         export LOGDIR=${LOGDIR:-${TMP}/test_logs/$(date +%s)}
 254         export TESTLOG_PREFIX=$LOGDIR/$TESTSUITE
 255
 256         export HOSTNAME=${HOSTNAME:-$(hostname -s)}
 257         if ! echo $PATH | grep -q $LUSTRE/utils; then
 258                 export PATH=$LUSTRE/utils:$PATH
 259         fi
 260         if ! echo $PATH | grep -q $LUSTRE/utils/gss; then
 261                 export PATH=$LUSTRE/utils/gss:$PATH
 262         fi
 263         if ! echo $PATH | grep -q $LUSTRE/tests; then
 264                 export PATH=$LUSTRE/tests:$PATH
 265         fi
 266         if ! echo $PATH | grep -q $LUSTRE/../lustre-iokit/sgpdd-survey; then
 267                 export PATH=$LUSTRE/../lustre-iokit/sgpdd-survey:$PATH
 268         fi
 269         export LST=${LST:-"$LUSTRE/../lnet/utils/lst"}
 270         [ ! -f "$LST" ] && export LST=$(which lst)
 271         export SGPDDSURVEY=${SGPDDSURVEY:-"$LUSTRE/../lustre-iokit/sgpdd-survey/sgpdd-survey")}
 272         [ ! -f "$SGPDDSURVEY" ] && export SGPDDSURVEY=$(which sgpdd-survey)
 273         export MCREATE=${MCREATE:-mcreate}
 274         export MULTIOP=${MULTIOP:-multiop}
 275         # Ubuntu, at least, has a truncate command in /usr/bin
 276         # so fully path our truncate command.
 277         export TRUNCATE=${TRUNCATE:-$LUSTRE/tests/truncate}
 278         export FSX=${FSX:-$LUSTRE/tests/fsx}
 279         export MDSRATE=${MDSRATE:-"$LUSTRE/tests/mpi/mdsrate"}
 280         [ ! -f "$MDSRATE" ] && export MDSRATE=$(which mdsrate 2> /dev/null)
 281         if ! echo $PATH | grep -q $LUSTRE/tests/racer; then
 282                 export PATH=$LUSTRE/tests/racer:$PATH:
 283         fi
 284         if ! echo $PATH | grep -q $LUSTRE/tests/mpi; then
 285                 export PATH=$LUSTRE/tests/mpi:$PATH
 286         fi
 287         export RSYNC_RSH=${RSYNC_RSH:-rsh}
 288
 289         export LCTL=${LCTL:-"$LUSTRE/utils/lctl"}
 290         [ ! -f "$LCTL" ] && export LCTL=$(which lctl)
 291         export LFS=${LFS:-"$LUSTRE/utils/lfs"}
 292         [ ! -f "$LFS" ] && export LFS=$(which lfs)
 293         SETSTRIPE=${SETSTRIPE:-"$LFS setstripe"}
 294         GETSTRIPE=${GETSTRIPE:-"$LFS getstripe"}
 295
 296         export PERM_CMD=${PERM_CMD:-"$LCTL conf_param"}
 297
 298         export L_GETIDENTITY=${L_GETIDENTITY:-"$LUSTRE/utils/l_getidentity"}
 299         if [ ! -f "$L_GETIDENTITY" ]; then
 300                 if `which l_getidentity > /dev/null 2>&1`; then
 301                         export L_GETIDENTITY=$(which l_getidentity)
 302                 else
 303                         export L_GETIDENTITY=NONE
 304                 fi
 305         fi
 306         export LL_DECODE_FILTER_FID=${LL_DECODE_FILTER_FID:-"$LUSTRE/utils/ll_decode_filter_fid"}
 307         [ ! -f "$LL_DECODE_FILTER_FID" ] && export LL_DECODE_FILTER_FID="ll_decode_filter_fid"
 308         export LL_DECODE_LINKEA=${LL_DECODE_LINKEA:-"$LUSTRE/utils/ll_decode_linkea"}
 309         [ ! -f "$LL_DECODE_LINKEA" ] && export LL_DECODE_LINKEA="ll_decode_linkea"
 310         export MKFS=${MKFS:-"$LUSTRE/utils/mkfs.lustre"}
 311         [ ! -f "$MKFS" ] && export MKFS="mkfs.lustre"
 312         export TUNEFS=${TUNEFS:-"$LUSTRE/utils/tunefs.lustre"}
 313         [ ! -f "$TUNEFS" ] && export TUNEFS="tunefs.lustre"
 314         export CHECKSTAT="${CHECKSTAT:-"checkstat -v"} "
 315         export LUSTRE_RMMOD=${LUSTRE_RMMOD:-$LUSTRE/scripts/lustre_rmmod}
 316         [ ! -f "$LUSTRE_RMMOD" ] &&
 317                 export LUSTRE_RMMOD=$(which lustre_rmmod 2> /dev/null)
 318         export LUSTRE_ROUTES_CONVERSION=${LUSTRE_ROUTES_CONVERSION:-$LUSTRE/scripts/lustre_routes_conversion}
 319         [ ! -f "$LUSTRE_ROUTES_CONVERSION" ] &&
 320                 export LUSTRE_ROUTES_CONVERSION=$(which lustre_routes_conversion 2> /dev/null)
 321         export LFS_MIGRATE=${LFS_MIGRATE:-$LUSTRE/scripts/lfs_migrate}
 322         [ ! -f "$LFS_MIGRATE" ] &&
 323                 export LFS_MIGRATE=$(which lfs_migrate 2> /dev/null)
 324         export LR_READER=${LR_READER:-"$LUSTRE/utils/lr_reader"}
 325         [ ! -f "$LR_READER" ] &&
 326                 export LR_READER=$(which lr_reader 2> /dev/null)
 327         [ -z "$LR_READER" ] && export LR_READER="/usr/sbin/lr_reader"
 328         export LSOM_SYNC=${LSOM_SYNC:-"$LUSTRE/utils/llsom_sync"}
 329         [ ! -f "$LSOM_SYNC" ] &&
 330                 export LSOM_SYNC=$(which llsom_sync 2> /dev/null)
 331         [ -z "$LSOM_SYNC" ] && export LSOM_SYNC="/usr/sbin/llsom_sync"
 332         export NAME=${NAME:-local}
 333         export LGSSD=${LGSSD:-"$LUSTRE/utils/gss/lgssd"}
 334         [ "$GSS_PIPEFS" = "true" ] && [ ! -f "$LGSSD" ] &&
 335                 export LGSSD=$(which lgssd)
 336         export LSVCGSSD=${LSVCGSSD:-"$LUSTRE/utils/gss/lsvcgssd"}
 337         [ ! -f "$LSVCGSSD" ] && export LSVCGSSD=$(which lsvcgssd 2> /dev/null)
 338         export KRB5DIR=${KRB5DIR:-"/usr/kerberos"}
 339         export DIR2
 340         export SAVE_PWD=${SAVE_PWD:-$LUSTRE/tests}
 341         export AT_MAX_PATH
 342         export LDEV=${LDEV:-"$LUSTRE/scripts/ldev"}
 343         [ ! -f "$LDEV" ] && export LDEV=$(which ldev 2> /dev/null)
 344
 345         export DMSETUP=${DMSETUP:-dmsetup}
 346         export DM_DEV_PATH=${DM_DEV_PATH:-/dev/mapper}
 347         export LOSETUP=${LOSETUP:-losetup}
 348
 349         if [ "$ACCEPTOR_PORT" ]; then
 350                 export PORT_OPT="--port $ACCEPTOR_PORT"
 351         fi
 352
 353         if $SHARED_KEY; then
 354                 $RPC_MODE || echo "Using GSS shared-key feature"
 355                 which lgss_sk > /dev/null 2>&1 ||
 356                         error_exit "built with lgss_sk disabled! SEC=$SEC"
 357                 GSS=true
 358                 GSS_SK=true
 359                 SEC=$SK_FLAVOR
 360         fi
 361
 362         case "x$SEC" in
 363                 xkrb5*)
 364                 $RPC_MODE || echo "Using GSS/krb5 ptlrpc security flavor"
 365                 which lgss_keyring > /dev/null 2>&1 ||
 366                         error_exit "built with gss disabled! SEC=$SEC"
 367                 GSS=true
 368                 GSS_KRB5=true
 369                 ;;
 370         esac
 371
 372         case "x$IDUP" in
 373                 xtrue)
 374                         IDENTITY_UPCALL=true
 375                         ;;
 376                 xfalse)
 377                         IDENTITY_UPCALL=false
 378                         ;;
 379         esac
 380
 381         export LOAD_MODULES_REMOTE=${LOAD_MODULES_REMOTE:-false}
 382
 383         # Paths on remote nodes, if different
 384         export RLUSTRE=${RLUSTRE:-$LUSTRE}
 385         export RPWD=${RPWD:-$PWD}
 386         export I_MOUNTED=${I_MOUNTED:-"no"}
 387         export AUSTER_CLEANUP=${AUSTER_CLEANUP:-false}
 388         if [ ! -f /lib/modules/$(uname -r)/kernel/fs/lustre/mdt.ko -a \
 389              ! -f /lib/modules/$(uname -r)/updates/kernel/fs/lustre/mdt.ko -a \
 390              ! -f /lib/modules/$(uname -r)/extra/kernel/fs/lustre/mdt.ko -a \
 391              ! -f $LUSTRE/mdt/mdt.ko ]; then
 392             export CLIENTMODSONLY=yes
 393         fi
 394
 395         export SHUTDOWN_ATTEMPTS=${SHUTDOWN_ATTEMPTS:-3}
 396         export OSD_TRACK_DECLARES_LBUG=${OSD_TRACK_DECLARES_LBUG:-"yes"}
 397
 398         # command line
 399
 400         while getopts "rvwf:" opt $*; do
 401                 case $opt in
 402                         f) CONFIG=$OPTARG;;
 403                         r) REFORMAT=yes;;
 404                         v) VERBOSE=true;;
 405                         w) WRITECONF=writeconf;;
 406                         \?) usage;;
 407                 esac
 408         done
 409
 410         shift $((OPTIND - 1))
 411         ONLY=${ONLY:-$*}
 412
 413         # print the durations of each test if "true"
 414         DDETAILS=${DDETAILS:-false}
 415         [ "$TESTSUITELOG" ] && rm -f $TESTSUITELOG || true
 416         if ! $RPC_MODE; then
 417                 rm -f $TMP/*active
 418         fi
 419
 420         export TF_FAIL=${TF_FAIL:-$TMP/tf.fail}
 421
 422         # Constants used in more than one test script
 423         export LOV_MAX_STRIPE_COUNT=2000
 424 }
 425
 426 check_cpt_number() {
 427         local facet=$1
 428         local ncpts
 429
 430         ncpts=$(do_facet $facet "lctl get_param -n " \
 431                 "cpu_partition_table 2>/dev/null| wc -l" || echo 1)
 432
 433         if [ $ncpts -eq 0 ]; then
 434                 echo "1"
 435         else
 436                 echo $ncpts
 437         fi
 438 }
 439
 440 # Return a numeric version code based on a version string.  The version
 441 # code is useful for comparison two version strings to see which is newer.
 442 version_code() {
 443         # split arguments like "1.8.6-wc3" into "1", "8", "6", "wc3"
 444         eval set -- $(tr "[:punct:]" " " <<< $*)
 445
 446         echo -n "$((($1 << 16) | ($2 << 8) | $3))"
 447 }
 448
 449 export LINUX_VERSION=$(uname -r | sed -e "s/\([0-9]*\.[0-9]*\.[0-9]*\).*/\1/")
 450 export LINUX_VERSION_CODE=$(version_code ${LINUX_VERSION//\./ })
 451
 452 # Report the Lustre build version string (e.g. 1.8.7.3 or 2.4.1).
 453 #
 454 # usage: lustre_build_version
 455 #
 456 # All Lustre versions support "lctl get_param" to report the version of the
 457 # code running in the kernel (what our tests are interested in), but it
 458 # doesn't work without modules loaded.  After 2.9.53 and in upstream kernels
 459 # the "version" parameter doesn't include "lustre: " at the beginning.
 460 # If that fails, call "lctl lustre_build_version" which prints either (or both)
 461 # the userspace and kernel build versions, but until 2.8.55 required root
 462 # access to get the Lustre kernel version.  If that also fails, fall back to
 463 # using "lctl --version", which is easy to parse and works without the kernel
 464 # modules, but was only added in 2.6.50 and only prints the lctl tool version,
 465 # not the module version, though they are usually the same.
 466 #
 467 # Various commands and their output format for different Lustre versions:
 468 # lctl get_param version:       2.9.55
 469 # lctl get_param version:       lustre: 2.8.53
 470 # lctl get_param version:       lustre: 2.6.52
 471 #                               kernel: patchless_client
 472 #                               build: v2_6_92_0-2.6.32-431.el6_lustre.x86_64
 473 # lctl lustre_build_version:    Lustre version: 2.8.53_27_gae67fc01
 474 # lctl lustre_build_version:    error: lustre_build_version: Permission denied
 475 #       (as non-root user)      lctl   version: v2_6_92_0-2.6.32-431.el6.x86_64
 476 # lctl lustre_build_version:    Lustre version: 2.5.3-2.6.32.26-175.fc12.x86_64
 477 #                               lctl   version: 2.5.3-2.6.32..26-175fc12.x86_64
 478 # lctl --version:               lctl 2.6.50
 479 #
 480 # output: prints version string to stdout in (up to 4) dotted-decimal values
 481 lustre_build_version() {
 482         local facet=${1:-client}
 483         local ver=$(do_facet $facet "$LCTL get_param -n version 2>/dev/null ||
 484                                 $LCTL lustre_build_version 2>/dev/null ||
 485                                 $LCTL --version 2>/dev/null | cut -d' ' -f2")
 486         local lver=$(egrep -i "lustre: |version: " <<<"$ver" | head -n 1)
 487         [ -n "$lver" ] && ver="$lver"
 488
 489         sed -e 's/[^:]*: //' -e 's/^v//' -e 's/[ -].*//' -e 's/_/./g' <<<$ver |
 490                 cut -d. -f1-4
 491 }
 492
 493 # Report the Lustre numeric build version code for the supplied facet.
 494 lustre_version_code() {
 495         version_code $(lustre_build_version $1)
 496 }
 497
 498 module_loaded () {
 499         /sbin/lsmod | grep -q "^\<$1\>"
 500 }
 501
 502 PRLFS=false
 503 lustre_insmod() {
 504         local module=$1
 505         shift
 506         local args="$@"
 507         local msg
 508         local rc=0
 509
 510         if ! $PRLFS; then
 511                 msg="$(insmod $module $args 2>&1)" && return 0 || rc=$?
 512         fi
 513
 514         # parallels can't load modules directly from prlfs, use /tmp instead
 515         if $PRLFS || [[ "$(stat -f -c%t $module)" == "7c7c6673" ]]; then
 516                 local target="$(mktemp)"
 517
 518                 cp "$module" "$target"
 519                 insmod $target $args
 520                 rc=$?
 521                 [[ $rc == 0 ]] && PRLFS=true
 522                 rm -f $target
 523         else
 524                 echo "$msg"
 525         fi
 526         return $rc
 527 }
 528
 529 # Load a module on the system where this is running.
 530 #
 531 # usage: load_module module_name [module arguments for insmod/modprobe]
 532 #
 533 # If module arguments are not given but MODOPTS_<MODULE> is set, then its value
 534 # will be used as the arguments.  Otherwise arguments will be obtained from
 535 # /etc/modprobe.conf, from /etc/modprobe.d/Lustre, or else none will be used.
 536 #
 537 load_module() {
 538         local module=$1 # '../libcfs/libcfs/libcfs', 'obdclass/obdclass', ...
 539         shift
 540         local ext=".ko"
 541         local base=$(basename $module $ext)
 542         local path
 543         local -A module_is_loaded_aa
 544         local optvar
 545         local mod
 546
 547         for mod in $(lsmod | awk '{ print $1; }'); do
 548                 module_is_loaded_aa[${mod//-/_}]=true
 549         done
 550
 551         module_is_loaded() {
 552                 ${module_is_loaded_aa[${1//-/_}]:-false}
 553         }
 554
 555         if module_is_loaded $base; then
 556                 return
 557         fi
 558
 559         if [[ -f $LUSTRE/$module$ext ]]; then
 560                 path=$LUSTRE/$module$ext
 561         elif [[ "$base" == lnet_selftest ]] &&
 562              [[ -f $LUSTRE/../lnet/selftest/$base$ext ]]; then
 563                 path=$LUSTRE/../lnet/selftest/$base$ext
 564         else
 565                 path=''
 566         fi
 567
 568         if [[ -n "$path" ]]; then
 569                 # Try to load any non-Lustre modules that $module depends on.
 570                 for mod in $(modinfo --field=depends $path | tr ',' ' '); do
 571                         if ! module_is_loaded $mod; then
 572                                 modprobe $mod
 573                         fi
 574                 done
 575         fi
 576
 577         # If no module arguments were passed then get them from
 578         # $MODOPTS_<MODULE>, otherwise from modprobe.conf.
 579         if [ $# -eq 0 ]; then
 580                 # $MODOPTS_<MODULE>; we could use associative arrays, but that's
 581                 # not in Bash until 4.x, so we resort to eval.
 582                 optvar="MODOPTS_$(basename $module | tr a-z A-Z)"
 583                 eval set -- \$$optvar
 584                 if [ $# -eq 0 -a -n "$MODPROBECONF" ]; then
 585                         # Nothing in $MODOPTS_<MODULE>; try modprobe.conf
 586                         local opt
 587                         opt=$(awk -v var="^options $base" '$0 ~ var \
 588                               {gsub("'"options $base"'",""); print}' \
 589                                 $MODPROBECONF)
 590                         set -- $(echo -n $opt)
 591
 592                         # Ensure we have accept=all for lnet
 593                         if [[ "$base" == lnet ]]; then
 594                                 # OK, this is a bit wordy...
 595                                 local arg accept_all_present=false
 596
 597                                 for arg in "$@"; do
 598                                         [[ "$arg" == accept=all ]] &&
 599                                                 accept_all_present=true
 600                                 done
 601
 602                                 $accept_all_present || set -- "$@" accept=all
 603                         fi
 604
 605                         export $optvar="$*"
 606                 fi
 607         fi
 608
 609         [ $# -gt 0 ] && echo "${module} options: '$*'"
 610
 611         # Note that insmod will ignore anything in modprobe.conf, which is why
 612         # we're passing options on the command-line. If $path does not exist
 613         # then we must be testing a "make install" or"rpm" installation. Also
 614         # note that failing to load ptlrpc_gss is not considered fatal.
 615         if [[ -n "$path" ]]; then
 616                 lustre_insmod $path "$@"
 617         elif [[ "$base" == ptlrpc_gss ]]; then
 618                 if ! modprobe $base "$@" 2>/dev/null; then
 619                         echo "gss/krb5 is not supported"
 620                 fi
 621         else
 622                 modprobe $base "$@"
 623         fi
 624 }
 625
 626 load_modules_local() {
 627         if [ -n "$MODPROBE" ]; then
 628                 # use modprobe
 629                 echo "Using modprobe to load modules"
 630                 return 0
 631         fi
 632
 633         # Create special udev test rules on every node
 634         if [ -f $LUSTRE/lustre/conf/99-lustre.rules ]; then {
 635                 sed -e 's|/usr/sbin/lctl|$LCTL|g' $LUSTRE/lustre/conf/99-lustre.rules > /etc/udev/rules.d/99-lustre-test.rules
 636         } else {
 637                 echo "SUBSYSTEM==\"lustre\", ACTION==\"change\", ENV{PARAM}==\"?*\", RUN+=\"$LCTL set_param '\$env{PARAM}=\$env{SETTING}'\"" > /etc/udev/rules.d/99-lustre-test.rules
 638         } fi
 639         udevadm control --reload-rules
 640         udevadm trigger
 641
 642         # For kmemleak-enabled kernels we need clear all past state
 643         # that obviously has nothing to do with this Lustre run
 644         # Disable automatic memory scanning to avoid perf hit.
 645         if [ -f /sys/kernel/debug/kmemleak ] ; then
 646                 echo scan=off > /sys/kernel/debug/kmemleak
 647                 echo scan > /sys/kernel/debug/kmemleak
 648                 echo clear > /sys/kernel/debug/kmemleak
 649         fi
 650
 651         echo Loading modules from $LUSTRE
 652
 653         local ncpus
 654
 655         if [ -f /sys/devices/system/cpu/online ]; then
 656                 ncpus=$(($(cut -d "-" -f 2 /sys/devices/system/cpu/online) + 1))
 657                 echo "detected $ncpus online CPUs by sysfs"
 658         else
 659                 ncpus=$(getconf _NPROCESSORS_CONF 2>/dev/null)
 660                 local rc=$?
 661                 if [ $rc -eq 0 ]; then
 662                         echo "detected $ncpus online CPUs by getconf"
 663                 else
 664                         echo "Can't detect number of CPUs"
 665                         ncpus=1
 666                 fi
 667         fi
 668
 669         # if there is only one CPU core, libcfs can only create one partition
 670         # if there is more than 4 CPU cores, libcfs should create multiple CPU
 671         # partitions. So we just force libcfs to create 2 partitions for
 672         # system with 2 or 4 cores
 673         if [ $ncpus -le 4 ] && [ $ncpus -gt 1 ]; then
 674                 # force to enable multiple CPU partitions
 675                 echo "Force libcfs to create 2 CPU partitions"
 676                 MODOPTS_LIBCFS="cpu_npartitions=2 $MODOPTS_LIBCFS"
 677         else
 678                 echo "libcfs will create CPU partition based on online CPUs"
 679         fi
 680
 681         load_module ../libcfs/libcfs/libcfs
 682         # Prevent local MODOPTS_LIBCFS being passed as part of environment
 683         # variable to remote nodes
 684         unset MODOPTS_LIBCFS
 685
 686         set_default_debug
 687         load_module ../lnet/lnet/lnet
 688
 689         LNDPATH=${LNDPATH:-"../lnet/klnds"}
 690         if [ -z "$LNETLND" ]; then
 691                 case $NETTYPE in
 692                 o2ib*)  LNETLND="o2iblnd/ko2iblnd" ;;
 693                 tcp*)   LNETLND="socklnd/ksocklnd" ;;
 694                 *)      local lnd="${NETTYPE%%[0-9]}lnd"
 695                         [ -f "$LNDPATH/$lnd/k$lnd.ko" ] &&
 696                                 LNETLND="$lnd/k$lnd" ||
 697                                 LNETLND="socklnd/ksocklnd"
 698                 esac
 699         fi
 700         load_module ../lnet/klnds/$LNETLND
 701         load_module obdclass/obdclass
 702         load_module ptlrpc/ptlrpc
 703         load_module ptlrpc/gss/ptlrpc_gss
 704         load_module fld/fld
 705         load_module fid/fid
 706         load_module lmv/lmv
 707         load_module osc/osc
 708         load_module mdc/mdc
 709         load_module lov/lov
 710         load_module mgc/mgc
 711         load_module obdecho/obdecho
 712         if ! client_only; then
 713                 load_module lfsck/lfsck
 714                 [ "$LQUOTA" != "no" ] &&
 715                         load_module quota/lquota $LQUOTAOPTS
 716                 if [[ $(node_fstypes $HOSTNAME) == *zfs* ]]; then
 717                         load_module osd-zfs/osd_zfs
 718                 elif [[ $(node_fstypes $HOSTNAME) == *ldiskfs* ]]; then
 719                         load_module ../ldiskfs/ldiskfs
 720                         load_module osd-ldiskfs/osd_ldiskfs
 721                 fi
 722                 load_module mgs/mgs
 723                 load_module mdd/mdd
 724                 load_module mdt/mdt
 725                 load_module ost/ost
 726                 load_module lod/lod
 727                 load_module osp/osp
 728                 load_module ofd/ofd
 729                 load_module osp/osp
 730         fi
 731
 732         load_module llite/lustre
 733         [ -d /r ] && OGDB=${OGDB:-"/r/tmp"}
 734         OGDB=${OGDB:-$TMP}
 735         rm -f $OGDB/ogdb-$HOSTNAME
 736         $LCTL modules > $OGDB/ogdb-$HOSTNAME
 737
 738         # 'mount' doesn't look in $PATH, just sbin
 739         local mount_lustre=$LUSTRE/utils/mount.lustre
 740         if [ -f $mount_lustre ]; then
 741                 local sbin_mount=$(readlink -f /sbin)/mount.lustre
 742                 if grep -qw "$sbin_mount" /proc/mounts; then
 743                         cmp -s $mount_lustre $sbin_mount || umount $sbin_mount
 744                 fi
 745                 if ! grep -qw "$sbin_mount" /proc/mounts; then
 746                         [ ! -f "$sbin_mount" ] && touch "$sbin_mount"
 747                         if [ ! -s "$sbin_mount" -a -w "$sbin_mount" ]; then
 748                                 cat <<- EOF > "$sbin_mount"
 749                                 #!/bin/sh
 750                                 #STUB MARK
 751                                 echo "This $sbin_mount just a mountpoint." 1>&2
 752                                 echo "It is never supposed to be run." 1>&2
 753                                 logger -p emerg -- "using stub $sbin_mount $@"
 754                                 exit 1
 755                                 EOF
 756                                 chmod a+x $sbin_mount
 757                         fi
 758                         mount --bind $mount_lustre $sbin_mount ||
 759                                 error "can't bind $mount_lustre to $sbin_mount"
 760                 fi
 761         fi
 762 }
 763
 764 load_modules () {
 765         load_modules_local
 766         # bug 19124
 767         # load modules on remote nodes optionally
 768         # lustre-tests have to be installed on these nodes
 769         if $LOAD_MODULES_REMOTE; then
 770                 local list=$(comma_list $(remote_nodes_list))
 771                 if [ -n "$list" ]; then
 772                         echo "loading modules on: '$list'"
 773                         do_rpc_nodes "$list" load_modules_local
 774                 fi
 775         fi
 776 }
 777
 778 check_mem_leak () {
 779     LEAK_LUSTRE=$(dmesg | tail -n 30 | grep "obd_memory.*leaked" || true)
 780     LEAK_PORTALS=$(dmesg | tail -n 20 | grep "Portals memory leaked" || true)
 781     if [ "$LEAK_LUSTRE" -o "$LEAK_PORTALS" ]; then
 782         echo "$LEAK_LUSTRE" 1>&2
 783         echo "$LEAK_PORTALS" 1>&2
 784         mv $TMP/debug $TMP/debug-leak.`date +%s` || true
 785         echo "Memory leaks detected"
 786         [ -n "$IGNORE_LEAK" ] && { echo "ignoring leaks" && return 0; } || true
 787         return 1
 788     fi
 789 }
 790
 791 unload_modules() {
 792         wait_exit_ST client # bug 12845
 793
 794         $LUSTRE_RMMOD ldiskfs || return 2
 795
 796         [ -f /etc/udev/rules.d/99-lustre-test.rules ] &&
 797                 rm /etc/udev/rules.d/99-lustre-test.rules
 798         udevadm control --reload-rules
 799         udevadm trigger
 800
 801         if $LOAD_MODULES_REMOTE; then
 802                 local list=$(comma_list $(remote_nodes_list))
 803                 if [ -n "$list" ]; then
 804                         echo "unloading modules on: '$list'"
 805                         do_rpc_nodes "$list" $LUSTRE_RMMOD ldiskfs
 806                         do_rpc_nodes "$list" check_mem_leak
 807                         do_rpc_nodes "$list" "rm /etc/udev/rules.d/99-lustre-test.rules"
 808                         do_rpc_nodes "$list" "udevadm control --reload-rules"
 809                         do_rpc_nodes "$list" "udevadm trigger"
 810                 fi
 811         fi
 812
 813         local sbin_mount=$(readlink -f /sbin)/mount.lustre
 814         if grep -qe "$sbin_mount " /proc/mounts; then
 815                 umount $sbin_mount || true
 816                 [ -s $sbin_mount ] && ! grep -q "STUB MARK" $sbin_mount ||
 817                         rm -f $sbin_mount
 818         fi
 819
 820         check_mem_leak || return 254
 821
 822         echo "modules unloaded."
 823         return 0
 824 }
 825
 826 fs_log_size() {
 827         local facet=${1:-$SINGLEMDS}
 828         local size=0
 829
 830         case $(facet_fstype $facet) in
 831                 ldiskfs) size=50;; # largest seen is 44, leave some headroom
 832                 # grant_block_size is in bytes, allow at least 2x max blocksize
 833                 zfs)     size=$(lctl get_param osc.$FSNAME*.import |
 834                                 awk '/grant_block_size:/ {print $2/512; exit;}')
 835                           ;;
 836         esac
 837
 838         echo -n $((size * MDSCOUNT))
 839 }
 840
 841 fs_inode_ksize() {
 842         local facet=${1:-$SINGLEMDS}
 843         local fstype=$(facet_fstype $facet)
 844         local size=0
 845         case $fstype in
 846                 ldiskfs) size=4;;  # ~4KB per inode
 847                 zfs)     size=11;; # 10 to 11KB per inode
 848         esac
 849
 850         echo -n $size
 851 }
 852
 853 check_gss_daemon_nodes() {
 854     local list=$1
 855     dname=$2
 856
 857     do_nodesv $list "num=\\\$(ps -o cmd -C $dname | grep $dname | wc -l);
 858 if [ \\\"\\\$num\\\" -ne 1 ]; then
 859     echo \\\$num instance of $dname;
 860     exit 1;
 861 fi; "
 862 }
 863
 864 check_gss_daemon_facet() {
 865     facet=$1
 866     dname=$2
 867
 868     num=`do_facet $facet ps -o cmd -C $dname | grep $dname | wc -l`
 869     if [ $num -ne 1 ]; then
 870         echo "$num instance of $dname on $facet"
 871         return 1
 872     fi
 873     return 0
 874 }
 875
 876 send_sigint() {
 877     local list=$1
 878     shift
 879     echo Stopping $@ on $list
 880     do_nodes $list "killall -2 $@ 2>/dev/null || true"
 881 }
 882
 883 # start gss daemons on all nodes, or "daemon" on "nodes" if set
 884 start_gss_daemons() {
 885         local nodes=$1
 886         local daemon=$2
 887
 888         if [ "$nodes" ] && [ "$daemon" ] ; then
 889                 echo "Starting gss daemon on nodes: $nodes"
 890                 do_nodes $nodes "$daemon" || return 8
 891                 return 0
 892         fi
 893
 894         nodes=$(comma_list $(mdts_nodes))
 895         echo "Starting gss daemon on mds: $nodes"
 896         if $GSS_SK; then
 897                 # Start all versions, in case of switching
 898                 do_nodes $nodes "$LSVCGSSD -vvv -s -m -o -z" || return 1
 899         else
 900                 do_nodes $nodes "$LSVCGSSD -v" || return 1
 901         fi
 902         if $GSS_PIPEFS; then
 903                 do_nodes $nodes "$LGSSD -v" || return 2
 904         fi
 905
 906         nodes=$(comma_list $(osts_nodes))
 907         echo "Starting gss daemon on ost: $nodes"
 908         if $GSS_SK; then
 909                 # Start all versions, in case of switching
 910                 do_nodes $nodes "$LSVCGSSD -vvv -s -m -o -z" || return 3
 911         else
 912                 do_nodes $nodes "$LSVCGSSD -v" || return 3
 913         fi
 914         # starting on clients
 915
 916         local clients=${CLIENTS:-$HOSTNAME}
 917         if $GSS_PIPEFS; then
 918                 echo "Starting $LGSSD on clients $clients "
 919                 do_nodes $clients  "$LGSSD -v" || return 4
 920         fi
 921
 922         # wait daemons entering "stable" status
 923         sleep 5
 924
 925         #
 926         # check daemons are running
 927         #
 928         nodes=$(comma_list $(mdts_nodes) $(osts_nodes))
 929         check_gss_daemon_nodes $nodes lsvcgssd || return 5
 930         if $GSS_PIPEFS; then
 931                 nodes=$(comma_list $(mdts_nodes))
 932                 check_gss_daemon_nodes $nodes lgssd || return 6
 933         fi
 934         if $GSS_PIPEFS; then
 935                 check_gss_daemon_nodes $clients lgssd || return 7
 936         fi
 937 }
 938
 939 stop_gss_daemons() {
 940         local nodes=$(comma_list $(mdts_nodes))
 941
 942         send_sigint $nodes lsvcgssd lgssd
 943
 944         nodes=$(comma_list $(osts_nodes))
 945         send_sigint $nodes lsvcgssd
 946
 947         nodes=${CLIENTS:-$HOSTNAME}
 948         send_sigint $nodes lgssd
 949 }
 950
 951 add_sk_mntflag() {
 952         # Add mount flags for shared key
 953         local mt_opts=$@
 954         if grep -q skpath <<< "$mt_opts" ; then
 955                 mt_opts=$(echo $mt_opts |
 956                         sed -e "s#skpath=[^ ,]*#skpath=$SK_PATH#")
 957         else
 958                 if [ -z "$mt_opts" ]; then
 959                         mt_opts="-o skpath=$SK_PATH"
 960                 else
 961                         mt_opts="$mt_opts,skpath=$SK_PATH"
 962                 fi
 963         fi
 964         echo -n $mt_opts
 965 }
 966
 967 init_gss() {
 968         if $SHARED_KEY; then
 969                 GSS=true
 970                 GSS_SK=true
 971         fi
 972
 973         if ! $GSS; then
 974                 return
 975         fi
 976
 977         case $LUSTRE in
 978         /usr/lib/lustre/* | /usr/lib64/lustre/* | /usr/lib/lustre | \
 979         /usr/lib64/lustre )
 980                 from_build_tree=false
 981                 ;;
 982         *)
 983                 from_build_tree=true
 984                 ;;
 985         esac
 986
 987         if ! module_loaded ptlrpc_gss; then
 988                 load_module ptlrpc/gss/ptlrpc_gss
 989                 module_loaded ptlrpc_gss ||
 990                         error_exit "init_gss: GSS=$GSS, but gss/krb5 missing"
 991         fi
 992
 993         if $GSS_KRB5 || $GSS_SK; then
 994                 start_gss_daemons || error_exit "start gss daemon failed! rc=$?"
 995         fi
 996
 997         if $GSS_SK && $SK_NO_KEY; then
 998                 local numclients=${1:-$CLIENTCOUNT}
 999                 local clients=${CLIENTS:-$HOSTNAME}
1000
1001                 # security ctx config for keyring
1002                 SK_NO_KEY=false
1003                 local lgssc_conf_file="/etc/request-key.d/lgssc.conf"
1004
1005                 if $from_build_tree; then
1006                         mkdir -p $SK_OM_PATH
1007                         if grep -q request-key /proc/mounts > /dev/null; then
1008                                 echo "SSK: Request key already mounted."
1009                         else
1010                                 mount -o bind $SK_OM_PATH /etc/request-key.d/
1011                         fi
1012                         local lgssc_conf_line='create lgssc * * '
1013                         lgssc_conf_line+=$(which lgss_keyring)
1014                         lgssc_conf_line+=' %o %k %t %d %c %u %g %T %P %S'
1015                         echo "$lgssc_conf_line" > $lgssc_conf_file
1016                 fi
1017
1018                 [ -e $lgssc_conf_file ] ||
1019                         error_exit "Could not find key options in $lgssc_conf_file"
1020                 echo "$lgssc_conf_file content is:"
1021                 cat $lgssc_conf_file
1022
1023                 if ! local_mode; then
1024                         if $from_build_tree; then
1025                                 do_nodes $(comma_list $(all_nodes)) "mkdir -p \
1026                                         $SK_OM_PATH"
1027                                 do_nodes $(comma_list $(all_nodes)) "mount \
1028                                         -o bind $SK_OM_PATH \
1029                                         /etc/request-key.d/"
1030                                 do_nodes $(comma_list $(all_nodes)) "rsync \
1031                                         -aqv $HOSTNAME:$lgssc_conf_file \
1032                                         $lgssc_conf_file >/dev/null 2>&1"
1033                         else
1034                                 do_nodes $(comma_list $(all_nodes)) \
1035                                         "echo $lgssc_conf_file: ; \
1036                                         cat $lgssc_conf_file"
1037                         fi
1038                 fi
1039
1040                 # create shared key on all nodes
1041                 mkdir -p $SK_PATH/nodemap
1042                 rm -f $SK_PATH/$FSNAME.key $SK_PATH/nodemap/c*.key \
1043                         $SK_PATH/$FSNAME-*.key
1044                 # for nodemap testing each client may need own key,
1045                 # and S2S now requires keys as well, both for "client"
1046                 # and for "server"
1047                 if $SK_S2S; then
1048                         lgss_sk -t server -f$FSNAME -n $SK_S2SNMCLI \
1049                                 -w $SK_PATH/$FSNAME-nmclient.key \
1050                                 -d /dev/urandom >/dev/null 2>&1
1051                         lgss_sk -t mgs,server -f$FSNAME -n $SK_S2SNM \
1052                                 -w $SK_PATH/$FSNAME-s2s-server.key \
1053                                 -d /dev/urandom >/dev/null 2>&1
1054                 fi
1055                 # basic key create
1056                 lgss_sk -t server -f$FSNAME -w $SK_PATH/$FSNAME.key \
1057                         -d /dev/urandom >/dev/null 2>&1
1058                 # per-nodemap keys
1059                 for i in $(seq 0 $((numclients - 1))); do
1060                         lgss_sk -t server -f$FSNAME -n c$i \
1061                                 -w $SK_PATH/nodemap/c$i.key -d /dev/urandom \
1062                                 >/dev/null 2>&1
1063                 done
1064                 # Distribute keys
1065                 if ! local_mode; then
1066                         for lnode in $(all_nodes); do
1067                                 scp -r $SK_PATH ${lnode}:$(dirname $SK_PATH)/
1068                         done
1069                 fi
1070                 # Set client keys to client type to generate prime P
1071                 if local_mode; then
1072                         do_nodes $(all_nodes) "lgss_sk -t client,server -m \
1073                                 $SK_PATH/$FSNAME.key >/dev/null 2>&1"
1074                 else
1075                         do_nodes $clients "lgss_sk -t client -m \
1076                                 $SK_PATH/$FSNAME.key >/dev/null 2>&1"
1077                         do_nodes $clients "find $SK_PATH/nodemap -name \*.key | \
1078                                 xargs -IX lgss_sk -t client -m X >/dev/null 2>&1"
1079                 fi
1080                 # This is required for servers as well, if S2S in use
1081                 if $SK_S2S; then
1082                         do_nodes $(comma_list $(mdts_nodes)) \
1083                                 "cp $SK_PATH/$FSNAME-s2s-server.key \
1084                                 $SK_PATH/$FSNAME-s2s-client.key; lgss_sk \
1085                                 -t client -m $SK_PATH/$FSNAME-s2s-client.key \
1086                                 >/dev/null 2>&1"
1087                         do_nodes $(comma_list $(osts_nodes)) \
1088                                 "cp $SK_PATH/$FSNAME-s2s-server.key \
1089                                 $SK_PATH/$FSNAME-s2s-client.key; lgss_sk \
1090                                 -t client -m $SK_PATH/$FSNAME-s2s-client.key \
1091                                 >/dev/null 2>&1"
1092                         do_nodes $clients "lgss_sk -t client \
1093                                 -m $SK_PATH/$FSNAME-nmclient.key \
1094                                  >/dev/null 2>&1"
1095                 fi
1096         fi
1097         if $GSS_SK; then
1098                 # mount options for servers and clients
1099                 MGS_MOUNT_OPTS=$(add_sk_mntflag $MGS_MOUNT_OPTS)
1100                 MDS_MOUNT_OPTS=$(add_sk_mntflag $MDS_MOUNT_OPTS)
1101                 OST_MOUNT_OPTS=$(add_sk_mntflag $OST_MOUNT_OPTS)
1102                 MOUNT_OPTS=$(add_sk_mntflag $MOUNT_OPTS)
1103                 SEC=$SK_FLAVOR
1104         fi
1105
1106         if [ -n "$LGSS_KEYRING_DEBUG" ]; then
1107                 lctl set_param -n \
1108                         sptlrpc.gss.lgss_keyring.debug_level=$LGSS_KEYRING_DEBUG
1109         fi
1110 }
1111
1112 cleanup_gss() {
1113         if $GSS; then
1114                 stop_gss_daemons
1115                 # maybe cleanup credential cache?
1116         fi
1117 }
1118
1119 cleanup_sk() {
1120         if $GSS_SK; then
1121                 case $LUSTRE in
1122                 /usr/lib/lustre/* | /usr/lib64/lustre/* | /usr/lib/lustre | \
1123                 /usr/lib64/lustre )
1124                         from_build_tree=false
1125                         ;;
1126                 *)
1127                         from_build_tree=true
1128                         ;;
1129                 esac
1130
1131                 if $SK_S2S; then
1132                         do_node $(mgs_node) "$LCTL nodemap_del $SK_S2SNM"
1133                         do_node $(mgs_node) "$LCTL nodemap_del $SK_S2SNMCLI"
1134                         $RPC_MODE || echo "Sleeping for 10 sec for Nodemap.."
1135                         sleep 10
1136                 fi
1137                 stop_gss_daemons
1138                 $RPC_MODE || echo "Cleaning up Shared Key.."
1139                 do_nodes $(comma_list $(all_nodes)) "rm -f \
1140                         $SK_PATH/$FSNAME*.key $SK_PATH/nodemap/$FSNAME*.key"
1141                 do_nodes $(comma_list $(all_nodes)) "keyctl show | \
1142                   awk '/lustre/ { print \\\$1 }' | xargs -IX keyctl unlink X"
1143                 if $from_build_tree; then
1144                         # Remove the mount and clean up the files we added to
1145                         # SK_PATH
1146                         do_nodes $(comma_list $(all_nodes)) "while grep -q \
1147                                 request-key.d /proc/mounts; do umount \
1148                                 /etc/request-key.d/; done"
1149                         do_nodes $(comma_list $(all_nodes)) "rm -f \
1150                                 $SK_OM_PATH/lgssc.conf"
1151                         do_nodes $(comma_list $(all_nodes)) "rmdir $SK_OM_PATH"
1152                 fi
1153                 SK_NO_KEY=true
1154         fi
1155 }
1156
1157 facet_svc() {
1158         local facet=$1
1159         local var=${facet}_svc
1160
1161         echo -n ${!var}
1162 }
1163
1164 facet_type() {
1165         local facet=$1
1166
1167         echo -n $facet | sed -e 's/^fs[0-9]\+//' -e 's/[0-9_]\+//' |
1168                 tr '[:lower:]' '[:upper:]'
1169 }
1170
1171 facet_number() {
1172         local facet=$1
1173
1174         if [ $facet == mgs ] || [ $facet == client ]; then
1175                 return 1
1176         fi
1177
1178         echo -n $facet | sed -e 's/^fs[0-9]\+//' | sed -e 's/^[a-z]\+//'
1179 }
1180
1181 facet_fstype() {
1182         local facet=$1
1183         local var
1184
1185         var=${facet}_FSTYPE
1186         if [ -n "${!var}" ]; then
1187                 echo -n ${!var}
1188                 return
1189         fi
1190
1191         var=$(facet_type $facet)FSTYPE
1192         if [ -n "${!var}" ]; then
1193                 echo -n ${!var}
1194                 return
1195         fi
1196
1197         if [ -n "$FSTYPE" ]; then
1198                 echo -n $FSTYPE
1199                 return
1200         fi
1201
1202         if [[ $facet == mgs ]] && combined_mgs_mds; then
1203                 facet_fstype mds1
1204                 return
1205         fi
1206
1207         return 1
1208 }
1209
1210 node_fstypes() {
1211         local node=$1
1212         local fstypes
1213         local fstype
1214         local facets=$(get_facets)
1215         local facet
1216
1217         for facet in ${facets//,/ }; do
1218                 if [ $node == $(facet_host $facet) ] ||
1219                    [ $node == "$(facet_failover_host $facet)" ]; then
1220                         fstype=$(facet_fstype $facet)
1221                         if [[ $fstypes != *$fstype* ]]; then
1222                                 fstypes+="${fstypes:+,}$fstype"
1223                         fi
1224                 fi
1225         done
1226         echo -n $fstypes
1227 }
1228
1229 facet_index() {
1230         local facet=$1
1231         local num=$(facet_number $facet)
1232         local index
1233
1234         if [[ $(facet_type $facet) = OST ]]; then
1235                 index=OSTINDEX${num}
1236                 if [[ -n "${!index}" ]]; then
1237                         echo -n ${!index}
1238                         return
1239                 fi
1240
1241                 index=${OST_INDICES[num - 1]}
1242         fi
1243
1244         [[ -n "$index" ]] || index=$((num - 1))
1245         echo -n $index
1246 }
1247
1248 devicelabel() {
1249         local facet=$1
1250         local dev=$2
1251         local label
1252         local fstype=$(facet_fstype $facet)
1253
1254         case $fstype in
1255         ldiskfs)
1256                 label=$(do_facet ${facet} "$E2LABEL ${dev} 2>/dev/null");;
1257         zfs)
1258                 label=$(do_facet ${facet} "$ZFS get -H -o value lustre:svname \
1259                                            ${dev} 2>/dev/null");;
1260         *)
1261                 error "unknown fstype!";;
1262         esac
1263
1264         echo -n $label
1265 }
1266
1267 mdsdevlabel() {
1268         local num=$1
1269         local device=$(mdsdevname $num)
1270         local label=$(devicelabel mds$num ${device} | grep -v "CMD: ")
1271         echo -n $label
1272 }
1273
1274 ostdevlabel() {
1275         local num=$1
1276         local device=$(ostdevname $num)
1277         local label=$(devicelabel ost$num ${device} | grep -v "CMD: ")
1278         echo -n $label
1279 }
1280
1281 #
1282 # Get the device of a facet.
1283 #
1284 facet_device() {
1285         local facet=$1
1286         local device
1287
1288         case $facet in
1289                 mgs) device=$(mgsdevname) ;;
1290                 mds*) device=$(mdsdevname $(facet_number $facet)) ;;
1291                 ost*) device=$(ostdevname $(facet_number $facet)) ;;
1292                 fs2mds) device=$(mdsdevname 1_2) ;;
1293                 fs2ost) device=$(ostdevname 1_2) ;;
1294                 fs3ost) device=$(ostdevname 2_2) ;;
1295                 *) ;;
1296         esac
1297
1298         echo -n $device
1299 }
1300
1301 #
1302 # Get the virtual device of a facet.
1303 #
1304 facet_vdevice() {
1305         local facet=$1
1306         local device
1307
1308         case $facet in
1309                 mgs) device=$(mgsvdevname) ;;
1310                 mds*) device=$(mdsvdevname $(facet_number $facet)) ;;
1311                 ost*) device=$(ostvdevname $(facet_number $facet)) ;;
1312                 fs2mds) device=$(mdsvdevname 1_2) ;;
1313                 fs2ost) device=$(ostvdevname 1_2) ;;
1314                 fs3ost) device=$(ostvdevname 2_2) ;;
1315                 *) ;;
1316         esac
1317
1318         echo -n $device
1319 }
1320
1321 running_in_vm() {
1322         local virt=$(virt-what 2> /dev/null)
1323
1324         [ $? -eq 0 ] && [ -n "$virt" ] && { echo $virt; return; }
1325
1326         virt=$(dmidecode -s system-product-name | awk '{print $1}')
1327
1328         case $virt in
1329                 VMware|KVM|VirtualBox|Parallels)
1330                         echo $virt | tr '[A-Z]' '[a-z]' ;;
1331                 *) ;;
1332         esac
1333 }
1334
1335 #
1336 # Re-read the partition table on failover partner host.
1337 # After a ZFS storage pool is created on a shared device, the partition table
1338 # on the device may change. However, the operating system on the failover
1339 # host may not notice the change automatically. Without the up-to-date partition
1340 # block devices, 'zpool import ..' cannot find the labels, whose positions are
1341 # relative to partition rather than disk beginnings.
1342 #
1343 # This function performs partprobe on the failover host to make it re-read the
1344 # partition table.
1345 #
1346 refresh_partition_table() {
1347         local facet=$1
1348         local device=$2
1349         local host
1350
1351         host=$(facet_passive_host $facet)
1352         if [[ -n "$host" ]]; then
1353                 do_node $host "$PARTPROBE $device"
1354         fi
1355 }
1356
1357 #
1358 # Get ZFS storage pool name.
1359 #
1360 zpool_name() {
1361         local facet=$1
1362         local device
1363         local poolname
1364
1365         device=$(facet_device $facet)
1366         # poolname is string before "/"
1367         poolname="${device%%/*}"
1368
1369         echo -n $poolname
1370 }
1371
1372 #
1373 #
1374 # Get ZFS local fsname.
1375 #
1376 zfs_local_fsname() {
1377         local facet=$1
1378         local lfsname=$(basename $(facet_device $facet))
1379
1380         echo -n $lfsname
1381 }
1382
1383 #
1384 # Create ZFS storage pool.
1385 #
1386 create_zpool() {
1387         local facet=$1
1388         local poolname=$2
1389         local vdev=$3
1390         shift 3
1391         local opts=${@:-"-o cachefile=none"}
1392
1393         do_facet $facet "lsmod | grep zfs >&/dev/null || modprobe zfs;
1394                 $ZPOOL list -H $poolname >/dev/null 2>&1 ||
1395                 $ZPOOL create -f $opts $poolname $vdev"
1396 }
1397
1398 #
1399 # Create ZFS file system.
1400 #
1401 create_zfs() {
1402         local facet=$1
1403         local dataset=$2
1404         shift 2
1405         local opts=${@:-"-o mountpoint=legacy"}
1406
1407         do_facet $facet "$ZFS list -H $dataset >/dev/null 2>&1 ||
1408                 $ZFS create $opts $dataset"
1409 }
1410
1411 #
1412 # Export ZFS storage pool.
1413 # Before exporting the pool, all datasets within the pool should be unmounted.
1414 #
1415 export_zpool() {
1416         local facet=$1
1417         shift
1418         local opts="$@"
1419         local poolname
1420
1421         poolname=$(zpool_name $facet)
1422
1423         if [[ -n "$poolname" ]]; then
1424                 do_facet $facet "! $ZPOOL list -H $poolname >/dev/null 2>&1 ||
1425                         grep -q ^$poolname/ /proc/mounts ||
1426                         $ZPOOL export $opts $poolname"
1427         fi
1428 }
1429
1430 #
1431 # Destroy ZFS storage pool.
1432 # Destroy the given pool and free up any devices for other use. This command
1433 # tries to unmount any active datasets before destroying the pool.
1434 # -f    Force any active datasets contained within the pool to be unmounted.
1435 #
1436 destroy_zpool() {
1437         local facet=$1
1438         local poolname=${2:-$(zpool_name $facet)}
1439
1440         if [[ -n "$poolname" ]]; then
1441                 do_facet $facet "! $ZPOOL list -H $poolname >/dev/null 2>&1 ||
1442                         $ZPOOL destroy -f $poolname"
1443         fi
1444 }
1445
1446 #
1447 # Import ZFS storage pool.
1448 # Force importing, even if the pool appears to be potentially active.
1449 #
1450 import_zpool() {
1451         local facet=$1
1452         shift
1453         local opts=${@:-"-o cachefile=none -o failmode=panic"}
1454         local poolname
1455
1456         poolname=$(zpool_name $facet)
1457
1458         if [[ -n "$poolname" ]]; then
1459                 opts+=" -d $(dirname $(facet_vdevice $facet))"
1460                 do_facet $facet "lsmod | grep zfs >&/dev/null || modprobe zfs;
1461                         $ZPOOL list -H $poolname >/dev/null 2>&1 ||
1462                         $ZPOOL import -f $opts $poolname"
1463         fi
1464 }
1465
1466 #
1467 # Reimport ZFS storage pool with new name
1468 #
1469 reimport_zpool() {
1470         local facet=$1
1471         local newpool=$2
1472         local opts="-o cachefile=none"
1473         local poolname=$(zpool_name $facet)
1474
1475         opts+=" -d $(dirname $(facet_vdevice $facet))"
1476         do_facet $facet "$ZPOOL export $poolname;
1477                          $ZPOOL import $opts $poolname $newpool"
1478 }
1479
1480 #
1481 # Set the "cachefile=none" property on ZFS storage pool so that the pool
1482 # is not automatically imported on system startup.
1483 #
1484 # In a failover environment, this will provide resource level fencing which
1485 # will ensure that the same ZFS storage pool will not be imported concurrently
1486 # on different nodes.
1487 #
1488 disable_zpool_cache() {
1489         local facet=$1
1490         local poolname
1491
1492         poolname=$(zpool_name $facet)
1493
1494         if [[ -n "$poolname" ]]; then
1495                 do_facet $facet "$ZPOOL set cachefile=none $poolname"
1496         fi
1497 }
1498
1499 #
1500 # This and set_osd_param() shall be used to access OSD parameters
1501 # once existed under "obdfilter":
1502 #
1503 #   mntdev
1504 #   stats
1505 #   read_cache_enable
1506 #   writethrough_cache_enable
1507 #
1508 get_osd_param() {
1509         local nodes=$1
1510         local device=${2:-$FSNAME-OST*}
1511         local name=$3
1512
1513         do_nodes $nodes "$LCTL get_param -n obdfilter.$device.$name \
1514                 osd-*.$device.$name 2>&1" | grep -v 'error:'
1515 }
1516
1517 set_osd_param() {
1518         local nodes=$1
1519         local device=${2:-$FSNAME-OST*}
1520         local name=$3
1521         local value=$4
1522
1523         do_nodes $nodes "$LCTL set_param -n obdfilter.$device.$name=$value \
1524                 osd-*.$device.$name=$value 2>&1" | grep -v 'error:'
1525 }
1526
1527 set_debug_size () {
1528     local dz=${1:-$DEBUG_SIZE}
1529
1530     if [ -f /sys/devices/system/cpu/possible ]; then
1531         local cpus=$(($(cut -d "-" -f 2 /sys/devices/system/cpu/possible)+1))
1532     else
1533         local cpus=$(getconf _NPROCESSORS_CONF 2>/dev/null)
1534     fi
1535
1536     # bug 19944, adjust size to be -gt num_possible_cpus()
1537     # promise 2MB for every cpu at least
1538     if [ -n "$cpus" ] && [ $((cpus * 2)) -gt $dz ]; then
1539         dz=$((cpus * 2))
1540     fi
1541     lctl set_param debug_mb=$dz
1542 }
1543
1544 set_default_debug () {
1545     local debug=${1:-"$PTLDEBUG"}
1546     local subsys=${2:-"$SUBSYSTEM"}
1547     local debug_size=${3:-$DEBUG_SIZE}
1548
1549     [ -n "$debug" ] && lctl set_param debug="$debug" >/dev/null
1550     [ -n "$subsys" ] && lctl set_param subsystem_debug="${subsys# }" >/dev/null
1551
1552     [ -n "$debug_size" ] && set_debug_size $debug_size > /dev/null
1553 }
1554
1555 set_default_debug_nodes () {
1556         local nodes="$1"
1557
1558         if [[ ,$nodes, = *,$HOSTNAME,* ]]; then
1559                 nodes=$(exclude_items_from_list "$nodes" "$HOSTNAME")
1560                 set_default_debug
1561         fi
1562
1563         do_rpc_nodes "$nodes" set_default_debug \
1564                 \\\"$PTLDEBUG\\\" \\\"$SUBSYSTEM\\\" $DEBUG_SIZE || true
1565 }
1566
1567 set_default_debug_facet () {
1568     local facet=$1
1569     local node=$(facet_active_host $facet)
1570     [ -z "$node" ] && echo "No host defined for facet $facet" && exit 1
1571
1572     set_default_debug_nodes $node
1573 }
1574
1575 set_hostid () {
1576     local hostid=${1:-$(hostid)}
1577
1578     if [ ! -s /etc/hostid ]; then
1579         printf $(echo -n $hostid |
1580             sed 's/\(..\)\(..\)\(..\)\(..\)/\\x\4\\x\3\\x\2\\x\1/') >/etc/hostid
1581     fi
1582 }
1583
1584 # Facet functions
1585 mount_facets () {
1586         local facets=${1:-$(get_facets)}
1587         local facet
1588
1589         for facet in ${facets//,/ }; do
1590                 mount_facet $facet
1591                 local RC=$?
1592                 [ $RC -eq 0 ] && continue
1593
1594                 if [ "$TESTSUITE.$TESTNAME" = "replay-dual.test_0a" ]; then
1595                         skip_noexit "Restart of $facet failed!." &&
1596                                 touch $LU482_FAILED
1597                 else
1598                         error "Restart of $facet failed!"
1599                 fi
1600                 return $RC
1601         done
1602 }
1603
1604 #
1605 # Add argument "arg" (e.g., "loop") to the comma-separated list
1606 # of arguments for option "opt" (e.g., "-o") on command
1607 # line "opts" (e.g., "-o flock").
1608 #
1609 csa_add() {
1610         local opts=$1
1611         local opt=$2
1612         local arg=$3
1613         local opt_pattern="\([[:space:]]\+\|^\)$opt"
1614
1615         if echo "$opts" | grep -q $opt_pattern; then
1616                 opts=$(echo "$opts" | sed -e \
1617                         "s/$opt_pattern[[:space:]]*[^[:space:]]\+/&,$arg/")
1618         else
1619                 opts+="${opts:+ }$opt $arg"
1620         fi
1621         echo -n "$opts"
1622 }
1623
1624 #
1625 # Associate loop device with a given regular file.
1626 # Return the loop device.
1627 #
1628 setup_loop_device() {
1629         local facet=$1
1630         local file=$2
1631
1632         do_facet $facet "loop_dev=\\\$($LOSETUP -j $file | cut -d : -f 1);
1633                          if [[ -z \\\$loop_dev ]]; then
1634                                 loop_dev=\\\$($LOSETUP -f);
1635                                 $LOSETUP \\\$loop_dev $file || loop_dev=;
1636                          fi;
1637                          echo -n \\\$loop_dev"
1638 }
1639
1640 #
1641 # Detach a loop device.
1642 #
1643 cleanup_loop_device() {
1644         local facet=$1
1645         local loop_dev=$2
1646
1647         do_facet $facet "! $LOSETUP $loop_dev >/dev/null 2>&1 ||
1648                          $LOSETUP -d $loop_dev"
1649 }
1650
1651 #
1652 # Check if a given device is a block device.
1653 #
1654 is_blkdev() {
1655         local facet=$1
1656         local dev=$2
1657         local size=${3:-""}
1658
1659         [[ -n "$dev" ]] || return 1
1660         do_facet $facet "test -b $dev" || return 1
1661         if [[ -n "$size" ]]; then
1662                 local in=$(do_facet $facet "dd if=$dev of=/dev/null bs=1k \
1663                                             count=1 skip=$size 2>&1" |
1664                                             awk '($3 == "in") { print $1 }')
1665                 [[ "$in" = "1+0" ]] || return 1
1666         fi
1667 }
1668
1669 #
1670 # Check if a given device is a device-mapper device.
1671 #
1672 is_dm_dev() {
1673         local facet=$1
1674         local dev=$2
1675
1676         [[ -n "$dev" ]] || return 1
1677         do_facet $facet "$DMSETUP status $dev >/dev/null 2>&1"
1678 }
1679
1680 #
1681 # Check if a given device is a device-mapper flakey device.
1682 #
1683 is_dm_flakey_dev() {
1684         local facet=$1
1685         local dev=$2
1686         local type
1687
1688         [[ -n "$dev" ]] || return 1
1689
1690         type=$(do_facet $facet "$DMSETUP status $dev 2>&1" |
1691                awk '{print $3}')
1692         [[ $type = flakey ]] && return 0 || return 1
1693 }
1694
1695 #
1696 # Check if device-mapper flakey device is supported by the kernel
1697 # of $facet node or not.
1698 #
1699 dm_flakey_supported() {
1700         local facet=$1
1701
1702         $FLAKEY || return 1
1703         do_facet $facet "modprobe dm-flakey;
1704                          $DMSETUP targets | grep -q flakey" &> /dev/null
1705 }
1706
1707 #
1708 # Get the device-mapper flakey device name of a given facet.
1709 #
1710 dm_facet_devname() {
1711         local facet=$1
1712         [[ $facet = mgs ]] && combined_mgs_mds && facet=mds1
1713
1714         echo -n ${facet}_flakey
1715 }
1716
1717 #
1718 # Get the device-mapper flakey device of a given facet.
1719 # A device created by dmsetup will appear as /dev/mapper/<device-name>.
1720 #
1721 dm_facet_devpath() {
1722         local facet=$1
1723
1724         echo -n $DM_DEV_PATH/$(dm_facet_devname $facet)
1725 }
1726
1727 #
1728 # Set a device-mapper device with a new table.
1729 #
1730 # The table has the following format:
1731 # <logical_start_sector> <num_sectors> <target_type> <target_args>
1732 #
1733 # flakey <target_args> includes:
1734 # <destination_device> <offset> <up_interval> <down_interval> \
1735 # [<num_features> [<feature_arguments>]]
1736 #
1737 # linear <target_args> includes:
1738 # <destination_device> <start_sector>
1739 #
1740 dm_set_dev_table() {
1741         local facet=$1
1742         local dm_dev=$2
1743         local target_type=$3
1744         local num_sectors
1745         local real_dev
1746         local tmp
1747         local table
1748
1749         read tmp num_sectors tmp real_dev tmp \
1750                 <<< $(do_facet $facet "$DMSETUP table $dm_dev")
1751
1752         case $target_type in
1753         flakey)
1754                 table="0 $num_sectors flakey $real_dev 0 0 1800 1 drop_writes"
1755                 ;;
1756         linear)
1757                 table="0 $num_sectors linear $real_dev 0"
1758                 ;;
1759         *) error "invalid target type $target_type" ;;
1760         esac
1761
1762         do_facet $facet "$DMSETUP suspend --nolockfs --noflush $dm_dev" ||
1763                 error "failed to suspend $dm_dev"
1764         do_facet $facet "$DMSETUP load $dm_dev --table \\\"$table\\\"" ||
1765                 error "failed to load $target_type table into $dm_dev"
1766         do_facet $facet "$DMSETUP resume $dm_dev" ||
1767                 error "failed to resume $dm_dev"
1768 }
1769
1770 #
1771 # Set a device-mapper flakey device as "read-only" by using the "drop_writes"
1772 # feature parameter.
1773 #
1774 # drop_writes:
1775 #       All write I/O is silently ignored.
1776 #       Read I/O is handled correctly.
1777 #
1778 dm_set_dev_readonly() {
1779         local facet=$1
1780         local dm_dev=${2:-$(dm_facet_devpath $facet)}
1781
1782         dm_set_dev_table $facet $dm_dev flakey
1783 }
1784
1785 #
1786 # Set a device-mapper device to traditional linear mapping mode.
1787 #
1788 dm_clear_dev_readonly() {
1789         local facet=$1
1790         local dm_dev=${2:-$(dm_facet_devpath $facet)}
1791
1792         dm_set_dev_table $facet $dm_dev linear
1793 }
1794
1795 #
1796 # Set the device of a given facet as "read-only".
1797 #
1798 set_dev_readonly() {
1799         local facet=$1
1800         local svc=${facet}_svc
1801
1802         if [[ $(facet_fstype $facet) = zfs ]] ||
1803            ! dm_flakey_supported $facet; then
1804                 do_facet $facet $LCTL --device ${!svc} readonly
1805         else
1806                 dm_set_dev_readonly $facet
1807         fi
1808 }
1809
1810 #
1811 # Get size in 512-byte sectors (BLKGETSIZE64 / 512) of a given device.
1812 #
1813 get_num_sectors() {
1814         local facet=$1
1815         local dev=$2
1816         local num_sectors
1817
1818         num_sectors=$(do_facet $facet "blockdev --getsz $dev 2>/dev/null")
1819         [[ ${PIPESTATUS[0]} = 0 && -n "$num_sectors" ]] || num_sectors=0
1820         echo -n $num_sectors
1821 }
1822
1823 #
1824 # Create a device-mapper device with a given block device or regular file (will
1825 # be associated with loop device).
1826 # Return the full path of the device-mapper device.
1827 #
1828 dm_create_dev() {
1829         local facet=$1
1830         local real_dev=$2                                  # destination device
1831         local dm_dev_name=${3:-$(dm_facet_devname $facet)} # device name
1832         local dm_dev=$DM_DEV_PATH/$dm_dev_name            # device-mapper device
1833
1834         # check if the device-mapper device to be created already exists
1835         if is_dm_dev $facet $dm_dev; then
1836                 # if the existing device was set to "read-only", then clear it
1837                 ! is_dm_flakey_dev $facet $dm_dev ||
1838                         dm_clear_dev_readonly $facet $dm_dev
1839
1840                 echo -n $dm_dev
1841                 return 0
1842         fi
1843
1844         # check if the destination device is a block device, and if not,
1845         # associate it with a loop device
1846         is_blkdev $facet $real_dev ||
1847                 real_dev=$(setup_loop_device $facet $real_dev)
1848         [[ -n "$real_dev" ]] || { echo -n $real_dev; return 2; }
1849
1850         # now create the device-mapper device
1851         local num_sectors=$(get_num_sectors $facet $real_dev)
1852         local table="0 $num_sectors linear $real_dev 0"
1853         local rc=0
1854
1855         do_facet $facet "$DMSETUP create $dm_dev_name --table \\\"$table\\\"" ||
1856                 { rc=${PIPESTATUS[0]}; dm_dev=; }
1857         do_facet $facet "$DMSETUP mknodes >/dev/null 2>&1"
1858
1859         echo -n $dm_dev
1860         return $rc
1861 }
1862
1863 #
1864 # Map the facet name to its device variable name.
1865 #
1866 facet_device_alias() {
1867         local facet=$1
1868         local dev_alias=$facet
1869
1870         case $facet in
1871                 fs2mds) dev_alias=mds1_2 ;;
1872                 fs2ost) dev_alias=ost1_2 ;;
1873                 fs3ost) dev_alias=ost2_2 ;;
1874                 *) ;;
1875         esac
1876
1877         echo -n $dev_alias
1878 }
1879
1880 #
1881 # Save the original value of the facet device and export the new value.
1882 #
1883 export_dm_dev() {
1884         local facet=$1
1885         local dm_dev=$2
1886
1887         local active_facet=$(facet_active $facet)
1888         local dev_alias=$(facet_device_alias $active_facet)
1889         local dev_name=${dev_alias}_dev
1890         local dev=${!dev_name}
1891
1892         if [[ $active_facet = $facet ]]; then
1893                 local failover_dev=${dev_alias}failover_dev
1894                 if [[ ${!failover_dev} = $dev ]]; then
1895                         eval export ${failover_dev}_saved=$dev
1896                         eval export ${failover_dev}=$dm_dev
1897                 fi
1898         else
1899                 dev_alias=$(facet_device_alias $facet)
1900                 local facet_dev=${dev_alias}_dev
1901                 if [[ ${!facet_dev} = $dev ]]; then
1902                         eval export ${facet_dev}_saved=$dev
1903                         eval export ${facet_dev}=$dm_dev
1904                 fi
1905         fi
1906
1907         eval export ${dev_name}_saved=$dev
1908         eval export ${dev_name}=$dm_dev
1909 }
1910
1911 #
1912 # Restore the saved value of the facet device.
1913 #
1914 unexport_dm_dev() {
1915         local facet=$1
1916
1917         [[ $facet = mgs ]] && combined_mgs_mds && facet=mds1
1918         local dev_alias=$(facet_device_alias $facet)
1919
1920         local saved_dev=${dev_alias}_dev_saved
1921         [[ -z ${!saved_dev} ]] ||
1922                 eval export ${dev_alias}_dev=${!saved_dev}
1923
1924         saved_dev=${dev_alias}failover_dev_saved
1925         [[ -z ${!saved_dev} ]] ||
1926                 eval export ${dev_alias}failover_dev=${!saved_dev}
1927 }
1928
1929 #
1930 # Remove a device-mapper device.
1931 # If the destination device is a loop device, then also detach it.
1932 #
1933 dm_cleanup_dev() {
1934         local facet=$1
1935         local dm_dev=${2:-$(dm_facet_devpath $facet)}
1936         local major
1937         local minor
1938
1939         is_dm_dev $facet $dm_dev || return 0
1940
1941         read major minor <<< $(do_facet $facet "$DMSETUP table $dm_dev" |
1942                 awk '{ print $4 }' | awk -F: '{ print $1" "$2 }')
1943
1944         do_facet $facet "$DMSETUP remove $dm_dev"
1945         do_facet $facet "$DMSETUP mknodes >/dev/null 2>&1"
1946
1947         unexport_dm_dev $facet
1948
1949         # detach a loop device
1950         [[ $major -ne 7 ]] || cleanup_loop_device $facet /dev/loop$minor
1951
1952         # unload dm-flakey module
1953         do_facet $facet "modprobe -r dm-flakey" || true
1954 }
1955
1956 mount_facet() {
1957         local facet=$1
1958         shift
1959         local active_facet=$(facet_active $facet)
1960         local dev_alias=$(facet_device_alias $active_facet)
1961         local dev=${dev_alias}_dev
1962         local opt=${facet}_opt
1963         local mntpt=$(facet_mntpt $facet)
1964         local opts="${!opt} $@"
1965         local fstype=$(facet_fstype $facet)
1966         local devicelabel
1967         local dm_dev=${!dev}
1968
1969         module_loaded lustre || load_modules
1970
1971         case $fstype in
1972         ldiskfs)
1973                 if dm_flakey_supported $facet; then
1974                         dm_dev=$(dm_create_dev $facet ${!dev})
1975                         [[ -n "$dm_dev" ]] || dm_dev=${!dev}
1976                 fi
1977
1978                 is_blkdev $facet $dm_dev || opts=$(csa_add "$opts" -o loop)
1979
1980                 devicelabel=$(do_facet ${facet} "$E2LABEL $dm_dev");;
1981         zfs)
1982                 # import ZFS storage pool
1983                 import_zpool $facet || return ${PIPESTATUS[0]}
1984
1985                 devicelabel=$(do_facet ${facet} "$ZFS get -H -o value \
1986                                                 lustre:svname $dm_dev");;
1987         *)
1988                 error "unknown fstype!";;
1989         esac
1990
1991         echo "Starting ${facet}: $opts $dm_dev $mntpt"
1992         # for testing LU-482 error handling in mount_facets() and test_0a()
1993         if [ -f $TMP/test-lu482-trigger ]; then
1994                 RC=2
1995         else
1996                 do_facet ${facet} \
1997                         "mkdir -p $mntpt; $MOUNT_CMD $opts $dm_dev $mntpt"
1998                 RC=${PIPESTATUS[0]}
1999         fi
2000
2001         if [ $RC -ne 0 ]; then
2002                 echo "Start of $dm_dev on ${facet} failed ${RC}"
2003                 return $RC
2004         fi
2005
2006         health=$(do_facet ${facet} "$LCTL get_param -n health_check")
2007         if [[ "$health" != "healthy" ]]; then
2008                 error "$facet is in a unhealthy state"
2009         fi
2010
2011         set_default_debug_facet $facet
2012
2013         if [[ $opts =~ .*nosvc.* ]]; then
2014                 echo "Start $dm_dev without service"
2015         else
2016
2017                 case $fstype in
2018                 ldiskfs)
2019                         wait_update_facet ${facet} "$E2LABEL $dm_dev \
2020                                 2>/dev/null | grep -E ':[a-zA-Z]{3}[0-9]{4}'" \
2021                                 "" || error "$dm_dev failed to initialize!";;
2022                 zfs)
2023                         wait_update_facet ${facet} "$ZFS get -H -o value \
2024                                 lustre:svname $dm_dev 2>/dev/null | \
2025                                 grep -E ':[a-zA-Z]{3}[0-9]{4}'" "" ||
2026                                 error "$dm_dev failed to initialize!";;
2027
2028                 *)
2029                         error "unknown fstype!";;
2030                 esac
2031         fi
2032
2033         # commit the device label change to disk
2034         if [[ $devicelabel =~ (:[a-zA-Z]{3}[0-9]{4}) ]]; then
2035                 echo "Commit the device label on ${!dev}"
2036                 do_facet $facet "sync; sleep 1; sync"
2037         fi
2038
2039
2040         label=$(devicelabel ${facet} $dm_dev)
2041         [ -z "$label" ] && echo no label for $dm_dev && exit 1
2042         eval export ${facet}_svc=${label}
2043         echo Started ${label}
2044
2045         export_dm_dev $facet $dm_dev
2046
2047         return $RC
2048 }
2049
2050 # start facet device options
2051 start() {
2052         local facet=$1
2053         shift
2054         local device=$1
2055         shift
2056         local dev_alias=$(facet_device_alias $facet)
2057
2058         eval export ${dev_alias}_dev=${device}
2059         eval export ${facet}_opt=\"$@\"
2060
2061         local varname=${dev_alias}failover_dev
2062         if [ -n "${!varname}" ] ; then
2063                 eval export ${dev_alias}failover_dev=${!varname}
2064         else
2065                 eval export ${dev_alias}failover_dev=$device
2066         fi
2067
2068         local mntpt=$(facet_mntpt $facet)
2069         do_facet ${facet} mkdir -p $mntpt
2070         eval export ${facet}_MOUNT=$mntpt
2071         mount_facet ${facet}
2072         RC=$?
2073
2074         return $RC
2075 }
2076
2077 stop() {
2078         local running
2079         local facet=$1
2080         shift
2081         local HOST=$(facet_active_host $facet)
2082         [[ -z $HOST ]] && echo stop: no host for $facet && return 0
2083
2084         local mntpt=$(facet_mntpt $facet)
2085         running=$(do_facet ${facet} "grep -c $mntpt' ' /proc/mounts || true")
2086         if [ ${running} -ne 0 ]; then
2087                 echo "Stopping $mntpt (opts:$@) on $HOST"
2088                 do_facet ${facet} $UMOUNT $@ $mntpt
2089         fi
2090
2091         # umount should block, but we should wait for unrelated obd's
2092         # like the MGS or MGC to also stop.
2093         wait_exit_ST ${facet} || return ${PIPESTATUS[0]}
2094
2095         if [[ $(facet_fstype $facet) == zfs ]]; then
2096                 # export ZFS storage pool
2097                 [ "$KEEP_ZPOOL" = "true" ] || export_zpool $facet
2098         elif dm_flakey_supported $facet; then
2099                 local host=${facet}_HOST
2100                 local failover_host=${facet}failover_HOST
2101                 if [[ -n ${!failover_host} && ${!failover_host} != ${!host} ]]||
2102                         $CLEANUP_DM_DEV || [[ $facet = fs* ]]; then
2103                         dm_cleanup_dev $facet
2104                 fi
2105         fi
2106 }
2107
2108 # get mdt quota type
2109 mdt_quota_type() {
2110         local varsvc=${SINGLEMDS}_svc
2111         do_facet $SINGLEMDS $LCTL get_param -n \
2112                 osd-$(facet_fstype $SINGLEMDS).${!varsvc}.quota_slave.enabled
2113 }
2114
2115 # get ost quota type
2116 ost_quota_type() {
2117         # All OSTs should have same quota type
2118         local varsvc=ost1_svc
2119         do_facet ost1 $LCTL get_param -n \
2120                 osd-$(facet_fstype ost1).${!varsvc}.quota_slave.enabled
2121 }
2122
2123 # restore old quota type settings
2124 restore_quota() {
2125         if [ "$old_MDT_QUOTA_TYPE" ]; then
2126                 if [[ $PERM_CMD == *"set_param -P"* ]]; then
2127                         do_facet mgs $PERM_CMD \
2128                                 osd-*.$FSNAME-MDT*.quota_slave.enable = \
2129                                 $old_MDT_QUOTA_TYPE
2130                 else
2131                         do_facet mgs $PERM_CMD \
2132                                 $FSNAME.quota.mdt=$old_MDT_QUOTA_TYPE
2133                 fi
2134         fi
2135         if [ "$old_OST_QUOTA_TYPE" ]; then
2136                 if [[ $PERM_CMD == *"set_param -P"* ]]; then
2137                         do_facet mgs $PERM_CMD \
2138                                 osd-*.$FSNAME-OST*.quota_slave.enable = \
2139                                 $old_OST_QUOTA_TYPE
2140                 else
2141                         do_facet mgs $LCTL conf_param \
2142                                 $FSNAME.quota.ost=$old_OST_QUOTA_TYPE
2143                 fi
2144         fi
2145 }
2146
2147 # Handle the case when there is a space in the lfs df
2148 # "filesystem summary" line the same as when there is no space.
2149 # This will allow fixing the "lfs df" summary line in the future.
2150 lfs_df() {
2151         $LFS df $* | sed -e 's/filesystem /filesystem_/'
2152 }
2153
2154 # Get free inodes on the MDT specified by mdt index, free indoes on
2155 # the whole filesystem will be returned when index == -1.
2156 mdt_free_inodes() {
2157         local index=$1
2158         local free_inodes
2159         local mdt_uuid
2160
2161         if [ $index -eq -1 ]; then
2162                 mdt_uuid="summary"
2163         else
2164                 mdt_uuid=$(mdtuuid_from_index $index)
2165         fi
2166
2167         free_inodes=$(lfs_df -i $MOUNT | grep $mdt_uuid | awk '{print $4}')
2168         echo $free_inodes
2169 }
2170
2171 #
2172 # Get the OST device status from 'lfs df' with a given OST index.
2173 #
2174 ost_dev_status() {
2175         local ost_idx=$1
2176         local mnt_pnt=${2:-$MOUNT}
2177         local ost_uuid
2178
2179         ost_uuid=$(ostuuid_from_index $ost_idx $mnt_pnt)
2180         lfs_df $mnt_pnt | awk '/'$ost_uuid'/ { print $7 }'
2181 }
2182
2183 setup_quota(){
2184         local mntpt=$1
2185
2186         # save old quota type & set new quota type
2187         local mdt_qtype=$(mdt_quota_type)
2188         local ost_qtype=$(ost_quota_type)
2189
2190         echo "[HOST:$HOSTNAME] [old_mdt_qtype:$mdt_qtype]" \
2191                 "[old_ost_qtype:$ost_qtype] [new_qtype:$QUOTA_TYPE]"
2192
2193         export old_MDT_QUOTA_TYPE=$mdt_qtype
2194         export old_OST_QUOTA_TYPE=$ost_qtype
2195
2196         if [[ $PERM_CMD == *"set_param -P"* ]]; then
2197                 do_facet mgs $PERM_CMD \
2198                         osd-*.$FSNAME-MDT*.quota_slave.enable=$QUOTA_TYPE
2199                 do_facet mgs $PERM_CMD \
2200                         osd-*.$FSNAME-OST*.quota_slave.enable=$QUOTA_TYPE
2201         else
2202                 do_facet mgs $PERM_CMD $FSNAME.quota.mdt=$QUOTA_TYPE ||
2203                         error "set mdt quota type failed"
2204                 do_facet mgs $PERM_CMD $FSNAME.quota.ost=$QUOTA_TYPE ||
2205                         error "set ost quota type failed"
2206         fi
2207
2208         local quota_usrs=$QUOTA_USERS
2209
2210         # get_filesystem_size
2211         local disksz=$(lfs_df $mntpt | grep "summary" | awk '{print $2}')
2212         local blk_soft=$((disksz + 1024))
2213         local blk_hard=$((blk_soft + blk_soft / 20)) # Go 5% over
2214
2215         local inodes=$(lfs_df -i $mntpt | grep "summary" | awk '{print $2}')
2216         local i_soft=$inodes
2217         local i_hard=$((i_soft + i_soft / 20))
2218
2219         echo "Total disk size: $disksz  block-softlimit: $blk_soft" \
2220                 "block-hardlimit: $blk_hard inode-softlimit: $i_soft" \
2221                 "inode-hardlimit: $i_hard"
2222
2223         local cmd
2224         for usr in $quota_usrs; do
2225                 echo "Setting up quota on $HOSTNAME:$mntpt for $usr..."
2226                 for type in u g; do
2227                         cmd="$LFS setquota -$type $usr -b $blk_soft"
2228                         cmd="$cmd -B $blk_hard -i $i_soft -I $i_hard $mntpt"
2229                         echo "+ $cmd"
2230                         eval $cmd || error "$cmd FAILED!"
2231                 done
2232                 # display the quota status
2233                 echo "Quota settings for $usr : "
2234                 $LFS quota -v -u $usr $mntpt || true
2235         done
2236 }
2237
2238 zconf_mount() {
2239         local client=$1
2240         local mnt=$2
2241         local opts=${3:-$MOUNT_OPTS}
2242         opts=${opts:+-o $opts}
2243         local flags=${4:-$MOUNT_FLAGS}
2244
2245         local device=$MGSNID:/$FSNAME$FILESET
2246         if [ -z "$mnt" -o -z "$FSNAME" ]; then
2247                 echo "Bad mount command: opt=$flags $opts dev=$device " \
2248                      "mnt=$mnt"
2249                 exit 1
2250         fi
2251
2252         echo "Starting client: $client: $flags $opts $device $mnt"
2253         do_node $client mkdir -p $mnt
2254         if [ -n "$FILESET" -a -z "$SKIP_FILESET" ];then
2255                 do_node $client $MOUNT_CMD $flags $opts $MGSNID:/$FSNAME \
2256                         $mnt || return 1
2257                 #disable FILESET if not supported
2258                 do_nodes $client lctl get_param -n \
2259                         mdc.$FSNAME-MDT0000*.import | grep -q subtree ||
2260                                 device=$MGSNID:/$FSNAME
2261                 do_node $client mkdir -p $mnt/$FILESET
2262                 do_node $client "! grep -q $mnt' ' /proc/mounts ||
2263                         umount $mnt"
2264         fi
2265         if $GSS_SK && ($SK_UNIQUE_NM || $SK_S2S); then
2266                 # Mount using nodemap key
2267                 local mountkey=$SK_PATH/$FSNAME-nmclient.key
2268                 if $SK_UNIQUE_NM; then
2269                         mountkey=$SK_PATH/nodemap/c0.key
2270                 fi
2271                 local prunedopts=$(echo $opts |
2272                                 sed -e "s#skpath=[^,^ ]*#skpath=$mountkey#g")
2273                 do_node $client $MOUNT_CMD $flags $prunedopts $device $mnt ||
2274                                 return 1
2275         else
2276                 do_node $client $MOUNT_CMD $flags $opts $device $mnt ||
2277                                 return 1
2278         fi
2279
2280         set_default_debug_nodes $client
2281
2282         return 0
2283 }
2284
2285 zconf_umount() {
2286     local client=$1
2287     local mnt=$2
2288     local force
2289     local busy
2290     local need_kill
2291
2292     [ "$3" ] && force=-f
2293     local running=$(do_node $client "grep -c $mnt' ' /proc/mounts") || true
2294     if [ $running -ne 0 ]; then
2295         echo "Stopping client $client $mnt (opts:$force)"
2296         do_node $client lsof -t $mnt || need_kill=no
2297         if [ "x$force" != "x" -a "x$need_kill" != "xno" ]; then
2298             pids=$(do_node $client lsof -t $mnt | sort -u);
2299             if [ -n $pids ]; then
2300                 do_node $client kill -9 $pids || true
2301             fi
2302         fi
2303
2304         busy=$(do_node $client "umount $force $mnt 2>&1" | grep -c "busy") || true
2305         if [ $busy -ne 0 ] ; then
2306             echo "$mnt is still busy, wait one second" && sleep 1
2307             do_node $client umount $force $mnt
2308         fi
2309     fi
2310 }
2311
2312 # Mount the file system on the MGS
2313 mount_mgs_client() {
2314         do_facet mgs "mkdir -p $MOUNT"
2315         zconf_mount $mgs_HOST $MOUNT $MOUNT_OPTS ||
2316                 error "unable to mount $MOUNT on MGS"
2317 }
2318
2319 # Unmount the file system on the MGS
2320 umount_mgs_client() {
2321         zconf_umount $mgs_HOST $MOUNT
2322         do_facet mgs "rm -rf $MOUNT"
2323 }
2324
2325 # nodes is comma list
2326 sanity_mount_check_nodes () {
2327     local nodes=$1
2328     shift
2329     local mnts="$@"
2330     local mnt
2331
2332     # FIXME: assume that all cluster nodes run the same os
2333     [ "$(uname)" = Linux ] || return 0
2334
2335     local rc=0
2336     for mnt in $mnts ; do
2337         do_nodes $nodes "running=\\\$(grep -c $mnt' ' /proc/mounts);
2338 mpts=\\\$(mount | grep -c $mnt' ');
2339 if [ \\\$running -ne \\\$mpts ]; then
2340     echo \\\$(hostname) env are INSANE!;
2341     exit 1;
2342 fi"
2343     [ $? -eq 0 ] || rc=1
2344     done
2345     return $rc
2346 }
2347
2348 sanity_mount_check_servers () {
2349     [ -n "$CLIENTONLY" ] &&
2350         { echo "CLIENTONLY mode, skip mount_check_servers"; return 0; } || true
2351     echo Checking servers environments
2352
2353     # FIXME: modify get_facets to display all facets wo params
2354     local facets="$(get_facets OST),$(get_facets MDS),mgs"
2355     local node
2356     local mntpt
2357     local facet
2358     for facet in ${facets//,/ }; do
2359         node=$(facet_host ${facet})
2360         mntpt=$(facet_mntpt $facet)
2361         sanity_mount_check_nodes $node $mntpt ||
2362             { error "server $node environments are insane!"; return 1; }
2363     done
2364 }
2365
2366 sanity_mount_check_clients () {
2367     local clients=${1:-$CLIENTS}
2368     local mntpt=${2:-$MOUNT}
2369     local mntpt2=${3:-$MOUNT2}
2370
2371     [ -z $clients ] && clients=$(hostname)
2372     echo Checking clients $clients environments
2373
2374     sanity_mount_check_nodes $clients $mntpt $mntpt2 ||
2375        error "clients environments are insane!"
2376 }
2377
2378 sanity_mount_check () {
2379     sanity_mount_check_servers || return 1
2380     sanity_mount_check_clients || return 2
2381 }
2382
2383 # mount clients if not mouted
2384 zconf_mount_clients() {
2385         local clients=$1
2386         local mnt=$2
2387         local opts=${3:-$MOUNT_OPTS}
2388         opts=${opts:+-o $opts}
2389         local flags=${4:-$MOUNT_FLAGS}
2390         local device=$MGSNID:/$FSNAME$FILESET
2391         if [ -z "$mnt" -o -z "$FSNAME" ]; then
2392                 echo "Bad conf mount command: opt=$flags $opts dev=$device " \
2393                      "mnt=$mnt"
2394                 exit 1
2395         fi
2396
2397         echo "Starting client $clients: $flags $opts $device $mnt"
2398         do_nodes $clients mkdir -p $mnt
2399         if [ -n "$FILESET" -a -z "$SKIP_FILESET" ]; then
2400                 if $GSS_SK && ($SK_UNIQUE_NM || $SK_S2S); then
2401                         # Mount with own nodemap key
2402                         local i=0
2403                         # Mount all server nodes first with per-NM keys
2404                         for nmclient in ${clients//,/ }; do
2405 #                               do_nodes $(comma_list $(all_server_nodes)) "lgss_sk -t server -l $SK_PATH/nodemap/c$i.key -n c$i"
2406                                 do_nodes $(comma_list $(all_server_nodes)) "lgss_sk -t server -l $SK_PATH/nodemap/c$i.key"
2407                                 i=$((i + 1))
2408                         done
2409                         # set perms for per-nodemap keys else permission denied
2410                         do_nodes $(comma_list $(all_nodes)) \
2411                                 "keyctl show | grep lustre | cut -c1-11 |
2412                                 sed -e 's/ //g;' |
2413                                 xargs -IX keyctl setperm X 0x3f3f3f3f"
2414                         local mountkey=$SK_PATH/$FSNAME-nmclient.key
2415                         i=0
2416                         for nmclient in ${clients//,/ }; do
2417                                 if $SK_UNIQUE_NM; then
2418                                         mountkey=$SK_PATH/nodemap/c$i.key
2419                                 fi
2420                                 do_node $nmclient "! grep -q $mnt' ' \
2421                                         /proc/mounts || umount $mnt"
2422                                 local prunedopts=$(add_sk_mntflag $prunedopts);
2423                                 prunedopts=$(echo $prunedopts | sed -e \
2424                                         "s#skpath=[^ ^,]*#skpath=$mountkey#g")
2425                                 set -x
2426                                 do_nodes $(comma_list $(all_server_nodes)) \
2427                                         "keyctl show"
2428                                 set +x
2429                                 do_node $nmclient $MOUNT_CMD $flags \
2430                                         $prunedopts $MGSNID:/$FSNAME $mnt ||
2431                                         return 1
2432                                 i=$((i + 1))
2433                         done
2434                 else
2435                         do_nodes $clients "! grep -q $mnt' ' /proc/mounts ||
2436                                         umount $mnt"
2437                         do_nodes $clients $MOUNT_CMD $flags $opts \
2438                                         $MGSNID:/$FSNAME $mnt || return 1
2439                 fi
2440                 #disable FILESET if not supported
2441                 do_nodes $clients lctl get_param -n \
2442                         mdc.$FSNAME-MDT0000*.import | grep -q subtree ||
2443                                 device=$MGSNID:/$FSNAME
2444                 do_nodes $clients mkdir -p $mnt/$FILESET
2445                 do_nodes $clients "! grep -q $mnt' ' /proc/mounts ||
2446                         umount $mnt"
2447         fi
2448
2449         if $GSS_SK && ($SK_UNIQUE_NM || $SK_S2S); then
2450                 # Mount with nodemap key
2451                 local i=0
2452                 local mountkey=$SK_PATH/$FSNAME-nmclient.key
2453                 for nmclient in ${clients//,/ }; do
2454                         if $SK_UNIQUE_NM; then
2455                                 mountkey=$SK_PATH/nodemap/c$i.key
2456                         fi
2457                         local prunedopts=$(echo $opts | sed -e \
2458                                 "s#skpath=[^ ^,]*#skpath=$mountkey#g");
2459                         do_node $nmclient "! grep -q $mnt' ' /proc/mounts ||
2460                                 umount $mnt"
2461                         do_node $nmclient "
2462                 running=\\\$(mount | grep -c $mnt' ');
2463                 rc=0;
2464                 if [ \\\$running -eq 0 ] ; then
2465                         mkdir -p $mnt;
2466                         $MOUNT_CMD $flags $prunedopts $device $mnt;
2467                         rc=\\\$?;
2468                 else
2469                         lustre_mnt_count=\\\$(mount | grep $mnt' ' | \
2470                                 grep 'type lustre' | wc -l);
2471                         if [ \\\$running -ne \\\$lustre_mnt_count ] ; then
2472                                 echo zconf_mount_clients FAILED: \
2473                                         mount count \\\$running, not matching \
2474                                         with mount count of 'type lustre' \
2475                                         \\\$lustre_mnt_count;
2476                                 rc=1;
2477                         fi;
2478                 fi;
2479         exit \\\$rc" || return ${PIPESTATUS[0]}
2480
2481                         i=$((i + 1))
2482                 done
2483         else
2484
2485                 local tmpopts=$opts
2486                 if $SHARED_KEY; then
2487                         tmpopts=$(add_sk_mntflag $opts)
2488                 fi
2489                 do_nodes $clients "
2490 running=\\\$(mount | grep -c $mnt' ');
2491 rc=0;
2492 if [ \\\$running -eq 0 ] ; then
2493         mkdir -p $mnt;
2494         $MOUNT_CMD $flags $tmpopts $device $mnt;
2495         rc=\\\$?;
2496 fi;
2497 exit \\\$rc" || return ${PIPESTATUS[0]}
2498         fi
2499
2500         echo "Started clients $clients: "
2501         do_nodes $clients "mount | grep $mnt' '"
2502
2503         set_default_debug_nodes $clients
2504
2505         return 0
2506 }
2507
2508 zconf_umount_clients() {
2509     local clients=$1
2510     local mnt=$2
2511     local force
2512
2513     [ "$3" ] && force=-f
2514
2515     echo "Stopping clients: $clients $mnt (opts:$force)"
2516     do_nodes $clients "running=\\\$(grep -c $mnt' ' /proc/mounts);
2517 if [ \\\$running -ne 0 ] ; then
2518 echo Stopping client \\\$(hostname) $mnt opts:$force;
2519 lsof $mnt || need_kill=no;
2520 if [ "x$force" != "x" -a "x\\\$need_kill" != "xno" ]; then
2521     pids=\\\$(lsof -t $mnt | sort -u);
2522     if [ -n \\\"\\\$pids\\\" ]; then
2523              kill -9 \\\$pids;
2524     fi
2525 fi;
2526 while umount $force $mnt 2>&1 | grep -q "busy"; do
2527     echo "$mnt is still busy, wait one second" && sleep 1;
2528 done;
2529 fi"
2530 }
2531
2532 shutdown_node () {
2533     local node=$1
2534     echo + $POWER_DOWN $node
2535     $POWER_DOWN $node
2536 }
2537
2538 shutdown_node_hard () {
2539     local host=$1
2540     local attempts=$SHUTDOWN_ATTEMPTS
2541
2542     for i in $(seq $attempts) ; do
2543         shutdown_node $host
2544         sleep 1
2545         wait_for_function --quiet "! ping -w 3 -c 1 $host" 5 1 && return 0
2546         echo "waiting for $host to fail attempts=$attempts"
2547         [ $i -lt $attempts ] || \
2548             { echo "$host still pingable after power down! attempts=$attempts" && return 1; }
2549     done
2550 }
2551
2552 shutdown_client() {
2553     local client=$1
2554     local mnt=${2:-$MOUNT}
2555     local attempts=3
2556
2557     if [ "$FAILURE_MODE" = HARD ]; then
2558         shutdown_node_hard $client
2559     else
2560        zconf_umount_clients $client $mnt -f
2561     fi
2562 }
2563
2564 facets_on_host () {
2565     local host=$1
2566     local facets="$(get_facets OST),$(get_facets MDS)"
2567     local affected
2568
2569     combined_mgs_mds || facets="$facets,mgs"
2570
2571     for facet in ${facets//,/ }; do
2572         if [ $(facet_active_host $facet) == $host ]; then
2573            affected="$affected $facet"
2574         fi
2575     done
2576
2577     echo $(comma_list $affected)
2578 }
2579
2580 facet_up() {
2581         local facet=$1
2582         local host=${2:-$(facet_host $facet)}
2583
2584         local label=$(convert_facet2label $facet)
2585         do_node $host $LCTL dl | awk '{ print $4 }' | grep -q "^$label\$"
2586 }
2587
2588 facets_up_on_host () {
2589     local host=$1
2590     local facets=$(facets_on_host $host)
2591     local affected_up
2592
2593     for facet in ${facets//,/ }; do
2594         if $(facet_up $facet $host); then
2595             affected_up="$affected_up $facet"
2596         fi
2597     done
2598
2599     echo $(comma_list $affected_up)
2600 }
2601
2602 shutdown_facet() {
2603         local facet=$1
2604         local affected_facet
2605         local affected_facets
2606
2607         if [[ "$FAILURE_MODE" = HARD ]]; then
2608                 if [[ $(facet_fstype $facet) = ldiskfs ]] &&
2609                         dm_flakey_supported $facet; then
2610                         affected_facets=$(affected_facets $facet)
2611                         for affected_facet in ${affected_facets//,/ }; do
2612                                 unexport_dm_dev $affected_facet
2613                         done
2614                 fi
2615
2616                 shutdown_node_hard $(facet_active_host $facet)
2617         else
2618                 stop $facet
2619         fi
2620 }
2621
2622 reboot_node() {
2623     local node=$1
2624     echo + $POWER_UP $node
2625     $POWER_UP $node
2626 }
2627
2628 remount_facet() {
2629     local facet=$1
2630
2631     stop $facet
2632     mount_facet $facet
2633 }
2634
2635 reboot_facet() {
2636         local facet=$1
2637         if [ "$FAILURE_MODE" = HARD ]; then
2638                 reboot_node $(facet_active_host $facet)
2639         else
2640                 sleep 10
2641         fi
2642 }
2643
2644 boot_node() {
2645     local node=$1
2646     if [ "$FAILURE_MODE" = HARD ]; then
2647        reboot_node $node
2648        wait_for_host $node
2649     fi
2650 }
2651
2652 facets_hosts () {
2653     local facets=$1
2654     local hosts
2655
2656     for facet in ${facets//,/ }; do
2657         hosts=$(expand_list $hosts $(facet_host $facet) )
2658     done
2659
2660     echo $hosts
2661 }
2662
2663 _check_progs_installed () {
2664     local progs=$@
2665     local rc=0
2666
2667     for prog in $progs; do
2668         if ! [ "$(which $prog)"  -o  "${!prog}" ]; then
2669            echo $prog missing on $(hostname)
2670            rc=1
2671         fi
2672     done
2673     return $rc
2674 }
2675
2676 check_progs_installed () {
2677         local nodes=$1
2678         shift
2679
2680         do_rpc_nodes "$nodes" _check_progs_installed $@
2681 }
2682
2683 # recovery-scale functions
2684 node_var_name() {
2685     echo __$(echo $1 | tr '-' '_' | tr '.' '_')
2686 }
2687
2688 start_client_load() {
2689         local client=$1
2690         local load=$2
2691         local var=$(node_var_name $client)_load
2692         eval export ${var}=$load
2693
2694         do_node $client "PATH=$PATH MOUNT=$MOUNT ERRORS_OK=$ERRORS_OK \
2695                         BREAK_ON_ERROR=$BREAK_ON_ERROR \
2696                         END_RUN_FILE=$END_RUN_FILE \
2697                         LOAD_PID_FILE=$LOAD_PID_FILE \
2698                         TESTLOG_PREFIX=$TESTLOG_PREFIX \
2699                         TESTNAME=$TESTNAME \
2700                         DBENCH_LIB=$DBENCH_LIB \
2701                         DBENCH_SRC=$DBENCH_SRC \
2702                         CLIENT_COUNT=$((CLIENTCOUNT - 1)) \
2703                         LFS=$LFS \
2704                         LCTL=$LCTL \
2705                         FSNAME=$FSNAME \
2706                         MPIRUN=$MPIRUN \
2707                         MPIRUN_OPTIONS=\\\"$MPIRUN_OPTIONS\\\" \
2708                         MACHINEFILE_OPTION=\\\"$MACHINEFILE_OPTION\\\" \
2709                         num_clients=$(get_node_count ${CLIENTS//,/ }) \
2710                         ior_THREADS=$ior_THREADS ior_iteration=$ior_iteration \
2711                         ior_blockSize=$ior_blockSize \
2712                         ior_blockUnit=$ior_blockUnit \
2713                         ior_xferSize=$ior_xferSize ior_type=$ior_type \
2714                         ior_DURATION=$ior_DURATION \
2715                         ior_stripe_params=\\\"$ior_stripe_params\\\" \
2716                         ior_custom_params=\\\"$ior_custom_param\\\" \
2717                         mpi_ior_custom_threads=$mpi_ior_custom_threads \
2718                         run_${load}.sh" &
2719         local ppid=$!
2720         log "Started client load: ${load} on $client"
2721
2722         # get the children process IDs
2723         local pids=$(ps --ppid $ppid -o pid= | xargs)
2724         CLIENT_LOAD_PIDS="$CLIENT_LOAD_PIDS $ppid $pids"
2725         return 0
2726 }
2727
2728 start_client_loads () {
2729     local -a clients=(${1//,/ })
2730     local numloads=${#CLIENT_LOADS[@]}
2731     local testnum
2732
2733     for ((nodenum=0; nodenum < ${#clients[@]}; nodenum++ )); do
2734         testnum=$((nodenum % numloads))
2735         start_client_load ${clients[nodenum]} ${CLIENT_LOADS[testnum]}
2736     done
2737     # bug 22169: wait the background threads to start
2738     sleep 2
2739 }
2740
2741 # only for remote client
2742 check_client_load () {
2743         local client=$1
2744         local var=$(node_var_name $client)_load
2745         local testload=run_${!var}.sh
2746
2747         ps auxww | grep -v grep | grep $client | grep -q $testload || return 1
2748
2749         # bug 18914: try to connect several times not only when
2750         # check ps, but  while check_node_health also
2751
2752         local tries=3
2753         local RC=254
2754         while [ $RC = 254 -a $tries -gt 0 ]; do
2755                 let tries=$tries-1
2756                 # assume success
2757                 RC=0
2758                 if ! check_node_health $client; then
2759                         RC=${PIPESTATUS[0]}
2760                         if [ $RC -eq 254 ]; then
2761                                 # FIXME: not sure how long we shuold sleep here
2762                                 sleep 10
2763                                 continue
2764                         fi
2765                         echo "check node health failed: RC=$RC "
2766                         return $RC
2767                 fi
2768         done
2769         # We can continue try to connect if RC=254
2770         # Just print the warning about this
2771         if [ $RC = 254 ]; then
2772                 echo "got a return status of $RC from do_node while checking " \
2773                 "node health on $client"
2774         fi
2775
2776         # see if the load is still on the client
2777         tries=3
2778         RC=254
2779         while [ $RC = 254 -a $tries -gt 0 ]; do
2780                 let tries=$tries-1
2781                 # assume success
2782                 RC=0
2783                 if ! do_node $client \
2784                         "ps auxwww | grep -v grep | grep -q $testload"; then
2785                         RC=${PIPESTATUS[0]}
2786                         sleep 30
2787                 fi
2788         done
2789         if [ $RC = 254 ]; then
2790                 echo "got a return status of $RC from do_node while checking " \
2791                 "(node health and 'ps') the client load on $client"
2792                 # see if we can diagnose a bit why this is
2793         fi
2794
2795         return $RC
2796 }
2797 check_client_loads () {
2798    local clients=${1//,/ }
2799    local client=
2800    local rc=0
2801
2802    for client in $clients; do
2803       check_client_load $client
2804       rc=${PIPESTATUS[0]}
2805       if [ "$rc" != 0 ]; then
2806         log "Client load failed on node $client, rc=$rc"
2807         return $rc
2808       fi
2809    done
2810 }
2811
2812 restart_client_loads () {
2813     local clients=${1//,/ }
2814     local expectedfail=${2:-""}
2815     local client=
2816     local rc=0
2817
2818     for client in $clients; do
2819         check_client_load $client
2820         rc=${PIPESTATUS[0]}
2821         if [ "$rc" != 0 -a "$expectedfail" ]; then
2822             local var=$(node_var_name $client)_load
2823             start_client_load $client ${!var}
2824             echo "Restarted client load ${!var}: on $client. Checking ..."
2825             check_client_load $client
2826             rc=${PIPESTATUS[0]}
2827             if [ "$rc" != 0 ]; then
2828                 log "Client load failed to restart on node $client, rc=$rc"
2829                 # failure one client load means test fail
2830                 # we do not need to check other
2831                 return $rc
2832             fi
2833         else
2834             return $rc
2835         fi
2836     done
2837 }
2838
2839 # Start vmstat and save its process ID in a file.
2840 start_vmstat() {
2841     local nodes=$1
2842     local pid_file=$2
2843
2844     [ -z "$nodes" -o -z "$pid_file" ] && return 0
2845
2846     do_nodes $nodes \
2847         "vmstat 1 > $TESTLOG_PREFIX.$TESTNAME.vmstat.\\\$(hostname -s).log \
2848         2>/dev/null </dev/null & echo \\\$! > $pid_file"
2849 }
2850
2851 # Display the nodes on which client loads failed.
2852 print_end_run_file() {
2853     local file=$1
2854     local node
2855
2856     [ -s $file ] || return 0
2857
2858     echo "Found the END_RUN_FILE file: $file"
2859     cat $file
2860
2861     # A client load will stop if it finds the END_RUN_FILE file.
2862     # That does not mean the client load actually failed though.
2863     # The first node in END_RUN_FILE is the one we are interested in.
2864     read node < $file
2865
2866     if [ -n "$node" ]; then
2867         local var=$(node_var_name $node)_load
2868
2869         local prefix=$TESTLOG_PREFIX
2870         [ -n "$TESTNAME" ] && prefix=$prefix.$TESTNAME
2871         local stdout_log=$prefix.run_${!var}_stdout.$node.log
2872         local debug_log=$(echo $stdout_log | sed 's/\(.*\)stdout/\1debug/')
2873
2874         echo "Client load ${!var} failed on node $node:"
2875         echo "$stdout_log"
2876         echo "$debug_log"
2877     fi
2878 }
2879
2880 # Stop the process which had its PID saved in a file.
2881 stop_process() {
2882     local nodes=$1
2883     local pid_file=$2
2884
2885     [ -z "$nodes" -o -z "$pid_file" ] && return 0
2886
2887     do_nodes $nodes "test -f $pid_file &&
2888         { kill -s TERM \\\$(cat $pid_file); rm -f $pid_file; }" || true
2889 }
2890
2891 # Stop all client loads.
2892 stop_client_loads() {
2893     local nodes=${1:-$CLIENTS}
2894     local pid_file=$2
2895
2896     # stop the client loads
2897     stop_process $nodes $pid_file
2898
2899     # clean up the processes that started them
2900     [ -n "$CLIENT_LOAD_PIDS" ] && kill -9 $CLIENT_LOAD_PIDS 2>/dev/null || true
2901 }
2902 # End recovery-scale functions
2903
2904 # verify that lustre actually cleaned up properly
2905 cleanup_check() {
2906         VAR=$(lctl get_param -n catastrophe 2>&1)
2907         if [ $? = 0 ] ; then
2908                 if [ $VAR != 0 ]; then
2909                         error "LBUG/LASSERT detected"
2910                 fi
2911         fi
2912         BUSY=$(dmesg | grep -i destruct || true)
2913         if [ -n "$BUSY" ]; then
2914                 echo "$BUSY" 1>&2
2915                 [ -e $TMP/debug ] && mv $TMP/debug $TMP/debug-busy.$(date +%s)
2916                 exit 205
2917         fi
2918
2919         check_mem_leak || exit 204
2920
2921         [[ $($LCTL dl 2>/dev/null | wc -l) -gt 0 ]] && $LCTL dl &&
2922                 echo "$TESTSUITE: lustre didn't clean up..." 1>&2 &&
2923                 return 202 || true
2924
2925         if module_loaded lnet || module_loaded libcfs; then
2926                 echo "$TESTSUITE: modules still loaded..." 1>&2
2927                 /sbin/lsmod 1>&2
2928                 return 203
2929         fi
2930         return 0
2931 }
2932
2933 wait_update () {
2934         local verbose=false
2935         if [[ "$1" == "--verbose" ]]; then
2936                 shift
2937                 verbose=true
2938         fi
2939
2940         local node=$1
2941         local TEST=$2
2942         local FINAL=$3
2943         local MAX=${4:-90}
2944         local RESULT
2945         local PREV_RESULT
2946         local WAIT=0
2947         local sleep=1
2948         local print=10
2949
2950         PREV_RESULT=$(do_node $node "$TEST")
2951         while [ true ]; do
2952                 RESULT=$(do_node $node "$TEST")
2953                 if [[ "$RESULT" == "$FINAL" ]]; then
2954                         [[ -z "$RESULT" || $WAIT -le $sleep ]] ||
2955                                 echo "Updated after ${WAIT}s: wanted '$FINAL'"\
2956                                      "got '$RESULT'"
2957                         return 0
2958                 fi
2959                 if [[ $verbose && "$RESULT" != "$PREV_RESULT" ]]; then
2960                         echo "Changed after ${WAIT}s: from '$PREV_RESULT'"\
2961                              "to '$RESULT'"
2962                         PREV_RESULT=$RESULT
2963                 fi
2964                 [[ $WAIT -ge $MAX ]] && break
2965                 [[ $((WAIT % print)) -eq 0 ]] &&
2966                         echo "Waiting $((MAX - WAIT)) secs for update"
2967                 WAIT=$((WAIT + sleep))
2968                 sleep $sleep
2969         done
2970         echo "Update not seen after ${MAX}s: wanted '$FINAL' got '$RESULT'"
2971         return 3
2972 }
2973
2974 wait_update_facet() {
2975         local verbose=
2976         [ "$1" = "--verbose" ] && verbose="$1" && shift
2977
2978         local facet=$1
2979         shift
2980         wait_update $verbose $(facet_active_host $facet) "$@"
2981 }
2982
2983 sync_all_data() {
2984         do_nodes $(comma_list $(mdts_nodes)) \
2985             "lctl set_param -n os[cd]*.*MDT*.force_sync=1"
2986         do_nodes $(comma_list $(osts_nodes)) \
2987             "lctl set_param -n osd*.*OS*.force_sync=1" 2>&1 |
2988                 grep -v 'Found no match'
2989 }
2990
2991 wait_zfs_commit() {
2992         local zfs_wait=${2:-5}
2993
2994         # the occupied disk space will be released
2995         # only after TXGs are committed
2996         if [[ $(facet_fstype $1) == zfs ]]; then
2997                 echo "sleep $zfs_wait for ZFS $(facet_fstype $1)"
2998                 sleep $zfs_wait
2999         fi
3000 }
3001
3002 wait_delete_completed_mds() {
3003         local max_wait=${1:-20}
3004         local mds2sync=""
3005         local stime=$(date +%s)
3006         local etime
3007         local node
3008         local changes
3009
3010         # find MDS with pending deletions
3011         for node in $(mdts_nodes); do
3012                 changes=$(do_node $node "$LCTL get_param -n osc.*MDT*.sync_*" \
3013                         2>/dev/null | calc_sum)
3014                 if [[ $changes -eq 0 ]]; then
3015                         continue
3016                 fi
3017                 mds2sync="$mds2sync $node"
3018         done
3019         if [ -z "$mds2sync" ]; then
3020                 wait_zfs_commit $SINGLEMDS
3021                 return 0
3022         fi
3023         mds2sync=$(comma_list $mds2sync)
3024
3025         # sync MDS transactions
3026         do_nodes $mds2sync "$LCTL set_param -n os[cd]*.*MD*.force_sync 1"
3027
3028         # wait till all changes are sent and commmitted by OSTs
3029         # for ldiskfs space is released upon execution, but DMU
3030         # do this upon commit
3031
3032         local WAIT=0
3033         while [[ $WAIT -ne $max_wait ]]; do
3034                 changes=$(do_nodes $mds2sync \
3035                         "$LCTL get_param -n osc.*MDT*.sync_*" | calc_sum)
3036                 #echo "$node: $changes changes on all"
3037                 if [[ $changes -eq 0 ]]; then
3038                         wait_zfs_commit $SINGLEMDS
3039
3040                         # the occupied disk space will be released
3041                         # only after TXGs are committed
3042                         wait_zfs_commit ost1
3043                         return 0
3044                 fi
3045                 sleep 1
3046                 WAIT=$((WAIT + 1))
3047         done
3048
3049         etime=$(date +%s)
3050         echo "Delete is not completed in $((etime - stime)) seconds"
3051         do_nodes $mds2sync "$LCTL get_param osc.*MDT*.sync_*"
3052         return 1
3053 }
3054
3055 wait_for_host() {
3056     local hostlist=$1
3057
3058     # we can use "for" here because we are waiting the slowest
3059     for host in ${hostlist//,/ }; do
3060         check_network "$host" 900
3061     done
3062     while ! do_nodes $hostlist hostname  > /dev/null; do sleep 5; done
3063 }
3064
3065 wait_for_facet() {
3066     local facetlist=$1
3067     local hostlist
3068
3069     for facet in ${facetlist//,/ }; do
3070         hostlist=$(expand_list $hostlist $(facet_active_host $facet))
3071     done
3072     wait_for_host $hostlist
3073 }
3074
3075 _wait_recovery_complete () {
3076     local param=$1
3077
3078     # Use default policy if $2 is not passed by caller.
3079     local MAX=${2:-$(max_recovery_time)}
3080
3081     local WAIT=0
3082     local STATUS=
3083
3084     while [ $WAIT -lt $MAX ]; do
3085         STATUS=$(lctl get_param -n $param | grep status)
3086         echo $param $STATUS
3087         [[ $STATUS = "status: COMPLETE" || $STATUS = "status: INACTIVE" ]] && return 0
3088         sleep 5
3089         WAIT=$((WAIT + 5))
3090         echo "Waiting $((MAX - WAIT)) secs for $param recovery done. $STATUS"
3091     done
3092     echo "$param recovery not done in $MAX sec. $STATUS"
3093     return 1
3094 }
3095
3096 wait_recovery_complete () {
3097     local facet=$1
3098
3099     # with an assumption that at_max is the same on all nodes
3100     local MAX=${2:-$(max_recovery_time)}
3101
3102     local facets=$facet
3103     if [ "$FAILURE_MODE" = HARD ]; then
3104         facets=$(facets_on_host $(facet_active_host $facet))
3105     fi
3106     echo affected facets: $facets
3107
3108         # we can use "for" here because we are waiting the slowest
3109         for facet in ${facets//,/ }; do
3110                 local var_svc=${facet}_svc
3111                 local param="*.${!var_svc}.recovery_status"
3112
3113                 local host=$(facet_active_host $facet)
3114                 do_rpc_nodes "$host" _wait_recovery_complete $param $MAX
3115         done
3116 }
3117
3118 wait_mds_ost_sync () {
3119         # just because recovery is done doesn't mean we've finished
3120         # orphan cleanup. Wait for llogs to get synchronized.
3121         echo "Waiting for orphan cleanup..."
3122         # MAX value includes time needed for MDS-OST reconnection
3123         local MAX=$(( TIMEOUT * 2 ))
3124         local WAIT_TIMEOUT=${1:-$MAX}
3125         local WAIT=0
3126         local new_wait=true
3127         local list=$(comma_list $(mdts_nodes))
3128         local cmd="$LCTL get_param -n osp.*osc*.old_sync_processed"
3129         if ! do_facet $SINGLEMDS \
3130                 "$LCTL list_param osp.*osc*.old_sync_processed 2> /dev/null"
3131         then
3132                 # old way, use mds_sync
3133                 new_wait=false
3134                 list=$(comma_list $(osts_nodes))
3135                 cmd="$LCTL get_param -n obdfilter.*.mds_sync"
3136         fi
3137
3138         echo "wait $WAIT_TIMEOUT secs maximumly for $list mds-ost sync done."
3139         while [ $WAIT -lt $WAIT_TIMEOUT ]; do
3140                 local -a sync=($(do_nodes $list "$cmd"))
3141                 local con=1
3142                 local i
3143                 for ((i=0; i<${#sync[@]}; i++)); do
3144                         if $new_wait; then
3145                                 [ ${sync[$i]} -eq 1 ] && continue
3146                         else
3147                                 [ ${sync[$i]} -eq 0 ] && continue
3148                         fi
3149                         # there is a not finished MDS-OST synchronization
3150                         con=0
3151                         break;
3152                 done
3153                 sleep 2 # increase waiting time and cover statfs cache
3154                 [ ${con} -eq 1 ] && return 0
3155                 echo "Waiting $WAIT secs for $list $i mds-ost sync done."
3156                 WAIT=$((WAIT + 2))
3157         done
3158
3159         # show which nodes are not finished.
3160         cmd=$(echo $cmd | sed 's/-n//')
3161         do_nodes $list "$cmd"
3162         echo "$facet recovery node $i not done in $WAIT_TIMEOUT sec. $STATUS"
3163         return 1
3164 }
3165
3166 # Wait OSTs to be active on both client and MDT side.
3167 wait_osts_up() {
3168         local cmd="$LCTL get_param -n lov.$FSNAME-clilov-*.target_obd |
3169                 awk 'BEGIN {c = 0} /ACTIVE/{c += 1} END {printf \\\"%d\\\", c}'"
3170         wait_update $HOSTNAME "eval $cmd" $OSTCOUNT ||
3171                 error "wait_update OSTs up on client failed"
3172
3173         cmd="$LCTL get_param osp.$FSNAME-OST*-MDT0000.prealloc_last_id |
3174              awk '/=[1-9][0-9]/ { c += 1 } END { printf \\\"%d\\\", c }'"
3175         wait_update_facet $SINGLEMDS "eval $cmd" $OSTCOUNT ||
3176                 error "wait_update OSTs up on MDT0000 failed"
3177 }
3178
3179 wait_destroy_complete () {
3180         echo "Waiting for local destroys to complete"
3181         # MAX value shouldn't be big as this mean server responsiveness
3182         # never increase this just to make test pass but investigate
3183         # why it takes so long time
3184         local MAX=5
3185         local WAIT=0
3186         while [ $WAIT -lt $MAX ]; do
3187                 local -a RPCs=($($LCTL get_param -n osc.*.destroys_in_flight))
3188                 local con=1
3189                 local i
3190
3191                 for ((i=0; i<${#RPCs[@]}; i++)); do
3192                         [ ${RPCs[$i]} -eq 0 ] && continue
3193                         # there are still some destroy RPCs in flight
3194                         con=0
3195                         break;
3196                 done
3197                 sleep 1
3198                 [ ${con} -eq 1 ] && return 0 # done waiting
3199                 echo "Waiting ${WAIT}s for local destroys to complete"
3200                 WAIT=$((WAIT + 1))
3201         done
3202         echo "Local destroys weren't done in $MAX sec."
3203         return 1
3204 }
3205
3206 wait_delete_completed() {
3207         wait_delete_completed_mds $1 || return $?
3208         wait_destroy_complete || return $?
3209 }
3210
3211 wait_exit_ST () {
3212     local facet=$1
3213
3214     local WAIT=0
3215     local INTERVAL=1
3216     local running
3217     # conf-sanity 31 takes a long time cleanup
3218     while [ $WAIT -lt 300 ]; do
3219         running=$(do_facet ${facet} "lsmod | grep lnet > /dev/null &&
3220 lctl dl | grep ' ST ' || true")
3221         [ -z "${running}" ] && return 0
3222         echo "waited $WAIT for${running}"
3223         [ $INTERVAL -lt 64 ] && INTERVAL=$((INTERVAL + INTERVAL))
3224         sleep $INTERVAL
3225         WAIT=$((WAIT + INTERVAL))
3226     done
3227     echo "service didn't stop after $WAIT seconds.  Still running:"
3228     echo ${running}
3229     return 1
3230 }
3231
3232 wait_remote_prog () {
3233    local prog=$1
3234    local WAIT=0
3235    local INTERVAL=5
3236    local rc=0
3237
3238    [ "$PDSH" = "no_dsh" ] && return 0
3239
3240    while [ $WAIT -lt $2 ]; do
3241         running=$(ps uax | grep "$PDSH.*$prog.*$MOUNT" | grep -v grep) || true
3242         [ -z "${running}" ] && return 0 || true
3243         echo "waited $WAIT for: "
3244         echo "$running"
3245         [ $INTERVAL -lt 60 ] && INTERVAL=$((INTERVAL + INTERVAL))
3246         sleep $INTERVAL
3247         WAIT=$((WAIT + INTERVAL))
3248     done
3249     local pids=$(ps  uax | grep "$PDSH.*$prog.*$MOUNT" | grep -v grep | awk '{print $2}')
3250     [ -z "$pids" ] && return 0
3251     echo "$PDSH processes still exists after $WAIT seconds.  Still running: $pids"
3252     # FIXME: not portable
3253     for pid in $pids; do
3254         cat /proc/${pid}/status || true
3255         cat /proc/${pid}/wchan || true
3256         echo "Killing $pid"
3257         kill -9 $pid || true
3258         sleep 1
3259         ps -P $pid && rc=1
3260     done
3261
3262     return $rc
3263 }
3264
3265 lfs_df_check() {
3266         local clients=${1:-$CLIENTS}
3267
3268         if [ -z "$clients" ]; then
3269                 $LFS df $MOUNT
3270         else
3271                 $PDSH $clients "$LFS df $MOUNT" > /dev/null
3272         fi
3273 }
3274
3275 clients_up() {
3276         # not every config has many clients
3277         sleep 1
3278         lfs_df_check
3279 }
3280
3281 client_up() {
3282         # usually checked on particular client or locally
3283         sleep 1
3284         lfs_df_check $1
3285 }
3286
3287 client_evicted() {
3288     ! client_up $1
3289 }
3290
3291 client_reconnect_try() {
3292         local f=$MOUNT/recon
3293
3294         uname -n >> $f
3295         if [ -z "$CLIENTS" ]; then
3296                 $LFS df $MOUNT; uname -n >> $f
3297         else
3298                 do_nodes $CLIENTS "$LFS df $MOUNT; uname -n >> $f" > /dev/null
3299         fi
3300         echo "Connected clients: $(cat $f)"
3301         ls -l $f > /dev/null
3302         rm $f
3303 }
3304
3305 client_reconnect() {
3306         # one client_reconnect_try call does not always do the job...
3307         while true ; do
3308                 client_reconnect_try && break
3309                 sleep 1
3310         done
3311 }
3312
3313 affected_facets () {
3314     local facet=$1
3315
3316     local host=$(facet_active_host $facet)
3317     local affected=$facet
3318
3319     if [ "$FAILURE_MODE" = HARD ]; then
3320         affected=$(facets_up_on_host $host)
3321     fi
3322     echo $affected
3323 }
3324
3325 facet_failover() {
3326         local E2FSCK_ON_MDT0=false
3327         if [ "$1" == "--fsck" ]; then
3328                 shift
3329                 [ $(facet_fstype $SINGLEMDS) == ldiskfs ] &&
3330                         E2FSCK_ON_MDT0=true
3331         fi
3332
3333         local facets=$1
3334         local sleep_time=$2
3335         local -a affecteds
3336         local facet
3337         local total=0
3338         local index=0
3339         local skip
3340
3341         #Because it will only get up facets, we need get affected
3342         #facets before shutdown
3343         #For HARD Failure mode, it needs make sure facets on the same
3344         #HOST will only be shutdown and reboot once
3345         for facet in ${facets//,/ }; do
3346                 local affected_facet
3347                 skip=0
3348                 #check whether facet has been included in other affected facets
3349                 for ((index=0; index<$total; index++)); do
3350                         [[ *,$facet,* == ,${affecteds[index]}, ]] && skip=1
3351                 done
3352
3353                 if [ $skip -eq 0 ]; then
3354                         affecteds[$total]=$(affected_facets $facet)
3355                         total=$((total+1))
3356                 fi
3357         done
3358
3359         for ((index=0; index<$total; index++)); do
3360                 facet=$(echo ${affecteds[index]} | tr -s " " | cut -d"," -f 1)
3361                 local host=$(facet_active_host $facet)
3362                 echo "Failing ${affecteds[index]} on $host"
3363                 shutdown_facet $facet
3364         done
3365
3366         $E2FSCK_ON_MDT0 && (run_e2fsck $(facet_active_host $SINGLEMDS) \
3367                 $(mdsdevname 1) "-n" || error "Running e2fsck")
3368
3369         for ((index=0; index<$total; index++)); do
3370                 facet=$(echo ${affecteds[index]} | tr -s " " | cut -d"," -f 1)
3371                 echo reboot facets: ${affecteds[index]}
3372
3373                 reboot_facet $facet
3374
3375                 change_active ${affecteds[index]}
3376
3377                 wait_for_facet ${affecteds[index]}
3378                 # start mgs first if it is affected
3379                 if ! combined_mgs_mds &&
3380                         list_member ${affecteds[index]} mgs; then
3381                         mount_facet mgs || error "Restart of mgs failed"
3382                 fi
3383                 # FIXME; has to be changed to mount all facets concurrently
3384                 affected=$(exclude_items_from_list ${affecteds[index]} mgs)
3385                 echo mount facets: ${affecteds[index]}
3386                 mount_facets ${affecteds[index]}
3387         done
3388 }
3389
3390 obd_name() {
3391     local facet=$1
3392 }
3393
3394 replay_barrier() {
3395         local facet=$1
3396         do_facet $facet "sync; sync; sync"
3397         $LFS df $MOUNT
3398
3399         # make sure there will be no seq change
3400         local clients=${CLIENTS:-$HOSTNAME}
3401         local f=fsa-\\\$\(hostname\)
3402         do_nodes $clients "mcreate $MOUNT/$f; rm $MOUNT/$f"
3403         do_nodes $clients "if [ -d $MOUNT2 ]; then mcreate $MOUNT2/$f; rm $MOUNT2/$f; fi"
3404
3405         local svc=${facet}_svc
3406         do_facet $facet $LCTL --device ${!svc} notransno
3407         #
3408         # If a ZFS OSD is made read-only here, its pool is "freezed". This
3409         # in-memory state has to be cleared by either rebooting the host or
3410         # exporting and reimporting the pool.
3411         #
3412         # Although the uberblocks are not updated when a pool is freezed,
3413         # transactions are still written to the disks. Modified blocks may be
3414         # cached in memory when tests try reading them back. The
3415         # export-and-reimport process also evicts any cached pool data from
3416         # memory to provide the correct "data loss" semantics.
3417         #
3418         # In the test framework, the exporting and importing operations are
3419         # handled by stop() and mount_facet() separately, which are used
3420         # inside fail() and fail_abort().
3421         #
3422         set_dev_readonly $facet
3423         do_facet $facet $LCTL mark "$facet REPLAY BARRIER on ${!svc}"
3424         $LCTL mark "local REPLAY BARRIER on ${!svc}"
3425 }
3426
3427 replay_barrier_nodf() {
3428         local facet=$1    echo running=${running}
3429         do_facet $facet "sync; sync; sync"
3430         local svc=${facet}_svc
3431         echo Replay barrier on ${!svc}
3432         do_facet $facet $LCTL --device ${!svc} notransno
3433         set_dev_readonly $facet
3434         do_facet $facet $LCTL mark "$facet REPLAY BARRIER on ${!svc}"
3435         $LCTL mark "local REPLAY BARRIER on ${!svc}"
3436 }
3437
3438 replay_barrier_nosync() {
3439         local facet=$1    echo running=${running}
3440         local svc=${facet}_svc
3441         echo Replay barrier on ${!svc}
3442         do_facet $facet $LCTL --device ${!svc} notransno
3443         set_dev_readonly $facet
3444         do_facet $facet $LCTL mark "$facet REPLAY BARRIER on ${!svc}"
3445         $LCTL mark "local REPLAY BARRIER on ${!svc}"
3446 }
3447
3448 #
3449 # Get Lustre client uuid for a given Lustre mount point.
3450 #
3451 get_client_uuid() {
3452         local mntpnt=${1:-$MOUNT}
3453
3454         local name=$($LFS getname $mntpnt | cut -d' ' -f1)
3455         local uuid=$($LCTL get_param -n llite.$name.uuid)
3456
3457         echo -n $uuid
3458 }
3459
3460 mds_evict_client() {
3461         local mntpnt=${1:-$MOUNT}
3462         local uuid=$(get_client_uuid $mntpnt)
3463
3464         do_facet $SINGLEMDS \
3465                 "$LCTL set_param -n mdt.${mds1_svc}.evict_client $uuid"
3466 }
3467
3468 ost_evict_client() {
3469         local mntpnt=${1:-$MOUNT}
3470         local uuid=$(get_client_uuid $mntpnt)
3471
3472         do_facet ost1 \
3473                 "$LCTL set_param -n obdfilter.${ost1_svc}.evict_client $uuid"
3474 }
3475
3476 fail() {
3477         local facets=$1
3478         local clients=${CLIENTS:-$HOSTNAME}
3479
3480         facet_failover $* || error "failover: $?"
3481         # to initiate all OSC idling connections
3482         clients_up
3483         wait_clients_import_state "$clients" "$facets" "\(FULL\|IDLE\)"
3484         clients_up || error "post-failover stat: $?"
3485 }
3486
3487 fail_nodf() {
3488         local facet=$1
3489         facet_failover $facet
3490 }
3491
3492 fail_abort() {
3493         local facet=$1
3494         stop $facet
3495         change_active $facet
3496         wait_for_facet $facet
3497         mount_facet $facet -o abort_recovery
3498         clients_up || echo "first stat failed: $?"
3499         clients_up || error "post-failover stat: $?"
3500 }
3501
3502 host_nids_address() {
3503         local nodes=$1
3504         local net=${2:-"."}
3505
3506         do_nodes $nodes "$LCTL list_nids | grep $net | cut -f 1 -d @"
3507 }
3508
3509 h2name_or_ip() {
3510         if [ "$1" = "'*'" ]; then echo \'*\'; else
3511                 echo $1"@$2"
3512         fi
3513 }
3514
3515 h2nettype() {
3516         if [[ -n "$NETTYPE" ]]; then
3517                 h2name_or_ip "$1" "$NETTYPE"
3518         else
3519                 h2name_or_ip "$1" "$2"
3520         fi
3521 }
3522 declare -fx h2nettype
3523
3524 # Wrapper function to print the deprecation warning
3525 h2tcp() {
3526         echo "h2tcp: deprecated, use h2nettype instead" 1>&2
3527         if [[ -n "$NETTYPE" ]]; then
3528                 h2nettype "$@"
3529         else
3530                 h2nettype "$1" "tcp"
3531         fi
3532 }
3533
3534 # Wrapper function to print the deprecation warning
3535 h2o2ib() {
3536         echo "h2o2ib: deprecated, use h2nettype instead" 1>&2
3537         if [[ -n "$NETTYPE" ]]; then
3538                 h2nettype "$@"
3539         else
3540                 h2nettype "$1" "o2ib"
3541         fi
3542 }
3543
3544 # This enables variables in cfg/"setup".sh files to support the pdsh HOSTLIST
3545 # expressions format. As a bonus we can then just pass in those variables
3546 # to pdsh. What this function does is take a HOSTLIST type string and
3547 # expand it into a space deliminated list for us.
3548 hostlist_expand() {
3549     local hostlist=$1
3550     local offset=$2
3551     local myList
3552     local item
3553     local list
3554
3555     [ -z "$hostlist" ] && return
3556
3557     # Translate the case of [..],..,[..] to [..] .. [..]
3558     list="${hostlist/],/] }"
3559     front=${list%%[*}
3560     [[ "$front" == *,* ]] && {
3561         new="${list%,*} "
3562         old="${list%,*},"
3563         list=${list/${old}/${new}}
3564     }
3565
3566     for item in $list; do
3567         # Test if we have any []'s at all
3568         if [ "$item" != "${item/\[/}" ]; then {
3569             # Expand the [*] into list
3570             name=${item%%[*}
3571             back=${item#*]}
3572
3573             if [ "$name" != "$item" ]; then
3574                 group=${item#$name[*}
3575                 group=${group%%]*}
3576
3577                 for range in ${group//,/ }; do
3578                     local order
3579
3580                     begin=${range%-*}
3581                     end=${range#*-}
3582
3583                     # Number of leading zeros
3584                     padlen=${#begin}
3585                     padlen2=${#end}
3586                     end=$(echo $end | sed 's/0*//')
3587                     [[ -z "$end" ]] && end=0
3588                     [[ $padlen2 -gt $padlen ]] && {
3589                         [[ $padlen2 -eq ${#end} ]] && padlen2=0
3590                         padlen=$padlen2
3591                     }
3592                     begin=$(echo $begin | sed 's/0*//')
3593                     [ -z $begin ] && begin=0
3594
3595                     if [ ! -z "${begin##[!0-9]*}" ]; then
3596                         order=$(seq -f "%0${padlen}g" $begin $end)
3597                     else
3598                         order=$(eval echo {$begin..$end});
3599                     fi
3600
3601                     for num in $order; do
3602                         value="${name#*,}${num}${back}"
3603                         [ "$value" != "${value/\[/}" ] && {
3604                             value=$(hostlist_expand "$value")
3605                         }
3606                         myList="$myList $value"
3607                     done
3608                 done
3609             fi
3610         } else {
3611             myList="$myList $item"
3612         } fi
3613     done
3614     myList=${myList//,/ }
3615     myList=${myList:1} # Remove first character which is a space
3616
3617     # Filter any duplicates without sorting
3618     list="$myList "
3619     myList="${list%% *}"
3620
3621     while [[ "$list" != ${myList##* } ]]; do
3622         local tlist=" $list"
3623         list=${tlist// ${list%% *} / }
3624         list=${list:1}
3625         myList="$myList ${list%% *}"
3626     done
3627     myList="${myList%* }";
3628
3629     # We can select an object at an offset in the list
3630     [ $# -eq 2 ] && {
3631         cnt=0
3632         for item in $myList; do
3633             let cnt=cnt+1
3634             [ $cnt -eq $offset ] && {
3635                 myList=$item
3636             }
3637         done
3638         [ $(get_node_count $myList) -ne 1 ] && myList=""
3639     }
3640     echo $myList
3641 }
3642
3643 facet_host() {
3644         local facet=$1
3645         local varname
3646
3647         [ "$facet" == client ] && echo -n $HOSTNAME && return
3648         varname=${facet}_HOST
3649         if [ -z "${!varname}" ]; then
3650                 if [ "${facet:0:3}" == "ost" ]; then
3651                         local fh=${facet%failover}_HOST
3652                         eval export ${facet}_HOST=${!fh}
3653                         if [ -z "${!varname}" ]; then
3654                                 eval export ${facet}_HOST=${ost_HOST}
3655                         fi
3656                 elif [ "${facet:0:3}" == "mdt" -o \
3657                         "${facet:0:3}" == "mds" -o \
3658                         "${facet:0:3}" == "mgs" ]; then
3659                         eval export ${facet}_HOST=${mds_HOST}
3660                 fi
3661         fi
3662         echo -n ${!varname}
3663 }
3664
3665 facet_failover_host() {
3666         local facet=$1
3667         local varname
3668
3669         var=${facet}failover_HOST
3670         if [ -n "${!var}" ]; then
3671                 echo ${!var}
3672                 return
3673         fi
3674
3675         if [ "${facet:0:3}" == "mdt" -o "${facet:0:3}" == "mds" -o \
3676              "${facet:0:3}" == "mgs" ]; then
3677
3678                 eval export ${facet}failover_host=${mds_HOST}
3679                 echo ${mds_HOST}
3680                 return
3681         fi
3682
3683         if [[ $facet == ost* ]]; then
3684                 eval export ${facet}failover_host=${ost_HOST}
3685                 echo ${ost_HOST}
3686                 return
3687         fi
3688 }
3689
3690 facet_active() {
3691     local facet=$1
3692     local activevar=${facet}active
3693
3694     if [ -f $TMP/${facet}active ] ; then
3695         source $TMP/${facet}active
3696     fi
3697
3698     active=${!activevar}
3699     if [ -z "$active" ] ; then
3700         echo -n ${facet}
3701     else
3702         echo -n ${active}
3703     fi
3704 }
3705
3706 facet_active_host() {
3707         facet_host $(facet_active $1)
3708 }
3709
3710 # Get the passive failover partner host of facet.
3711 facet_passive_host() {
3712         local facet=$1
3713         [[ $facet = client ]] && return
3714
3715         local host=${facet}_HOST
3716         local failover_host=${facet}failover_HOST
3717         local active_host=$(facet_active_host $facet)
3718
3719         [[ -z ${!failover_host} || ${!failover_host} = ${!host} ]] && return
3720
3721         if [[ $active_host = ${!host} ]]; then
3722                 echo -n ${!failover_host}
3723         else
3724                 echo -n ${!host}
3725         fi
3726 }
3727
3728 change_active() {
3729     local facetlist=$1
3730     local facet
3731
3732     facetlist=$(exclude_items_from_list $facetlist mgs)
3733
3734     for facet in ${facetlist//,/ }; do
3735     local failover=${facet}failover
3736     local host=`facet_host $failover`
3737     [ -z "$host" ] && return
3738
3739     local curactive=`facet_active $facet`
3740     if [ -z "${curactive}" -o "$curactive" == "$failover" ] ; then
3741         eval export ${facet}active=$facet
3742     else
3743         eval export ${facet}active=$failover
3744     fi
3745     # save the active host for this facet
3746     local activevar=${facet}active
3747     echo "$activevar=${!activevar}" > $TMP/$activevar
3748     [[ $facet = mds1 ]] && combined_mgs_mds && \
3749         echo "mgsactive=${!activevar}" > $TMP/mgsactive
3750     local TO=`facet_active_host $facet`
3751     echo "Failover $facet to $TO"
3752     done
3753 }
3754
3755 do_node() {
3756     local verbose=false
3757     # do not stripe off hostname if verbose, bug 19215
3758     if [ x$1 = x--verbose ]; then
3759         shift
3760         verbose=true
3761     fi
3762
3763     local HOST=$1
3764     shift
3765     local myPDSH=$PDSH
3766     if [ "$HOST" = "$HOSTNAME" ]; then
3767         myPDSH="no_dsh"
3768     elif [ -z "$myPDSH" -o "$myPDSH" = "no_dsh" ]; then
3769         echo "cannot run remote command on $HOST with $myPDSH"
3770         return 128
3771     fi
3772     if $VERBOSE; then
3773         echo "CMD: $HOST $@" >&2
3774         $myPDSH $HOST "$LCTL mark \"$@\"" > /dev/null 2>&1 || :
3775     fi
3776
3777         if [[ "$myPDSH" == "rsh" ]] ||
3778            [[ "$myPDSH" == *pdsh* && "$myPDSH" != *-S* ]]; then
3779                 # we need this because rsh and pdsh do not return
3780                 # exit code of an executed command
3781                 local command_status="$TMP/cs"
3782                 eval $myPDSH $HOST ":> $command_status"
3783                 eval $myPDSH $HOST "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests;
3784                                      PATH=\$PATH:/sbin:/usr/sbin;
3785                                      cd $RPWD;
3786                                      LUSTRE=\"$RLUSTRE\" sh -c \"$@\") ||
3787                                      echo command failed >$command_status"
3788                 [[ -n "$($myPDSH $HOST cat $command_status)" ]] && return 1 ||
3789                         return 0
3790         fi
3791
3792     if $verbose ; then
3793         # print HOSTNAME for myPDSH="no_dsh"
3794         if [[ $myPDSH = no_dsh ]]; then
3795             $myPDSH $HOST "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" sh -c \"$@\")" | sed -e "s/^/${HOSTNAME}: /"
3796         else
3797             $myPDSH $HOST "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" sh -c \"$@\")"
3798         fi
3799     else
3800         $myPDSH $HOST "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" sh -c \"$@\")" | sed "s/^${HOST}: //"
3801     fi
3802     return ${PIPESTATUS[0]}
3803 }
3804
3805 do_nodev() {
3806     do_node --verbose "$@"
3807 }
3808
3809 single_local_node () {
3810    [ "$1" = "$HOSTNAME" ]
3811 }
3812
3813 # Outputs environment variable assignments that should be passed to remote nodes
3814 get_env_vars() {
3815         local var
3816         local value
3817         local facets=$(get_facets)
3818         local facet
3819
3820         for var in ${!MODOPTS_*}; do
3821                 value=${!var//\"/\\\"}
3822                 echo -n " ${var}=\"$value\""
3823         done
3824
3825         for facet in ${facets//,/ }; do
3826                 var=${facet}_FSTYPE
3827                 if [ -n "${!var}" ]; then
3828                         echo -n " $var=${!var}"
3829                 fi
3830         done
3831
3832         for var in MGSFSTYPE MDSFSTYPE OSTFSTYPE; do
3833                 if [ -n "${!var}" ]; then
3834                         echo -n " $var=${!var}"
3835                 fi
3836         done
3837
3838         for var in VERBOSE; do
3839                 if [ -n "${!var}" ]; then
3840                         echo -n " $var=${!var}"
3841                 fi
3842         done
3843
3844         if [ -n "$FSTYPE" ]; then
3845                 echo -n " FSTYPE=$FSTYPE"
3846         fi
3847
3848         for var in LNETLND NETTYPE; do
3849                 if [ -n "${!var}" ]; then
3850                         echo -n " $var=${!var}"
3851                 fi
3852         done
3853 }
3854
3855 do_nodes() {
3856     local verbose=false
3857     # do not stripe off hostname if verbose, bug 19215
3858     if [ x$1 = x--verbose ]; then
3859         shift
3860         verbose=true
3861     fi
3862
3863     local rnodes=$1
3864     shift
3865
3866     if single_local_node $rnodes; then
3867         if $verbose; then
3868            do_nodev $rnodes "$@"
3869         else
3870            do_node $rnodes "$@"
3871         fi
3872         return $?
3873     fi
3874
3875     # This is part from do_node
3876     local myPDSH=$PDSH
3877
3878     [ -z "$myPDSH" -o "$myPDSH" = "no_dsh" -o "$myPDSH" = "rsh" ] && \
3879         echo "cannot run remote command on $rnodes with $myPDSH" && return 128
3880
3881     export FANOUT=$(get_node_count "${rnodes//,/ }")
3882     if $VERBOSE; then
3883         echo "CMD: $rnodes $@" >&2
3884         $myPDSH $rnodes "$LCTL mark \"$@\"" > /dev/null 2>&1 || :
3885     fi
3886
3887     # do not replace anything from pdsh output if -N is used
3888     # -N     Disable hostname: prefix on lines of output.
3889     if $verbose || [[ $myPDSH = *-N* ]]; then
3890         $myPDSH $rnodes "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" $(get_env_vars) sh -c \"$@\")"
3891     else
3892         $myPDSH $rnodes "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" $(get_env_vars) sh -c \"$@\")" | sed -re "s/^[^:]*: //g"
3893     fi
3894     return ${PIPESTATUS[0]}
3895 }
3896
3897 ##
3898 # Execute commands on a single service's host
3899 #
3900 # The \a facet (service) may be on a local or remote node, which is
3901 # determined at the time the command is run.
3902 #
3903 # usage: do_facet $facet command [arg ...]
3904 do_facet() {
3905         local facet=$1
3906         shift
3907         local HOST=$(facet_active_host $facet)
3908         [ -z $HOST ] && echo "No host defined for facet ${facet}" && exit 1
3909         do_node $HOST "$@"
3910 }
3911
3912 # Function: do_facet_random_file $FACET $FILE $SIZE
3913 # Creates FILE with random content on the given FACET of given SIZE
3914
3915 do_facet_random_file() {
3916         local facet="$1"
3917         local fpath="$2"
3918         local fsize="$3"
3919         local cmd="dd if=/dev/urandom of='$fpath' bs=$fsize count=1"
3920         do_facet $facet "$cmd 2>/dev/null"
3921 }
3922
3923 do_facet_create_file() {
3924         local facet="$1"
3925         local fpath="$2"
3926         local fsize="$3"
3927         local cmd="dd if=/dev/zero of='$fpath' bs=$fsize count=1"
3928         do_facet $facet "$cmd 2>/dev/null"
3929 }
3930
3931 do_nodesv() {
3932     do_nodes --verbose "$@"
3933 }
3934
3935 add() {
3936         local facet=$1
3937         shift
3938         # make sure its not already running
3939         stop ${facet} -f
3940         rm -f $TMP/${facet}active
3941         [[ $facet = mds1 ]] && combined_mgs_mds && rm -f $TMP/mgsactive
3942         do_facet ${facet} $MKFS $* || return ${PIPESTATUS[0]}
3943
3944         if [[ $(facet_fstype $facet) == zfs ]]; then
3945                 #
3946                 # After formatting a ZFS target, "cachefile=none" property will
3947                 # be set on the ZFS storage pool so that the pool is not
3948                 # automatically imported on system startup. And then the pool
3949                 # will be exported so as to leave the importing and exporting
3950                 # operations handled by mount_facet() and stop() separately.
3951                 #
3952                 refresh_partition_table $facet $(facet_vdevice $facet)
3953                 disable_zpool_cache $facet
3954                 export_zpool $facet
3955         fi
3956 }
3957
3958 # Device formatted as ost
3959 ostdevname() {
3960         local num=$1
3961         local DEVNAME=OSTDEV$num
3962
3963         local fstype=$(facet_fstype ost$num)
3964
3965         case $fstype in
3966                 ldiskfs )
3967                         local dev=ost${num}_dev
3968                         [[ -n ${!dev} ]] && eval DEVPTR=${!dev} ||
3969                         #if $OSTDEVn isn't defined, default is $OSTDEVBASE + num
3970                         eval DEVPTR=${!DEVNAME:=${OSTDEVBASE}${num}};;
3971                 zfs )
3972                         #try $OSTZFSDEVn - independent of vdev
3973                         DEVNAME=OSTZFSDEV$num
3974                         eval DEVPTR=${!DEVNAME:=${FSNAME}-ost${num}/ost${num}};;
3975                 * )
3976                         error "unknown fstype!";;
3977         esac
3978
3979     echo -n $DEVPTR
3980 }
3981
3982 # Physical device location of data
3983 ostvdevname() {
3984         local num=$1
3985         local DEVNAME
3986         local VDEVPTR
3987
3988         local fstype=$(facet_fstype ost$num)
3989
3990         case $fstype in
3991                 ldiskfs )
3992                         # vdevs are not supported by ldiskfs
3993                         eval VDEVPTR="";;
3994                 zfs )
3995                         #if $OSTDEVn isn't defined, default is $OSTDEVBASE{n}
3996                         # Device formatted by zfs
3997                         DEVNAME=OSTDEV$num
3998                         eval VDEVPTR=${!DEVNAME:=${OSTDEVBASE}${num}};;
3999                 * )
4000                         error "unknown fstype!";;
4001         esac
4002
4003         echo -n $VDEVPTR
4004 }
4005
4006 # Logical device formatted for lustre
4007 mdsdevname() {
4008         local num=$1
4009         local DEVNAME=MDSDEV$num
4010
4011         local fstype=$(facet_fstype mds$num)
4012
4013         case $fstype in
4014                 ldiskfs )
4015                         local dev=mds${num}_dev
4016                         [[ -n ${!dev} ]] && eval DEVPTR=${!dev} ||
4017                         #if $MDSDEVn isn't defined, default is $MDSDEVBASE{n}
4018                         eval DEVPTR=${!DEVNAME:=${MDSDEVBASE}${num}};;
4019                 zfs )
4020                         # try $MDSZFSDEVn - independent of vdev
4021                         DEVNAME=MDSZFSDEV$num
4022                         eval DEVPTR=${!DEVNAME:=${FSNAME}-mdt${num}/mdt${num}};;
4023                 * )
4024                         error "unknown fstype!";;
4025         esac
4026
4027         echo -n $DEVPTR
4028 }
4029
4030 # Physical location of data
4031 mdsvdevname() {
4032         local VDEVPTR=""
4033         local num=$1
4034         local fstype=$(facet_fstype mds$num)
4035
4036         case $fstype in
4037                 ldiskfs )
4038                         # vdevs are not supported by ldiskfs
4039                         eval VDEVPTR="";;
4040                 zfs )
4041                         # if $MDSDEVn isn't defined, default is $MDSDEVBASE{n}
4042                         # Device formatted by ZFS
4043                         local DEVNAME=MDSDEV$num
4044                         eval VDEVPTR=${!DEVNAME:=${MDSDEVBASE}${num}};;
4045                 * )
4046                         error "unknown fstype!";;
4047         esac
4048
4049         echo -n $VDEVPTR
4050 }
4051
4052 mgsdevname() {
4053         local DEVPTR
4054         local fstype=$(facet_fstype mgs)
4055
4056         case $fstype in
4057         ldiskfs )
4058                 if [ $(facet_host mgs) = $(facet_host mds1) ] &&
4059                    ( [ -z "$MGSDEV" ] || [ $MGSDEV = $MDSDEV1 ] ); then
4060                         DEVPTR=$(mdsdevname 1)
4061                 else
4062                         [[ -n $mgs_dev ]] && DEVPTR=$mgs_dev ||
4063                         DEVPTR=$MGSDEV
4064                 fi;;
4065         zfs )
4066                 if [ $(facet_host mgs) = $(facet_host mds1) ] &&
4067                     ( [ -z "$MGSZFSDEV" ] &&
4068                         [ -z "$MGSDEV" -o "$MGSDEV" = $(mdsvdevname 1) ] ); then
4069                         DEVPTR=$(mdsdevname 1)
4070                 else
4071                         DEVPTR=${MGSZFSDEV:-${FSNAME}-mgs/mgs}
4072                 fi;;
4073         * )
4074                 error "unknown fstype!";;
4075         esac
4076
4077         echo -n $DEVPTR
4078 }
4079
4080 mgsvdevname() {
4081         local VDEVPTR=""
4082
4083         local fstype=$(facet_fstype mgs)
4084
4085         case $fstype in
4086         ldiskfs )
4087                 # vdevs are not supported by ldiskfs
4088                 ;;
4089         zfs )
4090                 if [ $(facet_host mgs) = $(facet_host mds1) ] &&
4091                    ( [ -z "$MGSDEV" ] &&
4092                        [ -z "$MGSZFSDEV" -o "$MGSZFSDEV" = $(mdsdevname 1) ]); then
4093                         VDEVPTR=$(mdsvdevname 1)
4094                 elif [ -n "$MGSDEV" ]; then
4095                         VDEVPTR=$MGSDEV
4096                 fi;;
4097         * )
4098                 error "unknown fstype!";;
4099         esac
4100
4101         echo -n $VDEVPTR
4102 }
4103
4104 facet_mntpt () {
4105     local facet=$1
4106     [[ $facet = mgs ]] && combined_mgs_mds && facet="mds1"
4107
4108     local var=${facet}_MOUNT
4109     eval mntpt=${!var:-${MOUNT}-$facet}
4110
4111     echo -n $mntpt
4112 }
4113
4114 mount_ldiskfs() {
4115         local facet=$1
4116         local dev=$(facet_device $facet)
4117         local mnt=${2:-$(facet_mntpt $facet)}
4118         local opts
4119         local dm_dev=$dev
4120
4121         if dm_flakey_supported $facet; then
4122                 dm_dev=$(dm_create_dev $facet $dev)
4123                 [[ -n "$dm_dev" ]] || dm_dev=$dev
4124         fi
4125         is_blkdev $facet $dm_dev || opts=$(csa_add "$opts" -o loop)
4126         export_dm_dev $facet $dm_dev
4127
4128         do_facet $facet mount -t ldiskfs $opts $dm_dev $mnt
4129 }
4130
4131 unmount_ldiskfs() {
4132         local facet=$1
4133         local dev=$(facet_device $facet)
4134         local mnt=${2:-$(facet_mntpt $facet)}
4135
4136         do_facet $facet $UMOUNT $mnt
4137 }
4138
4139 var_name() {
4140         echo -n "$1" | tr -c '[:alnum:]\n' '_'
4141 }
4142
4143 mount_zfs() {
4144         local facet=$1
4145         local ds=$(facet_device $facet)
4146         local mnt=${2:-$(facet_mntpt $facet)}
4147         local canmnt
4148         local mntpt
4149
4150         import_zpool $facet
4151         canmnt=$(do_facet $facet $ZFS get -H -o value canmount $ds)
4152         mntpt=$(do_facet $facet $ZFS get -H -o value mountpoint $ds)
4153         do_facet $facet $ZFS set canmount=noauto $ds
4154         #
4155         # The "legacy" mount method is used here because "zfs unmount $mnt"
4156         # calls stat(2) on $mnt/../*, which may include $MOUNT.  If certain
4157         # targets are not available at the time, the stat(2) on $MOUNT will
4158         # hang.
4159         #
4160         do_facet $facet $ZFS set mountpoint=legacy $ds
4161         do_facet $facet mount -t zfs $ds $mnt
4162         eval export mz_$(var_name ${facet}_$ds)_canmount=$canmnt
4163         eval export mz_$(var_name ${facet}_$ds)_mountpoint=$mntpt
4164 }
4165
4166 unmount_zfs() {
4167         local facet=$1
4168         local ds=$(facet_device $facet)
4169         local mnt=${2:-$(facet_mntpt $facet)}
4170         local var_mntpt=mz_$(var_name ${facet}_$ds)_mountpoint
4171         local var_canmnt=mz_$(var_name ${facet}_$ds)_canmount
4172         local mntpt=${!var_mntpt}
4173         local canmnt=${!var_canmnt}
4174
4175         unset $var_mntpt
4176         unset $var_canmnt
4177         do_facet $facet umount $mnt
4178         do_facet $facet $ZFS set mountpoint=$mntpt $ds
4179         do_facet $facet $ZFS set canmount=$canmnt $ds
4180         export_zpool $facet
4181 }
4182
4183 mount_fstype() {
4184         local facet=$1
4185         local mnt=$2
4186         local fstype=$(facet_fstype $facet)
4187
4188         mount_$fstype $facet $mnt
4189 }
4190
4191 unmount_fstype() {
4192         local facet=$1
4193         local mnt=$2
4194         local fstype=$(facet_fstype $facet)
4195
4196         unmount_$fstype $facet $mnt
4197 }
4198
4199 ########
4200 ## MountConf setup
4201
4202 stopall() {
4203         # make sure we are using the primary server, so test-framework will
4204         # be able to clean up properly.
4205         activemds=`facet_active mds1`
4206         if [ $activemds != "mds1" ]; then
4207                 fail mds1
4208         fi
4209
4210         local clients=$CLIENTS
4211         [ -z $clients ] && clients=$(hostname)
4212
4213         zconf_umount_clients $clients $MOUNT "$*" || true
4214         [ -n "$MOUNT2" ] && zconf_umount_clients $clients $MOUNT2 "$*" || true
4215
4216         [ -n "$CLIENTONLY" ] && return
4217
4218         # The add fn does rm ${facet}active file, this would be enough
4219         # if we use do_facet <facet> only after the facet added, but
4220         # currently we use do_facet mds in local.sh
4221         for num in `seq $MDSCOUNT`; do
4222                 stop mds$num -f
4223                 rm -f ${TMP}/mds${num}active
4224         done
4225         combined_mgs_mds && rm -f $TMP/mgsactive
4226
4227         for num in `seq $OSTCOUNT`; do
4228                 stop ost$num -f
4229                 rm -f $TMP/ost${num}active
4230         done
4231
4232         if ! combined_mgs_mds ; then
4233                 stop mgs
4234         fi
4235
4236         if $SHARED_KEY; then
4237                 export SK_MOUNTED=false
4238         fi
4239
4240         return 0
4241 }
4242
4243 cleanup_echo_devs () {
4244         trap 0
4245         local dev
4246         local devs=$($LCTL dl | grep echo | awk '{print $4}')
4247
4248         for dev in $devs; do
4249                 $LCTL --device $dev cleanup
4250                 $LCTL --device $dev detach
4251         done
4252 }
4253
4254 cleanupall() {
4255         nfs_client_mode && return
4256         cifs_client_mode && return
4257
4258         cleanup_echo_devs
4259         CLEANUP_DM_DEV=true stopall $*
4260
4261         unload_modules
4262         cleanup_sk
4263         cleanup_gss
4264 }
4265
4266 combined_mgs_mds () {
4267         [[ "$(mdsdevname 1)" = "$(mgsdevname)" ]] &&
4268                 [[ "$(facet_host mds1)" = "$(facet_host mgs)" ]]
4269 }
4270
4271 lower() {
4272         echo -n "$1" | tr '[:upper:]' '[:lower:]'
4273 }
4274
4275 upper() {
4276         echo -n "$1" | tr '[:lower:]' '[:upper:]'
4277 }
4278
4279 mkfs_opts() {
4280         local facet=$1
4281         local dev=$2
4282         local fsname=${3:-"$FSNAME"}
4283         local type=$(facet_type $facet)
4284         local index=$(facet_index $facet)
4285         local fstype=$(facet_fstype $facet)
4286         local host=$(facet_host $facet)
4287         local opts
4288         local fs_mkfs_opts
4289         local var
4290
4291         if [ $type == MGS ] || ( [ $type == MDS ] &&
4292                                  [ "$dev" == $(mgsdevname) ] &&
4293                                  [ "$host" == "$(facet_host mgs)" ] ); then
4294                 opts="--mgs"
4295         else
4296                 opts="--mgsnode=$MGSNID"
4297         fi
4298
4299         if [ $type != MGS ]; then
4300                 opts+=" --fsname=$fsname --$(lower ${type/MDS/MDT}) \
4301                         --index=$index"
4302         fi
4303
4304         var=${facet}failover_HOST
4305         if [ -n "${!var}" ] && [ ${!var} != $(facet_host $facet) ]; then
4306                 opts+=" --failnode=$(h2nettype ${!var})"
4307         fi
4308
4309         opts+=${TIMEOUT:+" --param=sys.timeout=$TIMEOUT"}
4310         opts+=${LDLM_TIMEOUT:+" --param=sys.ldlm_timeout=$LDLM_TIMEOUT"}
4311
4312         if [ $type == MDS ]; then
4313                 opts+=${MDSCAPA:+" --param-mdt.capa=$MDSCAPA"}
4314                 opts+=${DEF_STRIPE_SIZE:+" --param=lov.stripesize=$DEF_STRIPE_SIZE"}
4315                 opts+=${DEF_STRIPE_COUNT:+" --param=lov.stripecount=$DEF_STRIPE_COUNT"}
4316                 opts+=${L_GETIDENTITY:+" --param=mdt.identity_upcall=$L_GETIDENTITY"}
4317
4318                 if [ $fstype == ldiskfs ]; then
4319                         fs_mkfs_opts+="-O ea_inode"
4320
4321                         var=${facet}_JRN
4322                         if [ -n "${!var}" ]; then
4323                                 fs_mkfs_opts+=" -J device=${!var}"
4324                         else
4325                                 fs_mkfs_opts+=${MDSJOURNALSIZE:+" -J size=$MDSJOURNALSIZE"}
4326                         fi
4327                         fs_mkfs_opts+=${MDSISIZE:+" -i $MDSISIZE"}
4328                 fi
4329         fi
4330
4331         if [ $type == OST ]; then
4332                 opts+=${OSSCAPA:+" --param=ost.capa=$OSSCAPA"}
4333
4334                 if [ $fstype == ldiskfs ]; then
4335                         var=${facet}_JRN
4336                         if [ -n "${!var}" ]; then
4337                                 fs_mkfs_opts+=" -J device=${!var}"
4338                         else
4339                                 fs_mkfs_opts+=${OSTJOURNALSIZE:+" -J size=$OSTJOURNALSIZE"}
4340                         fi
4341                 fi
4342         fi
4343
4344         opts+=" --backfstype=$fstype"
4345
4346         var=${type}SIZE
4347         if [ -n "${!var}" ]; then
4348                 opts+=" --device-size=${!var}"
4349         fi
4350
4351         var=$(upper $fstype)_MKFS_OPTS
4352         fs_mkfs_opts+=${!var:+" ${!var}"}
4353
4354         var=${type}_FS_MKFS_OPTS
4355         fs_mkfs_opts+=${!var:+" ${!var}"}
4356
4357         if [ -n "${fs_mkfs_opts## }" ]; then
4358                 opts+=" --mkfsoptions=\\\"${fs_mkfs_opts## }\\\""
4359         fi
4360
4361         var=${type}OPT
4362         opts+=${!var:+" ${!var}"}
4363
4364         echo -n "$opts"
4365 }
4366
4367 mountfs_opts() {
4368         local facet=$1
4369         local type=$(facet_type $facet)
4370         local var=${type}_MOUNT_FS_OPTS
4371         local opts=""
4372         if [ -n "${!var}" ]; then
4373                 opts+=" --mountfsoptions=${!var}"
4374         fi
4375         echo -n "$opts"
4376 }
4377
4378 check_ost_indices() {
4379         local index_count=${#OST_INDICES[@]}
4380         [[ $index_count -eq 0 || $OSTCOUNT -le $index_count ]] && return 0
4381
4382         # OST count is greater than the index count in $OST_INDEX_LIST.
4383         # We need check whether there are duplicate indices.
4384         local i
4385         local j
4386         local index
4387         for i in $(seq $((index_count + 1)) $OSTCOUNT); do
4388                 index=$(facet_index ost$i)
4389                 for j in $(seq 0 $((index_count - 1))); do
4390                         [[ $index -ne ${OST_INDICES[j]} ]] ||
4391                         error "ost$i has the same index $index as ost$((j+1))"
4392                 done
4393         done
4394 }
4395
4396 __touch_device()
4397 {
4398         local facet_type=$1 # mgs || mds || ost
4399         local facet_num=$2
4400         local facet=${1}${2}
4401         local device
4402
4403         case "$(facet_fstype $facet)" in
4404         ldiskfs)
4405                 device=$(${facet_type}devname $facet_num)
4406                 ;;
4407         zfs)
4408                 device=$(${facet_type}vdevname $facet_num)
4409                 ;;
4410         *)
4411                 error "Unhandled filesystem type"
4412                 ;;
4413         esac
4414
4415         do_facet $facet "[ -e \"$device\" ]" && return
4416
4417         # Note: the following check only works with absolute paths
4418         [[ ! "$device" =~ ^/dev/ ]] || [[ "$device" =~ ^/dev/shm/ ]] ||
4419                 error "$facet: device '$device' does not exist"
4420
4421         do_facet $facet "touch \"${device}\""
4422 }
4423
4424 format_mgs() {
4425         local quiet
4426
4427         if ! $VERBOSE; then
4428                 quiet=yes
4429         fi
4430         echo "Format mgs: $(mgsdevname)"
4431         reformat_external_journal mgs
4432
4433         # touch "device" in case it is a loopback file for testing and needs to
4434         # be created. mkfs.lustre doesn't do this to avoid accidentally writing
4435         # to non-existent files in /dev if the admin made a typo during setup
4436         __touch_device mgs
4437
4438         add mgs $(mkfs_opts mgs $(mgsdevname)) $(mountfs_opts mgs) --reformat \
4439                 $(mgsdevname) $(mgsvdevname) ${quiet:+>/dev/null} || exit 10
4440 }
4441
4442 format_mdt() {
4443         local num=$1
4444         local quiet
4445
4446         if ! $VERBOSE; then
4447                 quiet=yes
4448         fi
4449         echo "Format mds$num: $(mdsdevname $num)"
4450         reformat_external_journal mds$num
4451
4452         __touch_device mds $num
4453
4454         add mds$num $(mkfs_opts mds$num $(mdsdevname ${num})) \
4455                 $(mountfs_opts mds$num) --reformat $(mdsdevname $num) \
4456                 $(mdsvdevname $num) ${quiet:+>/dev/null} || exit 10
4457 }
4458
4459 format_ost() {
4460         local num=$1
4461
4462         if ! $VERBOSE; then
4463                 quiet=yes
4464         fi
4465         echo "Format ost$num: $(ostdevname $num)"
4466         reformat_external_journal ost$num
4467
4468         __touch_device ost $num
4469
4470         add ost$num $(mkfs_opts ost$num $(ostdevname ${num})) \
4471                 $(mountfs_opts ost$num) --reformat $(ostdevname $num) \
4472                 $(ostvdevname ${num}) ${quiet:+>/dev/null} || exit 10
4473 }
4474
4475 formatall() {
4476         stopall -f
4477         # Set hostid for ZFS/SPL zpool import protection
4478         # (Assumes MDS version is also OSS version)
4479         if [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.8.54) ];
4480         then
4481                 do_rpc_nodes "$(comma_list $(all_server_nodes))" set_hostid
4482         fi
4483
4484         # We need ldiskfs here, may as well load them all
4485         load_modules
4486         [ -n "$CLIENTONLY" ] && return
4487         echo Formatting mgs, mds, osts
4488         if ! combined_mgs_mds ; then
4489                 format_mgs
4490         fi
4491
4492         for num in $(seq $MDSCOUNT); do
4493                 format_mdt $num
4494         done
4495
4496         export OST_INDICES=($(hostlist_expand "$OST_INDEX_LIST"))
4497         check_ost_indices
4498         for num in $(seq $OSTCOUNT); do
4499                 format_ost $num
4500         done
4501 }
4502
4503 mount_client() {
4504         grep " $1 " /proc/mounts || zconf_mount $HOSTNAME $*
4505 }
4506
4507 umount_client() {
4508         grep " $1 " /proc/mounts && zconf_umount $HOSTNAME $*
4509 }
4510
4511 # return value:
4512 # 0: success, the old identity set already.
4513 # 1: success, the old identity does not set.
4514 # 2: fail.
4515 switch_identity() {
4516     local num=$1
4517     local switch=$2
4518     local j=`expr $num - 1`
4519     local MDT="`(do_facet mds$num lctl get_param -N mdt.*MDT*$j 2>/dev/null | cut -d"." -f2 2>/dev/null) || true`"
4520
4521     if [ -z "$MDT" ]; then
4522         return 2
4523     fi
4524
4525     local old="`do_facet mds$num "lctl get_param -n mdt.$MDT.identity_upcall"`"
4526
4527     if $switch; then
4528         do_facet mds$num "lctl set_param -n mdt.$MDT.identity_upcall \"$L_GETIDENTITY\""
4529     else
4530         do_facet mds$num "lctl set_param -n mdt.$MDT.identity_upcall \"NONE\""
4531     fi
4532
4533     do_facet mds$num "lctl set_param -n mdt/$MDT/identity_flush=-1"
4534
4535     if [ $old = "NONE" ]; then
4536         return 1
4537     else
4538         return 0
4539     fi
4540 }
4541
4542 remount_client()
4543 {
4544         zconf_umount $HOSTNAME $1 || error "umount failed"
4545         zconf_mount $HOSTNAME $1 || error "mount failed"
4546 }
4547
4548 writeconf_facet() {
4549         local facet=$1
4550         local dev=$2
4551
4552         stop ${facet} -f
4553         rm -f $TMP/${facet}active
4554         do_facet ${facet} "$TUNEFS --quiet --writeconf $dev" || return 1
4555         return 0
4556 }
4557
4558 writeconf_all () {
4559         local mdt_count=${1:-$MDSCOUNT}
4560         local ost_count=${2:-$OSTCOUNT}
4561         local rc=0
4562
4563         for num in $(seq $mdt_count); do
4564                 DEVNAME=$(mdsdevname $num)
4565                 writeconf_facet mds$num $DEVNAME || rc=$?
4566         done
4567
4568         for num in $(seq $ost_count); do
4569                 DEVNAME=$(ostdevname $num)
4570                 writeconf_facet ost$num $DEVNAME || rc=$?
4571         done
4572         return $rc
4573 }
4574
4575 mountmgs() {
4576         if ! combined_mgs_mds ; then
4577                 start mgs $(mgsdevname) $MGS_MOUNT_OPTS
4578         fi
4579 }
4580
4581 mountmds() {
4582         local num
4583         local devname
4584         local host
4585         local varname
4586         for num in $(seq $MDSCOUNT); do
4587                 devname=$(mdsdevname $num)
4588                 start mds$num $devname $MDS_MOUNT_OPTS
4589
4590                 # We started mds$num, now we should set mds${num}_HOST
4591                 # and mds${num}failover_HOST variables properly if they
4592                 # are not set.
4593                 host=$(facet_host mds$num)
4594                 for varname in mds${num}_HOST mds${num}failover_HOST; do
4595                         if [[ -z "${!varname}" ]]; then
4596                                 eval $varname=$host
4597                         fi
4598                 done
4599                 if [ $IDENTITY_UPCALL != "default" ]; then
4600                         switch_identity $num $IDENTITY_UPCALL
4601                 fi
4602         done
4603 }
4604
4605 mountoss() {
4606         local num
4607         local devname
4608         local host
4609         local varname
4610         for num in $(seq $OSTCOUNT); do
4611                 devname=$(ostdevname $num)
4612                 start ost$num $devname $OST_MOUNT_OPTS
4613
4614                 # We started ost$num, now we should set ost${num}_HOST
4615                 # and ost${num}failover_HOST variables properly if they
4616                 # are not set.
4617                 host=$(facet_host ost$num)
4618                 for varname in ost${num}_HOST ost${num}failover_HOST; do
4619                         if [[ -z "${!varname}" ]]; then
4620                                 eval $varname=$host
4621                         fi
4622                 done
4623         done
4624 }
4625
4626 mountcli() {
4627         [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
4628         if [ ! -z $arg1 ]; then
4629                 [ "$arg1" = "server_only" ] && return
4630         fi
4631         mount_client $MOUNT
4632         if [ -n "$CLIENTS" ]; then
4633                 zconf_mount_clients $CLIENTS $MOUNT
4634         fi
4635         clients_up
4636
4637         if [ "$MOUNT_2" ]; then
4638                 mount_client $MOUNT2
4639                 if [ -n "$CLIENTS" ]; then
4640                         zconf_mount_clients $CLIENTS $MOUNT2
4641                 fi
4642         fi
4643 }
4644
4645 sk_nodemap_setup() {
4646         local sk_map_name=${1:-$SK_S2SNM}
4647         local sk_map_nodes=${2:-$HOSTNAME}
4648         do_node $(mgs_node) "$LCTL nodemap_add $sk_map_name"
4649         for servernode in $sk_map_nodes; do
4650                 local nids=$(do_nodes $servernode "$LCTL list_nids")
4651                 for nid in $nids; do
4652                         do_node $(mgs_node) "$LCTL nodemap_add_range --name \
4653                                 $sk_map_name --range $nid"
4654                 done
4655         done
4656 }
4657
4658 setupall() {
4659         local arg1=$1
4660
4661         nfs_client_mode && return
4662         cifs_client_mode && return
4663
4664         sanity_mount_check || error "environments are insane!"
4665
4666         load_modules
4667
4668         init_gss
4669
4670         if [ -z "$CLIENTONLY" ]; then
4671                 echo Setup mgs, mdt, osts
4672                 echo $WRITECONF | grep -q "writeconf" && writeconf_all
4673
4674                 if $SK_MOUNTED; then
4675                         echo "Shared Key file system already mounted"
4676                 else
4677                         mountmgs
4678                         mountmds
4679                         mountoss
4680                         if $SHARED_KEY; then
4681                                 export SK_MOUNTED=true
4682                         fi
4683                 fi
4684                 if $GSS_SK; then
4685                         echo "GSS_SK: setting kernel keyring perms"
4686                         do_nodes $(comma_list $(all_nodes)) \
4687                                 "keyctl show | grep lustre | cut -c1-11 |
4688                                 sed -e 's/ //g;' |
4689                                 xargs -IX keyctl setperm X 0x3f3f3f3f"
4690
4691                         if $SK_S2S; then
4692                                 # Need to start one nodemap for servers,
4693                                 # and one for clients.
4694                                 sk_nodemap_setup $SK_S2SNM \
4695                                         $(comma_list $(all_server_nodes))
4696                                 mountcli
4697                                 sk_nodemap_setup $SK_S2SNMCLI \
4698                                         ${CLIENTS:-$HOSTNAME}
4699                                 echo "Nodemap set up for SK S2S, remounting."
4700                                 stopall
4701                                 mountmgs
4702                                 mountmds
4703                                 mountoss
4704                         fi
4705                 fi
4706         fi
4707
4708         # wait a while to allow sptlrpc configuration be propogated to targets,
4709         # only needed when mounting new target devices.
4710         if $GSS; then
4711                 sleep 10
4712         fi
4713
4714         mountcli
4715         init_param_vars
4716
4717         # by remounting mdt before ost, initial connect from mdt to ost might
4718         # timeout because ost is not ready yet. wait some time to its fully
4719         # recovery. initial obd_connect timeout is 5s; in GSS case it's
4720         # preceeded by a context negotiation rpc with $TIMEOUT.
4721         # FIXME better by monitoring import status.
4722         if $GSS; then
4723                 if $GSS_SK; then
4724                         set_rule $FSNAME any cli2mdt $SK_FLAVOR
4725                         set_rule $FSNAME any cli2ost $SK_FLAVOR
4726                         if $SK_SKIPFIRST; then
4727                                 export SK_SKIPFIRST=false
4728
4729                                 sleep 30
4730                                 do_nodes $CLIENTS \
4731                                          "lctl set_param osc.*.idle_connect=1"
4732                                 return
4733                         else
4734                                 wait_flavor cli2mdt $SK_FLAVOR
4735                                 wait_flavor cli2ost $SK_FLAVOR
4736                         fi
4737                 else
4738                         set_flavor_all $SEC
4739                 fi
4740                 sleep $((TIMEOUT + 5))
4741         else
4742                 sleep 5
4743         fi
4744 }
4745
4746 mounted_lustre_filesystems() {
4747         awk '($3 ~ "lustre" && $1 ~ ":") { print $2 }' /proc/mounts
4748 }
4749
4750 init_facet_vars () {
4751         [ -n "$CLIENTONLY" ] && return 0
4752         local facet=$1
4753         shift
4754         local device=$1
4755
4756         shift
4757
4758         eval export ${facet}_dev=${device}
4759         eval export ${facet}_opt=\"$@\"
4760
4761         local dev=${facet}_dev
4762
4763         # We need to loop for the label
4764         # in case its not initialized yet.
4765         for wait_time in {0,1,3,5,10}; do
4766
4767                 if [ $wait_time -gt 0 ]; then
4768                         echo "${!dev} not yet initialized,"\
4769                                 "waiting ${wait_time} seconds."
4770                         sleep $wait_time
4771                 fi
4772
4773                 local label=$(devicelabel ${facet} ${!dev})
4774
4775                 # Check to make sure the label does
4776                 # not include ffff at the end of the label.
4777                 # This indicates it has not been initialized yet.
4778
4779                 if [[ $label =~ [f|F]{4}$ ]]; then
4780                         # label is not initialized, unset the result
4781                         # and either try again or fail
4782                         unset label
4783                 else
4784                         break
4785                 fi
4786         done
4787
4788         [ -z "$label" ] && echo no label for ${!dev} && exit 1
4789
4790         eval export ${facet}_svc=${label}
4791
4792         local varname=${facet}failover_HOST
4793         if [ -z "${!varname}" ]; then
4794                 eval export $varname=$(facet_host $facet)
4795         fi
4796
4797         varname=${facet}_HOST
4798         if [ -z "${!varname}" ]; then
4799                 eval export $varname=$(facet_host $facet)
4800         fi
4801
4802         # ${facet}failover_dev is set in cfg file
4803         varname=${facet}failover_dev
4804         if [ -n "${!varname}" ] ; then
4805                 eval export ${facet}failover_dev=${!varname}
4806         else
4807                 eval export ${facet}failover_dev=$device
4808         fi
4809
4810         # get mount point of already mounted device
4811         # is facet_dev is already mounted then use the real
4812         #  mount point of this facet; otherwise use $(facet_mntpt $facet)
4813         # i.e. ${facet}_MOUNT if specified by user or default
4814         local mntpt=$(do_facet ${facet} cat /proc/mounts | \
4815                         awk '"'${!dev}'" == $1 && $3 == "lustre" { print $2 }')
4816         if [ -z $mntpt ]; then
4817                 mntpt=$(facet_mntpt $facet)
4818         fi
4819         eval export ${facet}_MOUNT=$mntpt
4820 }
4821
4822 init_facets_vars () {
4823         local DEVNAME
4824
4825         if ! remote_mds_nodsh; then
4826                 for num in $(seq $MDSCOUNT); do
4827                         DEVNAME=`mdsdevname $num`
4828                         init_facet_vars mds$num $DEVNAME $MDS_MOUNT_OPTS
4829                 done
4830         fi
4831
4832         combined_mgs_mds || init_facet_vars mgs $(mgsdevname) $MGS_MOUNT_OPTS
4833
4834         if ! remote_ost_nodsh; then
4835                 for num in $(seq $OSTCOUNT); do
4836                         DEVNAME=$(ostdevname $num)
4837                         init_facet_vars ost$num $DEVNAME $OST_MOUNT_OPTS
4838                 done
4839         fi
4840 }
4841
4842 osc_ensure_active () {
4843     local facet=$1
4844     local timeout=$2
4845     local period=0
4846
4847     while [ $period -lt $timeout ]; do
4848         count=$(do_facet $facet "lctl dl | grep ' IN osc ' 2>/dev/null | wc -l")
4849         if [ $count -eq 0 ]; then
4850             break
4851         fi
4852
4853         echo "There are $count OST are inactive, wait $period seconds, and try again"
4854         sleep 3
4855         period=$((period+3))
4856     done
4857
4858     [ $period -lt $timeout ] || log "$count OST are inactive after $timeout seconds, give up"
4859 }
4860
4861 set_conf_param_and_check() {
4862         local myfacet=$1
4863         local TEST=$2
4864         local PARAM=$3
4865         local ORIG=$(do_facet $myfacet "$TEST")
4866         if [ $# -gt 3 ]; then
4867                 local FINAL=$4
4868         else
4869                 local -i FINAL
4870                 FINAL=$((ORIG + 5))
4871         fi
4872         echo "Setting $PARAM from $ORIG to $FINAL"
4873         do_facet mgs "$LCTL conf_param $PARAM='$FINAL'" ||
4874                 error "conf_param $PARAM failed"
4875
4876         wait_update_facet $myfacet "$TEST" "$FINAL" ||
4877                 error "check $PARAM failed!"
4878 }
4879
4880 set_persistent_param() {
4881         local myfacet=$1
4882         local test_param=$2
4883         local param=$3
4884         local orig=$(do_facet $myfacet "$LCTL get_param -n $test_param")
4885
4886         if [ $# -gt 3 ]; then
4887                 local final=$4
4888         else
4889                 local -i final
4890                 final=$((orig + 5))
4891         fi
4892
4893         if [[ $PERM_CMD == *"set_param -P"* ]]; then
4894                 echo "Setting $test_param from $orig to $final"
4895                 do_facet mgs "$PERM_CMD $test_param='$final'" ||
4896                         error "$PERM_CMD $test_param failed"
4897         else
4898                 echo "Setting $param from $orig to $final"
4899                 do_facet mgs "$PERM_CMD $param='$final'" ||
4900                         error "$PERM_CMD $param failed"
4901         fi
4902 }
4903
4904 set_persistent_param_and_check() {
4905         local myfacet=$1
4906         local test_param=$2
4907         local param=$3
4908         local orig=$(do_facet $myfacet "$LCTL get_param -n $test_param")
4909
4910         if [ $# -gt 3 ]; then
4911                 local final=$4
4912         else
4913                 local -i final
4914                 final=$((orig + 5))
4915         fi
4916
4917         set_persistent_param $myfacet $test_param $param "$final"
4918
4919         wait_update_facet $myfacet "$LCTL get_param -n $test_param" "$final" ||
4920                 error "check $param failed!"
4921 }
4922
4923 init_param_vars () {
4924         TIMEOUT=$(lctl get_param -n timeout)
4925         TIMEOUT=${TIMEOUT:-20}
4926
4927         if [ -n $arg1 ]; then
4928                 [ "$arg1" = "server_only" ] && return
4929         fi
4930
4931         remote_mds_nodsh && log "Using TIMEOUT=$TIMEOUT" && return 0
4932
4933         TIMEOUT=$(do_facet $SINGLEMDS "lctl get_param -n timeout")
4934         log "Using TIMEOUT=$TIMEOUT"
4935
4936         osc_ensure_active $SINGLEMDS $TIMEOUT
4937         osc_ensure_active client $TIMEOUT
4938         $LCTL set_param osc.*.idle_timeout=debug
4939
4940         if [ -n "$(lctl get_param -n mdc.*.connect_flags|grep jobstats)" ]; then
4941                 local current_jobid_var=$($LCTL get_param -n jobid_var)
4942
4943                 if [ $JOBID_VAR = "existing" ]; then
4944                         echo "keeping jobstats as $current_jobid_var"
4945                 elif [ $current_jobid_var != $JOBID_VAR ]; then
4946                         echo "setting jobstats to $JOBID_VAR"
4947
4948                         set_persistent_param_and_check client \
4949                                 "jobid_var" "$FSNAME.sys.jobid_var" $JOBID_VAR
4950                 fi
4951         else
4952                 echo "jobstats not supported by server"
4953         fi
4954
4955         if [ $QUOTA_AUTO -ne 0 ]; then
4956                 if [ "$ENABLE_QUOTA" ]; then
4957                         echo "enable quota as required"
4958                         setup_quota $MOUNT || return 2
4959                 else
4960                         echo "disable quota as required"
4961                         # $LFS quotaoff -ug $MOUNT > /dev/null 2>&1
4962                 fi
4963         fi
4964         return 0
4965 }
4966
4967 nfs_client_mode () {
4968     if [ "$NFSCLIENT" ]; then
4969         echo "NFSCLIENT mode: setup, cleanup, check config skipped"
4970         local clients=$CLIENTS
4971         [ -z $clients ] && clients=$(hostname)
4972
4973         # FIXME: remove hostname when 19215 fixed
4974         do_nodes $clients "echo \\\$(hostname); grep ' '$MOUNT' ' /proc/mounts"
4975         declare -a nfsexport=(`grep ' '$MOUNT' ' /proc/mounts | awk '{print $1}' | awk -F: '{print $1 " "  $2}'`)
4976         if [[ ${#nfsexport[@]} -eq 0 ]]; then
4977                 error_exit NFSCLIENT=$NFSCLIENT mode, but no NFS export found!
4978         fi
4979         do_nodes ${nfsexport[0]} "echo \\\$(hostname); df -T  ${nfsexport[1]}"
4980         return
4981     fi
4982     return 1
4983 }
4984
4985 cifs_client_mode () {
4986         [ x$CIFSCLIENT = xyes ] &&
4987                 echo "CIFSCLIENT=$CIFSCLIENT mode: setup, cleanup, check config skipped"
4988 }
4989
4990 check_config_client () {
4991     local mntpt=$1
4992
4993     local mounted=$(mount | grep " $mntpt ")
4994     if [ -n "$CLIENTONLY" ]; then
4995         # bug 18021
4996         # CLIENTONLY should not depend on *_HOST settings
4997         local mgc=$($LCTL device_list | awk '/MGC/ {print $4}')
4998         # in theory someone could create a new,
4999         # client-only config file that assumed lustre was already
5000         # configured and didn't set the MGSNID. If MGSNID is not set,
5001         # then we should use the mgs nid currently being used
5002         # as the default value. bug 18021
5003         [[ x$MGSNID = x ]] &&
5004             MGSNID=${mgc//MGC/}
5005
5006         if [[ x$mgc != xMGC$MGSNID ]]; then
5007             if [ "$mgs_HOST" ]; then
5008                 local mgc_ip=$(ping -q -c1 -w1 $mgs_HOST | grep PING | awk '{print $3}' | sed -e "s/(//g" -e "s/)//g")
5009 #                [[ x$mgc = xMGC$mgc_ip@$NETTYPE ]] ||
5010 #                    error_exit "MGSNID=$MGSNID, mounted: $mounted, MGC : $mgc"
5011             fi
5012         fi
5013         return 0
5014     fi
5015
5016     echo Checking config lustre mounted on $mntpt
5017     local mgshost=$(mount | grep " $mntpt " | awk -F@ '{print $1}')
5018     mgshost=$(echo $mgshost | awk -F: '{print $1}')
5019
5020 }
5021
5022 check_config_clients () {
5023         local clients=${CLIENTS:-$HOSTNAME}
5024         local mntpt=$1
5025
5026         nfs_client_mode && return
5027         cifs_client_mode && return
5028
5029         do_rpc_nodes "$clients" check_config_client $mntpt
5030
5031         sanity_mount_check || error "environments are insane!"
5032 }
5033
5034 check_timeout () {
5035     local mdstimeout=$(do_facet $SINGLEMDS "lctl get_param -n timeout")
5036     local cltimeout=$(lctl get_param -n timeout)
5037     if [ $mdstimeout -ne $TIMEOUT ] || [ $mdstimeout -ne $cltimeout ]; then
5038         error "timeouts are wrong! mds: $mdstimeout, client: $cltimeout, TIMEOUT=$TIMEOUT"
5039         return 1
5040     fi
5041 }
5042
5043 is_mounted () {
5044     local mntpt=$1
5045     [ -z $mntpt ] && return 1
5046     local mounted=$(mounted_lustre_filesystems)
5047
5048     echo $mounted' ' | grep -w -q $mntpt' '
5049 }
5050
5051 is_empty_dir() {
5052         [ $(find $1 -maxdepth 1 -print | wc -l) = 1 ] && return 0
5053         return 1
5054 }
5055
5056 # empty lustre filesystem may have empty directories lost+found and .lustre
5057 is_empty_fs() {
5058         # exclude .lustre & lost+found
5059         [ $(find $1 -maxdepth 1 -name lost+found -o -name .lustre -prune -o \
5060                 -print | wc -l) = 1 ] || return 1
5061         [ ! -d $1/lost+found ] || is_empty_dir $1/lost+found || return 1
5062         if [ $(lustre_version_code $SINGLEMDS) -gt $(version_code 2.4.0) ]; then
5063                 # exclude .lustre/fid (LU-2780)
5064                 [ $(find $1/.lustre -maxdepth 1 -name fid -prune -o \
5065                         -print | wc -l) = 1 ] || return 1
5066         else
5067                 [ ! -d $1/.lustre ] || is_empty_dir $1/.lustre || return 1
5068         fi
5069         return 0
5070 }
5071
5072 check_and_setup_lustre() {
5073         sanitize_parameters
5074         nfs_client_mode && return
5075         cifs_client_mode && return
5076
5077         local MOUNTED=$(mounted_lustre_filesystems)
5078
5079         local do_check=true
5080         # 1.
5081         # both MOUNT and MOUNT2 are not mounted
5082         if ! is_mounted $MOUNT && ! is_mounted $MOUNT2; then
5083                 [ "$REFORMAT" = "yes" ] && CLEANUP_DM_DEV=true formatall
5084                 # setupall mounts both MOUNT and MOUNT2 (if MOUNT_2 is set)
5085                 setupall
5086                 is_mounted $MOUNT || error "NAME=$NAME not mounted"
5087                 export I_MOUNTED=yes
5088                 do_check=false
5089     # 2.
5090     # MOUNT2 is mounted
5091     elif is_mounted $MOUNT2; then
5092             # 3.
5093             # MOUNT2 is mounted, while MOUNT_2 is not set
5094             if ! [ "$MOUNT_2" ]; then
5095                 cleanup_mount $MOUNT2
5096                 export I_UMOUNTED2=yes
5097
5098             # 4.
5099             # MOUNT2 is mounted, MOUNT_2 is set
5100             else
5101                 # FIXME: what to do if check_config failed?
5102                 # i.e. if:
5103                 # 1) remote client has mounted other Lustre fs ?
5104                 # 2) it has insane env ?
5105                 # let's try umount MOUNT2 on all clients and mount it again:
5106                 if ! check_config_clients $MOUNT2; then
5107                     cleanup_mount $MOUNT2
5108                     restore_mount $MOUNT2
5109                     export I_MOUNTED2=yes
5110                 fi
5111             fi
5112
5113     # 5.
5114     # MOUNT is mounted MOUNT2 is not mounted
5115     elif [ "$MOUNT_2" ]; then
5116         restore_mount $MOUNT2
5117         export I_MOUNTED2=yes
5118     fi
5119
5120     if $do_check; then
5121         # FIXME: what to do if check_config failed?
5122         # i.e. if:
5123         # 1) remote client has mounted other Lustre fs?
5124         # 2) lustre is mounted on remote_clients atall ?
5125         check_config_clients $MOUNT
5126         init_facets_vars
5127         init_param_vars
5128
5129         set_default_debug_nodes $(comma_list $(nodes_list))
5130     fi
5131
5132         if [ -z "$CLIENTONLY" -a $(lower $OSD_TRACK_DECLARES_LBUG) == 'yes' ]; then
5133                 local facets=""
5134                 [ "$(facet_fstype ost1)" = "ldiskfs" ] &&
5135                         facets="$(get_facets OST)"
5136                 [ "$(facet_fstype mds1)" = "ldiskfs" ] &&
5137                         facets="$facets,$(get_facets MDS)"
5138                 [ "$(facet_fstype mgs)" = "ldiskfs" ] &&
5139                         facets="$facets,mgs"
5140                 local nodes="$(facets_hosts ${facets})"
5141                 if [ -n "$nodes" ] ; then
5142                         do_nodes $nodes "$LCTL set_param \
5143                                  osd-ldiskfs.track_declares_assert=1 || true"
5144                 fi
5145         fi
5146
5147         if $GSS_SK; then
5148                 set_flavor_all null
5149         elif $GSS; then
5150                 set_flavor_all $SEC
5151         fi
5152
5153         if [ "$ONLY" == "setup" ]; then
5154                 exit 0
5155         fi
5156 }
5157
5158 restore_mount () {
5159    local clients=${CLIENTS:-$HOSTNAME}
5160    local mntpt=$1
5161
5162    zconf_mount_clients $clients $mntpt
5163 }
5164
5165 cleanup_mount () {
5166         local clients=${CLIENTS:-$HOSTNAME}
5167         local mntpt=$1
5168
5169         zconf_umount_clients $clients $mntpt
5170 }
5171
5172 cleanup_and_setup_lustre() {
5173     if [ "$ONLY" == "cleanup" -o "`mount | grep $MOUNT`" ]; then
5174         lctl set_param debug=0 || true
5175         cleanupall
5176         if [ "$ONLY" == "cleanup" ]; then
5177             exit 0
5178         fi
5179     fi
5180     check_and_setup_lustre
5181 }
5182
5183 # Get all of the server target devices from a given server node and type.
5184 get_mnt_devs() {
5185         local node=$1
5186         local type=$2
5187         local devs
5188         local dev
5189
5190         if [ "$type" == ost ]; then
5191                 devs=$(get_osd_param $node "" mntdev)
5192         else
5193                 devs=$(do_node $node $LCTL get_param -n osd-*.$FSNAME-M*.mntdev)
5194         fi
5195         for dev in $devs; do
5196                 case $dev in
5197                 *loop*) do_node $node "losetup $dev" | \
5198                                 sed -e "s/.*(//" -e "s/).*//" ;;
5199                 *) echo $dev ;;
5200                 esac
5201         done
5202 }
5203
5204 # Get all of the server target devices.
5205 get_svr_devs() {
5206         local node
5207         local i
5208
5209         # Master MDS parameters used by lfsck
5210         MDTNODE=$(facet_active_host $SINGLEMDS)
5211         MDTDEV=$(echo $(get_mnt_devs $MDTNODE mdt) | awk '{print $1}')
5212
5213         # MDT devices
5214         i=0
5215         for node in $(mdts_nodes); do
5216                 MDTDEVS[i]=$(get_mnt_devs $node mdt)
5217                 i=$((i + 1))
5218         done
5219
5220         # OST devices
5221         i=0
5222         for node in $(osts_nodes); do
5223                 OSTDEVS[i]=$(get_mnt_devs $node ost)
5224                 i=$((i + 1))
5225         done
5226 }
5227
5228 # Run e2fsck on MDT or OST device.
5229 run_e2fsck() {
5230         local node=$1
5231         local target_dev=$2
5232         local extra_opts=$3
5233         local cmd="$E2FSCK -d -v -t -t -f $extra_opts $target_dev"
5234         local log=$TMP/e2fsck.log
5235         local rc=0
5236
5237         echo $cmd
5238         do_node $node $cmd 2>&1 | tee $log
5239         rc=${PIPESTATUS[0]}
5240         if [ -n "$(grep "DNE mode isn't supported" $log)" ]; then
5241                 rm -f $log
5242                 if [ $MDSCOUNT -gt 1 ]; then
5243                         skip_noexit "DNE mode isn't supported!"
5244                         cleanupall
5245                         exit_status
5246                 else
5247                         error "It's not DNE mode."
5248                 fi
5249         fi
5250         rm -f $log
5251
5252         [ $rc -le $FSCK_MAX_ERR ] ||
5253                 error "$cmd returned $rc, should be <= $FSCK_MAX_ERR"
5254
5255         return 0
5256 }
5257
5258 #
5259 # Run resize2fs on MDT or OST device.
5260 #
5261 run_resize2fs() {
5262         local facet=$1
5263         local device=$2
5264         local size=$3
5265         shift 3
5266         local opts="$@"
5267
5268         do_facet $facet "$RESIZE2FS $opts $device $size"
5269 }
5270
5271 # verify a directory is shared among nodes.
5272 check_shared_dir() {
5273         local dir=$1
5274         local list=${2:-$(comma_list $(nodes_list))}
5275
5276         [ -z "$dir" ] && return 1
5277         do_rpc_nodes "$list" check_logdir $dir
5278         check_write_access $dir "$list" || return 1
5279         return 0
5280 }
5281
5282 run_lfsck() {
5283         do_nodes $(comma_list $(mdts_nodes) $(osts_nodes)) \
5284                 $LCTL set_param printk=+lfsck
5285         do_facet $SINGLEMDS "$LCTL lfsck_start -M $FSNAME-MDT0000 -r -A -t all"
5286
5287         for k in $(seq $MDSCOUNT); do
5288                 # wait up to 10+1 minutes for LFSCK to complete
5289                 wait_update_facet --verbose mds${k} "$LCTL get_param -n \
5290                         mdd.$(facet_svc mds${k}).lfsck_layout |
5291                         awk '/^status/ { print \\\$2 }'" "completed" 600 ||
5292                         error "MDS${k} layout isn't the expected 'completed'"
5293                 wait_update_facet --verbose mds${k} "$LCTL get_param -n \
5294                         mdd.$(facet_svc mds${k}).lfsck_namespace |
5295                         awk '/^status/ { print \\\$2 }'" "completed" 60 ||
5296                         error "MDS${k} namespace isn't the expected 'completed'"
5297         done
5298         local rep_mdt=$(do_nodes $(comma_list $(mdts_nodes)) \
5299                         $LCTL get_param -n mdd.$FSNAME-*.lfsck_* |
5300                         awk '/repaired/ { print $2 }' | calc_sum)
5301         local rep_ost=$(do_nodes $(comma_list $(osts_nodes)) \
5302                         $LCTL get_param -n obdfilter.$FSNAME-*.lfsck_* |
5303                         awk '/repaired/ { print $2 }' | calc_sum)
5304         local repaired=$((rep_mdt + rep_ost))
5305         [ $repaired -eq 0 ] ||
5306                 error "lfsck repaired $rep_mdt MDT and $rep_ost OST errors"
5307 }
5308
5309 dump_file_contents() {
5310         local nodes=$1
5311         local dir=$2
5312         local logname=$3
5313         local node
5314
5315         if [ -z "$nodes" -o -z "$dir" -o -z "$logname" ]; then
5316                 error_noexit false \
5317                         "Invalid parameters for dump_file_contents()"
5318                 return 1
5319         fi
5320         for node in ${nodes}; do
5321                 do_node $node "for i in \\\$(find $dir -type f); do
5322                                 echo ====\\\${i}=======================;
5323                                 cat \\\${i};
5324                                 done" >> ${logname}.${node}.log
5325         done
5326 }
5327
5328 dump_command_output() {
5329         local nodes=$1
5330         local cmd=$2
5331         local logname=$3
5332         local node
5333
5334         if [ -z "$nodes" -o -z "$cmd" -o -z "$logname" ]; then
5335                 error_noexit false \
5336                         "Invalid parameters for dump_command_output()"
5337                 return 1
5338         fi
5339
5340         for node in ${nodes}; do
5341                 do_node $node "echo ====${cmd}=======================;
5342                                 $cmd" >> ${logname}.${node}.log
5343         done
5344 }
5345
5346 log_zfs_info() {
5347         local logname=$1
5348
5349         # dump file contents from /proc/spl in case of zfs test
5350         if [ "$(facet_fstype ost1)" = "zfs" ]; then
5351                 dump_file_contents "$(osts_nodes)" "/proc/spl" "${logname}"
5352                 dump_command_output \
5353                         "$(osts_nodes)" "zpool events -v" "${logname}"
5354         fi
5355
5356         if [ "$(facet_fstype $SINGLEMDS)" = "zfs" ]; then
5357                 dump_file_contents "$(mdts_nodes)" "/proc/spl" "${logname}"
5358                 dump_command_output \
5359                         "$(mdts_nodes)" "zpool events -v" "${logname}"
5360         fi
5361 }
5362
5363 check_and_cleanup_lustre() {
5364         if [ "$LFSCK_ALWAYS" = "yes" -a "$TESTSUITE" != "sanity-lfsck" -a \
5365              "$TESTSUITE" != "sanity-scrub" ]; then
5366                 run_lfsck
5367         fi
5368
5369         if is_mounted $MOUNT; then
5370                 if $DO_CLEANUP; then
5371                         [ -n "$DIR" ] && rm -rf $DIR/[Rdfs][0-9]* ||
5372                                 error "remove sub-test dirs failed"
5373                 else
5374                         echo "skip cleanup"
5375                 fi
5376                 [ "$ENABLE_QUOTA" ] && restore_quota || true
5377         fi
5378
5379         if [ "$I_UMOUNTED2" = "yes" ]; then
5380                 restore_mount $MOUNT2 || error "restore $MOUNT2 failed"
5381         fi
5382
5383         if [ "$I_MOUNTED2" = "yes" ]; then
5384                 cleanup_mount $MOUNT2
5385         fi
5386
5387         if [[ "$I_MOUNTED" = "yes" ]] && ! $AUSTER_CLEANUP; then
5388                 cleanupall -f || error "cleanup failed"
5389                 unset I_MOUNTED
5390         fi
5391 }
5392
5393 #######
5394 # General functions
5395
5396 wait_for_function () {
5397     local quiet=""
5398
5399     # suppress fn both stderr and stdout
5400     if [ "$1" = "--quiet" ]; then
5401         shift
5402         quiet=" > /dev/null 2>&1"
5403
5404     fi
5405
5406     local fn=$1
5407     local max=${2:-900}
5408     local sleep=${3:-5}
5409
5410     local wait=0
5411
5412     while true; do
5413
5414         eval $fn $quiet && return 0
5415
5416         wait=$((wait + sleep))
5417         [ $wait -lt $max ] || return 1
5418         echo waiting $fn, $((max - wait)) secs left ...
5419         sleep $sleep
5420     done
5421 }
5422
5423 check_network() {
5424         local host=$1
5425         local max=$2
5426         local sleep=${3:-5}
5427
5428         [ "$host" = "$HOSTNAME" ] && return 0
5429
5430         echo "$(date +'%H:%M:%S (%s)') waiting for $host network $max secs ..."
5431         if ! wait_for_function --quiet "ping -c 1 -w 3 $host" $max $sleep ; then
5432                 echo "Network not available!"
5433                 exit 1
5434         fi
5435
5436         echo "$(date +'%H:%M:%S (%s)') network interface is UP"
5437 }
5438
5439 no_dsh() {
5440     shift
5441     eval $@
5442 }
5443
5444 # Convert a space-delimited list to a comma-delimited list.  If the input is
5445 # only whitespace, ensure the output is empty (i.e. "") so [ -n $list ] works
5446 comma_list() {
5447         # echo is used to convert newlines to spaces, since it doesn't
5448         # introduce a trailing space as using "tr '\n' ' '" does
5449         echo $(tr -s " " "\n" <<< $* | sort -b -u) | tr ' ' ','
5450 }
5451
5452 list_member () {
5453     local list=$1
5454     local item=$2
5455     echo $list | grep -qw $item
5456 }
5457
5458 # list, excluded are the comma separated lists
5459 exclude_items_from_list () {
5460     local list=$1
5461     local excluded=$2
5462     local item
5463
5464     list=${list//,/ }
5465     for item in ${excluded//,/ }; do
5466         list=$(echo " $list " | sed -re "s/\s+$item\s+/ /g")
5467     done
5468     echo $(comma_list $list)
5469 }
5470
5471 # list, expand  are the comma separated lists
5472 expand_list () {
5473     local list=${1//,/ }
5474     local expand=${2//,/ }
5475     local expanded=
5476
5477     expanded=$(for i in $list $expand; do echo $i; done | sort -u)
5478     echo $(comma_list $expanded)
5479 }
5480
5481 testslist_filter () {
5482     local script=$LUSTRE/tests/${TESTSUITE}.sh
5483
5484     [ -f $script ] || return 0
5485
5486     local start_at=$START_AT
5487     local stop_at=$STOP_AT
5488
5489     local var=${TESTSUITE//-/_}_START_AT
5490     [ x"${!var}" != x ] && start_at=${!var}
5491     var=${TESTSUITE//-/_}_STOP_AT
5492     [ x"${!var}" != x ] && stop_at=${!var}
5493
5494     sed -n 's/^test_\([^ (]*\).*/\1/p' $script | \
5495         awk ' BEGIN { if ("'${start_at:-0}'" != 0) flag = 1 }
5496             /^'${start_at}'$/ {flag = 0}
5497             {if (flag == 1) print $0}
5498             /^'${stop_at}'$/ { flag = 1 }'
5499 }
5500
5501 absolute_path() {
5502     (cd `dirname $1`; echo $PWD/`basename $1`)
5503 }
5504
5505 get_facets () {
5506     local types=${1:-"OST MDS MGS"}
5507
5508     local list=""
5509
5510     for entry in $types; do
5511         local name=$(echo $entry | tr "[:upper:]" "[:lower:]")
5512         local type=$(echo $entry | tr "[:lower:]" "[:upper:]")
5513
5514         case $type in
5515                 MGS ) list="$list $name";;
5516             MDS|OST|AGT ) local count=${type}COUNT
5517                        for ((i=1; i<=${!count}; i++)) do
5518                           list="$list ${name}$i"
5519                       done;;
5520                   * ) error "Invalid facet type"
5521                  exit 1;;
5522         esac
5523     done
5524     echo $(comma_list $list)
5525 }
5526
5527 ##################################
5528 # Adaptive Timeouts funcs
5529
5530 at_is_enabled() {
5531     # only check mds, we assume at_max is the same on all nodes
5532     local at_max=$(do_facet $SINGLEMDS "lctl get_param -n at_max")
5533     if [ $at_max -eq 0 ]; then
5534         return 1
5535     else
5536         return 0
5537     fi
5538 }
5539
5540 at_get() {
5541     local facet=$1
5542     local at=$2
5543
5544     # suppose that all ost-s have the same $at value set
5545     [ $facet != "ost" ] || facet=ost1
5546
5547     do_facet $facet "lctl get_param -n $at"
5548 }
5549
5550 at_max_get() {
5551     at_get $1 at_max
5552 }
5553
5554 at_min_get() {
5555         at_get $1 at_min
5556 }
5557
5558 at_max_set() {
5559     local at_max=$1
5560     shift
5561
5562     local facet
5563     local hosts
5564     for facet in $@; do
5565         if [ $facet == "ost" ]; then
5566             facet=$(get_facets OST)
5567         elif [ $facet == "mds" ]; then
5568             facet=$(get_facets MDS)
5569         fi
5570         hosts=$(expand_list $hosts $(facets_hosts $facet))
5571     done
5572
5573     do_nodes $hosts lctl set_param at_max=$at_max
5574 }
5575
5576 ##################################
5577 # OBD_FAIL funcs
5578
5579 drop_request() {
5580 # OBD_FAIL_MDS_ALL_REQUEST_NET
5581     RC=0
5582     do_facet $SINGLEMDS lctl set_param fail_val=0 fail_loc=0x123
5583     do_facet client "$1" || RC=$?
5584     do_facet $SINGLEMDS lctl set_param fail_loc=0
5585     return $RC
5586 }
5587
5588 drop_reply() {
5589 # OBD_FAIL_MDS_ALL_REPLY_NET
5590         RC=0
5591         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x122
5592         eval "$@" || RC=$?
5593         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
5594         return $RC
5595 }
5596
5597 drop_reint_reply() {
5598 # OBD_FAIL_MDS_REINT_NET_REP
5599         RC=0
5600         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x119
5601         eval "$@" || RC=$?
5602         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
5603         return $RC
5604 }
5605
5606 drop_update_reply() {
5607 # OBD_FAIL_OUT_UPDATE_NET_REP
5608         local index=$1
5609         shift 1
5610         RC=0
5611         do_facet mds${index} lctl set_param fail_loc=0x1701
5612         do_facet client "$@" || RC=$?
5613         do_facet mds${index} lctl set_param fail_loc=0
5614         return $RC
5615 }
5616
5617 pause_bulk() {
5618 #define OBD_FAIL_OST_BRW_PAUSE_BULK      0x214
5619         RC=0
5620
5621         local timeout=${2:-0}
5622         # default is (obd_timeout / 4) if unspecified
5623         echo "timeout is $timeout/$2"
5624         do_facet ost1 lctl set_param fail_val=$timeout fail_loc=0x80000214
5625         do_facet client "$1" || RC=$?
5626         do_facet client "sync"
5627         do_facet ost1 lctl set_param fail_loc=0
5628         return $RC
5629 }
5630
5631 drop_ldlm_cancel() {
5632 #define OBD_FAIL_LDLM_CANCEL_NET                        0x304
5633         local RC=0
5634         local list=$(comma_list $(mdts_nodes) $(osts_nodes))
5635         do_nodes $list lctl set_param fail_loc=0x304
5636
5637         do_facet client "$@" || RC=$?
5638
5639         do_nodes $list lctl set_param fail_loc=0
5640         return $RC
5641 }
5642
5643 drop_bl_callback_once() {
5644         local rc=0
5645         do_facet client lctl set_param ldlm.namespaces.*.early_lock_cancel=0
5646 #define OBD_FAIL_LDLM_BL_CALLBACK_NET                   0x305
5647         do_facet client lctl set_param fail_loc=0x80000305
5648         do_facet client "$@" || rc=$?
5649         do_facet client lctl set_param fail_loc=0
5650         do_facet client lctl set_param fail_val=0
5651         do_facet client lctl set_param ldlm.namespaces.*.early_lock_cancel=1
5652         return $rc
5653 }
5654
5655 drop_bl_callback() {
5656         rc=0
5657         do_facet client lctl set_param ldlm.namespaces.*.early_lock_cancel=0
5658 #define OBD_FAIL_LDLM_BL_CALLBACK_NET                   0x305
5659         do_facet client lctl set_param fail_loc=0x305
5660         do_facet client "$@" || rc=$?
5661         do_facet client lctl set_param fail_loc=0
5662         do_facet client lctl set_param fail_val=0
5663         do_facet client lctl set_param ldlm.namespaces.*.early_lock_cancel=1
5664         return $rc
5665 }
5666
5667 drop_mdt_ldlm_reply() {
5668 #define OBD_FAIL_MDS_LDLM_REPLY_NET     0x157
5669     RC=0
5670     local list=$(comma_list $(mdts_nodes))
5671     do_nodes $list lctl set_param fail_loc=0x157
5672
5673     do_facet client "$@" || RC=$?
5674
5675     do_nodes $list lctl set_param fail_loc=0
5676     return $RC
5677 }
5678
5679 drop_mdt_ldlm_reply_once() {
5680 #define OBD_FAIL_MDS_LDLM_REPLY_NET     0x157
5681     RC=0
5682     local list=$(comma_list $(mdts_nodes))
5683     do_nodes $list lctl set_param fail_loc=0x80000157
5684
5685     do_facet client "$@" || RC=$?
5686
5687     do_nodes $list lctl set_param fail_loc=0
5688     return $RC
5689 }
5690
5691 clear_failloc() {
5692     facet=$1
5693     pause=$2
5694     sleep $pause
5695     echo "clearing fail_loc on $facet"
5696     do_facet $facet "lctl set_param fail_loc=0 2>/dev/null || true"
5697 }
5698
5699 set_nodes_failloc () {
5700         local fv=${3:-0}
5701         do_nodes $(comma_list $1)  lctl set_param fail_val=$fv fail_loc=$2
5702 }
5703
5704 cancel_lru_locks() {
5705         #$LCTL mark "cancel_lru_locks $1 start"
5706         $LCTL set_param -n ldlm.namespaces.*$1*.lru_size=clear
5707         $LCTL get_param ldlm.namespaces.*$1*.lock_unused_count | grep -v '=0'
5708         #$LCTL mark "cancel_lru_locks $1 stop"
5709 }
5710
5711 default_lru_size()
5712 {
5713         NR_CPU=$(grep -c "processor" /proc/cpuinfo)
5714         DEFAULT_LRU_SIZE=$((100 * NR_CPU))
5715         echo "$DEFAULT_LRU_SIZE"
5716 }
5717
5718 lru_resize_enable()
5719 {
5720     lctl set_param ldlm.namespaces.*$1*.lru_size=0
5721 }
5722
5723 lru_resize_disable()
5724 {
5725     lctl set_param ldlm.namespaces.*$1*.lru_size $(default_lru_size)
5726 }
5727
5728 flock_is_enabled()
5729 {
5730         local RC=0
5731         [ -z "$(mount | grep "$MOUNT.*flock" | grep -v noflock)" ] && RC=1
5732         return $RC
5733 }
5734
5735 pgcache_empty() {
5736     local FILE
5737     for FILE in `lctl get_param -N "llite.*.dump_page_cache"`; do
5738         if [ `lctl get_param -n $FILE | wc -l` -gt 1 ]; then
5739             echo there is still data in page cache $FILE ?
5740             lctl get_param -n $FILE
5741             return 1
5742         fi
5743     done
5744     return 0
5745 }
5746
5747 debugsave() {
5748         DEBUGSAVE="$(lctl get_param -n debug)"
5749         DEBUGSAVE_SERVER=$(do_facet $SINGLEMDS "$LCTL get_param -n debug")
5750 }
5751
5752 debugrestore() {
5753         [ -n "$DEBUGSAVE" ] &&
5754                 do_nodes $CLIENTS "$LCTL set_param debug=\\\"${DEBUGSAVE}\\\""||
5755                 true
5756         DEBUGSAVE=""
5757
5758         [ -n "$DEBUGSAVE_SERVER" ] &&
5759                 do_nodes $(comma_list $(all_server_nodes)) \
5760                          "$LCTL set_param debug=\\\"${DEBUGSAVE_SERVER}\\\"" ||
5761                          true
5762         DEBUGSAVE_SERVER=""
5763 }
5764
5765 debug_size_save() {
5766     DEBUG_SIZE_SAVED="$(lctl get_param -n debug_mb)"
5767 }
5768
5769 debug_size_restore() {
5770     [ -n "$DEBUG_SIZE_SAVED" ] && \
5771         do_nodes $(comma_list $(nodes_list)) "$LCTL set_param debug_mb=$DEBUG_SIZE_SAVED"
5772     DEBUG_SIZE_SAVED=""
5773 }
5774
5775 start_full_debug_logging() {
5776     debugsave
5777     debug_size_save
5778
5779     local FULLDEBUG=-1
5780     local DEBUG_SIZE=150
5781
5782     do_nodes $(comma_list $(nodes_list)) "$LCTL set_param debug_mb=$DEBUG_SIZE"
5783     do_nodes $(comma_list $(nodes_list)) "$LCTL set_param debug=$FULLDEBUG;"
5784 }
5785
5786 stop_full_debug_logging() {
5787     debug_size_restore
5788     debugrestore
5789 }
5790
5791 # prints bash call stack
5792 print_stack_trace() {
5793         local skip=${1:-1}
5794         echo "  Trace dump:"
5795         for (( i=$skip; i < ${#BASH_LINENO[*]} ; i++ )) ; do
5796                 local src=${BASH_SOURCE[$i]}
5797                 local lineno=${BASH_LINENO[$i-1]}
5798                 local funcname=${FUNCNAME[$i]}
5799                 echo "  = $src:$lineno:$funcname()"
5800         done
5801 }
5802
5803 report_error() {
5804         local TYPE=${TYPE:-"FAIL"}
5805
5806         local dump=true
5807         # do not dump logs if $1=false
5808         if [ "x$1" = "xfalse" ]; then
5809                 shift
5810                 dump=false
5811         fi
5812
5813         log " ${TESTSUITE} ${TESTNAME}: @@@@@@ ${TYPE}: $@ "
5814         (print_stack_trace 2) >&2
5815         mkdir -p $LOGDIR
5816         # We need to dump the logs on all nodes
5817         if $dump; then
5818                 gather_logs $(comma_list $(nodes_list))
5819         fi
5820
5821         debugrestore
5822         [ "$TESTSUITELOG" ] &&
5823                 echo "$TESTSUITE: $TYPE: $TESTNAME $@" >> $TESTSUITELOG
5824         if [ -z "$*" ]; then
5825                 echo "error() without useful message, please fix" > $LOGDIR/err
5826         else
5827                 if [[ `echo $TYPE | grep ^IGNORE` ]]; then
5828                         echo "$@" > $LOGDIR/ignore
5829                 else
5830                         echo "$@" > $LOGDIR/err
5831                 fi
5832         fi
5833
5834         # cleanup the env for failed tests
5835         reset_fail_loc
5836 }
5837
5838 ##################################
5839 # Test interface
5840 ##################################
5841
5842 # usage: stack_trap arg sigspec
5843 #
5844 # stack_trap() behaves like bash's built-in trap, except that it "stacks" the
5845 # command ``arg`` on top of previously defined commands for ``sigspec`` instead
5846 # of overwriting them.
5847 # stacked traps are executed in reverse order of their registration
5848 #
5849 # arg and sigspec have the same meaning as in man (1) trap
5850 stack_trap()
5851 {
5852         local arg="$1"
5853         local sigspec="$2"
5854
5855         # Use "trap -p" to get the quoting right
5856         local old_trap="$(trap -p "$sigspec")"
5857         # Append ";" and remove the leading "trap -- '" added by "trap -p"
5858         old_trap="${old_trap:+"; ${old_trap#trap -- \'}"}"
5859
5860         # Once again, use "trap -p" to get the quoting right
5861         local new_trap="$(trap -- "$arg" "$sigspec"
5862                           trap -p "$sigspec"
5863                           trap -- '' "$sigspec")"
5864
5865         # Remove the trailing "' $sigspec" part added by "trap -p" and merge
5866         #
5867         # The resulting string should be safe to "eval" as it is (supposedly
5868         # correctly) quoted by "trap -p"
5869         eval "${new_trap%\' $sigspec}${old_trap:-"' $sigspec"}"
5870 }
5871
5872 error_noexit() {
5873         report_error "$@"
5874 }
5875
5876 exit_status () {
5877         local status=0
5878         local log=$TESTSUITELOG
5879
5880         [ -f "$log" ] && grep -qw FAIL $log && status=1
5881         exit $status
5882 }
5883
5884 error() {
5885         report_error "$@"
5886         exit 1
5887 }
5888
5889 error_exit() {
5890         report_error "$@"
5891         exit 1
5892 }
5893
5894 # use only if we are ignoring failures for this test, bugno required.
5895 # (like ALWAYS_EXCEPT, but run the test and ignore the results.)
5896 # e.g. error_ignore bz5494 "your message" or
5897 # error_ignore LU-5494 "your message"
5898 error_ignore() {
5899         local TYPE="IGNORE ($1)"
5900         shift
5901         report_error "$@"
5902 }
5903
5904 error_and_remount() {
5905         report_error "$@"
5906         remount_client $MOUNT
5907         exit 1
5908 }
5909
5910 # Throw an error if it's not running in vm - usually for performance
5911 # verification
5912 error_not_in_vm() {
5913         local virt=$(running_in_vm)
5914         if [[ -n "$virt" ]]; then
5915                 echo "running in VM '$virt', ignore error"
5916                 error_ignore env=$virt "$@"
5917         else
5918                 error "$@"
5919         fi
5920 }
5921
5922 #
5923 # Function: skip_env()
5924 # Purpose:  to skip a test during developer testing because some tool
5925 #           is missing, but fail the test in release testing because the test
5926 #           environment is not configured properly".
5927 #
5928 skip_env () {
5929         $FAIL_ON_SKIP_ENV && error false $@ || skip $@
5930 }
5931
5932 skip_noexit() {
5933         echo
5934         log " SKIP: $TESTSUITE $TESTNAME $@"
5935
5936         if [[ -n "$ALWAYS_SKIPPED" ]]; then
5937                 skip_logged $TESTNAME "$@"
5938         else
5939                 mkdir -p $LOGDIR
5940                 echo "$@" > $LOGDIR/skip
5941         fi
5942
5943         [[ -n "$TESTSUITELOG" ]] &&
5944                 echo "$TESTSUITE: SKIP: $TESTNAME $@" >> $TESTSUITELOG || true
5945 }
5946
5947 skip() {
5948         skip_noexit $@
5949         exit 0
5950 }
5951
5952 build_test_filter() {
5953         EXCEPT="$EXCEPT $(testslist_filter)"
5954
5955         for O in $ONLY; do
5956                 if [[ $O = [0-9]*-[0-9]* ]]; then
5957                         for num in $(seq $(echo $O | tr '-' ' ')); do
5958                                 eval ONLY_$num=true
5959                         done
5960                 else
5961                         eval ONLY_${O}=true
5962                 fi
5963         done
5964
5965     [ "$EXCEPT$ALWAYS_EXCEPT" ] && \
5966         log "excepting tests: `echo $EXCEPT $ALWAYS_EXCEPT`"
5967     [ "$EXCEPT_SLOW" ] && \
5968         log "skipping tests SLOW=no: `echo $EXCEPT_SLOW`"
5969     for E in $EXCEPT; do
5970         eval EXCEPT_${E}=true
5971     done
5972     for E in $ALWAYS_EXCEPT; do
5973         eval EXCEPT_ALWAYS_${E}=true
5974     done
5975     for E in $EXCEPT_SLOW; do
5976         eval EXCEPT_SLOW_${E}=true
5977     done
5978     for G in $GRANT_CHECK_LIST; do
5979         eval GCHECK_ONLY_${G}=true
5980         done
5981 }
5982
5983 basetest() {
5984     if [[ $1 = [a-z]* ]]; then
5985         echo $1
5986     else
5987         echo ${1%%[a-z]*}
5988     fi
5989 }
5990
5991 # print a newline if the last test was skipped
5992 export LAST_SKIPPED=
5993 export ALWAYS_SKIPPED=
5994 #
5995 # Main entry into test-framework. This is called with the name and
5996 # description of a test. The name is used to find the function to run
5997 # the test using "test_$name".
5998 #
5999 # This supports a variety of methods of specifying specific test to
6000 # run or not run.  These need to be documented...
6001 #
6002 run_test() {
6003         assert_DIR
6004
6005         export base=$(basetest $1)
6006         if [ -n "$ONLY" ]; then
6007                 testname=ONLY_$1
6008                 if [ ${!testname}x != x ]; then
6009                         [ -n "$LAST_SKIPPED" ] && echo "" && LAST_SKIPPED=
6010                         run_one_logged $1 "$2"
6011                         return $?
6012                 fi
6013                 testname=ONLY_$base
6014                 if [ ${!testname}x != x ]; then
6015                         [ -n "$LAST_SKIPPED" ] && echo "" && LAST_SKIPPED=
6016                         run_one_logged $1 "$2"
6017                         return $?
6018                 fi
6019                 LAST_SKIPPED="y"
6020                 return 0
6021         fi
6022
6023         LAST_SKIPPED="y"
6024         ALWAYS_SKIPPED="y"
6025         testname=EXCEPT_$1
6026         if [ ${!testname}x != x ]; then
6027                 TESTNAME=test_$1 skip_noexit "skipping excluded test $1"
6028                 return 0
6029         fi
6030         testname=EXCEPT_$base
6031         if [ ${!testname}x != x ]; then
6032                 TESTNAME=test_$1 skip_noexit "skipping excluded test $1 (base $base)"
6033                 return 0
6034         fi
6035         testname=EXCEPT_ALWAYS_$1
6036         if [ ${!testname}x != x ]; then
6037                 TESTNAME=test_$1 skip_noexit "skipping ALWAYS excluded test $1"
6038                 return 0
6039         fi
6040         testname=EXCEPT_ALWAYS_$base
6041         if [ ${!testname}x != x ]; then
6042                 TESTNAME=test_$1 skip_noexit "skipping ALWAYS excluded test $1 (base $base)"
6043                 return 0
6044         fi
6045         testname=EXCEPT_SLOW_$1
6046         if [ ${!testname}x != x ]; then
6047                 TESTNAME=test_$1 skip_noexit "skipping SLOW test $1"
6048                 return 0
6049         fi
6050         testname=EXCEPT_SLOW_$base
6051         if [ ${!testname}x != x ]; then
6052                 TESTNAME=test_$1 skip_noexit "skipping SLOW test $1 (base $base)"
6053                 return 0
6054         fi
6055
6056         LAST_SKIPPED=
6057         ALWAYS_SKIPPED=
6058         run_one_logged $1 "$2"
6059
6060         return $?
6061 }
6062
6063 log() {
6064         echo "$*" >&2
6065         load_module ../libcfs/libcfs/libcfs
6066
6067     local MSG="$*"
6068     # Get rid of '
6069     MSG=${MSG//\'/\\\'}
6070     MSG=${MSG//\(/\\\(}
6071     MSG=${MSG//\)/\\\)}
6072     MSG=${MSG//\;/\\\;}
6073     MSG=${MSG//\|/\\\|}
6074     MSG=${MSG//\>/\\\>}
6075     MSG=${MSG//\</\\\<}
6076     MSG=${MSG//\//\\\/}
6077     do_nodes $(comma_list $(nodes_list)) $LCTL mark "$MSG" 2> /dev/null || true
6078 }
6079
6080 trace() {
6081         log "STARTING: $*"
6082         strace -o $TMP/$1.strace -ttt $*
6083         RC=$?
6084         log "FINISHED: $*: rc $RC"
6085         return 1
6086 }
6087
6088 complete () {
6089     local duration=$1
6090
6091     banner test complete, duration $duration sec
6092     [ -f "$TESTSUITELOG" ] && egrep .FAIL $TESTSUITELOG || true
6093     echo duration $duration >>$TESTSUITELOG
6094 }
6095
6096 pass() {
6097         # Set TEST_STATUS here. It will be used for logging the result.
6098         TEST_STATUS="PASS"
6099
6100         if [[ -f $LOGDIR/err ]]; then
6101                 TEST_STATUS="FAIL"
6102         elif [[ -f $LOGDIR/skip ]]; then
6103                 TEST_STATUS="SKIP"
6104         fi
6105         echo "$TEST_STATUS $@" 2>&1 | tee -a $TESTSUITELOG
6106 }
6107
6108 check_mds() {
6109     local FFREE=$(do_node $SINGLEMDS \
6110         lctl get_param -n osd*.*MDT*.filesfree | calc_sum)
6111     local FTOTAL=$(do_node $SINGLEMDS \
6112         lctl get_param -n osd*.*MDT*.filestotal | calc_sum)
6113
6114     [ $FFREE -ge $FTOTAL ] && error "files free $FFREE > total $FTOTAL" || true
6115 }
6116
6117 reset_fail_loc () {
6118         echo -n "Resetting fail_loc on all nodes..."
6119         do_nodes $(comma_list $(nodes_list)) "lctl set_param -n fail_loc=0 \
6120             fail_val=0 2>/dev/null" || true
6121         echo done.
6122 }
6123
6124
6125 #
6126 # Log a message (on all nodes) padded with "=" before and after.
6127 # Also appends a timestamp and prepends the testsuite name.
6128 #
6129
6130 EQUALS="===================================================================================================="
6131 banner() {
6132     msg="== ${TESTSUITE} $*"
6133     last=${msg: -1:1}
6134     [[ $last != "=" && $last != " " ]] && msg="$msg "
6135     msg=$(printf '%s%.*s'  "$msg"  $((${#EQUALS} - ${#msg})) $EQUALS )
6136     # always include at least == after the message
6137     log "$msg== $(date +"%H:%M:%S (%s)")"
6138 }
6139
6140 check_dmesg_for_errors() {
6141         local res
6142         local errors="VFS: Busy inodes after unmount of\|\
6143 ldiskfs_check_descriptors: Checksum for group 0 failed\|\
6144 group descriptors corrupted"
6145
6146         res=$(do_nodes $(comma_list $(nodes_list)) "dmesg" | grep "$errors")
6147         [ -z "$res" ] && return 0
6148         echo "Kernel error detected: $res"
6149         return 1
6150 }
6151
6152 #
6153 # Run a single test function and cleanup after it.
6154 #
6155 # This function should be run in a subshell so the test func can
6156 # exit() without stopping the whole script.
6157 #
6158 run_one() {
6159         local testnum=$1
6160         local message=$2
6161         export tfile=f${testnum}.${TESTSUITE}
6162         export tdir=d${testnum}.${TESTSUITE}
6163         export TESTNAME=test_$testnum
6164         local SAVE_UMASK=`umask`
6165         umask 0022
6166
6167         if ! grep -q $DIR /proc/mounts; then
6168                 $SETUP
6169         fi
6170
6171         banner "test $testnum: $message"
6172         test_${testnum} || error "test_$testnum failed with $?"
6173         cd $SAVE_PWD
6174         reset_fail_loc
6175         check_grant ${testnum} || error "check_grant $testnum failed with $?"
6176         check_node_health
6177         check_dmesg_for_errors || error "Error in dmesg detected"
6178         if [ "$PARALLEL" != "yes" ]; then
6179                 ps auxww | grep -v grep | grep -q multiop &&
6180                                         error "multiop still running"
6181         fi
6182         unset TESTNAME
6183         unset tdir
6184         unset tfile
6185         umask $SAVE_UMASK
6186         $CLEANUP
6187         return 0
6188 }
6189
6190 #
6191 # Wrapper around run_one to ensure:
6192 #  - test runs in subshell
6193 #  - output of test is saved to separate log file for error reporting
6194 #  - test result is saved to data file
6195 #
6196 run_one_logged() {
6197         local BEFORE=$(date +%s)
6198         local TEST_ERROR
6199         local name=${TESTSUITE}.test_${1}.test_log.$(hostname -s).log
6200         local test_log=$LOGDIR/$name
6201         local zfs_log_name=${TESTSUITE}.test_${1}.zfs_log
6202         local zfs_debug_log=$LOGDIR/$zfs_log_name
6203         rm -rf $LOGDIR/err
6204         rm -rf $LOGDIR/ignore
6205         rm -rf $LOGDIR/skip
6206         local SAVE_UMASK=$(umask)
6207         umask 0022
6208
6209         echo
6210         log_sub_test_begin test_${1}
6211         (run_one $1 "$2") 2>&1 | tee -i $test_log
6212         local RC=${PIPESTATUS[0]}
6213
6214         [ $RC -ne 0 ] && [ ! -f $LOGDIR/err ] &&
6215                 echo "test_$1 returned $RC" | tee $LOGDIR/err
6216
6217         duration=$(($(date +%s) - $BEFORE))
6218         pass "$1" "(${duration}s)"
6219
6220         if [[ -f $LOGDIR/err ]]; then
6221                 TEST_ERROR=$(cat $LOGDIR/err)
6222         elif [[ -f $LOGDIR/ignore ]]; then
6223                 TEST_ERROR=$(cat $LOGDIR/ignore)
6224         elif [[ -f $LOGDIR/skip ]]; then
6225                 TEST_ERROR=$(cat $LOGDIR/skip)
6226         fi
6227         log_sub_test_end $TEST_STATUS $duration "$RC" "$TEST_ERROR"
6228
6229         if [[ "$TEST_STATUS" != "SKIP" ]] && [[ -f $TF_SKIP ]]; then
6230                 rm -f $TF_SKIP
6231         fi
6232
6233         if [ -f $LOGDIR/err ]; then
6234                 log_zfs_info "$zfs_debug_log"
6235                 $FAIL_ON_ERROR && exit $RC
6236         fi
6237
6238         umask $SAVE_UMASK
6239
6240         return 0
6241 }
6242
6243 #
6244 # Print information of skipped tests to result.yml
6245 #
6246 skip_logged(){
6247         log_sub_test_begin $1
6248         shift
6249         log_sub_test_end "SKIP" "0" "0" "$@"
6250 }
6251
6252 canonical_path() {
6253         (cd $(dirname $1); echo $PWD/$(basename $1))
6254 }
6255
6256
6257 check_grant() {
6258         export base=$(basetest $1)
6259         [ "$CHECK_GRANT" == "no" ] && return 0
6260
6261         testnamebase=GCHECK_ONLY_${base}
6262         testname=GCHECK_ONLY_$1
6263         [ ${!testnamebase}x == x -a ${!testname}x == x ] && return 0
6264
6265         echo -n "checking grant......"
6266
6267         local clients=$CLIENTS
6268         [ -z "$clients" ] && clients=$(hostname)
6269
6270         # sync all the data and make sure no pending data on server
6271         do_nodes $clients sync
6272         clients_up # initiate all idling connections
6273
6274         # get client grant
6275         client_grant=$(do_nodes $clients \
6276                 "$LCTL get_param -n osc.${FSNAME}-*.cur_*grant_bytes" |
6277                 awk '{ total += $1 } END { printf("%0.0f", total) }')
6278
6279         # get server grant
6280         # which is tot_granted less grant_precreate
6281         server_grant=$(do_nodes $(comma_list $(osts_nodes)) \
6282                 "$LCTL get_param "\
6283                 "obdfilter.${FSNAME}-OST*.{tot_granted,tot_pending,grant_precreate}" |
6284                 sed 's/=/ /'| awk '/tot_granted/{ total += $2 };
6285                                 /tot_pending/{ total -= $2 };
6286                                 /grant_precreate/{ total -= $2 };
6287                                 END { printf("%0.0f", total) }')
6288
6289         # check whether client grant == server grant
6290         if [[ $client_grant -ne $server_grant ]]; then
6291                 do_nodes $(comma_list $(osts_nodes)) \
6292                         "$LCTL get_param obdfilter.${FSNAME}-OST*.tot*" \
6293                         "obdfilter.${FSNAME}-OST*.grant_*"
6294                 do_nodes $clients "$LCTL get_param osc.${FSNAME}-*.cur_*_bytes"
6295                 error "failed: client:${client_grant} server: ${server_grant}."
6296         else
6297                 echo "pass: client:${client_grant} server: ${server_grant}"
6298         fi
6299 }
6300
6301 ########################
6302 # helper functions
6303
6304 osc_to_ost()
6305 {
6306     osc=$1
6307     ost=`echo $1 | awk -F_ '{print $3}'`
6308     if [ -z $ost ]; then
6309         ost=`echo $1 | sed 's/-osc.*//'`
6310     fi
6311     echo $ost
6312 }
6313
6314 ostuuid_from_index()
6315 {
6316     $LFS osts $2 | sed -ne "/^$1: /s/.* \(.*\) .*$/\1/p"
6317 }
6318
6319 ostname_from_index() {
6320     local uuid=$(ostuuid_from_index $1)
6321     echo ${uuid/_UUID/}
6322 }
6323
6324 index_from_ostuuid()
6325 {
6326     $LFS osts $2 | sed -ne "/${1}/s/\(.*\): .* .*$/\1/p"
6327 }
6328
6329 mdtuuid_from_index()
6330 {
6331     $LFS mdts $2 | sed -ne "/^$1: /s/.* \(.*\) .*$/\1/p"
6332 }
6333
6334 # Description:
6335 #   Return unique identifier for given hostname
6336 host_id() {
6337         local host_name=$1
6338         echo $host_name | md5sum | cut -d' ' -f1
6339 }
6340
6341 # Description:
6342 #   Returns list of ip addresses for each interface
6343 local_addr_list() {
6344         ip addr | awk '/inet\ / {print $2}' | awk -F\/ '{print $1}'
6345 }
6346
6347 is_local_addr() {
6348         local addr=$1
6349         # Cache address list to avoid mutiple execution of local_addr_list
6350         LOCAL_ADDR_LIST=${LOCAL_ADDR_LIST:-$(local_addr_list)}
6351         local i
6352         for i in $LOCAL_ADDR_LIST ; do
6353                 [[ "$i" == "$addr" ]] && return 0
6354         done
6355         return 1
6356 }
6357
6358 local_node() {
6359         local host_name=$1
6360         local is_local="IS_LOCAL_$(host_id $host_name)"
6361         if [ -z "${!is_local-}" ] ; then
6362                 eval $is_local=0
6363                 local host_ip=$($LUSTRE/tests/resolveip $host_name)
6364                 is_local_addr "$host_ip" && eval $is_local=1
6365         fi
6366         [[ "${!is_local}" == "1" ]]
6367 }
6368
6369 remote_node () {
6370         local node=$1
6371         local_node $node && return 1
6372         return 0
6373 }
6374
6375 remote_mds ()
6376 {
6377     local node
6378     for node in $(mdts_nodes); do
6379         remote_node $node && return 0
6380     done
6381     return 1
6382 }
6383
6384 remote_mds_nodsh()
6385 {
6386         [ -n "$CLIENTONLY" ] && return 0 || true
6387         remote_mds && [ "$PDSH" = "no_dsh" -o -z "$PDSH" -o -z "$mds_HOST" ]
6388 }
6389
6390 require_dsh_mds()
6391 {
6392         remote_mds_nodsh && echo "SKIP: $TESTSUITE: remote MDS with nodsh" &&
6393                 MSKIPPED=1 && return 1
6394         return 0
6395 }
6396
6397 remote_ost ()
6398 {
6399     local node
6400     for node in $(osts_nodes) ; do
6401         remote_node $node && return 0
6402     done
6403     return 1
6404 }
6405
6406 remote_ost_nodsh()
6407 {
6408         [ -n "$CLIENTONLY" ] && return 0 || true
6409         remote_ost && [ "$PDSH" = "no_dsh" -o -z "$PDSH" -o -z "$ost_HOST" ]
6410 }
6411
6412 require_dsh_ost()
6413 {
6414         remote_ost_nodsh && echo "SKIP: $TESTSUITE: remote OST with nodsh" && \
6415             OSKIPPED=1 && return 1
6416         return 0
6417 }
6418
6419 remote_mgs_nodsh()
6420 {
6421         [ -n "$CLIENTONLY" ] && return 0 || true
6422         local MGS
6423         MGS=$(facet_host mgs)
6424         remote_node $MGS && [ "$PDSH" = "no_dsh" -o -z "$PDSH" -o -z "$ost_HOST" ]
6425 }
6426
6427 local_mode ()
6428 {
6429     remote_mds_nodsh || remote_ost_nodsh || \
6430         $(single_local_node $(comma_list $(nodes_list)))
6431 }
6432
6433 remote_servers () {
6434     remote_ost && remote_mds
6435 }
6436
6437 # Get the active nodes for facets.
6438 facets_nodes () {
6439         local facets=$1
6440         local facet
6441         local nodes
6442         local nodes_sort
6443         local i
6444
6445         for facet in ${facets//,/ }; do
6446                 nodes="$nodes $(facet_active_host $facet)"
6447         done
6448
6449         nodes_sort=$(for i in $nodes; do echo $i; done | sort -u)
6450         echo -n $nodes_sort
6451 }
6452
6453 # Get name of the active MGS node.
6454 mgs_node () {
6455         echo -n $(facets_nodes $(get_facets MGS))
6456 }
6457
6458 # Get all of the active MDS nodes.
6459 mdts_nodes () {
6460         echo -n $(facets_nodes $(get_facets MDS))
6461 }
6462
6463 # Get all of the active OSS nodes.
6464 osts_nodes () {
6465         echo -n $(facets_nodes $(get_facets OST))
6466 }
6467
6468 # Get all of the active AGT (HSM agent) nodes.
6469 agts_nodes () {
6470         echo -n $(facets_nodes $(get_facets AGT))
6471 }
6472
6473 # Get all of the client nodes and active server nodes.
6474 nodes_list () {
6475         local nodes=$HOSTNAME
6476         local nodes_sort
6477         local i
6478
6479         # CLIENTS (if specified) contains the local client
6480         [ -n "$CLIENTS" ] && nodes=${CLIENTS//,/ }
6481
6482         if [ "$PDSH" -a "$PDSH" != "no_dsh" ]; then
6483                 nodes="$nodes $(facets_nodes $(get_facets))"
6484         fi
6485
6486         nodes_sort=$(for i in $nodes; do echo $i; done | sort -u)
6487         echo -n $nodes_sort
6488 }
6489
6490 # Get all of the remote client nodes and remote active server nodes.
6491 remote_nodes_list () {
6492         echo -n $(nodes_list) | sed -re "s/\<$HOSTNAME\>//g"
6493 }
6494
6495 # Get all of the MDS nodes, including active and passive nodes.
6496 all_mdts_nodes () {
6497         local host
6498         local failover_host
6499         local nodes
6500         local nodes_sort
6501         local i
6502
6503         for i in $(seq $MDSCOUNT); do
6504                 host=mds${i}_HOST
6505                 failover_host=mds${i}failover_HOST
6506                 nodes="$nodes ${!host} ${!failover_host}"
6507         done
6508
6509         [ -n "$nodes" ] || nodes="${mds_HOST} ${mdsfailover_HOST}"
6510         nodes_sort=$(for i in $nodes; do echo $i; done | sort -u)
6511         echo -n $nodes_sort
6512 }
6513
6514 # Get all of the OSS nodes, including active and passive nodes.
6515 all_osts_nodes () {
6516         local host
6517         local failover_host
6518         local nodes=
6519         local nodes_sort
6520         local i
6521
6522         for i in $(seq $OSTCOUNT); do
6523                 host=ost${i}_HOST
6524                 failover_host=ost${i}failover_HOST
6525                 nodes="$nodes ${!host} ${!failover_host}"
6526         done
6527
6528         [ -n "$nodes" ] || nodes="${ost_HOST} ${ostfailover_HOST}"
6529         nodes_sort=$(for i in $nodes; do echo $i; done | sort -u)
6530         echo -n $nodes_sort
6531 }
6532
6533 # Get all of the server nodes, including active and passive nodes.
6534 all_server_nodes () {
6535         local nodes
6536         local nodes_sort
6537         local i
6538
6539         nodes="$mgs_HOST $mgsfailover_HOST $(all_mdts_nodes) $(all_osts_nodes)"
6540
6541         nodes_sort=$(for i in $nodes; do echo $i; done | sort -u)
6542         echo -n $nodes_sort
6543 }
6544
6545 # Get all of the client and server nodes, including active and passive nodes.
6546 all_nodes () {
6547         local nodes=$HOSTNAME
6548         local nodes_sort
6549         local i
6550
6551         # CLIENTS (if specified) contains the local client
6552         [ -n "$CLIENTS" ] && nodes=${CLIENTS//,/ }
6553
6554         if [ "$PDSH" -a "$PDSH" != "no_dsh" ]; then
6555                 nodes="$nodes $(all_server_nodes)"
6556         fi
6557
6558         nodes_sort=$(for i in $nodes; do echo $i; done | sort -u)
6559         echo -n $nodes_sort
6560 }
6561
6562 init_clients_lists () {
6563     # Sanity check: exclude the local client from RCLIENTS
6564     local clients=$(hostlist_expand "$RCLIENTS")
6565     local rclients=$(exclude_items_from_list "$clients" $HOSTNAME)
6566
6567     # Sanity check: exclude the dup entries
6568     RCLIENTS=$(for i in ${rclients//,/ }; do echo $i; done | sort -u)
6569
6570     clients="$SINGLECLIENT $HOSTNAME $RCLIENTS"
6571
6572     # Sanity check: exclude the dup entries from CLIENTS
6573     # for those configs which has SINGLCLIENT set to local client
6574     clients=$(for i in $clients; do echo $i; done | sort -u)
6575
6576     CLIENTS=$(comma_list $clients)
6577     local -a remoteclients=($RCLIENTS)
6578     for ((i=0; $i<${#remoteclients[@]}; i++)); do
6579             varname=CLIENT$((i + 2))
6580             eval $varname=${remoteclients[i]}
6581     done
6582
6583     CLIENTCOUNT=$((${#remoteclients[@]} + 1))
6584 }
6585
6586 get_random_entry () {
6587     local rnodes=$1
6588
6589     rnodes=${rnodes//,/ }
6590
6591     local -a nodes=($rnodes)
6592     local num=${#nodes[@]}
6593     local i=$((RANDOM * num * 2 / 65536))
6594
6595     echo ${nodes[i]}
6596 }
6597
6598 client_only () {
6599         [ -n "$CLIENTONLY" ] || [ "x$CLIENTMODSONLY" = "xyes" ]
6600 }
6601
6602 check_versions () {
6603     [ "$(lustre_version_code client)" = "$(lustre_version_code $SINGLEMDS)" -a \
6604       "$(lustre_version_code client)" = "$(lustre_version_code ost1)" ]
6605 }
6606
6607 get_node_count() {
6608     local nodes="$@"
6609     echo $nodes | wc -w || true
6610 }
6611
6612 mixed_ost_devs () {
6613     local nodes=$(osts_nodes)
6614     local osscount=$(get_node_count "$nodes")
6615     [ ! "$OSTCOUNT" = "$osscount" ]
6616 }
6617
6618 mixed_mdt_devs () {
6619     local nodes=$(mdts_nodes)
6620     local mdtcount=$(get_node_count "$nodes")
6621     [ ! "$MDSCOUNT" = "$mdtcount" ]
6622 }
6623
6624 generate_machine_file() {
6625     local nodes=${1//,/ }
6626     local machinefile=$2
6627     rm -f $machinefile
6628     for node in $nodes; do
6629         echo $node >>$machinefile || \
6630             { echo "can not generate machinefile $machinefile" && return 1; }
6631     done
6632 }
6633
6634 get_stripe () {
6635         local file=$1/stripe
6636
6637         touch $file
6638         $LFS getstripe -v $file || error "getstripe $file failed"
6639         rm -f $file
6640 }
6641
6642 setstripe_nfsserver () {
6643         local dir=$1
6644         local nfsexportdir=$2
6645         shift
6646         shift
6647
6648         local -a nfsexport=($(awk '"'$dir'" ~ $2 && $3 ~ "nfs" && $2 != "/" \
6649                 { print $1 }' /proc/mounts | cut -f 1 -d :))
6650
6651         # check that only one nfs mounted
6652         [[ -z $nfsexport ]] && echo "$dir is not nfs mounted" && return 1
6653         (( ${#nfsexport[@]} == 1 )) ||
6654                 error "several nfs mounts found for $dir: ${nfsexport[@]} !"
6655
6656         do_nodev ${nfsexport[0]} lfs setstripe $nfsexportdir "$@"
6657 }
6658
6659 # Check and add a test group.
6660 add_group() {
6661         local group_id=$1
6662         local group_name=$2
6663         local rc=0
6664
6665         local gid=$(getent group $group_name | cut -d: -f3)
6666         if [[ -n "$gid" ]]; then
6667                 [[ "$gid" -eq "$group_id" ]] || {
6668                         error_noexit "inconsistent group ID:" \
6669                                      "new: $group_id, old: $gid"
6670                         rc=1
6671                 }
6672         else
6673                 groupadd -g $group_id $group_name
6674                 rc=${PIPESTATUS[0]}
6675         fi
6676
6677         return $rc
6678 }
6679
6680 # Check and add a test user.
6681 add_user() {
6682         local user_id=$1
6683         shift
6684         local user_name=$1
6685         shift
6686         local group_name=$1
6687         shift
6688         local home=$1
6689         shift
6690         local opts="$@"
6691         local rc=0
6692
6693         local uid=$(getent passwd $user_name | cut -d: -f3)
6694         if [[ -n "$uid" ]]; then
6695                 if [[ "$uid" -eq "$user_id" ]]; then
6696                         local dir=$(getent passwd $user_name | cut -d: -f6)
6697                         if [[ "$dir" != "$home" ]]; then
6698                                 mkdir -p $home
6699                                 usermod -d $home $user_name
6700                                 rc=${PIPESTATUS[0]}
6701                         fi
6702                 else
6703                         error_noexit "inconsistent user ID:" \
6704                                      "new: $user_id, old: $uid"
6705                         rc=1
6706                 fi
6707         else
6708                 mkdir -p $home
6709                 useradd -M -u $user_id -d $home -g $group_name $opts $user_name
6710                 rc=${PIPESTATUS[0]}
6711         fi
6712
6713         return $rc
6714 }
6715
6716 check_runas_id_ret() {
6717     local myRC=0
6718     local myRUNAS_UID=$1
6719     local myRUNAS_GID=$2
6720     shift 2
6721     local myRUNAS=$@
6722     if [ -z "$myRUNAS" ]; then
6723         error_exit "myRUNAS command must be specified for check_runas_id"
6724     fi
6725     if $GSS_KRB5; then
6726         $myRUNAS krb5_login.sh || \
6727             error "Failed to refresh Kerberos V5 TGT for UID $myRUNAS_ID."
6728     fi
6729     mkdir $DIR/d0_runas_test
6730     chmod 0755 $DIR
6731     chown $myRUNAS_UID:$myRUNAS_GID $DIR/d0_runas_test
6732     $myRUNAS touch $DIR/d0_runas_test/f$$ || myRC=$?
6733     rm -rf $DIR/d0_runas_test
6734     return $myRC
6735 }
6736
6737 check_runas_id() {
6738     local myRUNAS_UID=$1
6739     local myRUNAS_GID=$2
6740     shift 2
6741     local myRUNAS=$@
6742     check_runas_id_ret $myRUNAS_UID $myRUNAS_GID $myRUNAS || \
6743         error "unable to write to $DIR/d0_runas_test as UID $myRUNAS_UID.
6744         Please set RUNAS_ID to some UID which exists on MDS and client or
6745         add user $myRUNAS_UID:$myRUNAS_GID on these nodes."
6746 }
6747
6748 # obtain the UID/GID for MPI_USER
6749 get_mpiuser_id() {
6750     local mpi_user=$1
6751
6752     MPI_USER_UID=$(do_facet client "getent passwd $mpi_user | cut -d: -f3;
6753 exit \\\${PIPESTATUS[0]}") || error_exit "failed to get the UID for $mpi_user"
6754
6755     MPI_USER_GID=$(do_facet client "getent passwd $mpi_user | cut -d: -f4;
6756 exit \\\${PIPESTATUS[0]}") || error_exit "failed to get the GID for $mpi_user"
6757 }
6758
6759 # obtain and cache Kerberos ticket-granting ticket
6760 refresh_krb5_tgt() {
6761     local myRUNAS_UID=$1
6762     local myRUNAS_GID=$2
6763     shift 2
6764     local myRUNAS=$@
6765     if [ -z "$myRUNAS" ]; then
6766         error_exit "myRUNAS command must be specified for refresh_krb5_tgt"
6767     fi
6768
6769     CLIENTS=${CLIENTS:-$HOSTNAME}
6770     do_nodes $CLIENTS "set -x
6771 if ! $myRUNAS krb5_login.sh; then
6772     echo "Failed to refresh Krb5 TGT for UID/GID $myRUNAS_UID/$myRUNAS_GID."
6773     exit 1
6774 fi"
6775 }
6776
6777 # Run multiop in the background, but wait for it to print
6778 # "PAUSING" to its stdout before returning from this function.
6779 multiop_bg_pause() {
6780     MULTIOP_PROG=${MULTIOP_PROG:-$MULTIOP}
6781     FILE=$1
6782     ARGS=$2
6783
6784     TMPPIPE=/tmp/multiop_open_wait_pipe.$$
6785     mkfifo $TMPPIPE
6786
6787     echo "$MULTIOP_PROG $FILE v$ARGS"
6788     $MULTIOP_PROG $FILE v$ARGS > $TMPPIPE &
6789
6790     echo "TMPPIPE=${TMPPIPE}"
6791     read -t 60 multiop_output < $TMPPIPE
6792     if [ $? -ne 0 ]; then
6793         rm -f $TMPPIPE
6794         return 1
6795     fi
6796     rm -f $TMPPIPE
6797     if [ "$multiop_output" != "PAUSING" ]; then
6798         echo "Incorrect multiop output: $multiop_output"
6799         kill -9 $PID
6800         return 1
6801     fi
6802
6803     return 0
6804 }
6805
6806 do_and_time () {
6807     local cmd=$1
6808     local rc
6809
6810     SECONDS=0
6811     eval '$cmd'
6812
6813     [ ${PIPESTATUS[0]} -eq 0 ] || rc=1
6814
6815     echo $SECONDS
6816     return $rc
6817 }
6818
6819 inodes_available () {
6820         local IFree=$($LFS df -i $MOUNT | grep ^$FSNAME | awk '{ print $4 }' |
6821                 sort -un | head -n1) || return 1
6822         echo $((IFree))
6823 }
6824
6825 mdsrate_inodes_available () {
6826         local min_inodes=$(inodes_available)
6827         echo $((min_inodes * 99 / 100))
6828 }
6829
6830 # reset stat counters
6831 clear_stats() {
6832         local paramfile="$1"
6833         lctl set_param -n $paramfile=0
6834 }
6835
6836 # sum stat items
6837 calc_stats() {
6838         local paramfile="$1"
6839         local stat="$2"
6840         lctl get_param -n $paramfile |
6841                 awk '/^'$stat'/ { sum += $2 } END { printf("%0.0f", sum) }'
6842 }
6843
6844 calc_sum () {
6845         awk '{sum += $1} END { printf("%0.0f", sum) }'
6846 }
6847
6848 calc_osc_kbytes () {
6849         $LFS df $MOUNT > /dev/null
6850         $LCTL get_param -n osc.*[oO][sS][cC][-_][0-9a-f]*.$1 | calc_sum
6851 }
6852
6853 # save_lustre_params(comma separated facet list, parameter_mask)
6854 # generate a stream of formatted strings (<facet> <param name>=<param value>)
6855 save_lustre_params() {
6856         local facets=$1
6857         local facet
6858         local facet_svc
6859
6860         for facet in ${facets//,/ }; do
6861                 facet_svc=$(facet_svc $facet)
6862                 do_facet $facet \
6863                         "params=\\\$($LCTL get_param $2);
6864                          [[ -z \\\"$facet_svc\\\" ]] && param= ||
6865                          param=\\\$(grep $facet_svc <<< \\\"\\\$params\\\");
6866                          [[ -z \\\$param ]] && param=\\\"\\\$params\\\";
6867                          while read s; do echo $facet \\\$s;
6868                          done <<< \\\"\\\$param\\\""
6869         done
6870 }
6871
6872 # restore lustre parameters from input stream, produces by save_lustre_params
6873 restore_lustre_params() {
6874         local facet
6875         local name
6876         local val
6877
6878         while IFS=" =" read facet name val; do
6879                 do_facet $facet "$LCTL set_param -n $name=$val"
6880         done
6881 }
6882
6883 check_node_health() {
6884         local nodes=${1:-$(comma_list $(nodes_list))}
6885
6886         for node in ${nodes//,/ }; do
6887                 check_network "$node" 5
6888                 if [ $? -eq 0 ]; then
6889                         do_node $node "rc=0;
6890                         val=\\\$($LCTL get_param -n catastrophe 2>&1);
6891                         if [[ \\\$? -eq 0 && \\\$val -ne 0 ]]; then
6892                                 echo \\\$(hostname -s): \\\$val;
6893                                 rc=\\\$val;
6894                         fi;
6895                         exit \\\$rc" || error "$node:LBUG/LASSERT detected"
6896                 fi
6897         done
6898 }
6899
6900 mdsrate_cleanup () {
6901         if [ -d $4 ]; then
6902                 mpi_run ${MACHINEFILE_OPTION} $2 -np $1 ${MDSRATE} --unlink \
6903                         --nfiles $3 --dir $4 --filefmt $5 $6
6904                 rmdir $4
6905         fi
6906 }
6907
6908 delayed_recovery_enabled () {
6909     local var=${SINGLEMDS}_svc
6910     do_facet $SINGLEMDS lctl get_param -n mdd.${!var}.stale_export_age > /dev/null 2>&1
6911 }
6912
6913 ########################
6914
6915 convert_facet2label() {
6916     local facet=$1
6917
6918     if [ x$facet = xost ]; then
6919        facet=ost1
6920     fi
6921
6922     local varsvc=${facet}_svc
6923
6924     if [ -n ${!varsvc} ]; then
6925         echo ${!varsvc}
6926     else
6927         error "No lablel for $facet!"
6928     fi
6929 }
6930
6931 get_clientosc_proc_path() {
6932         echo "${1}-osc-[-0-9a-f]*"
6933 }
6934
6935 # If the 2.0 MDS was mounted on 1.8 device, then the OSC and LOV names
6936 # used by MDT would not be changed.
6937 # mdt lov: fsname-mdtlov
6938 # mdt osc: fsname-OSTXXXX-osc
6939 mds_on_old_device() {
6940     local mds=${1:-"$SINGLEMDS"}
6941
6942     if [ $(lustre_version_code $mds) -gt $(version_code 1.9.0) ]; then
6943         do_facet $mds "lctl list_param osc.$FSNAME-OST*-osc \
6944             > /dev/null 2>&1" && return 0
6945     fi
6946     return 1
6947 }
6948
6949 get_mdtosc_proc_path() {
6950         local mds_facet=$1
6951         local ost_label=${2:-"*OST*"}
6952
6953         [ "$mds_facet" = "mds" ] && mds_facet=$SINGLEMDS
6954         local mdt_label=$(convert_facet2label $mds_facet)
6955         local mdt_index=$(echo $mdt_label | sed -e 's/^.*-//')
6956
6957         if [[ $ost_label = *OST* ]]; then
6958                 echo "${ost_label}-osc-${mdt_index}"
6959         else
6960                 echo "${ost_label}-osp-${mdt_index}"
6961         fi
6962 }
6963
6964 get_osc_import_name() {
6965     local facet=$1
6966     local ost=$2
6967     local label=$(convert_facet2label $ost)
6968
6969     if [ "${facet:0:3}" = "mds" ]; then
6970         get_mdtosc_proc_path $facet $label
6971         return 0
6972     fi
6973
6974     get_clientosc_proc_path $label
6975     return 0
6976 }
6977
6978 _wait_import_state () {
6979     local expected=$1
6980     local CONN_PROC=$2
6981     local maxtime=${3:-$(max_recovery_time)}
6982     local error_on_failure=${4:-1}
6983     local CONN_STATE
6984     local i=0
6985
6986         CONN_STATE=$($LCTL get_param -n $CONN_PROC 2>/dev/null | cut -f2 | uniq)
6987     while ! echo "${CONN_STATE}" | egrep -q "^${expected}\$" ; do
6988         if [ "${expected}" == "DISCONN" ]; then
6989             # for disconn we can check after proc entry is removed
6990             [ "x${CONN_STATE}" == "x" ] && return 0
6991             #  with AT enabled, we can have connect request timeout near of
6992             # reconnect timeout and test can't see real disconnect
6993             [ "${CONN_STATE}" == "CONNECTING" ] && return 0
6994         fi
6995         if [ $i -ge $maxtime ]; then
6996             [ $error_on_failure -ne 0 ] && \
6997                 error "can't put import for $CONN_PROC into ${expected}" \
6998                       "state after $i sec, have ${CONN_STATE}"
6999             return 1
7000         fi
7001         sleep 1
7002         # Add uniq for multi-mount case
7003         CONN_STATE=$($LCTL get_param -n $CONN_PROC 2>/dev/null | cut -f2 | uniq)
7004         i=$(($i + 1))
7005     done
7006
7007     log "$CONN_PROC in ${CONN_STATE} state after $i sec"
7008     return 0
7009 }
7010
7011 wait_import_state() {
7012     local state=$1
7013     local params=$2
7014     local maxtime=${3:-$(max_recovery_time)}
7015     local error_on_failure=${4:-1}
7016     local param
7017
7018     for param in ${params//,/ }; do
7019         _wait_import_state $state $param $maxtime $error_on_failure || return
7020     done
7021 }
7022
7023 wait_import_state_mount() {
7024         if ! is_mounted $MOUNT && ! is_mounted $MOUNT2; then
7025                 return 0
7026         fi
7027
7028         wait_import_state $*
7029 }
7030
7031 # One client request could be timed out because server was not ready
7032 # when request was sent by client.
7033 # The request timeout calculation details :
7034 # ptl_send_rpc ()
7035 #      /* We give the server rq_timeout secs to process the req, and
7036 #      add the network latency for our local timeout. */
7037 #      request->rq_deadline = request->rq_sent + request->rq_timeout +
7038 #           ptlrpc_at_get_net_latency(request) ;
7039 #
7040 # ptlrpc_connect_import ()
7041 #      request->rq_timeout = INITIAL_CONNECT_TIMEOUT
7042 #
7043 # init_imp_at () ->
7044 #   -> at_init(&at->iat_net_latency, 0, 0) -> iat_net_latency=0
7045 # ptlrpc_at_get_net_latency(request) ->
7046 #       at_get (max (iat_net_latency=0, at_min)) = at_min
7047 #
7048 # i.e.:
7049 # request->rq_timeout + ptlrpc_at_get_net_latency(request) =
7050 # INITIAL_CONNECT_TIMEOUT + at_min
7051 #
7052 # We will use obd_timeout instead of INITIAL_CONNECT_TIMEOUT
7053 # because we can not get this value in runtime,
7054 # the value depends on configure options, and it is not stored in /proc.
7055 # obd_support.h:
7056 # #define CONNECTION_SWITCH_MIN 5U
7057 # #define INITIAL_CONNECT_TIMEOUT max(CONNECTION_SWITCH_MIN,obd_timeout/20)
7058
7059 request_timeout () {
7060     local facet=$1
7061
7062     # request->rq_timeout = INITIAL_CONNECT_TIMEOUT
7063     local init_connect_timeout=$TIMEOUT
7064     [[ $init_connect_timeout -ge 5 ]] || init_connect_timeout=5
7065
7066     local at_min=$(at_get $facet at_min)
7067
7068     echo $(( init_connect_timeout + at_min ))
7069 }
7070
7071 _wait_osc_import_state() {
7072         local facet=$1
7073         local ost_facet=$2
7074         local expected=$3
7075         local target=$(get_osc_import_name $facet $ost_facet)
7076         local param="osc.${target}.ost_server_uuid"
7077         local params=$param
7078         local i=0
7079
7080         # 1. wait the deadline of client 1st request (it could be skipped)
7081         # 2. wait the deadline of client 2nd request
7082         local maxtime=$(( 2 * $(request_timeout $facet)))
7083
7084         if [[ $facet == client* ]]; then
7085                 # During setup time, the osc might not be setup, it need wait
7086                 # until list_param can return valid value.
7087                 params=$($LCTL list_param $param 2>/dev/null || true)
7088                 while [ -z "$params" ]; do
7089                         if [ $i -ge $maxtime ]; then
7090                                 echo "can't get $param in $maxtime secs"
7091                                 return 1
7092                         fi
7093                         sleep 1
7094                         i=$((i + 1))
7095                         params=$($LCTL list_param $param 2>/dev/null || true)
7096                 done
7097         fi
7098
7099         if [[ $ost_facet = mds* ]]; then
7100                 # no OSP connection to itself
7101                 if [[ $facet = $ost_facet ]]; then
7102                         return 0
7103                 fi
7104                 param="osp.${target}.mdt_server_uuid"
7105                 params=$param
7106         fi
7107
7108         if ! do_rpc_nodes "$(facet_active_host $facet)" \
7109                         wait_import_state $expected "$params" $maxtime; then
7110                 error "$facet: import is not in $expected state after $maxtime"
7111                 return 1
7112         fi
7113
7114         return 0
7115 }
7116
7117 wait_osc_import_state() {
7118         local facet=$1
7119         local ost_facet=$2
7120         local expected=$3
7121         local num
7122
7123         if [[ $facet = mds ]]; then
7124                 for num in $(seq $MDSCOUNT); do
7125                         _wait_osc_import_state mds$num "$ost_facet" "$expected"
7126                 done
7127         else
7128                 _wait_osc_import_state "$facet" "$ost_facet" "$expected"
7129         fi
7130 }
7131
7132 wait_osc_import_ready() {
7133         wait_osc_import_state $1 $2 "\(FULL\|IDLE\)"
7134 }
7135
7136 _wait_mgc_import_state() {
7137         local facet=$1
7138         local expected=$2
7139         local error_on_failure=${3:-1}
7140         local param="mgc.*.mgs_server_uuid"
7141         local params=$param
7142         local i=0
7143
7144         # 1. wait the deadline of client 1st request (it could be skipped)
7145         # 2. wait the deadline of client 2nd request
7146         local maxtime=$(( 2 * $(request_timeout $facet)))
7147
7148         if [[ $facet == client* ]]; then
7149                 # During setup time, the osc might not be setup, it need wait
7150                 # until list_param can return valid value. And also if there
7151                 # are mulitple osc entries we should list all of them before
7152                 # go to wait.
7153                 params=$($LCTL list_param $param 2>/dev/null || true)
7154                 while [ -z "$params" ]; do
7155                         if [ $i -ge $maxtime ]; then
7156                                 echo "can't get $param in $maxtime secs"
7157                                 return 1
7158                         fi
7159                         sleep 1
7160                         i=$((i + 1))
7161                         params=$($LCTL list_param $param 2>/dev/null || true)
7162                 done
7163         fi
7164         if ! do_rpc_nodes "$(facet_active_host $facet)" \
7165                         wait_import_state $expected "$params" $maxtime \
7166                                           $error_on_failure; then
7167                 if [ $error_on_failure -ne 0 ]; then
7168                     error "import is not in ${expected} state"
7169                 fi
7170                 return 1
7171         fi
7172
7173         return 0
7174 }
7175
7176 wait_mgc_import_state() {
7177         local facet=$1
7178         local expected=$2
7179         local error_on_failure=${3:-1}
7180         local num
7181
7182         if [[ $facet = mds ]]; then
7183                 for num in $(seq $MDSCOUNT); do
7184                         _wait_mgc_import_state mds$num "$expected" \
7185                                                $error_on_failure || return
7186                 done
7187         else
7188                 _wait_mgc_import_state "$facet" "$expected"
7189                                        $error_on_failure || return
7190         fi
7191 }
7192
7193 wait_dne_interconnect() {
7194         local num
7195
7196         if [ $MDSCOUNT -gt 1 ]; then
7197                 for num in $(seq $MDSCOUNT); do
7198                         wait_osc_import_ready mds mds$num
7199                 done
7200         fi
7201 }
7202
7203 get_clientmdc_proc_path() {
7204     echo "${1}-mdc-*"
7205 }
7206
7207 get_clientmgc_proc_path() {
7208     echo "*"
7209 }
7210
7211 do_rpc_nodes () {
7212         local list=$1
7213         shift
7214
7215         [ -z "$list" ] && return 0
7216
7217         # Add paths to lustre tests for 32 and 64 bit systems.
7218         local LIBPATH="/usr/lib/lustre/tests:/usr/lib64/lustre/tests:"
7219         local TESTPATH="$RLUSTRE/tests:"
7220         local RPATH="PATH=${TESTPATH}${LIBPATH}${PATH}:/sbin:/bin:/usr/sbin:"
7221         do_nodesv $list "${RPATH} NAME=${NAME} bash rpc.sh $@ "
7222 }
7223
7224 wait_clients_import_state () {
7225         local list=$1
7226         local facet=$2
7227         local expected=$3
7228
7229         local facets=$facet
7230
7231         if [ "$FAILURE_MODE" = HARD ]; then
7232                 facets=$(facets_on_host $(facet_active_host $facet))
7233         fi
7234
7235         for facet in ${facets//,/ }; do
7236                 local label=$(convert_facet2label $facet)
7237                 local proc_path
7238                 case $facet in
7239                 ost* ) proc_path="osc.$(get_clientosc_proc_path \
7240                                   $label).ost_server_uuid" ;;
7241                 mds* ) proc_path="mdc.$(get_clientmdc_proc_path \
7242                                   $label).mds_server_uuid" ;;
7243                 mgs* ) proc_path="mgc.$(get_clientmgc_proc_path \
7244                                   $label).mgs_server_uuid" ;;
7245                 *) error "unknown facet!" ;;
7246                 esac
7247
7248                 local params=$(expand_list $params $proc_path)
7249         done
7250
7251         if ! do_rpc_nodes "$list" wait_import_state_mount "$expected" $params;
7252         then
7253                 error "import is not in ${expected} state"
7254                 return 1
7255         fi
7256 }
7257
7258 wait_osp_active() {
7259         local facet=$1
7260         local tgt_name=$2
7261         local tgt_idx=$3
7262         local expected=$4
7263         local num
7264
7265         # wait until all MDTs are in the expected state
7266         for ((num = 1; num <= $MDSCOUNT; num++)); do
7267                 local mdtosp=$(get_mdtosc_proc_path mds${num} ${tgt_name})
7268                 local wait=0
7269                 local mproc
7270
7271                 if [ $facet = "mds" ]; then
7272                         mproc="osp.$mdtosp.active"
7273                         [ $num -eq $((tgt_idx + 1)) ] && continue
7274                 else
7275                         mproc="osc.$mdtosp.active"
7276                 fi
7277
7278                 echo "check $mproc"
7279                 while [ 1 ]; do
7280                         sleep 5
7281                         local result=$(do_facet mds${num} "$LCTL get_param -n $mproc")
7282                         local max=30
7283
7284                         [ ${PIPESTATUS[0]} = 0 ] || error "Can't read $mproc"
7285                         if [ $result -eq $expected ]; then
7286                                 echo -n "target updated after "
7287                                 echo "$wait sec (got $result)"
7288                                 break
7289                         fi
7290                         wait=$((wait + 5))
7291                         if [ $wait -eq $max ]; then
7292                                 error "$tgt_name: wanted $expected got $result"
7293                         fi
7294                         echo "Waiting $((max - wait)) secs for $tgt_name"
7295                 done
7296         done
7297 }
7298
7299 oos_full() {
7300         local -a AVAILA
7301         local -a GRANTA
7302         local -a TOTALA
7303         local OSCFULL=1
7304         AVAILA=($(do_nodes $(comma_list $(osts_nodes)) \
7305                   $LCTL get_param obdfilter.*.kbytesavail))
7306         GRANTA=($(do_nodes $(comma_list $(osts_nodes)) \
7307                   $LCTL get_param -n obdfilter.*.tot_granted))
7308         TOTALA=($(do_nodes $(comma_list $(osts_nodes)) \
7309                   $LCTL get_param -n obdfilter.*.kbytestotal))
7310         for ((i=0; i<${#AVAILA[@]}; i++)); do
7311                 local -a AVAIL1=(${AVAILA[$i]//=/ })
7312                 local -a TOTAL=(${TOTALA[$i]//=/ })
7313                 GRANT=$((${GRANTA[$i]}/1024))
7314                 # allow 1% of total space in bavail because of delayed
7315                 # allocation with ZFS which might release some free space after
7316                 # txg commit.  For small devices, we set a mininum of 8MB
7317                 local LIMIT=$((${TOTAL} / 100 + 8000))
7318                 echo -n $(echo ${AVAIL1[0]} | cut -d"." -f2) avl=${AVAIL1[1]} \
7319                         grnt=$GRANT diff=$((AVAIL1[1] - GRANT)) limit=${LIMIT}
7320                 [ $((AVAIL1[1] - GRANT)) -lt $LIMIT ] && OSCFULL=0 && \
7321                         echo " FULL" || echo
7322         done
7323         return $OSCFULL
7324 }
7325
7326 list_pool() {
7327         echo -e "$(do_facet $SINGLEMDS $LCTL pool_list $1 | sed '1d')"
7328 }
7329
7330 check_pool_not_exist() {
7331         local fsname=${1%%.*}
7332         local poolname=${1##$fsname.}
7333         [[ $# -ne 1 ]] && return 0
7334         [[ x$poolname = x ]] &&  return 0
7335         list_pool $fsname | grep -w $1 && return 1
7336         return 0
7337 }
7338
7339 create_pool() {
7340         local fsname=${1%%.*}
7341         local poolname=${1##$fsname.}
7342
7343         stack_trap "destroy_test_pools $fsname" EXIT
7344         do_facet mgs lctl pool_new $1
7345         local RC=$?
7346         # get param should return err unless pool is created
7347         [[ $RC -ne 0 ]] && return $RC
7348
7349         for mds_id in $(seq $MDSCOUNT); do
7350                 local mdt_id=$((mds_id-1))
7351                 local lodname=$fsname-MDT$(printf "%04x" $mdt_id)-mdtlov
7352                 wait_update_facet mds$mds_id \
7353                         "lctl get_param -n lod.$lodname.pools.$poolname \
7354                                 2>/dev/null || echo foo" "" ||
7355                         error "mds$mds_id: pool_new failed $1"
7356         done
7357         wait_update $HOSTNAME "lctl get_param -n lov.$fsname-*.pools.$poolname \
7358                 2>/dev/null || echo foo" "" || error "pool_new failed $1"
7359
7360         add_pool_to_list $1
7361         return $RC
7362 }
7363
7364 add_pool_to_list () {
7365         local fsname=${1%%.*}
7366         local poolname=${1##$fsname.}
7367
7368         local listvar=${fsname}_CREATED_POOLS
7369         local temp=${listvar}=$(expand_list ${!listvar} $poolname)
7370         eval export $temp
7371 }
7372
7373 remove_pool_from_list () {
7374         local fsname=${1%%.*}
7375         local poolname=${1##$fsname.}
7376
7377         local listvar=${fsname}_CREATED_POOLS
7378         local temp=${listvar}=$(exclude_items_from_list ${!listvar} $poolname)
7379         eval export $temp
7380 }
7381
7382 destroy_pool_int() {
7383         local ost
7384         local OSTS=$(list_pool $1)
7385         for ost in $OSTS; do
7386                 do_facet mgs lctl pool_remove $1 $ost
7387         done
7388         do_facet mgs lctl pool_destroy $1
7389 }
7390
7391 # <fsname>.<poolname> or <poolname>
7392 destroy_pool() {
7393         local fsname=${1%%.*}
7394         local poolname=${1##$fsname.}
7395
7396         [[ x$fsname = x$poolname ]] && fsname=$FSNAME
7397
7398         local RC
7399
7400         check_pool_not_exist $fsname.$poolname
7401         [[ $? -eq 0 ]] && return 0
7402
7403         destroy_pool_int $fsname.$poolname
7404         RC=$?
7405         [[ $RC -ne 0 ]] && return $RC
7406         for mds_id in $(seq $MDSCOUNT); do
7407                 local mdt_id=$((mds_id-1))
7408                 local lodname=$fsname-MDT$(printf "%04x" $mdt_id)-mdtlov
7409                 wait_update_facet mds$mds_id \
7410                         "lctl get_param -n lod.$lodname.pools.$poolname \
7411                                 2>/dev/null || echo foo" "foo" ||
7412                         error "mds$mds_id: destroy pool failed $1"
7413         done
7414         wait_update $HOSTNAME "lctl get_param -n lov.$fsname-*.pools.$poolname \
7415                 2>/dev/null || echo foo" "foo" || error "destroy pool failed $1"
7416
7417         remove_pool_from_list $fsname.$poolname
7418
7419         return $RC
7420 }
7421
7422 destroy_pools () {
7423         local fsname=${1:-$FSNAME}
7424         local poolname
7425         local listvar=${fsname}_CREATED_POOLS
7426
7427         [ x${!listvar} = x ] && return 0
7428
7429         echo "Destroy the created pools: ${!listvar}"
7430         for poolname in ${!listvar//,/ }; do
7431                 destroy_pool $fsname.$poolname
7432         done
7433 }
7434
7435 destroy_test_pools () {
7436         trap 0
7437         local fsname=${1:-$FSNAME}
7438         destroy_pools $fsname || true
7439 }
7440
7441 gather_logs () {
7442     local list=$1
7443
7444     local ts=$(date +%s)
7445     local docp=true
7446
7447     if [[ ! -f "$YAML_LOG" ]]; then
7448         # init_logging is not performed before gather_logs,
7449         # so the $LOGDIR needs to be checked here
7450         check_shared_dir $LOGDIR && touch $LOGDIR/shared
7451     fi
7452
7453     [ -f $LOGDIR/shared ] && docp=false
7454
7455     # dump lustre logs, dmesg
7456
7457     prefix="$TESTLOG_PREFIX.$TESTNAME"
7458     suffix="$ts.log"
7459     echo "Dumping lctl log to ${prefix}.*.${suffix}"
7460
7461     if [ -n "$CLIENTONLY" -o "$PDSH" == "no_dsh" ]; then
7462         echo "Dumping logs only on local client."
7463         $LCTL dk > ${prefix}.debug_log.$(hostname -s).${suffix}
7464         dmesg > ${prefix}.dmesg.$(hostname -s).${suffix}
7465         return
7466     fi
7467
7468     do_nodesv $list \
7469         "$LCTL dk > ${prefix}.debug_log.\\\$(hostname -s).${suffix};
7470          dmesg > ${prefix}.dmesg.\\\$(hostname -s).${suffix}"
7471
7472     if [ ! -f $LOGDIR/shared ]; then
7473         do_nodes $list rsync -az "${prefix}.*.${suffix}" $HOSTNAME:$LOGDIR
7474     fi
7475 }
7476
7477 do_ls () {
7478     local mntpt_root=$1
7479     local num_mntpts=$2
7480     local dir=$3
7481     local i
7482     local cmd
7483     local pids
7484     local rc=0
7485
7486     for i in $(seq 0 $num_mntpts); do
7487         cmd="ls -laf ${mntpt_root}$i/$dir"
7488         echo + $cmd;
7489         $cmd > /dev/null &
7490         pids="$pids $!"
7491     done
7492     echo pids=$pids
7493     for pid in $pids; do
7494         wait $pid || rc=$?
7495     done
7496
7497     return $rc
7498 }
7499
7500 # check_and_start_recovery_timer()
7501 #       service_time = at_est2timeout(service_time);
7502 #       service_time += 2 * INITIAL_CONNECT_TIMEOUT;
7503 #       service_time += 2 * (CONNECTION_SWITCH_MAX + CONNECTION_SWITCH_INC);
7504
7505 #define INITIAL_CONNECT_TIMEOUT max(CONNECTION_SWITCH_MIN, obd_timeout/20)
7506 #define CONNECTION_SWITCH_MAX min(50, max(CONNECTION_SWITCH_MIN, obd_timeout))
7507 #define CONNECTION_SWITCH_MIN 5
7508 #define CONNECTION_SWITCH_INC 5
7509 max_recovery_time() {
7510         local init_connect_timeout=$((TIMEOUT / 20))
7511         ((init_connect_timeout >= 5)) || init_connect_timeout=5
7512
7513         local service_time=$(($(at_max_get client) * 9 / 4 + 5))
7514         service_time=$((service_time + 2 * (init_connect_timeout + 50 + 5)))
7515
7516         echo -n $service_time
7517 }
7518
7519 recovery_time_min() {
7520         local connection_switch_min=5
7521         local connection_switch_inc=5
7522         local connection_switch_max
7523         local reconnect_delay_max
7524         local initial_connect_timeout
7525         local max
7526         local timout_20
7527
7528         #connection_switch_max=min(50, max($connection_switch_min,$TIMEOUT)
7529         (($connection_switch_min > $TIMEOUT)) &&
7530                 max=$connection_switch_min || max=$TIMEOUT
7531         (($max < 50)) && connection_switch_max=$max || connection_switch_max=50
7532
7533         #initial_connect_timeout = max(connection_switch_min, obd_timeout/20)
7534         timeout_20=$((TIMEOUT/20))
7535         (($connection_switch_min > $timeout_20)) &&
7536                 initial_connect_timeout=$connection_switch_min ||
7537                 initial_connect_timeout=$timeout_20
7538
7539         reconnect_delay_max=$((connection_switch_max + connection_switch_inc + \
7540                                initial_connect_timeout))
7541         echo $((2 * reconnect_delay_max))
7542 }
7543
7544 get_clients_mount_count () {
7545         local clients=${CLIENTS:-$HOSTNAME}
7546
7547         # we need to take into account the clients mounts and
7548         # exclude mds/ost mounts if any;
7549         do_nodes $clients cat /proc/mounts | grep lustre |
7550                 grep -w $MOUNT | wc -l
7551 }
7552
7553 # gss functions
7554 PROC_CLI="srpc_info"
7555 PROC_CON="srpc_contexts"
7556
7557 combination()
7558 {
7559     local M=$1
7560     local N=$2
7561     local R=1
7562
7563     if [ $M -lt $N ]; then
7564         R=0
7565     else
7566         N=$((N + 1))
7567         while [ $N -lt $M ]; do
7568             R=$((R * N))
7569             N=$((N + 1))
7570         done
7571     fi
7572
7573     echo $R
7574     return 0
7575 }
7576
7577 calc_connection_cnt() {
7578         local dir=$1
7579
7580         # MDT->MDT = 2 * C(M, 2)
7581         # MDT->OST = M * O
7582         # CLI->OST = C * O
7583         # CLI->MDT = C * M
7584         comb_m2=$(combination $MDSCOUNT 2)
7585
7586         local num_clients=$(get_clients_mount_count)
7587
7588         local cnt_mdt2mdt=$((comb_m2 * 2))
7589         local cnt_mdt2ost=$((MDSCOUNT * OSTCOUNT))
7590         local cnt_cli2ost=$((num_clients * OSTCOUNT))
7591         local cnt_cli2mdt=$((num_clients * MDSCOUNT))
7592         if is_mounted $MOUNT2; then
7593                 cnt_cli2mdt=$((cnt_cli2mdt * 2))
7594                 cnt_cli2ost=$((cnt_cli2ost * 2))
7595         fi
7596         if local_mode; then
7597                 cnt_mdt2mdt=0
7598                 cnt_mdt2ost=0
7599                 cnt_cli2ost=2
7600                 cnt_cli2mdt=1
7601         fi
7602         local cnt_all2ost=$((cnt_mdt2ost + cnt_cli2ost))
7603         local cnt_all2mdt=$((cnt_mdt2mdt + cnt_cli2mdt))
7604         local cnt_all2all=$((cnt_mdt2ost + cnt_mdt2mdt \
7605                 + cnt_cli2ost + cnt_cli2mdt))
7606
7607         local var=cnt_$dir
7608         local res=${!var}
7609
7610         echo $res
7611 }
7612
7613 set_rule()
7614 {
7615     local tgt=$1
7616     local net=$2
7617     local dir=$3
7618     local flavor=$4
7619     local cmd="$tgt.srpc.flavor"
7620
7621     if [ $net == "any" ]; then
7622         net="default"
7623     fi
7624     cmd="$cmd.$net"
7625
7626     if [ $dir != "any" ]; then
7627         cmd="$cmd.$dir"
7628     fi
7629
7630     cmd="$cmd=$flavor"
7631     log "Setting sptlrpc rule: $cmd"
7632     do_facet mgs "$LCTL conf_param $cmd"
7633 }
7634
7635 count_contexts()
7636 {
7637         local output=$1
7638         local total_ctx=$(echo "$output" | grep -c "expire.*key.*hdl")
7639         echo $total_ctx
7640 }
7641
7642 count_flvr()
7643 {
7644     local output=$1
7645     local flavor=$2
7646     local count=0
7647
7648     rpc_flvr=`echo $flavor | awk -F - '{ print $1 }'`
7649     bulkspec=`echo $flavor | awk -F - '{ print $2 }'`
7650
7651     count=`echo "$output" | grep "rpc flavor" | grep $rpc_flvr | wc -l`
7652
7653     if [ "x$bulkspec" != "x" ]; then
7654         algs=`echo $bulkspec | awk -F : '{ print $2 }'`
7655
7656         if [ "x$algs" != "x" ]; then
7657             bulk_count=`echo "$output" | grep "bulk flavor" | grep $algs | wc -l`
7658         else
7659             bulk=`echo $bulkspec | awk -F : '{ print $1 }'`
7660             if [ $bulk == "bulkn" ]; then
7661                 bulk_count=`echo "$output" | grep "bulk flavor" \
7662                             | grep "null/null" | wc -l`
7663             elif [ $bulk == "bulki" ]; then
7664                 bulk_count=`echo "$output" | grep "bulk flavor" \
7665                             | grep "/null" | grep -v "null/" | wc -l`
7666             else
7667                 bulk_count=`echo "$output" | grep "bulk flavor" \
7668                             | grep -v "/null" | grep -v "null/" | wc -l`
7669             fi
7670         fi
7671
7672         [ $bulk_count -lt $count ] && count=$bulk_count
7673     fi
7674
7675     echo $count
7676 }
7677
7678 flvr_cnt_cli2mdt()
7679 {
7680     local flavor=$1
7681     local cnt
7682
7683     local clients=${CLIENTS:-$HOSTNAME}
7684
7685     for c in ${clients//,/ }; do
7686         local output=$(do_node $c lctl get_param -n \
7687                  mdc.*-*-mdc-*.$PROC_CLI 2>/dev/null)
7688         local tmpcnt=$(count_flvr "$output" $flavor)
7689         if $GSS_SK && [ $flavor != "null" ]; then
7690                 # tmpcnt=min(contexts,flavors) to ensure SK context is on
7691                 output=$(do_node $c lctl get_param -n \
7692                          mdc.*-MDT*-mdc-*.$PROC_CON 2>/dev/null)
7693                 local outcon=$(count_contexts "$output")
7694                 if [ "$outcon" -lt "$tmpcnt" ]; then
7695                         tmpcnt=$outcon
7696                 fi
7697         fi
7698         cnt=$((cnt + tmpcnt))
7699     done
7700     echo $cnt
7701 }
7702
7703 flvr_cnt_cli2ost()
7704 {
7705     local flavor=$1
7706     local cnt
7707
7708     local clients=${CLIENTS:-$HOSTNAME}
7709
7710     for c in ${clients//,/ }; do
7711         # reconnect if idle
7712         do_node $c lctl set_param osc.*.idle_connect=1 >/dev/null 2>&1
7713         local output=$(do_node $c lctl get_param -n \
7714                  osc.*OST*-osc-[^M][^D][^T]*.$PROC_CLI 2>/dev/null)
7715         local tmpcnt=$(count_flvr "$output" $flavor)
7716         if $GSS_SK && [ $flavor != "null" ]; then
7717                 # tmpcnt=min(contexts,flavors) to ensure SK context is on
7718                 output=$(do_node $c lctl get_param -n \
7719                          osc.*OST*-osc-[^M][^D][^T]*.$PROC_CON 2>/dev/null)
7720                 local outcon=$(count_contexts "$output")
7721                 if [ "$outcon" -lt "$tmpcnt" ]; then
7722                         tmpcnt=$outcon
7723                 fi
7724         fi
7725         cnt=$((cnt + tmpcnt))
7726     done
7727     echo $cnt
7728 }
7729
7730 flvr_cnt_mdt2mdt()
7731 {
7732     local flavor=$1
7733     local cnt=0
7734
7735     if [ $MDSCOUNT -le 1 ]; then
7736         echo 0
7737         return
7738     fi
7739
7740     for num in `seq $MDSCOUNT`; do
7741         local output=$(do_facet mds$num lctl get_param -n \
7742                 osp.*-MDT*osp-MDT*.$PROC_CLI 2>/dev/null)
7743         local tmpcnt=$(count_flvr "$output" $flavor)
7744         if $GSS_SK && [ $flavor != "null" ]; then
7745                 # tmpcnt=min(contexts,flavors) to ensure SK context is on
7746                 output=$(do_facet mds$num lctl get_param -n \
7747                         osp.*-MDT*osp-MDT*.$PROC_CON 2>/dev/null)
7748                 local outcon=$(count_contexts "$output")
7749                 if [ "$outcon" -lt "$tmpcnt" ]; then
7750                         tmpcnt=$outcon
7751                 fi
7752         fi
7753         cnt=$((cnt + tmpcnt))
7754     done
7755     echo $cnt;
7756 }
7757
7758 flvr_cnt_mdt2ost()
7759 {
7760     local flavor=$1
7761     local cnt=0
7762     local mdtosc
7763
7764     for num in `seq $MDSCOUNT`; do
7765         mdtosc=$(get_mdtosc_proc_path mds$num)
7766         mdtosc=${mdtosc/-MDT*/-MDT\*}
7767         local output=$(do_facet mds$num lctl get_param -n \
7768                  osc.$mdtosc.$PROC_CLI 2>/dev/null)
7769         local tmpcnt=$(count_flvr "$output" $flavor)
7770         if $GSS_SK && [ $flavor != "null" ]; then
7771                 # tmpcnt=min(contexts,flavors) to ensure SK context is on
7772                 output=$(do_facet mds$num lctl get_param -n \
7773                          osc.$mdtosc.$PROC_CON 2>/dev/null)
7774                 local outcon=$(count_contexts "$output")
7775                 if [ "$outcon" -lt "$tmpcnt" ]; then
7776                         tmpcnt=$outcon
7777                 fi
7778         fi
7779         cnt=$((cnt + tmpcnt))
7780     done
7781     echo $cnt;
7782 }
7783
7784 flvr_cnt_mgc2mgs()
7785 {
7786     local flavor=$1
7787
7788     local output=$(do_facet client lctl get_param -n mgc.*.$PROC_CLI \
7789                         2>/dev/null)
7790     count_flvr "$output" $flavor
7791 }
7792
7793 do_check_flavor()
7794 {
7795     local dir=$1        # from to
7796     local flavor=$2     # flavor expected
7797     local res=0
7798
7799     if [ $dir == "cli2mdt" ]; then
7800         res=`flvr_cnt_cli2mdt $flavor`
7801     elif [ $dir == "cli2ost" ]; then
7802         res=`flvr_cnt_cli2ost $flavor`
7803     elif [ $dir == "mdt2mdt" ]; then
7804         res=`flvr_cnt_mdt2mdt $flavor`
7805     elif [ $dir == "mdt2ost" ]; then
7806         res=`flvr_cnt_mdt2ost $flavor`
7807     elif [ $dir == "all2ost" ]; then
7808         res1=`flvr_cnt_mdt2ost $flavor`
7809         res2=`flvr_cnt_cli2ost $flavor`
7810         res=$((res1 + res2))
7811     elif [ $dir == "all2mdt" ]; then
7812         res1=`flvr_cnt_mdt2mdt $flavor`
7813         res2=`flvr_cnt_cli2mdt $flavor`
7814         res=$((res1 + res2))
7815     elif [ $dir == "all2all" ]; then
7816         res1=`flvr_cnt_mdt2ost $flavor`
7817         res2=`flvr_cnt_cli2ost $flavor`
7818         res3=`flvr_cnt_mdt2mdt $flavor`
7819         res4=`flvr_cnt_cli2mdt $flavor`
7820         res=$((res1 + res2 + res3 + res4))
7821     fi
7822
7823     echo $res
7824 }
7825
7826 wait_flavor()
7827 {
7828         local dir=$1        # from to
7829         local flavor=$2     # flavor expected
7830         local expect=${3:-$(calc_connection_cnt $dir)} # number expected
7831         local WAITFLAVOR_MAX=20 # how many retries before abort?
7832
7833         local res=0
7834         for ((i = 0; i < $WAITFLAVOR_MAX; i++)); do
7835                 echo -n "checking $dir..."
7836                 res=$(do_check_flavor $dir $flavor)
7837                 echo "found $res/$expect $flavor connections"
7838                 [ $res -ge $expect ] && return 0
7839                 sleep 4
7840         done
7841
7842         echo "Error checking $flavor of $dir: expect $expect, actual $res"
7843 #       echo "Dumping additional logs for SK debug.."
7844         do_nodes $(comma_list $(all_server_nodes)) "keyctl show"
7845         if $dump; then
7846                 gather_logs $(comma_list $(nodes_list))
7847         fi
7848         return 1
7849 }
7850
7851 restore_to_default_flavor()
7852 {
7853         local proc="mgs.MGS.live.$FSNAME"
7854
7855         echo "restoring to default flavor..."
7856
7857         local nrule=$(do_facet mgs lctl get_param -n $proc 2>/dev/null |
7858                 grep ".srpc.flavor" | wc -l)
7859
7860         # remove all existing rules if any
7861         if [ $nrule -ne 0 ]; then
7862                 echo "$nrule existing rules"
7863                 for rule in $(do_facet mgs lctl get_param -n $proc 2>/dev/null |
7864                     grep ".srpc.flavor."); do
7865                         echo "remove rule: $rule"
7866                         spec=`echo $rule | awk -F = '{print $1}'`
7867                         do_facet mgs "$LCTL conf_param -d $spec"
7868                 done
7869         fi
7870
7871         # verify no rules left
7872         nrule=$(do_facet mgs lctl get_param -n $proc 2>/dev/null |
7873                 grep ".srpc.flavor." | wc -l)
7874         [ $nrule -ne 0 ] && error "still $nrule rules left"
7875
7876         # wait for default flavor to be applied
7877         if $GSS_SK; then
7878                 if $SK_S2S; then
7879                         set_rule $FSNAME any any $SK_FLAVOR
7880                         wait_flavor all2all $SK_FLAVOR
7881                 else
7882                         set_rule $FSNAME any cli2mdt $SK_FLAVOR
7883                         set_rule $FSNAME any cli2ost $SK_FLAVOR
7884                         wait_flavor cli2mdt $SK_FLAVOR
7885                         wait_flavor cli2ost $SK_FLAVOR
7886                 fi
7887                 echo "GSS_SK now at default flavor: $SK_FLAVOR"
7888         else
7889                 wait_flavor all2all null
7890         fi
7891 }
7892
7893 set_flavor_all()
7894 {
7895         local flavor=${1:-null}
7896
7897         echo "setting all flavor to $flavor"
7898
7899         # FIXME need parameter to this fn
7900         # and remove global vars
7901         local cnt_all2all=$(calc_connection_cnt all2all)
7902
7903         local res=$(do_check_flavor all2all $flavor)
7904         if [ $res -eq $cnt_all2all ]; then
7905                 echo "already have total $res $flavor connections"
7906                 return
7907         fi
7908
7909         echo "found $res $flavor out of total $cnt_all2all connections"
7910         restore_to_default_flavor
7911
7912         [[ $flavor = null ]] && return 0
7913
7914         if $GSS_SK && [ $flavor != "null" ]; then
7915                 if $SK_S2S; then
7916                         set_rule $FSNAME any any $flavor
7917                         wait_flavor all2all $flavor
7918                 else
7919                         set_rule $FSNAME any cli2mdt $flavor
7920                         set_rule $FSNAME any cli2ost $flavor
7921                         set_rule $FSNAME any mdt2ost null
7922                         set_rule $FSNAME any mdt2mdt null
7923                         wait_flavor cli2mdt $flavor
7924                         wait_flavor cli2ost $flavor
7925                 fi
7926                 echo "GSS_SK now at flavor: $flavor"
7927         else
7928                 set_rule $FSNAME any any $flavor
7929                 wait_flavor all2all $flavor
7930         fi
7931 }
7932
7933
7934 check_logdir() {
7935     local dir=$1
7936     # Checking for shared logdir
7937     if [ ! -d $dir ]; then
7938         # Not found. Create local logdir
7939         mkdir -p $dir
7940     else
7941         touch $dir/check_file.$(hostname -s)
7942     fi
7943     return 0
7944 }
7945
7946 check_write_access() {
7947         local dir=$1
7948         local list=${2:-$(comma_list $(nodes_list))}
7949         local node
7950         local file
7951
7952         for node in ${list//,/ }; do
7953                 file=$dir/check_file.$(short_nodename $node)
7954                 if [[ ! -f "$file" ]]; then
7955                         # Logdir not accessible/writable from this node.
7956                         return 1
7957                 fi
7958                 rm -f $file || return 1
7959         done
7960         return 0
7961 }
7962
7963 init_logging() {
7964         [[ -n $YAML_LOG ]] && return
7965         local save_umask=$(umask)
7966         umask 0000
7967
7968         export YAML_LOG=${LOGDIR}/results.yml
7969         mkdir -p $LOGDIR
7970         init_clients_lists
7971
7972         # If the yaml log already exists then we will just append to it
7973         if [ ! -f $YAML_LOG ]; then
7974                 if check_shared_dir $LOGDIR; then
7975                         touch $LOGDIR/shared
7976                         echo "Logging to shared log directory: $LOGDIR"
7977                 else
7978                         echo "Logging to local directory: $LOGDIR"
7979                 fi
7980
7981                 yml_nodes_file $LOGDIR >> $YAML_LOG
7982                 yml_results_file >> $YAML_LOG
7983         fi
7984
7985         umask $save_umask
7986
7987         # If modules are not yet loaded then older "lctl lustre_build_version"
7988         # will fail.  Use lctl build version instead.
7989         log "Client: $($LCTL lustre_build_version)"
7990         log "MDS: $(do_facet $SINGLEMDS $LCTL lustre_build_version 2>/dev/null||
7991                     do_facet $SINGLEMDS $LCTL --version)"
7992         log "OSS: $(do_facet ost1 $LCTL lustre_build_version 2> /dev/null ||
7993                     do_facet ost1 $LCTL --version)"
7994
7995         get_lustre_env
7996 }
7997
7998 log_test() {
7999     yml_log_test $1 >> $YAML_LOG
8000 }
8001
8002 log_test_status() {
8003      yml_log_test_status $@ >> $YAML_LOG
8004 }
8005
8006 log_sub_test_begin() {
8007     yml_log_sub_test_begin "$@" >> $YAML_LOG
8008 }
8009
8010 log_sub_test_end() {
8011     yml_log_sub_test_end "$@" >> $YAML_LOG
8012 }
8013
8014 run_llverdev()
8015 {
8016         local dev=$1
8017         local llverdev_opts=$2
8018         local devname=$(basename $1)
8019         local size=$(grep "$devname"$ /proc/partitions | awk '{print $3}')
8020         # loop devices aren't in /proc/partitions
8021         [ "x$size" == "x" ] && local size=$(ls -l $dev | awk '{print $5}')
8022
8023         size=$(($size / 1024 / 1024)) # Gb
8024
8025         local partial_arg=""
8026         # Run in partial (fast) mode if the size
8027         # of a partition > 1 GB
8028         [ $size -gt 1 ] && partial_arg="-p"
8029
8030         llverdev --force $partial_arg $llverdev_opts $dev
8031 }
8032
8033 run_llverfs()
8034 {
8035         local dir=$1
8036         local llverfs_opts=$2
8037         local use_partial_arg=$3
8038         local partial_arg=""
8039         local size=$(df -B G $dir |tail -n 1 |awk '{print $2}' |sed 's/G//') #GB
8040
8041         # Run in partial (fast) mode if the size
8042         # of a partition > 1 GB
8043         [ "x$use_partial_arg" != "xno" ] && [ $size -gt 1 ] && partial_arg="-p"
8044
8045         llverfs $partial_arg $llverfs_opts $dir
8046 }
8047
8048 #Remove objects from OST
8049 remove_ost_objects() {
8050         local facet=$1
8051         local ostdev=$2
8052         local group=$3
8053         shift 3
8054         local objids="$@"
8055         local mntpt=$(facet_mntpt $facet)
8056         local opts=$OST_MOUNT_OPTS
8057         local i
8058         local rc
8059
8060         echo "removing objects from $ostdev on $facet: $objids"
8061         if ! test -b $ostdev; then
8062                 opts=$(csa_add "$opts" -o loop)
8063         fi
8064         mount -t $(facet_fstype $facet) $opts $ostdev $mntpt ||
8065                 return $?
8066         rc=0
8067         for i in $objids; do
8068                 rm $mntpt/O/$group/d$((i % 32))/$i || { rc=$?; break; }
8069         done
8070         umount -f $mntpt || return $?
8071         return $rc
8072 }
8073
8074 #Remove files from MDT
8075 remove_mdt_files() {
8076         local facet=$1
8077         local mdtdev=$2
8078         shift 2
8079         local files="$@"
8080         local mntpt=$(facet_mntpt $facet)
8081         local opts=$MDS_MOUNT_OPTS
8082
8083         echo "removing files from $mdtdev on $facet: $files"
8084         if [ $(facet_fstype $facet) == ldiskfs ] &&
8085            ! do_facet $facet test -b $mdtdev; then
8086                 opts=$(csa_add "$opts" -o loop)
8087         fi
8088         mount -t $(facet_fstype $facet) $opts $mdtdev $mntpt ||
8089                 return $?
8090         rc=0
8091         for f in $files; do
8092                 rm $mntpt/ROOT/$f || { rc=$?; break; }
8093         done
8094         umount -f $mntpt || return $?
8095         return $rc
8096 }
8097
8098 duplicate_mdt_files() {
8099         local facet=$1
8100         local mdtdev=$2
8101         shift 2
8102         local files="$@"
8103         local mntpt=$(facet_mntpt $facet)
8104         local opts=$MDS_MOUNT_OPTS
8105
8106         echo "duplicating files on $mdtdev on $facet: $files"
8107         mkdir -p $mntpt || return $?
8108         if [ $(facet_fstype $facet) == ldiskfs ] &&
8109            ! do_facet $facet test -b $mdtdev; then
8110                 opts=$(csa_add "$opts" -o loop)
8111         fi
8112         mount -t $(facet_fstype $facet) $opts $mdtdev $mntpt ||
8113                 return $?
8114
8115     do_umount() {
8116         trap 0
8117         popd > /dev/null
8118         rm $tmp
8119         umount -f $mntpt
8120     }
8121     trap do_umount EXIT
8122
8123     tmp=$(mktemp $TMP/setfattr.XXXXXXXXXX)
8124     pushd $mntpt/ROOT > /dev/null || return $?
8125     rc=0
8126     for f in $files; do
8127         touch $f.bad || return $?
8128         getfattr -n trusted.lov $f | sed "s#$f#&.bad#" > $tmp
8129         rc=${PIPESTATUS[0]}
8130         [ $rc -eq 0 ] || return $rc
8131         setfattr --restore $tmp || return $?
8132     done
8133     do_umount
8134 }
8135
8136 run_sgpdd () {
8137     local devs=${1//,/ }
8138     shift
8139     local params=$@
8140     local rslt=$TMP/sgpdd_survey
8141
8142     # sgpdd-survey cleanups ${rslt}.* files
8143
8144     local cmd="rslt=$rslt $params scsidevs=\"$devs\" $SGPDDSURVEY"
8145     echo + $cmd
8146     eval $cmd
8147     cat ${rslt}.detail
8148 }
8149
8150 # returns the canonical name for an ldiskfs device
8151 ldiskfs_canon() {
8152         local dev="$1"
8153         local facet="$2"
8154
8155         do_facet $facet "dv=\\\$($LCTL get_param -n $dev);
8156                          if foo=\\\$(lvdisplay -c \\\$dv 2>/dev/null); then
8157                                 echo dm-\\\${foo##*:};
8158                          else
8159                                 name=\\\$(basename \\\$dv);
8160                                 if [[ \\\$name = *flakey* ]]; then
8161                                         name=\\\$(lsblk -o NAME,KNAME |
8162                                                 awk /\\\$name/'{print \\\$NF}');
8163                                 fi;
8164                                 echo \\\$name;
8165                          fi;"
8166 }
8167
8168 is_sanity_benchmark() {
8169     local benchmarks="dbench bonnie iozone fsx"
8170     local suite=$1
8171     for b in $benchmarks; do
8172         if [ "$b" == "$suite" ]; then
8173             return 0
8174         fi
8175     done
8176     return 1
8177 }
8178
8179 min_ost_size () {
8180         $LFS df | grep OST | awk '{print $4}' | sort -un | head -1
8181 }
8182
8183 #
8184 # Get the available size (KB) of a given obd target.
8185 #
8186 get_obd_size() {
8187         local facet=$1
8188         local obd=$2
8189         local size
8190
8191         [[ $facet != client ]] || return 0
8192
8193         size=$(do_facet $facet $LCTL get_param -n *.$obd.kbytesavail | head -n1)
8194         echo -n $size
8195 }
8196
8197 #
8198 # Get the page size (bytes) on a given facet node.
8199 # The local client page_size is directly available in PAGE_SIZE.
8200 #
8201 get_page_size() {
8202         local facet=$1
8203         local page_size=$(getconf PAGE_SIZE 2>/dev/null)
8204
8205         [ -z "$CLIENTONLY" -a "$facet" != "client" ] &&
8206                 page_size=$(do_facet $facet getconf PAGE_SIZE)
8207         echo -n ${page_size:-4096}
8208 }
8209
8210 #
8211 # Get the block count of the filesystem.
8212 #
8213 get_block_count() {
8214         local facet=$1
8215         local device=$2
8216         local count
8217
8218         [ -z "$CLIENTONLY" ] && count=$(do_facet $facet "$DUMPE2FS -h $device 2>&1" |
8219                 awk '/^Block count:/ {print $3}')
8220         echo -n ${count:-0}
8221 }
8222
8223 # Get the block size of the filesystem.
8224 get_block_size() {
8225         local facet=$1
8226         local device=$2
8227         local size
8228
8229         [ -z "$CLIENTONLY" ] && size=$(do_facet $facet "$DUMPE2FS -h $device 2>&1" |
8230                 awk '/^Block size:/ {print $3}')
8231         echo -n ${size:-0}
8232 }
8233
8234 # Check whether the "ea_inode" feature is enabled or not, to allow
8235 # ldiskfs xattrs over one block in size.  Allow both the historical
8236 # Lustre feature name (large_xattr) and the upstream name (ea_inode).
8237 large_xattr_enabled() {
8238         [[ $(facet_fstype $SINGLEMDS) == zfs ]] && return 0
8239
8240         local mds_dev=$(mdsdevname ${SINGLEMDS//mds/})
8241
8242         do_facet $SINGLEMDS "$DUMPE2FS -h $mds_dev 2>&1 |
8243                 grep -E -q '(ea_inode|large_xattr)'"
8244         return ${PIPESTATUS[0]}
8245 }
8246
8247 # Get the maximum xattr size supported by the filesystem.
8248 max_xattr_size() {
8249     local size
8250
8251     if large_xattr_enabled; then
8252         size=$($LCTL get_param -n llite.*.max_easize)
8253     else
8254         local mds_dev=$(mdsdevname ${SINGLEMDS//mds/})
8255         local block_size=$(get_block_size $SINGLEMDS $mds_dev)
8256
8257         # maximum xattr size = size of block - size of header -
8258         #                      size of 1 entry - 4 null bytes
8259         size=$((block_size - 32 - 32 - 4))
8260     fi
8261
8262     echo $size
8263 }
8264
8265 # Dump the value of the named xattr from a file.
8266 get_xattr_value() {
8267     local xattr_name=$1
8268     local file=$2
8269
8270     echo "$(getfattr -n $xattr_name --absolute-names --only-values $file)"
8271 }
8272
8273 # Generate a string with size of $size bytes.
8274 generate_string() {
8275     local size=${1:-1024} # in bytes
8276
8277     echo "$(head -c $size < /dev/zero | tr '\0' y)"
8278 }
8279
8280 reformat_external_journal() {
8281         local facet=$1
8282         local var
8283
8284         var=${facet}_JRN
8285         if [ -n "${!var}" ]; then
8286                 local rcmd="do_facet $facet"
8287
8288                 echo "reformat external journal on $facet:${!var}"
8289                 ${rcmd} mke2fs -O journal_dev ${!var} || return 1
8290         fi
8291 }
8292
8293 # MDT file-level backup/restore
8294 mds_backup_restore() {
8295         local facet=$1
8296         local igif=$2
8297         local devname=$(mdsdevname $(facet_number $facet))
8298         local mntpt=$(facet_mntpt brpt)
8299         local rcmd="do_facet $facet"
8300         local metaea=${TMP}/backup_restore.ea
8301         local metadata=${TMP}/backup_restore.tgz
8302         local opts=${MDS_MOUNT_OPTS}
8303         local svc=${facet}_svc
8304
8305         if ! ${rcmd} test -b ${devname}; then
8306                 opts=$(csa_add "$opts" -o loop)
8307         fi
8308
8309         echo "file-level backup/restore on $facet:${devname}"
8310
8311         # step 1: build mount point
8312         ${rcmd} mkdir -p $mntpt
8313         # step 2: cleanup old backup
8314         ${rcmd} rm -f $metaea $metadata
8315         # step 3: mount dev
8316         ${rcmd} mount -t ldiskfs $opts $devname $mntpt || return 1
8317         if [ ! -z $igif ]; then
8318                 # step 3.5: rm .lustre
8319                 ${rcmd} rm -rf $mntpt/ROOT/.lustre || return 1
8320         fi
8321         # step 4: backup metaea
8322         echo "backup EA"
8323         ${rcmd} "cd $mntpt && getfattr -R -d -m '.*' -P . > $metaea && cd -" ||
8324                 return 2
8325         # step 5: backup metadata
8326         echo "backup data"
8327         ${rcmd} tar zcf $metadata -C $mntpt/ . > /dev/null 2>&1 || return 3
8328         # step 6: umount
8329         ${rcmd} $UMOUNT $mntpt || return 4
8330         # step 8: reformat dev
8331         echo "reformat new device"
8332         format_mdt $(facet_number $facet)
8333         # step 9: mount dev
8334         ${rcmd} mount -t ldiskfs $opts $devname $mntpt || return 7
8335         # step 10: restore metadata
8336         echo "restore data"
8337         ${rcmd} tar zxfp $metadata -C $mntpt > /dev/null 2>&1 || return 8
8338         # step 11: restore metaea
8339         echo "restore EA"
8340         ${rcmd} "cd $mntpt && setfattr --restore=$metaea && cd - " || return 9
8341         # step 12: remove recovery logs
8342         echo "remove recovery logs"
8343         ${rcmd} rm -fv $mntpt/OBJECTS/* $mntpt/CATALOGS
8344         # step 13: umount dev
8345         ${rcmd} $UMOUNT $mntpt || return 10
8346         # step 14: cleanup tmp backup
8347         ${rcmd} rm -f $metaea $metadata
8348         # step 15: reset device label - it's not virgin on
8349         ${rcmd} e2label $devname ${!svc}
8350 }
8351
8352 # remove OI files
8353 mds_remove_ois() {
8354         local facet=$1
8355         local idx=$2
8356         local devname=$(mdsdevname $(facet_number $facet))
8357         local mntpt=$(facet_mntpt brpt)
8358         local rcmd="do_facet $facet"
8359         local opts=${MDS_MOUNT_OPTS}
8360
8361         if ! ${rcmd} test -b ${devname}; then
8362                 opts=$(csa_add "$opts" -o loop)
8363         fi
8364
8365         echo "removing OI files on $facet: idx=${idx}"
8366
8367         # step 1: build mount point
8368         ${rcmd} mkdir -p $mntpt
8369         # step 2: mount dev
8370         ${rcmd} mount -t ldiskfs $opts $devname $mntpt || return 1
8371         if [ -z $idx ]; then
8372                 # step 3: remove all OI files
8373                 ${rcmd} rm -fv $mntpt/oi.16*
8374         elif [ $idx -lt 2 ]; then
8375                 ${rcmd} rm -fv $mntpt/oi.16.${idx}
8376         else
8377                 local i
8378
8379                 # others, rm oi.16.[idx, idx * idx, idx ** ...]
8380                 for ((i=${idx}; i<64; i=$((i * idx)))); do
8381                         ${rcmd} rm -fv $mntpt/oi.16.${i}
8382                 done
8383         fi
8384         # step 4: umount
8385         ${rcmd} $UMOUNT $mntpt || return 2
8386         # OI files will be recreated when mounted as lustre next time.
8387 }
8388
8389 # generate maloo upload-able log file name
8390 # \param logname specify unique part of file name
8391 generate_logname() {
8392         local logname=${1:-"default_logname"}
8393
8394         echo "$TESTLOG_PREFIX.$TESTNAME.$logname.$(hostname -s).log"
8395 }
8396
8397 # make directory on different MDTs
8398 test_mkdir() {
8399         local path
8400         local p_option
8401         local dirstripe_count=${DIRSTRIPE_COUNT:-"2"}
8402         local dirstripe_index=${DIRSTRIPE_INDEX:-$((base % $MDSCOUNT))}
8403         local OPTIND=1
8404
8405         while getopts "c:i:p" opt; do
8406                 case $opt in
8407                         c) dirstripe_count=$OPTARG;;
8408                         i) dirstripe_index=$OPTARG;;
8409                         p) p_option="-p";;
8410                         \?) error "only support -i -c -p";;
8411                 esac
8412         done
8413
8414         shift $((OPTIND - 1))
8415         [ $# -eq 1 ] || error "Only creating single directory is supported"
8416         path="$*"
8417
8418         if [ "$p_option" == "-p" ]; then
8419                 local parent=$(dirname $path)
8420
8421                 [ -d $path ] && return 0
8422                 if [ ! -d ${parent} ]; then
8423                         mkdir -p ${parent} ||
8424                                 error "mkdir parent '$parent' failed"
8425                 fi
8426         fi
8427
8428         if [ $MDSCOUNT -le 1 ]; then
8429                 mkdir $path || error "mkdir '$path' failed"
8430         else
8431                 local mdt_index
8432
8433                 if [ $dirstripe_index -eq -1 ]; then
8434                         mdt_index=$((base % MDSCOUNT))
8435                 else
8436                         mdt_index=$dirstripe_index
8437                 fi
8438
8439                 if (($MDS1_VERSION >= $(version_code 2.8.0))); then
8440                         if [ $dirstripe_count -eq -1 ]; then
8441                                 dirstripe_count=$((RANDOM % MDSCOUNT + 1))
8442                         fi
8443                 else
8444                         dirstripe_count=1
8445                 fi
8446
8447                 echo "striped dir -i$mdt_index -c$dirstripe_count $path"
8448                 $LFS mkdir -i$mdt_index -c$dirstripe_count $path ||
8449                         error "mkdir -i $mdt_index -c$dirstripe_count $path failed"
8450         fi
8451 }
8452
8453 # free_fd: find the smallest and not in use file descriptor [above @last_fd]
8454 #
8455 # If called many times, passing @last_fd will avoid repeated searching
8456 # already-open FDs repeatedly if we know they are still in use.
8457 #
8458 # usage: free_fd [last_fd]
8459 free_fd()
8460 {
8461         local max_fd=$(ulimit -n)
8462         local fd=$((${1:-2} + 1))
8463
8464         while [[ $fd -le $max_fd && -e /proc/self/fd/$fd ]]; do
8465                 ((++fd))
8466         done
8467         [ $fd -lt $max_fd ] || error "finding free file descriptor failed"
8468         echo $fd
8469 }
8470
8471 check_mount_and_prep()
8472 {
8473         is_mounted $MOUNT || setupall
8474
8475         rm -rf $DIR/[df][0-9]* || error "Fail to cleanup the env!"
8476         mkdir $DIR/$tdir || error "Fail to mkdir $DIR/$tdir."
8477         for idx in $(seq $MDSCOUNT); do
8478                 local name="MDT$(printf '%04x' $((idx - 1)))"
8479                 rm -rf $MOUNT/.lustre/lost+found/$name/*
8480         done
8481 }
8482
8483 # calcule how many ost-objects to be created.
8484 precreated_ost_obj_count()
8485 {
8486         local mdt_idx=$1
8487         local ost_idx=$2
8488         local mdt_name="MDT$(printf '%04x' $mdt_idx)"
8489         local ost_name="OST$(printf '%04x' $ost_idx)"
8490         local proc_path="${FSNAME}-${ost_name}-osc-${mdt_name}"
8491         local last_id=$(do_facet mds$((mdt_idx + 1)) lctl get_param -n \
8492                         osp.$proc_path.prealloc_last_id)
8493         local next_id=$(do_facet mds$((mdt_idx + 1)) lctl get_param -n \
8494                         osp.$proc_path.prealloc_next_id)
8495         echo $((last_id - next_id + 1))
8496 }
8497
8498 check_file_in_pool()
8499 {
8500         local file=$1
8501         local pool=$2
8502         local tlist="$3"
8503         local res=$($GETSTRIPE $file | grep 0x | cut -f2)
8504         for i in $res
8505         do
8506                 for t in $tlist ; do
8507                         [ "$i" -eq "$t" ] && continue 2
8508                 done
8509
8510                 echo "pool list: $tlist"
8511                 echo "striping: $res"
8512                 error_noexit "$file not allocated in $pool"
8513                 return 1
8514         done
8515         return 0
8516 }
8517
8518 pool_add() {
8519         echo "Creating new pool"
8520         local pool=$1
8521
8522         create_pool $FSNAME.$pool ||
8523                 { error_noexit "No pool created, result code $?"; return 1; }
8524         [ $($LFS pool_list $FSNAME | grep -c "$FSNAME.${pool}\$") -eq 1 ] ||
8525                 { error_noexit "$pool not in lfs pool_list"; return 2; }
8526 }
8527
8528 pool_add_targets() {
8529         echo "Adding targets to pool"
8530         local pool=$1
8531         local first=$2
8532         local last=$3
8533         local step=${4:-1}
8534
8535         if [ -z $last ]; then
8536                 local list=$first
8537         else
8538                 local list=$(seq $first $step $last)
8539         fi
8540
8541         local t=$(for i in $list; do printf "$FSNAME-OST%04x_UUID " $i; done)
8542         do_facet mgs $LCTL pool_add \
8543                         $FSNAME.$pool $FSNAME-OST[$first-$last/$step]
8544
8545         # wait for OSTs to be added to the pool
8546         for mds_id in $(seq $MDSCOUNT); do
8547                 local mdt_id=$((mds_id-1))
8548                 local lodname=$FSNAME-MDT$(printf "%04x" $mdt_id)-mdtlov
8549                 wait_update_facet mds$mds_id \
8550                         "lctl get_param -n lod.$lodname.pools.$pool |
8551                                 sort -u | tr '\n' ' ' " "$t" || {
8552                         error_noexit "mds$mds_id: Add to pool failed"
8553                         return 3
8554                 }
8555         done
8556         wait_update $HOSTNAME "lctl get_param -n lov.$FSNAME-*.pools.$pool \
8557                         | sort -u | tr '\n' ' ' " "$t" || {
8558                 error_noexit "Add to pool failed"
8559                 return 1
8560         }
8561         local lfscount=$($LFS pool_list $FSNAME.$pool | grep -c "\-OST")
8562         local addcount=$(((last - first) / step + 1))
8563         [ $lfscount -eq $addcount ] || {
8564                 error_noexit "lfs pool_list bad ost count" \
8565                                                 "$lfscount != $addcount"
8566                 return 2
8567         }
8568 }
8569
8570 pool_set_dir() {
8571         local pool=$1
8572         local tdir=$2
8573         echo "Setting pool on directory $tdir"
8574
8575         $SETSTRIPE -c 2 -p $pool $tdir && return 0
8576
8577         error_noexit "Cannot set pool $pool to $tdir"
8578         return 1
8579 }
8580
8581 pool_check_dir() {
8582         local pool=$1
8583         local tdir=$2
8584         echo "Checking pool on directory $tdir"
8585
8586         local res=$($GETSTRIPE --pool $tdir | sed "s/\s*$//")
8587         [ "$res" = "$pool" ] && return 0
8588
8589         error_noexit "Pool on '$tdir' is '$res', not '$pool'"
8590         return 1
8591 }
8592
8593 pool_dir_rel_path() {
8594         echo "Testing relative path works well"
8595         local pool=$1
8596         local tdir=$2
8597         local root=$3
8598
8599         mkdir -p $root/$tdir/$tdir
8600         cd $root/$tdir
8601         pool_set_dir $pool $tdir          || return 1
8602         pool_set_dir $pool ./$tdir        || return 2
8603         pool_set_dir $pool ../$tdir       || return 3
8604         pool_set_dir $pool ../$tdir/$tdir || return 4
8605         rm -rf $tdir; cd - > /dev/null
8606 }
8607
8608 pool_alloc_files() {
8609         echo "Checking files allocation from directory pool"
8610         local pool=$1
8611         local tdir=$2
8612         local count=$3
8613         local tlist="$4"
8614
8615         local failed=0
8616         for i in $(seq -w 1 $count)
8617         do
8618                 local file=$tdir/file-$i
8619                 touch $file
8620                 check_file_in_pool $file $pool "$tlist" || \
8621                         failed=$((failed + 1))
8622         done
8623         [ "$failed" = 0 ] && return 0
8624
8625         error_noexit "$failed files not allocated in $pool"
8626         return 1
8627 }
8628
8629 pool_create_files() {
8630         echo "Creating files in pool"
8631         local pool=$1
8632         local tdir=$2
8633         local count=$3
8634         local tlist="$4"
8635
8636         mkdir -p $tdir
8637         local failed=0
8638         for i in $(seq -w 1 $count)
8639         do
8640                 local file=$tdir/spoo-$i
8641                 $SETSTRIPE -p $pool $file
8642                 check_file_in_pool $file $pool "$tlist" || \
8643                         failed=$((failed + 1))
8644         done
8645         [ "$failed" = 0 ] && return 0
8646
8647         error_noexit "$failed files not allocated in $pool"
8648         return 1
8649 }
8650
8651 pool_lfs_df() {
8652         echo "Checking 'lfs df' output"
8653         local pool=$1
8654
8655         local t=$($LCTL get_param -n lov.$FSNAME-clilov-*.pools.$pool |
8656                         tr '\n' ' ')
8657         local res=$($LFS df --pool $FSNAME.$pool |
8658                         awk '{print $1}' |
8659                         grep "$FSNAME-OST" |
8660                         tr '\n' ' ')
8661         [ "$res" = "$t" ] && return 0
8662
8663         error_noexit "Pools OSTs '$t' is not '$res' that lfs df reports"
8664         return 1
8665 }
8666
8667 pool_file_rel_path() {
8668         echo "Creating files in a pool with relative pathname"
8669         local pool=$1
8670         local tdir=$2
8671
8672         mkdir -p $tdir ||
8673                 { error_noexit "unable to create $tdir"; return 1 ; }
8674         local file="/..$tdir/$tfile-1"
8675         $SETSTRIPE -p $pool $file ||
8676                 { error_noexit "unable to create $file" ; return 2 ; }
8677
8678         cd $tdir
8679         $SETSTRIPE -p $pool $tfile-2 || {
8680                 error_noexit "unable to create $tfile-2 in $tdir"
8681                 return 3
8682         }
8683 }
8684
8685 pool_remove_first_target() {
8686         echo "Removing first target from a pool"
8687         local pool=$1
8688
8689         local pname="lov.$FSNAME-*.pools.$pool"
8690         local t=$($LCTL get_param -n $pname | head -1)
8691         do_facet mgs $LCTL pool_remove $FSNAME.$pool $t
8692         for mds_id in $(seq $MDSCOUNT); do
8693                 local mdt_id=$((mds_id-1))
8694                 local lodname=$FSNAME-MDT$(printf "%04x" $mdt_id)-mdtlov
8695                 wait_update_facet mds$mds_id \
8696                         "lctl get_param -n lod.$lodname.pools.$pool |
8697                                 grep $t" "" || {
8698                         error_noexit "mds$mds_id: $t not removed from" \
8699                         "$FSNAME.$pool"
8700                         return 2
8701                 }
8702         done
8703         wait_update $HOSTNAME "lctl get_param -n $pname | grep $t" "" || {
8704                 error_noexit "$t not removed from $FSNAME.$pool"
8705                 return 1
8706         }
8707 }
8708
8709 pool_remove_all_targets() {
8710         echo "Removing all targets from pool"
8711         local pool=$1
8712         local file=$2
8713         local pname="lov.$FSNAME-*.pools.$pool"
8714         for t in $($LCTL get_param -n $pname | sort -u)
8715         do
8716                 do_facet mgs $LCTL pool_remove $FSNAME.$pool $t
8717         done
8718         for mds_id in $(seq $MDSCOUNT); do
8719                 local mdt_id=$((mds_id-1))
8720                 local lodname=$FSNAME-MDT$(printf "%04x" $mdt_id)-mdtlov
8721                 wait_update_facet mds$mds_id "lctl get_param -n \
8722                         lod.$lodname.pools.$pool" "" || {
8723                         error_noexit "mds$mds_id: Pool $pool not drained"
8724                         return 4
8725                 }
8726         done
8727         wait_update $HOSTNAME "lctl get_param -n $pname" "" || {
8728                 error_noexit "Pool $FSNAME.$pool cannot be drained"
8729                 return 1
8730         }
8731         # striping on an empty/nonexistant pool should fall back
8732         # to "pool of everything"
8733         touch $file || {
8734                 error_noexit "failed to use fallback striping for empty pool"
8735                 return 2
8736         }
8737         # setstripe on an empty pool should fail
8738         $SETSTRIPE -p $pool $file 2>/dev/null && {
8739                 error_noexit "expected failure when creating file" \
8740                                                         "with empty pool"
8741                 return 3
8742         }
8743         return 0
8744 }
8745
8746 pool_remove() {
8747         echo "Destroying pool"
8748         local pool=$1
8749         local file=$2
8750
8751         do_facet mgs $LCTL pool_destroy $FSNAME.$pool
8752
8753         sleep 2
8754         # striping on an empty/nonexistant pool should fall back
8755         # to "pool of everything"
8756         touch $file || {
8757                 error_noexit "failed to use fallback striping for missing pool"
8758                 return 1
8759         }
8760         # setstripe on an empty pool should fail
8761         $SETSTRIPE -p $pool $file 2>/dev/null && {
8762                 error_noexit "expected failure when creating file" \
8763                                                         "with missing pool"
8764                 return 2
8765         }
8766
8767         # get param should return err once pool is gone
8768         if wait_update $HOSTNAME "lctl get_param -n \
8769                 lov.$FSNAME-*.pools.$pool 2>/dev/null || echo foo" "foo"
8770         then
8771                 remove_pool_from_list $FSNAME.$pool
8772                 return 0
8773         fi
8774         error_noexit "Pool $FSNAME.$pool is not destroyed"
8775         return 3
8776 }
8777
8778 # Get and check the actual stripe count of one file.
8779 # Usage: check_stripe_count <file> <expected_stripe_count>
8780 check_stripe_count() {
8781         local file=$1
8782         local expected=$2
8783         local actual
8784
8785         [[ -z "$file" || -z "$expected" ]] &&
8786                 error "check_stripe_count: invalid argument"
8787
8788         local cmd="$LFS getstripe -c $file"
8789         actual=$($cmd) || error "$cmd failed"
8790         actual=${actual%% *}
8791
8792         if [[ $actual -ne $expected ]]; then
8793                 [[ $expected -eq -1 ]] || { $LFS getstripe $file;
8794                         error "$cmd not expected ($expected): found $actual"; }
8795                 [[ $actual -eq $OSTCOUNT ]] || { $LFS getstripe $file;
8796                         error "$cmd not OST count ($OSTCOUNT): found $actual"; }
8797         fi
8798 }
8799
8800 # Get and check the actual list of OST indices on one file.
8801 # Usage: check_obdidx <file> <expected_comma_separated_list_of_ost_indices>
8802 check_obdidx() {
8803         local file=$1
8804         local expected=$2
8805         local obdidx
8806
8807         [[ -z "$file" || -z "$expected" ]] &&
8808                 error "check_obdidx: invalid argument!"
8809
8810         obdidx=$(comma_list $($GETSTRIPE $file | grep -A $OSTCOUNT obdidx |
8811                               grep -v obdidx | awk '{print $1}' | xargs))
8812
8813         [[ $obdidx = $expected ]] ||
8814                 error "list of OST indices on $file is $obdidx," \
8815                       "should be $expected"
8816 }
8817
8818 # Get and check the actual OST index of the first stripe on one file.
8819 # Usage: check_start_ost_idx <file> <expected_start_ost_idx>
8820 check_start_ost_idx() {
8821         local file=$1
8822         local expected=$2
8823         local start_ost_idx
8824
8825         [[ -z "$file" || -z "$expected" ]] &&
8826                 error "check_start_ost_idx: invalid argument!"
8827
8828         start_ost_idx=$($GETSTRIPE $file | grep -A 1 obdidx | grep -v obdidx |
8829                         awk '{print $1}')
8830
8831         [[ $start_ost_idx = $expected ]] ||
8832                 error "OST index of the first stripe on $file is" \
8833                       "$start_ost_idx, should be $expected"
8834 }
8835
8836 killall_process () {
8837         local clients=${1:-$(hostname)}
8838         local name=$2
8839         local signal=$3
8840         local rc=0
8841
8842         do_nodes $clients "killall $signal $name"
8843 }
8844
8845 lsnapshot_create()
8846 {
8847         do_facet mgs "$LCTL snapshot_create -F $FSNAME $*"
8848 }
8849
8850 lsnapshot_destroy()
8851 {
8852         do_facet mgs "$LCTL snapshot_destroy -F $FSNAME $*"
8853 }
8854
8855 lsnapshot_modify()
8856 {
8857         do_facet mgs "$LCTL snapshot_modify -F $FSNAME $*"
8858 }
8859
8860 lsnapshot_list()
8861 {
8862         do_facet mgs "$LCTL snapshot_list -F $FSNAME $*"
8863 }
8864
8865 lsnapshot_mount()
8866 {
8867         do_facet mgs "$LCTL snapshot_mount -F $FSNAME $*"
8868 }
8869
8870 lsnapshot_umount()
8871 {
8872         do_facet mgs "$LCTL snapshot_umount -F $FSNAME $*"
8873 }
8874
8875 lss_err()
8876 {
8877         local msg=$1
8878
8879         do_facet mgs "cat $LSNAPSHOT_LOG"
8880         error $msg
8881 }
8882
8883 lss_cleanup()
8884 {
8885         echo "Cleaning test environment ..."
8886
8887         # Every lsnapshot command takes exclusive lock with others,
8888         # so can NOT destroy the snapshot during list with 'xargs'.
8889         while true; do
8890                 local ssname=$(lsnapshot_list | grep snapshot_name |
8891                         grep lss_ | awk '{ print $2 }' | head -n 1)
8892                 [ -z "$ssname" ] && break
8893
8894                 lsnapshot_destroy -n $ssname -f ||
8895                         lss_err "Fail to destroy $ssname by force"
8896         done
8897 }
8898
8899 lss_gen_conf_one()
8900 {
8901         local facet=$1
8902         local role=$2
8903         local idx=$3
8904
8905         local host=$(facet_active_host $facet)
8906         local dir=$(dirname $(facet_vdevice $facet))
8907         local pool=$(zpool_name $facet)
8908         local lfsname=$(zfs_local_fsname $facet)
8909         local label=${FSNAME}-${role}$(printf '%04x' $idx)
8910
8911         do_facet mgs \
8912                 "echo '$host - $label zfs:${dir}/${pool}/${lfsname} - -' >> \
8913                 $LSNAPSHOT_CONF"
8914 }
8915
8916 lss_gen_conf()
8917 {
8918         do_facet mgs "rm -f $LSNAPSHOT_CONF"
8919         echo "Generating $LSNAPSHOT_CONF on MGS ..."
8920
8921         if ! combined_mgs_mds ; then
8922                 [ $(facet_fstype mgs) != zfs ] &&
8923                         skip "Lustre snapshot 1 only works for ZFS backend"
8924
8925                 local host=$(facet_active_host mgs)
8926                 local dir=$(dirname $(facet_vdevice mgs))
8927                 local pool=$(zpool_name mgs)
8928                 local lfsname=$(zfs_local_fsname mgs)
8929
8930                 do_facet mgs \
8931                         "echo '$host - MGS zfs:${dir}/${pool}/${lfsname} - -' \
8932                         >> $LSNAPSHOT_CONF" || lss_err "generate lss conf (mgs)"
8933         fi
8934
8935         for num in `seq $MDSCOUNT`; do
8936                 [ $(facet_fstype mds$num) != zfs ] &&
8937                         skip "Lustre snapshot 1 only works for ZFS backend"
8938
8939                 lss_gen_conf_one mds$num MDT $((num - 1)) ||
8940                         lss_err "generate lss conf (mds$num)"
8941         done
8942
8943         for num in `seq $OSTCOUNT`; do
8944                 [ $(facet_fstype ost$num) != zfs ] &&
8945                         skip "Lustre snapshot 1 only works for ZFS backend"
8946
8947                 lss_gen_conf_one ost$num OST $((num - 1)) ||
8948                         lss_err "generate lss conf (ost$num)"
8949         done
8950
8951         do_facet mgs "cat $LSNAPSHOT_CONF"
8952 }
8953
8954 # Parse 'lfs getstripe -d <path_with_dir_name>' for non-composite dir
8955 parse_plain_dir_param()
8956 {
8957         local invalues=($1)
8958         local param=""
8959
8960         if [[ ${invalues[0]} =~ "stripe_count:" ]]; then
8961                 param="-c ${invalues[1]}"
8962         fi
8963         if [[ ${invalues[2]} =~ "stripe_size:" ]]; then
8964                 param="$param -S ${invalues[3]}"
8965         fi
8966         if [[ ${invalues[4]} =~ "pattern:" ]]; then
8967                 if [[ ${invalues[5]} =~ "stripe_offset:" ]]; then
8968                         param="$param -i ${invalues[6]}"
8969                 else
8970                         param="$param -L ${invalues[5]} -i ${invalues[7]}"
8971                 fi
8972         elif [[ ${invalues[4]} =~ "stripe_offset:" ]]; then
8973                 param="$param -i ${invalues[5]}"
8974         fi
8975         echo "$param"
8976 }
8977
8978 parse_plain_param()
8979 {
8980         local line=$1
8981         local val=$(awk '{print $2}' <<< $line)
8982
8983         if [[ $line =~ ^"lmm_stripe_count:" ]]; then
8984                 echo "-c $val"
8985         elif [[ $line =~ ^"lmm_stripe_size:" ]]; then
8986                 echo "-S $val"
8987         elif [[ $line =~ ^"lmm_stripe_offset:" ]]; then
8988                 echo "-i $val"
8989         elif [[ $line =~ ^"lmm_pattern:" ]]; then
8990                 echo "-L $val"
8991         fi
8992 }
8993
8994 parse_layout_param()
8995 {
8996         local mode=""
8997         local val=""
8998         local param=""
8999
9000         while read line; do
9001                 if [[ ! -z $line ]]; then
9002                         if [[ -z $mode ]]; then
9003                                 if [[ $line =~ ^"stripe_count:" ]]; then
9004                                         mode="plain_dir"
9005                                 elif [[ $line =~ ^"lmm_stripe_count:" ]]; then
9006                                         mode="plain_file"
9007                                 elif [[ $line =~ ^"lcm_layout_gen:" ]]; then
9008                                         mode="pfl"
9009                                 fi
9010                         fi
9011
9012                         if [[ $mode = "plain_dir" ]]; then
9013                                 param=$(parse_plain_dir_param "$line")
9014                         elif [[ $mode = "plain_file" ]]; then
9015                                 val=$(parse_plain_param "$line")
9016                                 [[ ! -z $val ]] && param="$param $val"
9017                         elif [[ $mode = "pfl" ]]; then
9018                                 val=$(echo $line | awk '{print $2}')
9019                                 if [[ $line =~ ^"lcme_extent.e_end:" ]]; then
9020                                         if [[ $val = "EOF" ]]; then
9021                                                 param="$param -E -1"
9022                                         else
9023                                                 param="$param -E $val"
9024                                         fi
9025                                 elif [[ $line =~ ^"stripe_count:" ]]; then
9026                                         # pfl dir
9027                                         val=$(parse_plain_dir_param "$line")
9028                                         param="$param $val"
9029                                 else
9030                                         #pfl file
9031                                         val=$(parse_plain_param "$line")
9032                                         [[ ! -z $val ]] && param="$param $val"
9033                                 fi
9034                         fi
9035                 fi
9036         done
9037         echo "$param"
9038 }
9039
9040 get_layout_param()
9041 {
9042         local param=$($LFS getstripe -d $1 | parse_layout_param)
9043         echo "$param"
9044 }
9045
9046 lfsck_verify_pfid()
9047 {
9048         local f
9049         local rc=0
9050
9051         # Cancel locks before setting lfsck_verify_pfid so that errors are more
9052         # controllable
9053         cancel_lru_locks mdc
9054         cancel_lru_locks osc
9055
9056         # make sure PFID is set correctly for files
9057         do_nodes $(comma_list $(osts_nodes)) \
9058                "$LCTL set_param -n obdfilter.${FSNAME}-OST*.lfsck_verify_pfid=1"
9059
9060         for f in "$@"; do
9061                 cat $f &> /dev/nullA ||
9062                         { rc=$?; echo "verify $f failed"; break; }
9063         done
9064
9065         do_nodes $(comma_list $(osts_nodes)) \
9066                "$LCTL set_param -n obdfilter.${FSNAME}-OST*.lfsck_verify_pfid=0"
9067         return $rc
9068 }
9069
9070 # check that clients "oscs" was evicted after "before"
9071 check_clients_evicted() {
9072         local before=$1
9073         shift
9074         local oscs=${@}
9075         local osc
9076         local rc=0
9077
9078         for osc in $oscs; do
9079                 ((rc++))
9080                 echo "Check state for $osc"
9081                 local evicted=$(do_facet client $LCTL get_param osc.$osc.state |
9082                         tail -n 3 | awk -F"[ [,]" \
9083                         '/EVICTED ]$/ { if (mx<$5) {mx=$5;} } END { print mx }')
9084                 if (($? == 0)) && (($evicted > $before)); then
9085                         echo "$osc is evicted at $evicted"
9086                         ((rc--))
9087                 fi
9088         done
9089
9090         [ $rc -eq 0 ] || error "client not evicted from OST"
9091 }
9092
9093 # check that clients OSCS current_state is FULL
9094 check_clients_full() {
9095         local timeout=$1
9096         shift
9097         local oscs=${@}
9098
9099         for osc in $oscs; do
9100                 wait_update_facet client \
9101                         "lctl get_param -n osc.$osc.state |
9102                         grep 'current_state: FULL'" \
9103                         "current_state: FULL" $timeout
9104                 [ $? -eq 0 ] || error "$osc state is not FULL"
9105         done
9106 }
9107
9108 #Changelogs
9109 __changelog_deregister() {
9110         local facet=$1
9111         local mdt="$(facet_svc $facet)"
9112         local cl_user=$2
9113         local rc=0
9114
9115         # skip cleanup if no user registered for this MDT
9116         [ -z "$cl_user" ] && echo "$mdt: no changelog user" && return 0
9117         # user is no longer registered, skip cleanup
9118         changelog_users "$facet" | grep -q "$cl_user" ||
9119                 { echo "$mdt: changelog user '$cl_user' not found"; return 0; }
9120
9121         # From this point, if any operation fails, it is an error
9122         __changelog_clear $facet $cl_user 0 ||
9123                 error_noexit "$mdt: changelog_clear $cl_user 0 fail: $rc"
9124         do_facet $facet $LCTL --device $mdt changelog_deregister $cl_user ||
9125                 error_noexit "$mdt: changelog_deregister '$cl_user' fail: $rc"
9126 }
9127
9128 declare -Ax CL_USERS
9129 changelog_register() {
9130         for M in $(seq $MDSCOUNT); do
9131                 local facet=mds$M
9132                 local mdt="$(facet_svc $facet)"
9133                 local cl_mask
9134
9135                 cl_mask=$(do_facet $facet $LCTL get_param \
9136                              mdd.${mdt}.changelog_mask -n)
9137                 stack_trap "do_facet $facet $LCTL \
9138                         set_param mdd.$mdt.changelog_mask=\'$cl_mask\' -n" EXIT
9139                 do_facet $facet $LCTL set_param mdd.$mdt.changelog_mask=+hsm ||
9140                         error "$mdt: changelog_mask=+hsm failed: $?"
9141
9142                 local cl_user
9143                 cl_user=$(do_facet $facet \
9144                                   $LCTL --device $mdt changelog_register -n) ||
9145                         error "$mdt: register changelog user failed: $?"
9146                 stack_trap "__changelog_deregister $facet $cl_user" EXIT
9147
9148                 stack_trap "CL_USERS[$facet]='${CL_USERS[$facet]}'" EXIT
9149                 # Bash does not support nested arrays, but the format of a
9150                 # cl_user is constrained enough to use whitespaces as separators
9151                 CL_USERS[$facet]+="$cl_user "
9152         done
9153         echo "Registered $MDSCOUNT changelog users: '${CL_USERS[@]% }'"
9154 }
9155
9156 changelog_deregister() {
9157         local cl_user
9158         # bash assoc arrays do not guarantee to list keys in created order
9159         # so reorder to get same order than in changelog_register()
9160         local cl_facets=$(echo "${!CL_USERS[@]}" | tr " " "\n" | sort |
9161                           tr "\n" " ")
9162
9163         for facet in $cl_facets; do
9164                 for cl_user in ${CL_USERS[$facet]}; do
9165                         __changelog_deregister $facet $cl_user || return $?
9166                 done
9167                 unset CL_USERS[$facet]
9168         done
9169 }
9170
9171 changelog_users() {
9172         local facet=$1
9173         local service=$(facet_svc $facet)
9174
9175         do_facet $facet $LCTL get_param -n mdd.$service.changelog_users
9176 }
9177
9178 changelog_user_rec() {
9179         local facet=$1
9180         local cl_user=$2
9181         local service=$(facet_svc $facet)
9182
9183         changelog_users $facet | awk '$1 == "'$cl_user'" { print $2 }'
9184 }
9185
9186 changelog_chmask() {
9187         local mask=$1
9188
9189         do_nodes $(comma_list $(mdts_nodes)) \
9190                 $LCTL set_param mdd.*.changelog_mask="$mask"
9191 }
9192
9193 # usage: __changelog_clear FACET CL_USER [+]INDEX
9194 __changelog_clear()
9195 {
9196         local facet=$1
9197         local mdt="$(facet_svc $facet)"
9198         local cl_user=$2
9199         local -i rec
9200
9201         case "$3" in
9202         +*)
9203                 # Remove the leading '+'
9204                 rec=${3:1}
9205                 rec+=$(changelog_user_rec $facet $cl_user)
9206                 ;;
9207         *)
9208                 rec=$3
9209                 ;;
9210         esac
9211
9212         if [ $rec -eq 0 ]; then
9213                 echo "$mdt: clear the changelog for $cl_user of all records"
9214         else
9215                 echo "$mdt: clear the changelog for $cl_user to record #$rec"
9216         fi
9217         $LFS changelog_clear $mdt $cl_user $rec
9218 }
9219
9220 # usage: changelog_clear [+]INDEX
9221 #
9222 # If INDEX is prefixed with '+', increment every changelog user's record index
9223 # by INDEX. Otherwise, clear the changelog up to INDEX for every changelog
9224 # users.
9225 changelog_clear() {
9226         local rc
9227         # bash assoc arrays do not guarantee to list keys in created order
9228         # so reorder to get same order than in changelog_register()
9229         local cl_facets=$(echo "${!CL_USERS[@]}" | tr " " "\n" | sort |
9230                           tr "\n" " ")
9231
9232         for facet in $cl_facets; do
9233                 for cl_user in ${CL_USERS[$facet]}; do
9234                         __changelog_clear $facet $cl_user $1 || rc=${rc:-$?}
9235                 done
9236         done
9237
9238         return ${rc:-0}
9239 }
9240
9241 changelog_dump() {
9242         for M in $(seq $MDSCOUNT); do
9243                 local facet=mds$M
9244                 local mdt="$(facet_svc $facet)"
9245
9246                 $LFS changelog $mdt | sed -e 's/^/'$mdt'./'
9247         done
9248 }
9249
9250 changelog_extract_field() {
9251         local cltype=$1
9252         local file=$2
9253         local identifier=$3
9254
9255         changelog_dump | gawk "/$cltype.*$file$/ {
9256                 print gensub(/^.* "$identifier'(\[[^\]]*\]).*$/,"\\1",1)}' |
9257                 tail -1
9258 }
9259
9260 # Prints a changelog record produced by "lfs changelog" as an associative array
9261 #
9262 # Example:
9263 # $> changelog2array 16 01CREAT 10:28:46.968438800 2018.03.09 0x0 \
9264 #                    t=[0x200000401:0x10:0x0] j=touch.501 ef=0xf u=501:501 \
9265 #                    nid=0@lo p=[0x200000007:0x1:0x0] blob
9266 # ([index]='16' [type]='CREAT' [time]='10:28:46.968438800'
9267 #  [date]='2018.03.09' [flags]=0x0 ['target-fid']='[0x200000401:0x10:0x0]'
9268 #  ['jobid']='touch.501' ['extra-flags']='0x0f' [uid]='0' ['gid']='0'
9269 #  ['nid']='0@lo' ['parent-fid']='[0x200000007:0x1:0x0]')
9270 #
9271 # Note that the changelog record is not quoted
9272 # Also note that the line breaks in the output were only added for readability
9273 #
9274 # Typically, you want to eval the output of the command to fill an actual
9275 # associative array, like this:
9276 # $> eval declare -A changelog=$(changelog2array $entry)
9277 #
9278 # It can then be accessed like any bash associative array:
9279 # $> echo "${changelog[index]}" "${changelog[type]}" "${changelog[flags]}"
9280 # 16 CREAT 0x0
9281 # $> echo "${changelog[uid]}":"${changelog[gid]}"
9282 # 501:501
9283 #
9284 changelog2array()
9285 {
9286         # Start the array
9287         printf '('
9288
9289         # A changelog, as printed by "lfs changelog" typically looks like this:
9290         # <index> <type> <time> <date> <flags> <key1=value1> <key2=value2> ...
9291
9292         # Parse the positional part of the changelog
9293
9294         # changelog_dump() prefixes records with their mdt's name
9295         local index="${1##*.}"
9296
9297         printf "[index]='%s' [type]='%s' [time]='%s' [date]='%s' [flags]='%s'" \
9298                "$index" "${2:2}" "$3" "$4" "$5"
9299
9300         # Parse the key/value part of the changelog
9301         for arg in "${@:5}"; do
9302                 # Check it matches a key=value syntax
9303                 [[ "$arg" =~ ^[[:alpha:]]+= ]] || continue
9304
9305                 local key="${arg%%=*}"
9306                 local value="${arg#*=}"
9307
9308                 case "$key" in
9309                 u)
9310                         # u is actually for uid AND gid: u=UID:GID
9311                         printf " [uid]='%s'" "${value%:*}"
9312                         key=gid
9313                         value="${value#*:}"
9314                         ;;
9315                 t)
9316                         key=target-fid
9317                         value="${value#[}"
9318                         value="${value%]}"
9319                         ;;
9320                 j)
9321                         key=jobid
9322                         ;;
9323                 p)
9324                         key=parent-fid
9325                         value="${value#[}"
9326                         value="${value%]}"
9327                         ;;
9328                 ef)
9329                         key=extra-flags
9330                         ;;
9331                 m)
9332                         key=mode
9333                         ;;
9334                 x)
9335                         key=xattr
9336                         ;;
9337                 *)
9338                         ;;
9339                 esac
9340
9341                 printf " ['%s']='%s'" "$key" "$value"
9342         done
9343
9344         # end the array
9345         printf ')'
9346 }
9347
9348 # Format and print a changelog record
9349 #
9350 # Interpreted sequences are:
9351 #       %%      a single %
9352 #       %f      the "flags" attribute of a changelog record
9353 __changelog_printf()
9354 {
9355         local format="$1"
9356
9357         local -i i
9358         for ((i = 0; i < ${#format}; i++)); do
9359                 local char="${format:$i:1}"
9360                 if [ "$char" != % ]; then
9361                         printf '%c' "$char"
9362                         continue
9363                 fi
9364
9365                 i+=1
9366                 char="${format:$i:1}"
9367                 case "$char" in
9368                 f)
9369                         printf '%s' "${changelog[flags]}"
9370                         ;;
9371                 %)
9372                         printf '%'
9373                         ;;
9374                 esac
9375         done
9376         printf '\n'
9377 }
9378
9379 # Filter changelog records
9380 changelog_find()
9381 {
9382         local -A filter
9383         local action='print'
9384         local format
9385
9386         while [ $# -gt 0 ]; do
9387                 case "$1" in
9388                 -print)
9389                         action='print'
9390                         ;;
9391                 -printf)
9392                         action='printf'
9393                         format="$2"
9394                         shift
9395                         ;;
9396                 -*)
9397                         filter[${1#-}]="$2"
9398                         shift
9399                         ;;
9400                 esac
9401                 shift
9402         done
9403
9404         local found=false
9405         local record
9406         changelog_dump | { while read -r record; do
9407                 eval local -A changelog=$(changelog2array $record)
9408                 for key in "${!filter[@]}"; do
9409                         case "$key" in
9410                         *)
9411                                 [ "${changelog[$key]}" == "${filter[$key]}" ]
9412                                 ;;
9413                         esac || continue 2
9414                 done
9415
9416                 found=true
9417
9418                 case "${action:-print}" in
9419                 print)
9420                         printf '%s\n' "$record"
9421                         ;;
9422                 printf)
9423                         __changelog_printf "$format"
9424                         ;;
9425                 esac
9426         done; $found; }
9427 }
9428
9429 restore_layout() {
9430         local dir=$1
9431         local layout=$2
9432
9433         [ ! -d "$dir" ] && return
9434
9435         [ -z "$layout" ] && {
9436                 $LFS setstripe -d $dir || error "error deleting stripe '$dir'"
9437                 return
9438         }
9439
9440         setfattr -n trusted.lov -v $layout $dir ||
9441                 error "error restoring layout '$layout' to '$dir'"
9442 }
9443
9444 # save the layout of a directory, the returned string will be used by
9445 # restore_layout() to restore the layout
9446 save_layout() {
9447         local dir=$1
9448         local str=$(getfattr -n trusted.lov --absolute-names -e hex $dir \
9449                     2> /dev/null | awk -F'=' '/trusted.lov/{ print $2 }')
9450         echo "$str"
9451 }
9452
9453 # save layout of a directory and restore it at exit
9454 save_layout_restore_at_exit() {
9455         local dir=$1
9456         local layout=$(save_layout $dir)
9457
9458         stack_trap "restore_layout $dir $layout" EXIT
9459 }
9460
9461 verify_yaml_layout() {
9462         local src=$1
9463         local dst=$2
9464         local temp=$3
9465         local msg_prefix=$4
9466
9467         echo "getstripe --yaml $src"
9468         $LFS getstripe --yaml $src > $temp || error "getstripe $src failed"
9469         echo "setstripe --yaml=$temp $dst"
9470         $LFS setstripe --yaml=$temp $dst|| error "setstripe $dst failed"
9471
9472         echo "compare"
9473         local layout1=$(get_layout_param $src)
9474         local layout2=$(get_layout_param $dst)
9475         # compare their layout info
9476         [ "$layout1" == "$layout2" ] ||
9477                 error "$msg_prefix $src/$dst layouts are not equal"
9478 }