lustre/tests/test-framework.sh

   1 #!/bin/bash
   2
   3 trap 'print_summary && touch $TF_FAIL && \
   4     echo "test-framework exiting on error"' ERR
   5 set -e
   6 #set -x
   7
   8 export EJOURNAL=${EJOURNAL:-""}
   9 export REFORMAT=${REFORMAT:-""}
  10 export WRITECONF=${WRITECONF:-""}
  11 export VERBOSE=${VERBOSE:-false}
  12 export CATASTROPHE=${CATASTROPHE:-/proc/sys/lnet/catastrophe}
  13 export GSS=false
  14 export GSS_KRB5=false
  15 export GSS_PIPEFS=false
  16 export IDENTITY_UPCALL=default
  17 export QUOTA_AUTO=1
  18 # specify environment variable containing batch job name for server statistics
  19 export JOBID_VAR=${JOBID_VAR:-"procname_uid"}  # or "existing" or "disable"
  20
  21 # LOAD_LLOOP: LU-409: only load llite_lloop module if kernel < 2.6.32 or
  22 #             LOAD_LLOOP is true. LOAD_LLOOP is false by default.
  23 export LOAD_LLOOP=${LOAD_LLOOP:-false}
  24
  25 #export PDSH="pdsh -S -Rssh -w"
  26
  27 # function used by scripts run on remote nodes
  28 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
  29 . $LUSTRE/tests/functions.sh
  30 . $LUSTRE/tests/yaml.sh
  31
  32 export LD_LIBRARY_PATH=${LUSTRE}/utils:${LD_LIBRARY_PATH}
  33
  34 LUSTRE_TESTS_CFG_DIR=${LUSTRE_TESTS_CFG_DIR:-${LUSTRE}/tests/cfg}
  35
  36 EXCEPT_LIST_FILE=${EXCEPT_LIST_FILE:-${LUSTRE_TESTS_CFG_DIR}/tests-to-skip.sh}
  37
  38 if [ -f "$EXCEPT_LIST_FILE" ]; then
  39     echo "Reading test skip list from $EXCEPT_LIST_FILE"
  40     cat $EXCEPT_LIST_FILE
  41     . $EXCEPT_LIST_FILE
  42 fi
  43
  44 # check config files for options in decreasing order of preference
  45 [ -z "$MODPROBECONF" -a -f /etc/modprobe.d/lustre.conf ] &&
  46     MODPROBECONF=/etc/modprobe.d/lustre.conf
  47 [ -z "$MODPROBECONF" -a -f /etc/modprobe.d/Lustre ] &&
  48     MODPROBECONF=/etc/modprobe.d/Lustre
  49 [ -z "$MODPROBECONF" -a -f /etc/modprobe.conf ] &&
  50     MODPROBECONF=/etc/modprobe.conf
  51
  52 assert_DIR () {
  53     local failed=""
  54     [[ $DIR/ = $MOUNT/* ]] || \
  55         { failed=1 && echo "DIR=$DIR not in $MOUNT. Aborting."; }
  56     [[ $DIR1/ = $MOUNT1/* ]] || \
  57         { failed=1 && echo "DIR1=$DIR1 not in $MOUNT1. Aborting."; }
  58     [[ $DIR2/ = $MOUNT2/* ]] || \
  59         { failed=1 && echo "DIR2=$DIR2 not in $MOUNT2. Aborting"; }
  60
  61     [ -n "$failed" ] && exit 99 || true
  62 }
  63
  64 usage() {
  65     echo "usage: $0 [-r] [-f cfgfile]"
  66     echo "       -r: reformat"
  67
  68     exit
  69 }
  70
  71 print_summary () {
  72     trap 0
  73     [ "$TESTSUITE" == "lfsck" ] && return 0
  74     [ -n "$ONLY" ] && echo "WARNING: ONLY is set to $(echo $ONLY)"
  75     local details
  76     local form="%-13s %-17s %-9s %s %s\n"
  77     printf "$form" "status" "script" "Total(sec)" "E(xcluded) S(low)"
  78     echo "------------------------------------------------------------------------------------"
  79     for O in $DEFAULT_SUITES; do
  80         O=$(echo $O  | tr "-" "_" | tr "[:lower:]" "[:upper:]")
  81         [ "${!O}" = "no" ] && continue || true
  82         local o=$(echo $O  | tr "[:upper:]_" "[:lower:]-")
  83         local log=${TMP}/${o}.log
  84         if is_sanity_benchmark $o; then
  85             log=${TMP}/sanity-benchmark.log
  86         fi
  87         local slow=
  88         local skipped=
  89         local total=
  90         local status=Unfinished
  91         if [ -f $log ]; then
  92             skipped=$(grep excluded $log | awk '{ printf " %s", $3 }' | sed 's/test_//g')
  93             slow=$(egrep "^PASS|^FAIL" $log | tr -d "("| sed s/s\)$//g | sort -nr -k 3  | head -5 |  awk '{ print $2":"$3"s" }')
  94             total=$(grep duration $log | awk '{ print $2}')
  95             if [ "${!O}" = "done" ]; then
  96                 status=Done
  97             fi
  98             if $DDETAILS; then
  99                 local durations=$(egrep "^PASS|^FAIL" $log |  tr -d "("| sed s/s\)$//g | awk '{ print $2":"$3"|" }')
 100                 details=$(printf "%s\n%s %s %s\n" "$details" "DDETAILS" "$O" "$(echo $durations)")
 101             fi
 102         fi
 103         printf "$form" $status "$O" "${total}" "E=$skipped"
 104         printf "$form" "-" "-" "-" "S=$(echo $slow)"
 105     done
 106
 107     for O in $DEFAULT_SUITES; do
 108         O=$(echo $O  | tr "-" "_" | tr "[:lower:]" "[:upper:]")
 109         if [ "${!O}" = "no" ]; then
 110             printf "$form" "Skipped" "$O" ""
 111         fi
 112     done
 113
 114     # print the detailed tests durations if DDETAILS=true
 115     if $DDETAILS; then
 116         echo "$details"
 117     fi
 118 }
 119
 120 init_test_env() {
 121         export LUSTRE=$(absolute_path $LUSTRE)
 122         export TESTSUITE=$(basename $0 .sh)
 123         export TEST_FAILED=false
 124         export FAIL_ON_SKIP_ENV=${FAIL_ON_SKIP_ENV:-false}
 125         export RPC_MODE=${RPC_MODE:-false}
 126
 127     export MKE2FS=$MKE2FS
 128     if [ -z "$MKE2FS" ]; then
 129         if which mkfs.ldiskfs >/dev/null 2>&1; then
 130             export MKE2FS=mkfs.ldiskfs
 131         else
 132             export MKE2FS=mke2fs
 133         fi
 134     fi
 135
 136     export DEBUGFS=$DEBUGFS
 137     if [ -z "$DEBUGFS" ]; then
 138         if which debugfs.ldiskfs >/dev/null 2>&1; then
 139             export DEBUGFS=debugfs.ldiskfs
 140         else
 141             export DEBUGFS=debugfs
 142         fi
 143     fi
 144
 145     export TUNE2FS=$TUNE2FS
 146     if [ -z "$TUNE2FS" ]; then
 147         if which tunefs.ldiskfs >/dev/null 2>&1; then
 148             export TUNE2FS=tunefs.ldiskfs
 149         else
 150             export TUNE2FS=tune2fs
 151         fi
 152     fi
 153
 154     export E2LABEL=$E2LABEL
 155     if [ -z "$E2LABEL" ]; then
 156         if which label.ldiskfs >/dev/null 2>&1; then
 157             export E2LABEL=label.ldiskfs
 158         else
 159             export E2LABEL=e2label
 160         fi
 161     fi
 162
 163     export DUMPE2FS=$DUMPE2FS
 164     if [ -z "$DUMPE2FS" ]; then
 165         if which dumpfs.ldiskfs >/dev/null 2>&1; then
 166             export DUMPE2FS=dumpfs.ldiskfs
 167         else
 168             export DUMPE2FS=dumpe2fs
 169         fi
 170     fi
 171
 172     export E2FSCK=$E2FSCK
 173     if [ -z "$E2FSCK" ]; then
 174         if which fsck.ldiskfs >/dev/null 2>&1; then
 175             export E2FSCK=fsck.ldiskfs
 176         else
 177             export E2FSCK=e2fsck
 178         fi
 179     fi
 180
 181     export LFSCK_BIN=${LFSCK_BIN:-lfsck}
 182     export LFSCK_ALWAYS=${LFSCK_ALWAYS:-"no"} # check fs after each test suite
 183     export FSCK_MAX_ERR=4   # File system errors left uncorrected
 184
 185         export ZFS=${ZFS:-zfs}
 186         export ZPOOL=${ZPOOL:-zpool}
 187         export ZDB=${ZDB:-zdb}
 188         export PARTPROBE=${PARTPROBE:-partprobe}
 189
 190     #[ -d /r ] && export ROOT=${ROOT:-/r}
 191     export TMP=${TMP:-$ROOT/tmp}
 192     export TESTSUITELOG=${TMP}/${TESTSUITE}.log
 193     export LOGDIR=${LOGDIR:-${TMP}/test_logs/$(date +%s)}
 194     export TESTLOG_PREFIX=$LOGDIR/$TESTSUITE
 195
 196     export HOSTNAME=${HOSTNAME:-$(hostname -s)}
 197     if ! echo $PATH | grep -q $LUSTRE/utils; then
 198         export PATH=$LUSTRE/utils:$PATH
 199     fi
 200     if ! echo $PATH | grep -q $LUSTRE/utils/gss; then
 201         export PATH=$LUSTRE/utils/gss:$PATH
 202     fi
 203     if ! echo $PATH | grep -q $LUSTRE/tests; then
 204         export PATH=$LUSTRE/tests:$PATH
 205     fi
 206     if ! echo $PATH | grep -q $LUSTRE/../lustre-iokit/sgpdd-survey; then
 207         export PATH=$LUSTRE/../lustre-iokit/sgpdd-survey:$PATH
 208     fi
 209     export LST=${LST:-"$LUSTRE/../lnet/utils/lst"}
 210     [ ! -f "$LST" ] && export LST=$(which lst)
 211     export SGPDDSURVEY=${SGPDDSURVEY:-"$LUSTRE/../lustre-iokit/sgpdd-survey/sgpdd-survey")}
 212     [ ! -f "$SGPDDSURVEY" ] && export SGPDDSURVEY=$(which sgpdd-survey)
 213     # Ubuntu, at least, has a truncate command in /usr/bin
 214     # so fully path our truncate command.
 215     export TRUNCATE=${TRUNCATE:-$LUSTRE/tests/truncate}
 216     export MDSRATE=${MDSRATE:-"$LUSTRE/tests/mpi/mdsrate"}
 217     [ ! -f "$MDSRATE" ] && export MDSRATE=$(which mdsrate 2> /dev/null)
 218     if ! echo $PATH | grep -q $LUSTRE/tests/racer; then
 219         export PATH=$LUSTRE/tests/racer:$PATH:
 220     fi
 221     if ! echo $PATH | grep -q $LUSTRE/tests/mpi; then
 222         export PATH=$LUSTRE/tests/mpi:$PATH
 223     fi
 224     export RSYNC_RSH=${RSYNC_RSH:-rsh}
 225
 226     export LCTL=${LCTL:-"$LUSTRE/utils/lctl"}
 227     [ ! -f "$LCTL" ] && export LCTL=$(which lctl)
 228     export LFS=${LFS:-"$LUSTRE/utils/lfs"}
 229     [ ! -f "$LFS" ] && export LFS=$(which lfs)
 230     SETSTRIPE=${SETSTRIPE:-"$LFS setstripe"}
 231     GETSTRIPE=${GETSTRIPE:-"$LFS getstripe"}
 232
 233     export L_GETIDENTITY=${L_GETIDENTITY:-"$LUSTRE/utils/l_getidentity"}
 234     if [ ! -f "$L_GETIDENTITY" ]; then
 235         if `which l_getidentity > /dev/null 2>&1`; then
 236             export L_GETIDENTITY=$(which l_getidentity)
 237         else
 238             export L_GETIDENTITY=NONE
 239         fi
 240     fi
 241     export LL_DECODE_FILTER_FID=${LL_DECODE_FILTER_FID:-"$LUSTRE/utils/ll_decode_filter_fid"}
 242     [ ! -f "$LL_DECODE_FILTER_FID" ] && export LL_DECODE_FILTER_FID="ll_decode_filter_fid"
 243     export MKFS=${MKFS:-"$LUSTRE/utils/mkfs.lustre"}
 244     [ ! -f "$MKFS" ] && export MKFS="mkfs.lustre"
 245     export TUNEFS=${TUNEFS:-"$LUSTRE/utils/tunefs.lustre"}
 246     [ ! -f "$TUNEFS" ] && export TUNEFS="tunefs.lustre"
 247     export CHECKSTAT="${CHECKSTAT:-"checkstat -v"} "
 248     export LUSTRE_RMMOD=${LUSTRE_RMMOD:-$LUSTRE/scripts/lustre_rmmod}
 249     [ ! -f "$LUSTRE_RMMOD" ] &&
 250         export LUSTRE_RMMOD=$(which lustre_rmmod 2> /dev/null)
 251     export LFS_MIGRATE=${LFS_MIGRATE:-$LUSTRE/scripts/lfs_migrate}
 252     [ ! -f "$LFS_MIGRATE" ] &&
 253         export LFS_MIGRATE=$(which lfs_migrate 2> /dev/null)
 254     export NAME=${NAME:-local}
 255     export LGSSD=${LGSSD:-"$LUSTRE/utils/gss/lgssd"}
 256     [ "$GSS_PIPEFS" = "true" ] && [ ! -f "$LGSSD" ] && \
 257         export LGSSD=$(which lgssd)
 258     export LSVCGSSD=${LSVCGSSD:-"$LUSTRE/utils/gss/lsvcgssd"}
 259     [ ! -f "$LSVCGSSD" ] && export LSVCGSSD=$(which lsvcgssd 2> /dev/null)
 260     export KRB5DIR=${KRB5DIR:-"/usr/kerberos"}
 261     export DIR2
 262     export SAVE_PWD=${SAVE_PWD:-$LUSTRE/tests}
 263     export AT_MAX_PATH
 264
 265     if [ "$ACCEPTOR_PORT" ]; then
 266         export PORT_OPT="--port $ACCEPTOR_PORT"
 267     fi
 268
 269     case "x$SEC" in
 270         xkrb5*)
 271             echo "Using GSS/krb5 ptlrpc security flavor"
 272             which lgss_keyring > /dev/null 2>&1 || \
 273                 error_exit "built with gss disabled! SEC=$SEC"
 274             GSS=true
 275             GSS_KRB5=true
 276             ;;
 277     esac
 278
 279     case "x$IDUP" in
 280         xtrue)
 281             IDENTITY_UPCALL=true
 282             ;;
 283         xfalse)
 284             IDENTITY_UPCALL=false
 285             ;;
 286     esac
 287
 288     export LOAD_MODULES_REMOTE=${LOAD_MODULES_REMOTE:-false}
 289
 290     # Paths on remote nodes, if different
 291     export RLUSTRE=${RLUSTRE:-$LUSTRE}
 292     export RPWD=${RPWD:-$PWD}
 293     export I_MOUNTED=${I_MOUNTED:-"no"}
 294     if [ ! -f /lib/modules/$(uname -r)/kernel/fs/lustre/mdt.ko -a \
 295         ! -f /lib/modules/$(uname -r)/updates/kernel/fs/lustre/mdt.ko -a \
 296         ! -f `dirname $0`/../mdt/mdt.ko ]; then
 297         export CLIENTMODSONLY=yes
 298     fi
 299
 300     export SHUTDOWN_ATTEMPTS=${SHUTDOWN_ATTEMPTS:-3}
 301         export OSD_TRACK_DECLARES_LBUG=${OSD_TRACK_DECLARES_LBUG:-"yes"}
 302
 303     # command line
 304
 305     while getopts "rvwf:" opt $*; do
 306         case $opt in
 307             f) CONFIG=$OPTARG;;
 308             r) REFORMAT=--reformat;;
 309             v) VERBOSE=true;;
 310             w) WRITECONF=writeconf;;
 311             \?) usage;;
 312         esac
 313     done
 314
 315     shift $((OPTIND - 1))
 316     ONLY=${ONLY:-$*}
 317
 318         # print the durations of each test if "true"
 319         DDETAILS=${DDETAILS:-false}
 320         [ "$TESTSUITELOG" ] && rm -f $TESTSUITELOG || true
 321         if ! $RPC_MODE; then
 322                 rm -f $TMP/*active
 323         fi
 324 }
 325
 326 check_cpt_number() {
 327         local facet=$1
 328         local ncpts
 329
 330         ncpts=$(do_facet $facet "lctl get_param -n " \
 331                 "cpu_partition_table 2>/dev/null| wc -l" || echo 1)
 332
 333         if [ $ncpts -eq 0 ]; then
 334                 echo "1"
 335         else
 336                 echo $ncpts
 337         fi
 338 }
 339
 340 version_code() {
 341     # split arguments like "1.8.6-wc3" into "1", "8", "6", "wc3"
 342     eval set -- $(tr "[:punct:]" " " <<< $*)
 343
 344     echo -n "$((($1 << 16) | ($2 << 8) | $3))"
 345 }
 346
 347 export LINUX_VERSION=$(uname -r | sed -e "s/[-.]/ /3" -e "s/ .*//")
 348 export LINUX_VERSION_CODE=$(version_code ${LINUX_VERSION//\./ })
 349
 350 module_loaded () {
 351    /sbin/lsmod | grep -q "^\<$1\>"
 352 }
 353
 354 # Load a module on the system where this is running.
 355 #
 356 # Synopsis: load_module module_name [module arguments for insmod/modprobe]
 357 #
 358 # If module arguments are not given but MODOPTS_<MODULE> is set, then its value
 359 # will be used as the arguments.  Otherwise arguments will be obtained from
 360 # /etc/modprobe.conf, from /etc/modprobe.d/Lustre, or else none will be used.
 361 #
 362 load_module() {
 363     local optvar
 364     EXT=".ko"
 365     module=$1
 366     shift
 367     BASE=`basename $module $EXT`
 368
 369     module_loaded ${BASE} && return
 370
 371     # If no module arguments were passed, get them from $MODOPTS_<MODULE>, else from
 372     # modprobe.conf
 373     if [ $# -eq 0 ]; then
 374         # $MODOPTS_<MODULE>; we could use associative arrays, but that's not in
 375         # Bash until 4.x, so we resort to eval.
 376         optvar="MODOPTS_$(basename $module | tr a-z A-Z)"
 377         eval set -- \$$optvar
 378         if [ $# -eq 0 -a -n "$MODPROBECONF" ]; then
 379                 # Nothing in $MODOPTS_<MODULE>; try modprobe.conf
 380                 local opt
 381                 opt=$(awk -v var="^options $BASE" '$0 ~ var \
 382                         {gsub("'"options $BASE"'",""); print}' $MODPROBECONF)
 383                 set -- $(echo -n $opt)
 384
 385                 # Ensure we have accept=all for lnet
 386                 if [ $(basename $module) = lnet ]; then
 387                         # OK, this is a bit wordy...
 388                         local arg accept_all_present=false
 389
 390                         for arg in "$@"; do
 391                                 [ "$arg" = accept=all ] && \
 392                                         accept_all_present=true
 393                         done
 394                         $accept_all_present || set -- "$@" accept=all
 395                 fi
 396                 export $optvar="$*"
 397         fi
 398     fi
 399
 400     [ $# -gt 0 ] && echo "${module} options: '$*'"
 401
 402     # Note that insmod will ignore anything in modprobe.conf, which is why we're
 403     # passing options on the command-line.
 404     if [ "$BASE" == "lnet_selftest" ] && \
 405             [ -f ${LUSTRE}/../lnet/selftest/${module}${EXT} ]; then
 406         insmod ${LUSTRE}/../lnet/selftest/${module}${EXT}
 407     elif [ -f ${LUSTRE}/${module}${EXT} ]; then
 408         insmod ${LUSTRE}/${module}${EXT} "$@"
 409     else
 410         # must be testing a "make install" or "rpm" installation
 411         # note failed to load ptlrpc_gss is considered not fatal
 412         if [ "$BASE" == "ptlrpc_gss" ]; then
 413             modprobe $BASE "$@" 2>/dev/null || echo "gss/krb5 is not supported"
 414         else
 415             modprobe $BASE "$@"
 416         fi
 417     fi
 418 }
 419
 420 llite_lloop_enabled() {
 421     local n1=$(uname -r | cut -d. -f1)
 422     local n2=$(uname -r | cut -d. -f2)
 423     local n3=$(uname -r | cut -d- -f1 | cut -d. -f3)
 424
 425     # load the llite_lloop module for < 2.6.32 kernels
 426     if [[ $n1 -lt 2 ]] || [[ $n1 -eq 2 && $n2 -lt 6 ]] || \
 427        [[ $n1 -eq 2 && $n2 -eq 6 && $n3 -lt 32 ]] || \
 428         $LOAD_LLOOP; then
 429         return 0
 430     fi
 431     return 1
 432 }
 433
 434 load_modules_local() {
 435         if [ -n "$MODPROBE" ]; then
 436                 # use modprobe
 437                 echo "Using modprobe to load modules"
 438                 return 0
 439         fi
 440
 441         echo Loading modules from $LUSTRE
 442
 443         local ncpus
 444
 445         if [ -f /sys/devices/system/cpu/online ]; then
 446                 ncpus=$(($(cut -d "-" -f 2 /sys/devices/system/cpu/online) + 1))
 447                 echo "detected $ncpus online CPUs by sysfs"
 448         else
 449                 ncpus=$(getconf _NPROCESSORS_CONF 2>/dev/null)
 450                 local rc=$?
 451                 if [ $rc -eq 0 ]; then
 452                         echo "detected $ncpus online CPUs by getconf"
 453                 else
 454                         echo "Can't detect number of CPUs"
 455                         ncpus=1
 456                 fi
 457         fi
 458
 459         # if there is only one CPU core, libcfs can only create one partition
 460         # if there is more than 4 CPU cores, libcfs should create multiple CPU
 461         # partitions. So we just force libcfs to create 2 partitions for
 462         # system with 2 or 4 cores
 463         if [ $ncpus -le 4 ] && [ $ncpus -gt 1 ]; then
 464                 # force to enable multiple CPU partitions
 465                 echo "Force libcfs to create 2 CPU partitions"
 466                 MODOPTS_LIBCFS="cpu_npartitions=2 $MODOPTS_LIBCFS"
 467         else
 468                 echo "libcfs will create CPU partition based on online CPUs"
 469         fi
 470
 471         load_module ../libcfs/libcfs/libcfs
 472
 473     [ "$PTLDEBUG" ] && lctl set_param debug="$PTLDEBUG"
 474     [ "$SUBSYSTEM" ] && lctl set_param subsystem_debug="${SUBSYSTEM# }"
 475     load_module ../lnet/lnet/lnet
 476     LNETLND=${LNETLND:-"socklnd/ksocklnd"}
 477     load_module ../lnet/klnds/$LNETLND
 478     load_module lvfs/lvfs
 479     load_module obdclass/obdclass
 480     load_module ptlrpc/ptlrpc
 481     load_module ptlrpc/gss/ptlrpc_gss
 482     load_module fld/fld
 483     load_module fid/fid
 484     load_module lmv/lmv
 485     load_module mdc/mdc
 486     load_module osc/osc
 487     load_module lov/lov
 488     load_module mgc/mgc
 489     load_module obdecho/obdecho
 490     if ! client_only; then
 491         SYMLIST=/proc/kallsyms
 492         grep -q crc16 $SYMLIST || { modprobe crc16 2>/dev/null || true; }
 493         grep -q -w jbd $SYMLIST || { modprobe jbd 2>/dev/null || true; }
 494         grep -q -w jbd2 $SYMLIST || { modprobe jbd2 2>/dev/null || true; }
 495                 load_module lfsck/lfsck
 496                 [ "$LQUOTA" != "no" ] && load_module quota/lquota $LQUOTAOPTS
 497                 if [[ $(node_fstypes $HOSTNAME) == *zfs* ]]; then
 498                         modprobe zfs
 499                         load_module osd-zfs/osd_zfs
 500                 fi
 501                 load_module mgs/mgs
 502                 load_module mdd/mdd
 503                 if [[ $(node_fstypes $HOSTNAME) == *ldiskfs* ]]; then
 504                         #
 505                         # This block shall be moved up beside osd-zfs as soon
 506                         # as osd-ldiskfs stops using mdd symbols.
 507                         #
 508                         grep -q exportfs_decode_fh $SYMLIST ||
 509                                 { modprobe exportfs 2> /dev/null || true; }
 510                         load_module ../ldiskfs/ldiskfs/ldiskfs
 511                         load_module lvfs/fsfilt_ldiskfs
 512                         load_module osd-ldiskfs/osd_ldiskfs
 513                 fi
 514                 load_module mdt/mdt
 515                 load_module ost/ost
 516                 load_module lod/lod
 517                 load_module osp/osp
 518                 load_module ofd/ofd
 519                 load_module osp/osp
 520     fi
 521
 522
 523     load_module llite/lustre
 524     llite_lloop_enabled && load_module llite/llite_lloop
 525     [ -d /r ] && OGDB=${OGDB:-"/r/tmp"}
 526     OGDB=${OGDB:-$TMP}
 527     rm -f $OGDB/ogdb-$HOSTNAME
 528     $LCTL modules > $OGDB/ogdb-$HOSTNAME
 529
 530     # 'mount' doesn't look in $PATH, just sbin
 531     if [ -f $LUSTRE/utils/mount.lustre ] && \
 532        ! grep -qe "/sbin/mount\.lustre " /proc/mounts; then
 533         [ ! -f /sbin/mount.lustre ] && touch /sbin/mount.lustre
 534         mount --bind $LUSTRE/utils/mount.lustre /sbin/mount.lustre || true
 535     fi
 536 }
 537
 538 load_modules () {
 539         load_modules_local
 540         # bug 19124
 541         # load modules on remote nodes optionally
 542         # lustre-tests have to be installed on these nodes
 543         if $LOAD_MODULES_REMOTE; then
 544                 local list=$(comma_list $(remote_nodes_list))
 545                 if [ -n "$list" ]; then
 546                         echo "loading modules on: '$list'"
 547                         do_rpc_nodes "$list" load_modules_local
 548                 fi
 549         fi
 550 }
 551
 552 check_mem_leak () {
 553     LEAK_LUSTRE=$(dmesg | tail -n 30 | grep "obd_memory.*leaked" || true)
 554     LEAK_PORTALS=$(dmesg | tail -n 20 | grep "Portals memory leaked" || true)
 555     if [ "$LEAK_LUSTRE" -o "$LEAK_PORTALS" ]; then
 556         echo "$LEAK_LUSTRE" 1>&2
 557         echo "$LEAK_PORTALS" 1>&2
 558         mv $TMP/debug $TMP/debug-leak.`date +%s` || true
 559         echo "Memory leaks detected"
 560         [ -n "$IGNORE_LEAK" ] && { echo "ignoring leaks" && return 0; } || true
 561         return 1
 562     fi
 563 }
 564
 565 unload_modules() {
 566         wait_exit_ST client # bug 12845
 567
 568         $LUSTRE_RMMOD ldiskfs || return 2
 569
 570         if $LOAD_MODULES_REMOTE; then
 571                 local list=$(comma_list $(remote_nodes_list))
 572                 if [ -n "$list" ]; then
 573                         echo "unloading modules on: '$list'"
 574                         do_rpc_nodes "$list" $LUSTRE_RMMOD ldiskfs
 575                         do_rpc_nodes "$list" check_mem_leak
 576                 fi
 577         fi
 578
 579     if grep -qe "/sbin/mount\.lustre" /proc/mounts; then
 580         umount /sbin/mount.lustre || true
 581         [ -w /sbin/mount.lustre -a ! -s /sbin/mount.lustre ] && \
 582             rm -f /sbin/mount.lustre || true
 583     fi
 584
 585     check_mem_leak || return 254
 586
 587     echo "modules unloaded."
 588     return 0
 589 }
 590
 591 fs_log_size() {
 592         local facet=${1:-$SINGLEMDS}
 593         local fstype=$(facet_fstype $facet)
 594         local size=0
 595         case $fstype in
 596                 ldiskfs) size=50;; # largest seen is 44, leave some headroom
 597                 zfs)     size=400;; # largest seen is 384
 598         esac
 599
 600         echo -n $size
 601 }
 602
 603 check_gss_daemon_nodes() {
 604     local list=$1
 605     dname=$2
 606
 607     do_nodesv $list "num=\\\$(ps -o cmd -C $dname | grep $dname | wc -l);
 608 if [ \\\"\\\$num\\\" -ne 1 ]; then
 609     echo \\\$num instance of $dname;
 610     exit 1;
 611 fi; "
 612 }
 613
 614 check_gss_daemon_facet() {
 615     facet=$1
 616     dname=$2
 617
 618     num=`do_facet $facet ps -o cmd -C $dname | grep $dname | wc -l`
 619     if [ $num -ne 1 ]; then
 620         echo "$num instance of $dname on $facet"
 621         return 1
 622     fi
 623     return 0
 624 }
 625
 626 send_sigint() {
 627     local list=$1
 628     shift
 629     echo Stopping $@ on $list
 630     do_nodes $list "killall -2 $@ 2>/dev/null || true"
 631 }
 632
 633 # start gss daemons on all nodes, or
 634 # "daemon" on "list" if set
 635 start_gss_daemons() {
 636     local list=$1
 637     local daemon=$2
 638
 639     if [ "$list" ] && [ "$daemon" ] ; then
 640         echo "Starting gss daemon on nodes: $list"
 641         do_nodes $list "$daemon" || return 8
 642         return 0
 643     fi
 644
 645     local list=$(comma_list $(mdts_nodes))
 646
 647     echo "Starting gss daemon on mds: $list"
 648     do_nodes $list "$LSVCGSSD -v" || return 1
 649     if $GSS_PIPEFS; then
 650         do_nodes $list "$LGSSD -v" || return 2
 651     fi
 652
 653     list=$(comma_list $(osts_nodes))
 654     echo "Starting gss daemon on ost: $list"
 655     do_nodes $list "$LSVCGSSD -v" || return 3
 656     # starting on clients
 657
 658     local clients=${CLIENTS:-`hostname`}
 659     if $GSS_PIPEFS; then
 660         echo "Starting $LGSSD on clients $clients "
 661         do_nodes $clients  "$LGSSD -v" || return 4
 662     fi
 663
 664     # wait daemons entering "stable" status
 665     sleep 5
 666
 667     #
 668     # check daemons are running
 669     #
 670     list=$(comma_list $(mdts_nodes) $(osts_nodes))
 671     check_gss_daemon_nodes $list lsvcgssd || return 5
 672     if $GSS_PIPEFS; then
 673         list=$(comma_list $(mdts_nodes))
 674         check_gss_daemon_nodes $list lgssd || return 6
 675     fi
 676     if $GSS_PIPEFS; then
 677         check_gss_daemon_nodes $clients lgssd || return 7
 678     fi
 679 }
 680
 681 stop_gss_daemons() {
 682     local list=$(comma_list $(mdts_nodes))
 683
 684     send_sigint $list lsvcgssd lgssd
 685
 686     list=$(comma_list $(osts_nodes))
 687     send_sigint $list lsvcgssd
 688
 689     list=${CLIENTS:-`hostname`}
 690     send_sigint $list lgssd
 691 }
 692
 693 init_gss() {
 694     if $GSS; then
 695         if ! module_loaded ptlrpc_gss; then
 696             load_module ptlrpc/gss/ptlrpc_gss
 697             module_loaded ptlrpc_gss ||
 698                 error_exit "init_gss : GSS=$GSS, but gss/krb5 is not supported!"
 699         fi
 700         start_gss_daemons || error_exit "start gss daemon failed! rc=$?"
 701
 702         if [ -n "$LGSS_KEYRING_DEBUG" ]; then
 703             echo $LGSS_KEYRING_DEBUG > /proc/fs/lustre/sptlrpc/gss/lgss_keyring/debug_level
 704         fi
 705     fi
 706 }
 707
 708 cleanup_gss() {
 709     if $GSS; then
 710         stop_gss_daemons
 711         # maybe cleanup credential cache?
 712     fi
 713 }
 714
 715 facet_svc() {
 716         local facet=$1
 717         local var=${facet}_svc
 718
 719         echo -n ${!var}
 720 }
 721
 722 facet_type() {
 723         local facet=$1
 724
 725         echo -n $facet | sed -e 's/^fs[0-9]\+//' -e 's/[0-9_]\+//' |
 726                 tr '[:lower:]' '[:upper:]'
 727 }
 728
 729 facet_number() {
 730         local facet=$1
 731
 732         if [ $facet == mgs ]; then
 733                 return 1
 734         fi
 735
 736         echo -n $facet | sed -e 's/^fs[0-9]\+//' | sed -e 's/^[a-z]\+//'
 737 }
 738
 739 facet_fstype() {
 740         local facet=$1
 741         local var
 742
 743         var=${facet}_FSTYPE
 744         if [ -n "${!var}" ]; then
 745                 echo -n ${!var}
 746                 return
 747         fi
 748
 749         var=$(facet_type $facet)FSTYPE
 750         if [ -n "${!var}" ]; then
 751                 echo -n ${!var}
 752                 return
 753         fi
 754
 755         if [ -n "$FSTYPE" ]; then
 756                 echo -n $FSTYPE
 757                 return
 758         fi
 759
 760         if [[ $facet == mgs ]] && combined_mgs_mds; then
 761                 facet_fstype mds1
 762                 return
 763         fi
 764
 765         return 1
 766 }
 767
 768 node_fstypes() {
 769         local node=$1
 770         local fstypes
 771         local fstype
 772         local facets=$(get_facets)
 773         local facet
 774
 775         for facet in ${facets//,/ }; do
 776                 if [ $node == $(facet_host $facet) ] ||
 777                    [ $node == "$(facet_failover_host $facet)" ]; then
 778                         fstype=$(facet_fstype $facet)
 779                         if [[ $fstypes != *$fstype* ]]; then
 780                                 fstypes+="${fstypes:+,}$fstype"
 781                         fi
 782                 fi
 783         done
 784         echo -n $fstypes
 785 }
 786
 787 devicelabel() {
 788         local facet=$1
 789         local dev=$2
 790         local label
 791         local fstype=$(facet_fstype $facet)
 792
 793         case $fstype in
 794         ldiskfs)
 795                 label=$(do_facet ${facet} "$E2LABEL ${dev} 2>/dev/null");;
 796         zfs)
 797                 label=$(do_facet ${facet} "$ZFS get -H -o value lustre:svname \
 798                                            ${dev} 2>/dev/null");;
 799         *)
 800                 error "unknown fstype!";;
 801         esac
 802
 803         echo -n $label
 804 }
 805
 806 mdsdevlabel() {
 807         local num=$1
 808         local device=$(mdsdevname $num)
 809         local label=$(devicelabel mds$num ${device} | grep -v "CMD: ")
 810         echo -n $label
 811 }
 812
 813 ostdevlabel() {
 814         local num=$1
 815         local device=$(ostdevname $num)
 816         local label=$(devicelabel ost$num ${device} | grep -v "CMD: ")
 817         echo -n $label
 818 }
 819
 820 #
 821 # Get the device of a facet.
 822 #
 823 facet_device() {
 824         local facet=$1
 825         local device
 826
 827         case $facet in
 828                 mgs) device=$(mgsdevname) ;;
 829                 mds*) device=$(mdsdevname $(facet_number $facet)) ;;
 830                 ost*) device=$(ostdevname $(facet_number $facet)) ;;
 831                 fs2mds) device=$(mdsdevname 1_2) ;;
 832                 fs2ost) device=$(ostdevname 1_2) ;;
 833                 fs3ost) device=$(ostdevname 2_2) ;;
 834                 *) ;;
 835         esac
 836
 837         echo -n $device
 838 }
 839
 840 #
 841 # Get the virtual device of a facet.
 842 #
 843 facet_vdevice() {
 844         local facet=$1
 845         local device
 846
 847         case $facet in
 848                 mgs) device=$(mgsvdevname) ;;
 849                 mds*) device=$(mdsvdevname $(facet_number $facet)) ;;
 850                 ost*) device=$(ostvdevname $(facet_number $facet)) ;;
 851                 fs2mds) device=$(mdsvdevname 1_2) ;;
 852                 fs2ost) device=$(ostvdevname 1_2) ;;
 853                 fs3ost) device=$(ostvdevname 2_2) ;;
 854                 *) ;;
 855         esac
 856
 857         echo -n $device
 858 }
 859
 860 #
 861 # Re-read the partition table on failover partner host.
 862 # After a ZFS storage pool is created on a shared device, the partition table
 863 # on the device may change. However, the operating system on the failover
 864 # host may not notice the change automatically. Without the up-to-date partition
 865 # block devices, 'zpool import ..' cannot find the labels, whose positions are
 866 # relative to partition rather than disk beginnings.
 867 #
 868 # This function performs partprobe on the failover host to make it re-read the
 869 # partition table.
 870 #
 871 refresh_partition_table() {
 872         local facet=$1
 873         local device=$2
 874         local host
 875
 876         host=$(facet_passive_host $facet)
 877         if [[ -n "$host" ]]; then
 878                 do_node $host "$PARTPROBE $device"
 879         fi
 880 }
 881
 882 #
 883 # Get ZFS storage pool name.
 884 #
 885 zpool_name() {
 886         local facet=$1
 887         local device
 888         local poolname
 889
 890         device=$(facet_device $facet)
 891         # poolname is string before "/"
 892         poolname="${device%%/*}"
 893
 894         echo -n $poolname
 895 }
 896
 897 #
 898 # Export ZFS storage pool.
 899 # Before exporting the pool, all datasets within the pool should be unmounted.
 900 #
 901 export_zpool() {
 902         local facet=$1
 903         shift
 904         local opts="$@"
 905         local poolname
 906
 907         poolname=$(zpool_name $facet)
 908
 909         if [[ -n "$poolname" ]]; then
 910                 do_facet $facet "! $ZPOOL list -H $poolname >/dev/null 2>&1 ||
 911                         grep -q ^$poolname/ /proc/mounts ||
 912                         $ZPOOL export $opts $poolname"
 913         fi
 914 }
 915
 916 #
 917 # Import ZFS storage pool.
 918 # Force importing, even if the pool appears to be potentially active.
 919 #
 920 import_zpool() {
 921         local facet=$1
 922         shift
 923         local opts=${@:-"-o cachefile=none"}
 924         local poolname
 925
 926         poolname=$(zpool_name $facet)
 927
 928         if [[ -n "$poolname" ]]; then
 929                 opts+=" -d $(dirname $(facet_vdevice $facet))"
 930                 do_facet $facet "$ZPOOL list -H $poolname >/dev/null 2>&1 ||
 931                         $ZPOOL import -f $opts $poolname"
 932         fi
 933 }
 934
 935 #
 936 # Set the "cachefile=none" property on ZFS storage pool so that the pool
 937 # is not automatically imported on system startup.
 938 #
 939 # In a failover environment, this will provide resource level fencing which
 940 # will ensure that the same ZFS storage pool will not be imported concurrently
 941 # on different nodes.
 942 #
 943 disable_zpool_cache() {
 944         local facet=$1
 945         local poolname
 946
 947         poolname=$(zpool_name $facet)
 948
 949         if [[ -n "$poolname" ]]; then
 950                 do_facet $facet "$ZPOOL set cachefile=none $poolname"
 951         fi
 952 }
 953
 954 #
 955 # This and set_osd_param() shall be used to access OSD parameters
 956 # once existed under "obdfilter":
 957 #
 958 #   mntdev
 959 #   stats
 960 #   read_cache_enable
 961 #   writethrough_cache_enable
 962 #
 963 get_osd_param() {
 964         local nodes=$1
 965         local device=${2:-$FSNAME-OST*}
 966         local name=$3
 967
 968         do_nodes $nodes "$LCTL get_param -n obdfilter.$device.$name \
 969                 osd-*.$device.$name 2>&1" | grep -v 'Found no match'
 970 }
 971
 972 set_osd_param() {
 973         local nodes=$1
 974         local device=${2:-$FSNAME-OST*}
 975         local name=$3
 976         local value=$4
 977
 978         do_nodes $nodes "$LCTL set_param -n obdfilter.$device.$name=$value \
 979                 osd-*.$device.$name=$value 2>&1" | grep -v 'Found no match'
 980 }
 981
 982 set_debug_size () {
 983     local dz=${1:-$DEBUG_SIZE}
 984
 985     if [ -f /sys/devices/system/cpu/possible ]; then
 986         local cpus=$(($(cut -d "-" -f 2 /sys/devices/system/cpu/possible)+1))
 987     else
 988         local cpus=$(getconf _NPROCESSORS_CONF)
 989     fi
 990
 991     # bug 19944, adjust size to be -gt num_possible_cpus()
 992     # promise 2MB for every cpu at least
 993     if [ -n "$cpus" ] && [ $((cpus * 2)) -gt $dz ]; then
 994         dz=$((cpus * 2))
 995     fi
 996     lctl set_param debug_mb=$dz
 997 }
 998
 999 set_default_debug () {
1000     local debug=${1:-"$PTLDEBUG"}
1001     local subsys=${2:-"$SUBSYSTEM"}
1002     local debug_size=${3:-$DEBUG_SIZE}
1003
1004     [ -n "$debug" ] && lctl set_param debug="$debug" >/dev/null
1005     [ -n "$subsys" ] && lctl set_param subsystem_debug="${subsys# }" >/dev/null
1006
1007     [ -n "$debug_size" ] && set_debug_size $debug_size > /dev/null
1008 }
1009
1010 set_default_debug_nodes () {
1011         local nodes="$1"
1012
1013         if [[ ,$nodes, = *,$HOSTNAME,* ]]; then
1014                 nodes=$(exclude_items_from_list "$nodes" "$HOSTNAME")
1015                 set_default_debug
1016         fi
1017
1018         do_rpc_nodes "$nodes" set_default_debug \
1019                 \\\"$PTLDEBUG\\\" \\\"$SUBSYSTEM\\\" $DEBUG_SIZE || true
1020 }
1021
1022 set_default_debug_facet () {
1023     local facet=$1
1024     local node=$(facet_active_host $facet)
1025     [ -z "$node" ] && echo "No host defined for facet $facet" && exit 1
1026
1027     set_default_debug_nodes $node
1028 }
1029
1030 # Facet functions
1031 mount_facets () {
1032         local facets=${1:-$(get_facets)}
1033         local facet
1034
1035         for facet in ${facets//,/ }; do
1036                 mount_facet $facet
1037                 local RC=$?
1038                 [ $RC -eq 0 ] && continue
1039
1040                 if [ "$TESTSUITE.$TESTNAME" = "replay-dual.test_0a" ]; then
1041                         skip "Restart of $facet failed!." && touch $LU482_FAILED
1042                 else
1043                         error "Restart of $facet failed!"
1044                 fi
1045                 return $RC
1046         done
1047 }
1048
1049 #
1050 # Add argument "arg" (e.g., "loop") to the comma-separated list
1051 # of arguments for option "opt" (e.g., "-o") on command
1052 # line "opts" (e.g., "-o flock").
1053 #
1054 csa_add() {
1055         local opts=$1
1056         local opt=$2
1057         local arg=$3
1058         local opt_pattern="\([[:space:]]\+\|^\)$opt"
1059
1060         if echo "$opts" | grep -q $opt_pattern; then
1061                 opts=$(echo "$opts" | sed -e \
1062                         "s/$opt_pattern[[:space:]]*[^[:space:]]\+/&,$arg/")
1063         else
1064                 opts+="${opts:+ }$opt $arg"
1065         fi
1066         echo -n "$opts"
1067 }
1068
1069 mount_facet() {
1070         local facet=$1
1071         shift
1072         local dev=$(facet_active $facet)_dev
1073         local opt=${facet}_opt
1074         local mntpt=$(facet_mntpt $facet)
1075         local opts="${!opt} $@"
1076
1077         if [ $(facet_fstype $facet) == ldiskfs ] &&
1078            ! do_facet $facet test -b ${!dev}; then
1079                 opts=$(csa_add "$opts" -o loop)
1080         fi
1081
1082         if [[ $(facet_fstype $facet) == zfs ]]; then
1083                 # import ZFS storage pool
1084                 import_zpool $facet || return ${PIPESTATUS[0]}
1085         fi
1086
1087         echo "Starting ${facet}: $opts ${!dev} $mntpt"
1088         # for testing LU-482 error handling in mount_facets() and test_0a()
1089         if [ -f $TMP/test-lu482-trigger ]; then
1090                 RC=2
1091         else
1092                 do_facet ${facet} "mkdir -p $mntpt; mount -t lustre $opts \
1093                                    ${!dev} $mntpt"
1094                 RC=${PIPESTATUS[0]}
1095         fi
1096         if [ $RC -ne 0 ]; then
1097                 echo "Start of ${!dev} on ${facet} failed ${RC}"
1098     else
1099         set_default_debug_facet $facet
1100
1101                 label=$(devicelabel ${facet} ${!dev})
1102         [ -z "$label" ] && echo no label for ${!dev} && exit 1
1103         eval export ${facet}_svc=${label}
1104         echo Started ${label}
1105     fi
1106     return $RC
1107 }
1108
1109 # start facet device options
1110 start() {
1111     local facet=$1
1112     shift
1113     local device=$1
1114     shift
1115     eval export ${facet}_dev=${device}
1116     eval export ${facet}_opt=\"$@\"
1117
1118     local varname=${facet}failover_dev
1119     if [ -n "${!varname}" ] ; then
1120         eval export ${facet}failover_dev=${!varname}
1121     else
1122         eval export ${facet}failover_dev=$device
1123     fi
1124
1125     local mntpt=$(facet_mntpt $facet)
1126     do_facet ${facet} mkdir -p $mntpt
1127     eval export ${facet}_MOUNT=$mntpt
1128     mount_facet ${facet}
1129     RC=$?
1130     return $RC
1131 }
1132
1133 stop() {
1134     local running
1135     local facet=$1
1136     shift
1137     local HOST=`facet_active_host $facet`
1138     [ -z $HOST ] && echo stop: no host for $facet && return 0
1139
1140     local mntpt=$(facet_mntpt $facet)
1141     running=$(do_facet ${facet} "grep -c $mntpt' ' /proc/mounts") || true
1142     if [ ${running} -ne 0 ]; then
1143         echo "Stopping $mntpt (opts:$@) on $HOST"
1144         do_facet ${facet} umount -d $@ $mntpt
1145     fi
1146
1147         # umount should block, but we should wait for unrelated obd's
1148         # like the MGS or MGC to also stop.
1149         wait_exit_ST ${facet} || return ${PIPESTATUS[0]}
1150
1151         if [[ $(facet_fstype $facet) == zfs ]]; then
1152                 # export ZFS storage pool
1153                 export_zpool $facet
1154         fi
1155 }
1156
1157 # save quota version (both administrative and operational quotas)
1158 # add an additional parameter if mountpoint is ever different from $MOUNT
1159 #
1160 # XXX This function is kept for interoperability with old server (< 2.3.50),
1161 #     it should be removed whenever we drop the interoperability for such
1162 #     server.
1163 quota_save_version() {
1164     local fsname=${2:-$FSNAME}
1165     local spec=$1
1166     local ver=$(tr -c -d "123" <<< $spec)
1167     local type=$(tr -c -d "ug" <<< $spec)
1168
1169     [ -n "$ver" -a "$ver" != "3" ] && error "wrong quota version specifier"
1170
1171     [ -n "$type" ] && { $LFS quotacheck -$type $MOUNT || error "quotacheck has failed"; }
1172
1173     do_facet mgs "lctl conf_param ${fsname}-MDT*.mdd.quota_type=$spec"
1174     local varsvc
1175     local osts=$(get_facets OST)
1176     for ost in ${osts//,/ }; do
1177         varsvc=${ost}_svc
1178         do_facet mgs "lctl conf_param ${!varsvc}.ost.quota_type=$spec"
1179     done
1180 }
1181
1182 # client could mount several lustre
1183 #
1184 # XXX This function is kept for interoperability with old server (< 2.3.50),
1185 #     it should be removed whenever we drop the interoperability for such
1186 #     server.
1187 quota_type() {
1188         local fsname=${1:-$FSNAME}
1189         local rc=0
1190         do_facet $SINGLEMDS lctl get_param mdd.${fsname}-MDT*.quota_type ||
1191                 rc=$?
1192         do_nodes $(comma_list $(osts_nodes)) \
1193                 lctl get_param obdfilter.${fsname}-OST*.quota_type || rc=$?
1194         return $rc
1195 }
1196
1197 # XXX This function is kept for interoperability with old server (< 2.3.50),
1198 #     it should be removed whenever we drop the interoperability for such
1199 #     server.
1200 restore_quota_old() {
1201         local mntpt=${1:-$MOUNT}
1202         local quota_type=$(quota_type $FSNAME | grep MDT | cut -d "=" -f2)
1203         if [ ! "$old_QUOTA_TYPE" ] ||
1204                 [ "$quota_type" = "$old_QUOTA_TYPE" ]; then
1205                 return
1206         fi
1207         quota_save_version $old_QUOTA_TYPE
1208 }
1209
1210 # XXX This function is kept for interoperability with old server (< 2.3.50),
1211 #     it should be removed whenever we drop the interoperability for such
1212 #     server.
1213 setup_quota_old(){
1214         local mntpt=$1
1215
1216         # no quota enforcement for now and accounting works out of the box
1217         return
1218
1219     # We need save the original quota_type params, and restore them after testing
1220
1221     # Suppose that quota type the same on mds and ost
1222     local quota_type=$(quota_type | grep MDT | cut -d "=" -f2)
1223     [ ${PIPESTATUS[0]} -eq 0 ] || error "quota_type failed!"
1224     echo "[HOST:$HOSTNAME] [old_quota_type:$quota_type] [new_quota_type:$QUOTA_TYPE]"
1225     if [ "$quota_type" != "$QUOTA_TYPE" ]; then
1226         export old_QUOTA_TYPE=$quota_type
1227         quota_save_version $QUOTA_TYPE
1228     else
1229         qtype=$(tr -c -d "ug" <<< $QUOTA_TYPE)
1230         $LFS quotacheck -$qtype $mntpt || error "quotacheck has failed for $type"
1231     fi
1232
1233     local quota_usrs=$QUOTA_USERS
1234
1235     # get_filesystem_size
1236     local disksz=$(lfs_df $mntpt | grep "summary"  | awk '{print $2}')
1237     local blk_soft=$((disksz + 1024))
1238     local blk_hard=$((blk_soft + blk_soft / 20)) # Go 5% over
1239
1240     local Inodes=$(lfs_df -i $mntpt | grep "summary"  | awk '{print $2}')
1241     local i_soft=$Inodes
1242     local i_hard=$((i_soft + i_soft / 20))
1243
1244     echo "Total disk size: $disksz  block-softlimit: $blk_soft block-hardlimit:
1245         $blk_hard inode-softlimit: $i_soft inode-hardlimit: $i_hard"
1246
1247     local cmd
1248     for usr in $quota_usrs; do
1249         echo "Setting up quota on $HOSTNAME:$mntpt for $usr..."
1250         for type in u g; do
1251             cmd="$LFS setquota -$type $usr -b $blk_soft -B $blk_hard -i $i_soft -I $i_hard $mntpt"
1252             echo "+ $cmd"
1253             eval $cmd || error "$cmd FAILED!"
1254         done
1255         # display the quota status
1256         echo "Quota settings for $usr : "
1257         $LFS quota -v -u $usr $mntpt || true
1258     done
1259 }
1260
1261 # get mdt quota type
1262 mdt_quota_type() {
1263         local varsvc=${SINGLEMDS}_svc
1264         do_facet $SINGLEMDS $LCTL get_param -n \
1265                 osd-$(facet_fstype $SINGLEMDS).${!varsvc}.quota_slave.enabled
1266 }
1267
1268 # get ost quota type
1269 ost_quota_type() {
1270         # All OSTs should have same quota type
1271         local varsvc=ost1_svc
1272         do_facet ost1 $LCTL get_param -n \
1273                 osd-$(facet_fstype ost1).${!varsvc}.quota_slave.enabled
1274 }
1275
1276 # restore old quota type settings
1277 restore_quota() {
1278         if [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.3.50) ]; then
1279                 restore_quota_old
1280                 return
1281         fi
1282
1283         if [ "$old_MDT_QUOTA_TYPE" ]; then
1284                 do_facet mgs $LCTL conf_param \
1285                         $FSNAME.quota.mdt=$old_MDT_QUOTA_TYPE
1286         fi
1287         if [ "$old_OST_QUOTA_TYPE" ]; then
1288                 do_facet mgs $LCTL conf_param \
1289                         $FSNAME.quota.ost=$old_OST_QUOTA_TYPE
1290         fi
1291 }
1292
1293 # Handle the case when there is a space in the lfs df
1294 # "filesystem summary" line the same as when there is no space.
1295 # This will allow fixing the "lfs df" summary line in the future.
1296 lfs_df() {
1297         $LFS df $* | sed -e 's/filesystem /filesystem_/'
1298 }
1299
1300 setup_quota(){
1301         if [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.3.50) ]; then
1302                 setup_quota_old $1
1303                 return
1304         fi
1305
1306         local mntpt=$1
1307
1308         # save old quota type & set new quota type
1309         local mdt_qtype=$(mdt_quota_type)
1310         local ost_qtype=$(ost_quota_type)
1311
1312         echo "[HOST:$HOSTNAME] [old_mdt_qtype:$mdt_qtype]" \
1313                 "[old_ost_qtype:$ost_qtype] [new_qtype:$QUOTA_TYPE]"
1314
1315         export old_MDT_QUOTA_TYPE=$mdt_qtype
1316         export old_OST_QUOTA_TYPE=$ost_qtype
1317
1318         do_facet mgs $LCTL conf_param $FSNAME.quota.mdt=$QUOTA_TYPE ||
1319                 error "set mdt quota type failed"
1320         do_facet mgs $LCTL conf_param $FSNAME.quota.ost=$QUOTA_TYPE ||
1321                 error "set ost quota type failed"
1322
1323         local quota_usrs=$QUOTA_USERS
1324
1325         # get_filesystem_size
1326         local disksz=$(lfs_df $mntpt | grep "summary" | awk '{print $2}')
1327         local blk_soft=$((disksz + 1024))
1328         local blk_hard=$((blk_soft + blk_soft / 20)) # Go 5% over
1329
1330         local inodes=$(lfs_df -i $mntpt | grep "summary" | awk '{print $2}')
1331         local i_soft=$inodes
1332         local i_hard=$((i_soft + i_soft / 20))
1333
1334         echo "Total disk size: $disksz  block-softlimit: $blk_soft" \
1335                 "block-hardlimit: $blk_hard inode-softlimit: $i_soft" \
1336                 "inode-hardlimit: $i_hard"
1337
1338         local cmd
1339         for usr in $quota_usrs; do
1340                 echo "Setting up quota on $HOSTNAME:$mntpt for $usr..."
1341                 for type in u g; do
1342                         cmd="$LFS setquota -$type $usr -b $blk_soft"
1343                         cmd="$cmd -B $blk_hard -i $i_soft -I $i_hard $mntpt"
1344                         echo "+ $cmd"
1345                         eval $cmd || error "$cmd FAILED!"
1346                 done
1347                 # display the quota status
1348                 echo "Quota settings for $usr : "
1349                 $LFS quota -v -u $usr $mntpt || true
1350         done
1351 }
1352
1353 zconf_mount() {
1354     local client=$1
1355     local mnt=$2
1356     local OPTIONS=${3:-$MOUNTOPT}
1357
1358     local device=$MGSNID:/$FSNAME
1359     if [ -z "$mnt" -o -z "$FSNAME" ]; then
1360         echo Bad zconf mount command: opt=$OPTIONS dev=$device mnt=$mnt
1361         exit 1
1362     fi
1363
1364     echo "Starting client: $client: $OPTIONS $device $mnt"
1365     do_node $client mkdir -p $mnt
1366     do_node $client mount -t lustre $OPTIONS $device $mnt || return 1
1367
1368     set_default_debug_nodes $client
1369
1370     return 0
1371 }
1372
1373 zconf_umount() {
1374     local client=$1
1375     local mnt=$2
1376     local force
1377     local busy
1378     local need_kill
1379
1380     [ "$3" ] && force=-f
1381     local running=$(do_node $client "grep -c $mnt' ' /proc/mounts") || true
1382     if [ $running -ne 0 ]; then
1383         echo "Stopping client $client $mnt (opts:$force)"
1384         do_node $client lsof -t $mnt || need_kill=no
1385         if [ "x$force" != "x" -a "x$need_kill" != "xno" ]; then
1386             pids=$(do_node $client lsof -t $mnt | sort -u);
1387             if [ -n $pids ]; then
1388                 do_node $client kill -9 $pids || true
1389             fi
1390         fi
1391
1392         busy=$(do_node $client "umount $force $mnt 2>&1" | grep -c "busy") || true
1393         if [ $busy -ne 0 ] ; then
1394             echo "$mnt is still busy, wait one second" && sleep 1
1395             do_node $client umount $force $mnt
1396         fi
1397     fi
1398 }
1399
1400 # nodes is comma list
1401 sanity_mount_check_nodes () {
1402     local nodes=$1
1403     shift
1404     local mnts="$@"
1405     local mnt
1406
1407     # FIXME: assume that all cluster nodes run the same os
1408     [ "$(uname)" = Linux ] || return 0
1409
1410     local rc=0
1411     for mnt in $mnts ; do
1412         do_nodes $nodes "running=\\\$(grep -c $mnt' ' /proc/mounts);
1413 mpts=\\\$(mount | grep -c $mnt' ');
1414 if [ \\\$running -ne \\\$mpts ]; then
1415     echo \\\$(hostname) env are INSANE!;
1416     exit 1;
1417 fi"
1418     [ $? -eq 0 ] || rc=1
1419     done
1420     return $rc
1421 }
1422
1423 sanity_mount_check_servers () {
1424     [ "$CLIENTONLY" ] &&
1425         { echo "CLIENTONLY mode, skip mount_check_servers"; return 0; } || true
1426     echo Checking servers environments
1427
1428     # FIXME: modify get_facets to display all facets wo params
1429     local facets="$(get_facets OST),$(get_facets MDS),mgs"
1430     local node
1431     local mntpt
1432     local facet
1433     for facet in ${facets//,/ }; do
1434         node=$(facet_host ${facet})
1435         mntpt=$(facet_mntpt $facet)
1436         sanity_mount_check_nodes $node $mntpt ||
1437             { error "server $node environments are insane!"; return 1; }
1438     done
1439 }
1440
1441 sanity_mount_check_clients () {
1442     local clients=${1:-$CLIENTS}
1443     local mntpt=${2:-$MOUNT}
1444     local mntpt2=${3:-$MOUNT2}
1445
1446     [ -z $clients ] && clients=$(hostname)
1447     echo Checking clients $clients environments
1448
1449     sanity_mount_check_nodes $clients $mntpt $mntpt2 ||
1450        error "clients environments are insane!"
1451 }
1452
1453 sanity_mount_check () {
1454     sanity_mount_check_servers || return 1
1455     sanity_mount_check_clients || return 2
1456 }
1457
1458 # mount clients if not mouted
1459 zconf_mount_clients() {
1460     local clients=$1
1461     local mnt=$2
1462     local OPTIONS=${3:-$MOUNTOPT}
1463
1464     local device=$MGSNID:/$FSNAME
1465     if [ -z "$mnt" -o -z "$FSNAME" ]; then
1466         echo Bad zconf mount command: opt=$OPTIONS dev=$device mnt=$mnt
1467         exit 1
1468     fi
1469
1470     echo "Starting client $clients: $OPTIONS $device $mnt"
1471
1472     do_nodes $clients "
1473 running=\\\$(mount | grep -c $mnt' ');
1474 rc=0;
1475 if [ \\\$running -eq 0 ] ; then
1476     mkdir -p $mnt;
1477     mount -t lustre $OPTIONS $device $mnt;
1478     rc=\\\$?;
1479 fi;
1480 exit \\\$rc" || return ${PIPESTATUS[0]}
1481
1482     echo "Started clients $clients: "
1483     do_nodes $clients "mount | grep $mnt' '"
1484
1485     set_default_debug_nodes $clients
1486
1487     return 0
1488 }
1489
1490 zconf_umount_clients() {
1491     local clients=$1
1492     local mnt=$2
1493     local force
1494
1495     [ "$3" ] && force=-f
1496
1497     echo "Stopping clients: $clients $mnt (opts:$force)"
1498     do_nodes $clients "running=\\\$(grep -c $mnt' ' /proc/mounts);
1499 if [ \\\$running -ne 0 ] ; then
1500 echo Stopping client \\\$(hostname) $mnt opts:$force;
1501 lsof $mnt || need_kill=no;
1502 if [ "x$force" != "x" -a "x\\\$need_kill" != "xno" ]; then
1503     pids=\\\$(lsof -t $mnt | sort -u);
1504     if [ -n \\\"\\\$pids\\\" ]; then
1505              kill -9 \\\$pids;
1506     fi
1507 fi;
1508 while umount $force $mnt 2>&1 | grep -q "busy"; do
1509     echo "$mnt is still busy, wait one second" && sleep 1;
1510 done;
1511 fi"
1512 }
1513
1514 shutdown_node () {
1515     local node=$1
1516     echo + $POWER_DOWN $node
1517     $POWER_DOWN $node
1518 }
1519
1520 shutdown_node_hard () {
1521     local host=$1
1522     local attempts=$SHUTDOWN_ATTEMPTS
1523
1524     for i in $(seq $attempts) ; do
1525         shutdown_node $host
1526         sleep 1
1527         wait_for_function --quiet "! ping -w 3 -c 1 $host" 5 1 && return 0
1528         echo "waiting for $host to fail attempts=$attempts"
1529         [ $i -lt $attempts ] || \
1530             { echo "$host still pingable after power down! attempts=$attempts" && return 1; }
1531     done
1532 }
1533
1534 shutdown_client() {
1535     local client=$1
1536     local mnt=${2:-$MOUNT}
1537     local attempts=3
1538
1539     if [ "$FAILURE_MODE" = HARD ]; then
1540         shutdown_node_hard $client
1541     else
1542        zconf_umount_clients $client $mnt -f
1543     fi
1544 }
1545
1546 facets_on_host () {
1547     local host=$1
1548     local facets="$(get_facets OST),$(get_facets MDS)"
1549     local affected
1550
1551     combined_mgs_mds || facets="$facets,mgs"
1552
1553     for facet in ${facets//,/ }; do
1554         if [ $(facet_active_host $facet) == $host ]; then
1555            affected="$affected $facet"
1556         fi
1557     done
1558
1559     echo $(comma_list $affected)
1560 }
1561
1562 facet_up() {
1563         local facet=$1
1564         local host=${2:-$(facet_host $facet)}
1565
1566         local label=$(convert_facet2label $facet)
1567         do_node $host $LCTL dl | awk '{print $4}' | grep -q -x $label
1568 }
1569
1570 facets_up_on_host () {
1571     local host=$1
1572     local facets=$(facets_on_host $host)
1573     local affected_up
1574
1575     for facet in ${facets//,/ }; do
1576         if $(facet_up $facet $host); then
1577             affected_up="$affected_up $facet"
1578         fi
1579     done
1580
1581     echo $(comma_list $affected_up)
1582 }
1583
1584 shutdown_facet() {
1585     local facet=$1
1586
1587     if [ "$FAILURE_MODE" = HARD ]; then
1588         shutdown_node_hard $(facet_active_host $facet)
1589     else
1590         stop $facet
1591     fi
1592 }
1593
1594 reboot_node() {
1595     local node=$1
1596     echo + $POWER_UP $node
1597     $POWER_UP $node
1598 }
1599
1600 remount_facet() {
1601     local facet=$1
1602
1603     stop $facet
1604     mount_facet $facet
1605 }
1606
1607 reboot_facet() {
1608         local facet=$1
1609         if [ "$FAILURE_MODE" = HARD ]; then
1610                 reboot_node $(facet_active_host $facet)
1611         else
1612                 sleep 10
1613         fi
1614 }
1615
1616 boot_node() {
1617     local node=$1
1618     if [ "$FAILURE_MODE" = HARD ]; then
1619        reboot_node $node
1620        wait_for_host $node
1621     fi
1622 }
1623
1624 facets_hosts () {
1625     local facets=$1
1626     local hosts
1627
1628     for facet in ${facets//,/ }; do
1629         hosts=$(expand_list $hosts $(facet_host $facet) )
1630     done
1631
1632     echo $hosts
1633 }
1634
1635 _check_progs_installed () {
1636     local progs=$@
1637     local rc=0
1638
1639     for prog in $progs; do
1640         if ! [ "$(which $prog)"  -o  "${!prog}" ]; then
1641            echo $prog missing on $(hostname)
1642            rc=1
1643         fi
1644     done
1645     return $rc
1646 }
1647
1648 check_progs_installed () {
1649         local nodes=$1
1650         shift
1651
1652         do_rpc_nodes "$nodes" _check_progs_installed $@
1653 }
1654
1655 # recovery-scale functions
1656 node_var_name() {
1657     echo __$(echo $1 | tr '-' '_' | tr '.' '_')
1658 }
1659
1660 start_client_load() {
1661     local client=$1
1662     local load=$2
1663     local var=$(node_var_name $client)_load
1664     eval export ${var}=$load
1665
1666     do_node $client "PATH=$PATH MOUNT=$MOUNT ERRORS_OK=$ERRORS_OK \
1667 BREAK_ON_ERROR=$BREAK_ON_ERROR \
1668 END_RUN_FILE=$END_RUN_FILE \
1669 LOAD_PID_FILE=$LOAD_PID_FILE \
1670 TESTLOG_PREFIX=$TESTLOG_PREFIX \
1671 TESTNAME=$TESTNAME \
1672 DBENCH_LIB=$DBENCH_LIB \
1673 DBENCH_SRC=$DBENCH_SRC \
1674 CLIENT_COUNT=$((CLIENTCOUNT - 1)) \
1675 LFS=$LFS \
1676 run_${load}.sh" &
1677     local ppid=$!
1678     log "Started client load: ${load} on $client"
1679
1680     # get the children process IDs
1681     local pids=$(ps --ppid $ppid -o pid= | xargs)
1682     CLIENT_LOAD_PIDS="$CLIENT_LOAD_PIDS $ppid $pids"
1683     return 0
1684 }
1685
1686 start_client_loads () {
1687     local -a clients=(${1//,/ })
1688     local numloads=${#CLIENT_LOADS[@]}
1689     local testnum
1690
1691     for ((nodenum=0; nodenum < ${#clients[@]}; nodenum++ )); do
1692         testnum=$((nodenum % numloads))
1693         start_client_load ${clients[nodenum]} ${CLIENT_LOADS[testnum]}
1694     done
1695     # bug 22169: wait the background threads to start
1696     sleep 2
1697 }
1698
1699 # only for remote client
1700 check_client_load () {
1701     local client=$1
1702     local var=$(node_var_name $client)_load
1703     local TESTLOAD=run_${!var}.sh
1704
1705     ps auxww | grep -v grep | grep $client | grep -q "$TESTLOAD" || return 1
1706
1707     # bug 18914: try to connect several times not only when
1708     # check ps, but  while check_catastrophe also
1709     local tries=3
1710     local RC=254
1711     while [ $RC = 254 -a $tries -gt 0 ]; do
1712         let tries=$tries-1
1713         # assume success
1714         RC=0
1715         if ! check_catastrophe $client; then
1716             RC=${PIPESTATUS[0]}
1717             if [ $RC -eq 254 ]; then
1718                 # FIXME: not sure how long we shuold sleep here
1719                 sleep 10
1720                 continue
1721             fi
1722             echo "check catastrophe failed: RC=$RC "
1723             return $RC
1724         fi
1725     done
1726     # We can continue try to connect if RC=254
1727     # Just print the warning about this
1728     if [ $RC = 254 ]; then
1729         echo "got a return status of $RC from do_node while checking catastrophe on $client"
1730     fi
1731
1732     # see if the load is still on the client
1733     tries=3
1734     RC=254
1735     while [ $RC = 254 -a $tries -gt 0 ]; do
1736         let tries=$tries-1
1737         # assume success
1738         RC=0
1739         if ! do_node $client "ps auxwww | grep -v grep | grep -q $TESTLOAD"; then
1740             RC=${PIPESTATUS[0]}
1741             sleep 30
1742         fi
1743     done
1744     if [ $RC = 254 ]; then
1745         echo "got a return status of $RC from do_node while checking (catastrophe and 'ps') the client load on $client"
1746         # see if we can diagnose a bit why this is
1747     fi
1748
1749     return $RC
1750 }
1751 check_client_loads () {
1752    local clients=${1//,/ }
1753    local client=
1754    local rc=0
1755
1756    for client in $clients; do
1757       check_client_load $client
1758       rc=${PIPESTATUS[0]}
1759       if [ "$rc" != 0 ]; then
1760         log "Client load failed on node $client, rc=$rc"
1761         return $rc
1762       fi
1763    done
1764 }
1765
1766 restart_client_loads () {
1767     local clients=${1//,/ }
1768     local expectedfail=${2:-""}
1769     local client=
1770     local rc=0
1771
1772     for client in $clients; do
1773         check_client_load $client
1774         rc=${PIPESTATUS[0]}
1775         if [ "$rc" != 0 -a "$expectedfail" ]; then
1776             local var=$(node_var_name $client)_load
1777             start_client_load $client ${!var}
1778             echo "Restarted client load ${!var}: on $client. Checking ..."
1779             check_client_load $client
1780             rc=${PIPESTATUS[0]}
1781             if [ "$rc" != 0 ]; then
1782                 log "Client load failed to restart on node $client, rc=$rc"
1783                 # failure one client load means test fail
1784                 # we do not need to check other
1785                 return $rc
1786             fi
1787         else
1788             return $rc
1789         fi
1790     done
1791 }
1792
1793 # Start vmstat and save its process ID in a file.
1794 start_vmstat() {
1795     local nodes=$1
1796     local pid_file=$2
1797
1798     [ -z "$nodes" -o -z "$pid_file" ] && return 0
1799
1800     do_nodes $nodes \
1801         "vmstat 1 > $TESTLOG_PREFIX.$TESTNAME.vmstat.\\\$(hostname -s).log \
1802         2>/dev/null </dev/null & echo \\\$! > $pid_file"
1803 }
1804
1805 # Display the nodes on which client loads failed.
1806 print_end_run_file() {
1807     local file=$1
1808     local node
1809
1810     [ -s $file ] || return 0
1811
1812     echo "Found the END_RUN_FILE file: $file"
1813     cat $file
1814
1815     # A client load will stop if it finds the END_RUN_FILE file.
1816     # That does not mean the client load actually failed though.
1817     # The first node in END_RUN_FILE is the one we are interested in.
1818     read node < $file
1819
1820     if [ -n "$node" ]; then
1821         local var=$(node_var_name $node)_load
1822
1823         local prefix=$TESTLOG_PREFIX
1824         [ -n "$TESTNAME" ] && prefix=$prefix.$TESTNAME
1825         local stdout_log=$prefix.run_${!var}_stdout.$node.log
1826         local debug_log=$(echo $stdout_log | sed 's/\(.*\)stdout/\1debug/')
1827
1828         echo "Client load ${!var} failed on node $node:"
1829         echo "$stdout_log"
1830         echo "$debug_log"
1831     fi
1832 }
1833
1834 # Stop the process which had its PID saved in a file.
1835 stop_process() {
1836     local nodes=$1
1837     local pid_file=$2
1838
1839     [ -z "$nodes" -o -z "$pid_file" ] && return 0
1840
1841     do_nodes $nodes "test -f $pid_file &&
1842         { kill -s TERM \\\$(cat $pid_file); rm -f $pid_file; }" || true
1843 }
1844
1845 # Stop all client loads.
1846 stop_client_loads() {
1847     local nodes=${1:-$CLIENTS}
1848     local pid_file=$2
1849
1850     # stop the client loads
1851     stop_process $nodes $pid_file
1852
1853     # clean up the processes that started them
1854     [ -n "$CLIENT_LOAD_PIDS" ] && kill -9 $CLIENT_LOAD_PIDS 2>/dev/null || true
1855 }
1856 # End recovery-scale functions
1857
1858 # verify that lustre actually cleaned up properly
1859 cleanup_check() {
1860     [ -f $CATASTROPHE ] && [ `cat $CATASTROPHE` -ne 0 ] && \
1861         error "LBUG/LASSERT detected"
1862     BUSY=`dmesg | grep -i destruct || true`
1863     if [ "$BUSY" ]; then
1864         echo "$BUSY" 1>&2
1865         [ -e $TMP/debug ] && mv $TMP/debug $TMP/debug-busy.`date +%s`
1866         exit 205
1867     fi
1868
1869     check_mem_leak || exit 204
1870
1871         [ "`lctl dl 2> /dev/null | wc -l`" -gt 0 ] && lctl dl &&
1872                 echo "$TESTSUITE: lustre didn't clean up..." 1>&2 &&
1873                 return 202 || true
1874
1875         if module_loaded lnet || module_loaded libcfs; then
1876                 echo "$TESTSUITE: modules still loaded..." 1>&2
1877                 /sbin/lsmod 1>&2
1878                 return 203
1879         fi
1880         return 0
1881 }
1882
1883 wait_update () {
1884         local verbose=false
1885         if [[ "$1" == "--verbose" ]]; then
1886                 shift
1887                 verbose=true
1888         fi
1889
1890         local node=$1
1891         local TEST=$2
1892         local FINAL=$3
1893         local MAX=${4:-90}
1894         local RESULT
1895         local PREV_RESULT
1896         local WAIT=0
1897         local sleep=1
1898         local print=10
1899
1900         while [ true ]; do
1901                 RESULT=$(do_node $node "$TEST")
1902                 if [[ "$RESULT" == "$FINAL" ]]; then
1903                         [[ -z "$RESULT" || $WAIT -le $sleep ]] ||
1904                                 echo "Updated after ${WAIT}s: wanted '$FINAL'"\
1905                                      "got '$RESULT'"
1906                         return 0
1907                 fi
1908                 if [[ $verbose && "$RESULT" != "$PREV_RESULT" ]]; then
1909                         echo "Changed after ${WAIT}s: from '$PREV_RESULT'"\
1910                              "to '$RESULT'"
1911                         PREV_RESULT=$RESULT
1912                 fi
1913                 [[ $WAIT -ge $MAX ]] && break
1914                 [[ $((WAIT % print)) -eq 0 ]] &&
1915                         echo "Waiting $((MAX - WAIT)) secs for update"
1916                 WAIT=$((WAIT + sleep))
1917                 sleep $sleep
1918         done
1919         echo "Update not seen after ${MAX}s: wanted '$FINAL' got '$RESULT'"
1920         return 3
1921 }
1922
1923 wait_update_facet() {
1924         local facet=$1
1925         shift
1926         wait_update $(facet_active_host $facet) "$@"
1927 }
1928
1929 sync_all_data() {
1930         do_nodes $(comma_list $(mdts_nodes)) \
1931             "lctl set_param -n osd*.*MDT*.force_sync 1"
1932         do_nodes $(comma_list $(osts_nodes)) \
1933             "lctl set_param -n osd*.*OS*.force_sync 1" 2>&1 |
1934                 grep -v 'Found no match'
1935 }
1936
1937 wait_delete_completed_mds() {
1938         local MAX_WAIT=${1:-20}
1939         local mds2sync=""
1940         local stime=`date +%s`
1941         local etime
1942         local node
1943         local changes
1944
1945         # find MDS with pending deletions
1946         for node in $(mdts_nodes); do
1947                 changes=$(do_node $node "lctl get_param -n osc.*MDT*.sync_*" \
1948                         2>/dev/null | calc_sum)
1949                 if [ -z "$changes" ] || [ $changes -eq 0 ]; then
1950                         continue
1951                 fi
1952                 mds2sync="$mds2sync $node"
1953         done
1954         if [ "$mds2sync" == "" ]; then
1955                 return
1956         fi
1957         mds2sync=$(comma_list $mds2sync)
1958
1959         # sync MDS transactions
1960         do_nodes $mds2sync "lctl set_param -n osd*.*MD*.force_sync 1"
1961
1962         # wait till all changes are sent and commmitted by OSTs
1963         # for ldiskfs space is released upon execution, but DMU
1964         # do this upon commit
1965
1966         local WAIT=0
1967         while [ "$WAIT" -ne "$MAX_WAIT" ]; do
1968                 changes=$(do_nodes $mds2sync "lctl get_param -n osc.*MDT*.sync_*" \
1969                         | calc_sum)
1970                 #echo "$node: $changes changes on all"
1971                 if [ "$changes" -eq "0" ]; then
1972                         etime=`date +%s`
1973                         #echo "delete took $((etime - stime)) seconds"
1974                         return
1975                 fi
1976                 sleep 1
1977                 WAIT=$(( WAIT + 1))
1978         done
1979
1980         etime=`date +%s`
1981         echo "Delete is not completed in $((etime - stime)) seconds"
1982         do_nodes $mds2sync "lctl get_param osc.*MDT*.sync_*"
1983 }
1984
1985 wait_for_host() {
1986     local hostlist=$1
1987
1988     # we can use "for" here because we are waiting the slowest
1989     for host in ${hostlist//,/ }; do
1990         check_network "$host" 900
1991     done
1992     while ! do_nodes $hostlist hostname  > /dev/null; do sleep 5; done
1993 }
1994
1995 wait_for_facet() {
1996     local facetlist=$1
1997     local hostlist
1998
1999     for facet in ${facetlist//,/ }; do
2000         hostlist=$(expand_list $hostlist $(facet_active_host $facet))
2001     done
2002     wait_for_host $hostlist
2003 }
2004
2005 _wait_recovery_complete () {
2006     local param=$1
2007
2008     # Use default policy if $2 is not passed by caller.
2009     local MAX=${2:-$(max_recovery_time)}
2010
2011     local WAIT=0
2012     local STATUS=
2013
2014     while [ $WAIT -lt $MAX ]; do
2015         STATUS=$(lctl get_param -n $param | grep status)
2016         echo $param $STATUS
2017         [[ $STATUS = "status: COMPLETE" || $STATUS = "status: INACTIVE" ]] && return 0
2018         sleep 5
2019         WAIT=$((WAIT + 5))
2020         echo "Waiting $((MAX - WAIT)) secs for $param recovery done. $STATUS"
2021     done
2022     echo "$param recovery not done in $MAX sec. $STATUS"
2023     return 1
2024 }
2025
2026 wait_recovery_complete () {
2027     local facet=$1
2028
2029     # with an assumption that at_max is the same on all nodes
2030     local MAX=${2:-$(max_recovery_time)}
2031
2032     local facets=$facet
2033     if [ "$FAILURE_MODE" = HARD ]; then
2034         facets=$(facets_on_host $(facet_active_host $facet))
2035     fi
2036     echo affected facets: $facets
2037
2038         # we can use "for" here because we are waiting the slowest
2039         for facet in ${facets//,/ }; do
2040                 local var_svc=${facet}_svc
2041                 local param="*.${!var_svc}.recovery_status"
2042
2043                 local host=$(facet_active_host $facet)
2044                 do_rpc_nodes "$host" _wait_recovery_complete $param $MAX
2045         done
2046 }
2047
2048 wait_mds_ost_sync () {
2049         # just because recovery is done doesn't mean we've finished
2050         # orphan cleanup. Wait for llogs to get synchronized.
2051         echo "Waiting for orphan cleanup..."
2052         # MAX value includes time needed for MDS-OST reconnection
2053         local MAX=$(( TIMEOUT * 2 ))
2054         local WAIT=0
2055         local new_wait=true
2056         local list=$(comma_list $(mdts_nodes))
2057         local cmd="$LCTL get_param -n osp.*osc*.old_sync_processed"
2058         if ! do_facet $SINGLEMDS \
2059                 "$LCTL list_param osp.*osc*.old_sync_processed 2> /dev/null"
2060         then
2061                 # old way, use mds_sync
2062                 new_wait=false
2063                 list=$(comma_list $(osts_nodes))
2064                 cmd="$LCTL get_param -n obdfilter.*.mds_sync"
2065         fi
2066         while [ $WAIT -lt $MAX ]; do
2067                 local -a sync=($(do_nodes $list "$cmd"))
2068                 local con=1
2069                 local i
2070                 for ((i=0; i<${#sync[@]}; i++)); do
2071                         if $new_wait; then
2072                                 [ ${sync[$i]} -eq 1 ] && continue
2073                         else
2074                                 [ ${sync[$i]} -eq 0 ] && continue
2075                         fi
2076                         # there is a not finished MDS-OST synchronization
2077                         con=0
2078                         break;
2079                 done
2080                 sleep 2 # increase waiting time and cover statfs cache
2081                 [ ${con} -eq 1 ] && return 0
2082                 echo "Waiting $WAIT secs for $facet mds-ost sync done."
2083                 WAIT=$((WAIT + 2))
2084         done
2085         echo "$facet recovery not done in $MAX sec. $STATUS"
2086         return 1
2087 }
2088
2089 wait_destroy_complete () {
2090         echo "Waiting for local destroys to complete"
2091         # MAX value shouldn't be big as this mean server responsiveness
2092         # never increase this just to make test pass but investigate
2093         # why it takes so long time
2094         local MAX=5
2095         local WAIT=0
2096         while [ $WAIT -lt $MAX ]; do
2097                 local -a RPCs=($($LCTL get_param -n osc.*.destroys_in_flight))
2098                 local con=1
2099                 local i
2100
2101                 for ((i=0; i<${#RPCs[@]}; i++)); do
2102                         [ ${RPCs[$i]} -eq 0 ] && continue
2103                         # there are still some destroy RPCs in flight
2104                         con=0
2105                         break;
2106                 done
2107                 sleep 1
2108                 [ ${con} -eq 1 ] && return 0 # done waiting
2109                 echo "Waiting ${WAIT}s for local destroys to complete"
2110                 WAIT=$((WAIT + 1))
2111         done
2112         echo "Local destroys weren't done in $MAX sec."
2113         return 1
2114 }
2115
2116 wait_delete_completed() {
2117         wait_delete_completed_mds $1 || return $?
2118         wait_destroy_complete
2119 }
2120
2121 wait_exit_ST () {
2122     local facet=$1
2123
2124     local WAIT=0
2125     local INTERVAL=1
2126     local running
2127     # conf-sanity 31 takes a long time cleanup
2128     while [ $WAIT -lt 300 ]; do
2129         running=$(do_facet ${facet} "lsmod | grep lnet > /dev/null && lctl dl | grep ' ST '") || true
2130         [ -z "${running}" ] && return 0
2131         echo "waited $WAIT for${running}"
2132         [ $INTERVAL -lt 64 ] && INTERVAL=$((INTERVAL + INTERVAL))
2133         sleep $INTERVAL
2134         WAIT=$((WAIT + INTERVAL))
2135     done
2136     echo "service didn't stop after $WAIT seconds.  Still running:"
2137     echo ${running}
2138     return 1
2139 }
2140
2141 wait_remote_prog () {
2142    local prog=$1
2143    local WAIT=0
2144    local INTERVAL=5
2145    local rc=0
2146
2147    [ "$PDSH" = "no_dsh" ] && return 0
2148
2149    while [ $WAIT -lt $2 ]; do
2150         running=$(ps uax | grep "$PDSH.*$prog.*$MOUNT" | grep -v grep) || true
2151         [ -z "${running}" ] && return 0 || true
2152         echo "waited $WAIT for: "
2153         echo "$running"
2154         [ $INTERVAL -lt 60 ] && INTERVAL=$((INTERVAL + INTERVAL))
2155         sleep $INTERVAL
2156         WAIT=$((WAIT + INTERVAL))
2157     done
2158     local pids=$(ps  uax | grep "$PDSH.*$prog.*$MOUNT" | grep -v grep | awk '{print $2}')
2159     [ -z "$pids" ] && return 0
2160     echo "$PDSH processes still exists after $WAIT seconds.  Still running: $pids"
2161     # FIXME: not portable
2162     for pid in $pids; do
2163         cat /proc/${pid}/status || true
2164         cat /proc/${pid}/wchan || true
2165         echo "Killing $pid"
2166         kill -9 $pid || true
2167         sleep 1
2168         ps -P $pid && rc=1
2169     done
2170
2171     return $rc
2172 }
2173
2174 clients_up() {
2175     # not every config has many clients
2176     sleep 1
2177     if [ ! -z "$CLIENTS" ]; then
2178         $PDSH $CLIENTS "stat -f $MOUNT" > /dev/null
2179     else
2180         stat -f $MOUNT > /dev/null
2181     fi
2182 }
2183
2184 client_up() {
2185     local client=$1
2186     # usually checked on particular client or locally
2187     sleep 1
2188     if [ ! -z "$client" ]; then
2189         $PDSH $client "stat -f $MOUNT" > /dev/null
2190     else
2191         stat -f $MOUNT > /dev/null
2192     fi
2193 }
2194
2195 client_evicted() {
2196     ! client_up $1
2197 }
2198
2199 client_reconnect() {
2200     uname -n >> $MOUNT/recon
2201     if [ -z "$CLIENTS" ]; then
2202         df $MOUNT; uname -n >> $MOUNT/recon
2203     else
2204         do_nodes $CLIENTS "df $MOUNT; uname -n >> $MOUNT/recon" > /dev/null
2205     fi
2206     echo Connected clients:
2207     cat $MOUNT/recon
2208     ls -l $MOUNT/recon > /dev/null
2209     rm $MOUNT/recon
2210 }
2211
2212 affected_facets () {
2213     local facet=$1
2214
2215     local host=$(facet_active_host $facet)
2216     local affected=$facet
2217
2218     if [ "$FAILURE_MODE" = HARD ]; then
2219         affected=$(facets_up_on_host $host)
2220     fi
2221     echo $affected
2222 }
2223
2224 facet_failover() {
2225         local facets=$1
2226         local sleep_time=$2
2227         local -a affecteds
2228         local facet
2229         local total=0
2230         local index=0
2231         local skip
2232
2233         #Because it will only get up facets, we need get affected
2234         #facets before shutdown
2235         #For HARD Failure mode, it needs make sure facets on the same
2236         #HOST will only be shutdown and reboot once
2237         for facet in ${facets//,/ }; do
2238                 local affected_facet
2239                 skip=0
2240                 #check whether facet has been included in other affected facets
2241                 for ((index=0; index<$total; index++)); do
2242                         [[ *,$facet,* == ,${affecteds[index]}, ]] && skip=1
2243                 done
2244
2245                 if [ $skip -eq 0 ]; then
2246                         affecteds[$total]=$(affected_facets $facet)
2247                         total=$((total+1))
2248                 fi
2249         done
2250
2251         for ((index=0; index<$total; index++)); do
2252                 facet=$(echo ${affecteds[index]} | tr -s " " | cut -d"," -f 1)
2253                 local host=$(facet_active_host $facet)
2254                 echo "Failing ${affecteds[index]} on $host"
2255                 shutdown_facet $facet
2256         done
2257
2258         for ((index=0; index<$total; index++)); do
2259                 facet=$(echo ${affecteds[index]} | tr -s " " | cut -d"," -f 1)
2260                 echo reboot facets: ${affecteds[index]}
2261
2262                 reboot_facet $facet
2263
2264                 change_active ${affecteds[index]}
2265
2266                 wait_for_facet ${affecteds[index]}
2267                 # start mgs first if it is affected
2268                 if ! combined_mgs_mds &&
2269                         list_member ${affecteds[index]} mgs; then
2270                         mount_facet mgs || error "Restart of mgs failed"
2271                 fi
2272                 # FIXME; has to be changed to mount all facets concurrently
2273                 affected=$(exclude_items_from_list ${affecteds[index]} mgs)
2274                 echo mount facets: ${affecteds[index]}
2275                 mount_facets ${affecteds[index]}
2276         done
2277 }
2278
2279 obd_name() {
2280     local facet=$1
2281 }
2282
2283 replay_barrier() {
2284         local facet=$1
2285         do_facet $facet "sync; sync; sync"
2286         df $MOUNT
2287
2288         # make sure there will be no seq change
2289         local clients=${CLIENTS:-$HOSTNAME}
2290         local f=fsa-\\\$\(hostname\)
2291         do_nodes $clients "mcreate $MOUNT/$f; rm $MOUNT/$f"
2292         do_nodes $clients "if [ -d $MOUNT2 ]; then mcreate $MOUNT2/$f; rm $MOUNT2/$f; fi"
2293
2294         local svc=${facet}_svc
2295         do_facet $facet $LCTL --device ${!svc} notransno
2296         #
2297         # If a ZFS OSD is made read-only here, its pool is "freezed". This
2298         # in-memory state has to be cleared by either rebooting the host or
2299         # exporting and reimporting the pool.
2300         #
2301         # Although the uberblocks are not updated when a pool is freezed,
2302         # transactions are still written to the disks. Modified blocks may be
2303         # cached in memory when tests try reading them back. The
2304         # export-and-reimport process also evicts any cached pool data from
2305         # memory to provide the correct "data loss" semantics.
2306         #
2307         # In the test framework, the exporting and importing operations are
2308         # handled by stop() and mount_facet() separately, which are used
2309         # inside fail() and fail_abort().
2310         #
2311         do_facet $facet $LCTL --device ${!svc} readonly
2312         do_facet $facet $LCTL mark "$facet REPLAY BARRIER on ${!svc}"
2313         $LCTL mark "local REPLAY BARRIER on ${!svc}"
2314 }
2315
2316 replay_barrier_nodf() {
2317         local facet=$1    echo running=${running}
2318         do_facet $facet "sync; sync; sync"
2319         local svc=${facet}_svc
2320         echo Replay barrier on ${!svc}
2321         do_facet $facet $LCTL --device ${!svc} notransno
2322         do_facet $facet $LCTL --device ${!svc} readonly
2323         do_facet $facet $LCTL mark "$facet REPLAY BARRIER on ${!svc}"
2324         $LCTL mark "local REPLAY BARRIER on ${!svc}"
2325 }
2326
2327 replay_barrier_nosync() {
2328         local facet=$1    echo running=${running}
2329         local svc=${facet}_svc
2330         echo Replay barrier on ${!svc}
2331         do_facet $facet $LCTL --device ${!svc} notransno
2332         do_facet $facet $LCTL --device ${!svc} readonly
2333         do_facet $facet $LCTL mark "$facet REPLAY BARRIER on ${!svc}"
2334         $LCTL mark "local REPLAY BARRIER on ${!svc}"
2335 }
2336
2337 mds_evict_client() {
2338     UUID=`lctl get_param -n mdc.${mds1_svc}-mdc-*.uuid`
2339     do_facet mds1 "lctl set_param -n mdt.${mds1_svc}.evict_client $UUID"
2340 }
2341
2342 ost_evict_client() {
2343     UUID=`lctl get_param -n devices| grep ${ost1_svc}-osc- | egrep -v 'MDT' | awk '{print $5}'`
2344     do_facet ost1 "lctl set_param -n obdfilter.${ost1_svc}.evict_client $UUID"
2345 }
2346
2347 fail() {
2348         local facets=$1
2349         local clients=${CLIENTS:-$HOSTNAME}
2350
2351         facet_failover $* || error "failover: $?"
2352         wait_clients_import_state "$clients" "$facets" FULL
2353         clients_up || error "post-failover df: $?"
2354 }
2355
2356 fail_nodf() {
2357         local facet=$1
2358         facet_failover $facet
2359 }
2360
2361 fail_abort() {
2362         local facet=$1
2363         stop $facet
2364         change_active $facet
2365         wait_for_facet $facet
2366         mount_facet $facet -o abort_recovery
2367         clients_up || echo "first df failed: $?"
2368         clients_up || error "post-failover df: $?"
2369 }
2370
2371 do_lmc() {
2372     echo There is no lmc.  This is mountconf, baby.
2373     exit 1
2374 }
2375
2376 host_nids_address() {
2377     local nodes=$1
2378     local kind=$2
2379
2380     if [ -n "$kind" ]; then
2381         nids=$(do_nodes $nodes "$LCTL list_nids | grep $kind | cut -f 1 -d '@'")
2382     else
2383         nids=$(do_nodes $nodes "$LCTL list_nids all | cut -f 1 -d '@'")
2384     fi
2385     echo $nids
2386 }
2387
2388 h2name_or_ip() {
2389     if [ "$1" = "client" -o "$1" = "'*'" ]; then echo \'*\'; else
2390         echo $1"@$2"
2391     fi
2392 }
2393
2394 h2ptl() {
2395    if [ "$1" = "client" -o "$1" = "'*'" ]; then echo \'*\'; else
2396        ID=`xtprocadmin -n $1 2>/dev/null | egrep -v 'NID' | awk '{print $1}'`
2397        if [ -z "$ID" ]; then
2398            echo "Could not get a ptl id for $1..."
2399            exit 1
2400        fi
2401        echo $ID"@ptl"
2402    fi
2403 }
2404 declare -fx h2ptl
2405
2406 h2tcp() {
2407     h2name_or_ip "$1" "tcp"
2408 }
2409 declare -fx h2tcp
2410
2411 h2elan() {
2412     if [ "$1" = "client" -o "$1" = "'*'" ]; then echo \'*\'; else
2413         if type __h2elan >/dev/null 2>&1; then
2414             ID=$(__h2elan $1)
2415         else
2416             ID=`echo $1 | sed 's/[^0-9]*//g'`
2417         fi
2418         echo $ID"@elan"
2419     fi
2420 }
2421 declare -fx h2elan
2422
2423 h2o2ib() {
2424     h2name_or_ip "$1" "o2ib"
2425 }
2426 declare -fx h2o2ib
2427
2428 # This enables variables in cfg/"setup".sh files to support the pdsh HOSTLIST
2429 # expressions format. As a bonus we can then just pass in those variables
2430 # to pdsh. What this function does is take a HOSTLIST type string and
2431 # expand it into a space deliminated list for us.
2432 hostlist_expand() {
2433     local hostlist=$1
2434     local offset=$2
2435     local myList
2436     local item
2437     local list
2438
2439     [ -z "$hostlist" ] && return
2440
2441     # Translate the case of [..],..,[..] to [..] .. [..]
2442     list="${hostlist/],/] }"
2443     front=${list%%[*}
2444     [[ "$front" == *,* ]] && {
2445         new="${list%,*} "
2446         old="${list%,*},"
2447         list=${list/${old}/${new}}
2448     }
2449
2450     for item in $list; do
2451         # Test if we have any []'s at all
2452         if [ "$item" != "${item/\[/}" ]; then {
2453             # Expand the [*] into list
2454             name=${item%%[*}
2455             back=${item#*]}
2456
2457             if [ "$name" != "$item" ]; then
2458                 group=${item#$name[*}
2459                 group=${group%%]*}
2460
2461                 for range in ${group//,/ }; do
2462                     begin=${range%-*}
2463                     end=${range#*-}
2464
2465                     # Number of leading zeros
2466                     padlen=${#begin}
2467                     padlen2=${#end}
2468                     end=$(echo $end | sed 's/0*//')
2469                     [[ -z "$end" ]] && end=0
2470                     [[ $padlen2 -gt $padlen ]] && {
2471                         [[ $padlen2 -eq ${#end} ]] && padlen2=0
2472                         padlen=$padlen2
2473                     }
2474                     begin=$(echo $begin | sed 's/0*//')
2475                     [ -z $begin ] && begin=0
2476
2477                     for num in $(seq -f "%0${padlen}g" $begin $end); do
2478                         value="${name#*,}${num}${back}"
2479                         [ "$value" != "${value/\[/}" ] && {
2480                             value=$(hostlist_expand "$value")
2481                         }
2482                         myList="$myList $value"
2483                     done
2484                 done
2485             fi
2486         } else {
2487             myList="$myList $item"
2488         } fi
2489     done
2490     myList=${myList//,/ }
2491     myList=${myList:1} # Remove first character which is a space
2492
2493     # Filter any duplicates without sorting
2494     list="$myList "
2495     myList="${list%% *}"
2496
2497     while [[ "$list" != ${myList##* } ]]; do
2498         list=${list//${list%% *} /}
2499         myList="$myList ${list%% *}"
2500     done
2501     myList="${myList%* }";
2502
2503     # We can select an object at a offset in the list
2504     [ $# -eq 2 ] && {
2505         cnt=0
2506         for item in $myList; do
2507             let cnt=cnt+1
2508             [ $cnt -eq $offset ] && {
2509                 myList=$item
2510             }
2511         done
2512         [ $(get_node_count $myList) -ne 1 ] && myList=""
2513     }
2514     echo $myList
2515 }
2516
2517 facet_host() {
2518         local facet=$1
2519         local varname
2520
2521         [ "$facet" == client ] && echo -n $HOSTNAME && return
2522         varname=${facet}_HOST
2523         if [ -z "${!varname}" ]; then
2524                 if [ "${facet:0:3}" == "ost" ]; then
2525                         eval export ${facet}_HOST=${ost_HOST}
2526                 elif [ "${facet:0:3}" == "mdt" -o \
2527                         "${facet:0:3}" == "mds" -o \
2528                         "${facet:0:3}" == "mgs" ]; then
2529                         eval export ${facet}_HOST=${mds_HOST}
2530                 fi
2531         fi
2532         echo -n ${!varname}
2533 }
2534
2535 facet_failover_host() {
2536         local facet=$1
2537         local varname
2538
2539         var=${facet}failover_HOST
2540         if [ -n "${!var}" ]; then
2541                 echo ${!var}
2542                 return
2543         fi
2544
2545         if [ "${facet:0:3}" == "mdt" -o "${facet:0:3}" == "mds" -o \
2546              "${facet:0:3}" == "mgs" ]; then
2547
2548                 eval export ${facet}failover_host=${mds_HOST}
2549                 echo ${mds_HOST}
2550                 return
2551         fi
2552
2553         if [[ $facet == ost* ]]; then
2554                 eval export ${facet}failover_host=${ost_HOST}
2555                 echo ${ost_HOST}
2556                 return
2557         fi
2558 }
2559
2560 facet_active() {
2561     local facet=$1
2562     local activevar=${facet}active
2563
2564     if [ -f $TMP/${facet}active ] ; then
2565         source $TMP/${facet}active
2566     fi
2567
2568     active=${!activevar}
2569     if [ -z "$active" ] ; then
2570         echo -n ${facet}
2571     else
2572         echo -n ${active}
2573     fi
2574 }
2575
2576 facet_active_host() {
2577     local facet=$1
2578     local active=`facet_active $facet`
2579     if [ "$facet" == client ]; then
2580         echo $HOSTNAME
2581     else
2582         echo `facet_host $active`
2583     fi
2584 }
2585
2586 # Get the passive failover partner host of facet.
2587 facet_passive_host() {
2588         local facet=$1
2589         [[ $facet = client ]] && return
2590
2591         local host=${facet}_HOST
2592         local failover_host=${facet}failover_HOST
2593         local active_host=$(facet_active_host $facet)
2594
2595         [[ -z ${!failover_host} || ${!failover_host} = ${!host} ]] && return
2596
2597         if [[ $active_host = ${!host} ]]; then
2598                 echo -n ${!failover_host}
2599         else
2600                 echo -n ${!host}
2601         fi
2602 }
2603
2604 change_active() {
2605     local facetlist=$1
2606     local facet
2607
2608     facetlist=$(exclude_items_from_list $facetlist mgs)
2609
2610     for facet in ${facetlist//,/ }; do
2611     local failover=${facet}failover
2612     local host=`facet_host $failover`
2613     [ -z "$host" ] && return
2614
2615     local curactive=`facet_active $facet`
2616     if [ -z "${curactive}" -o "$curactive" == "$failover" ] ; then
2617         eval export ${facet}active=$facet
2618     else
2619         eval export ${facet}active=$failover
2620     fi
2621     # save the active host for this facet
2622     local activevar=${facet}active
2623     echo "$activevar=${!activevar}" > $TMP/$activevar
2624     [[ $facet = mds1 ]] && combined_mgs_mds && \
2625         echo "mgsactive=${!activevar}" > $TMP/mgsactive
2626     local TO=`facet_active_host $facet`
2627     echo "Failover $facet to $TO"
2628     done
2629 }
2630
2631 do_node() {
2632     local verbose=false
2633     # do not stripe off hostname if verbose, bug 19215
2634     if [ x$1 = x--verbose ]; then
2635         shift
2636         verbose=true
2637     fi
2638
2639     local HOST=$1
2640     shift
2641     local myPDSH=$PDSH
2642     if [ "$HOST" = "$HOSTNAME" ]; then
2643         myPDSH="no_dsh"
2644     elif [ -z "$myPDSH" -o "$myPDSH" = "no_dsh" ]; then
2645         echo "cannot run remote command on $HOST with $myPDSH"
2646         return 128
2647     fi
2648     if $VERBOSE; then
2649         echo "CMD: $HOST $@" >&2
2650         $myPDSH $HOST "$LCTL mark \"$@\"" > /dev/null 2>&1 || :
2651     fi
2652
2653     if [ "$myPDSH" = "rsh" ]; then
2654 # we need this because rsh does not return exit code of an executed command
2655         local command_status="$TMP/cs"
2656         rsh $HOST ":> $command_status"
2657         rsh $HOST "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin;
2658                     cd $RPWD; LUSTRE=\"$RLUSTRE\" sh -c \"$@\") ||
2659                     echo command failed >$command_status"
2660         [ -n "$($myPDSH $HOST cat $command_status)" ] && return 1 || true
2661         return 0
2662     fi
2663
2664     if $verbose ; then
2665         # print HOSTNAME for myPDSH="no_dsh"
2666         if [[ $myPDSH = no_dsh ]]; then
2667             $myPDSH $HOST "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" sh -c \"$@\")" | sed -e "s/^/${HOSTNAME}: /"
2668         else
2669             $myPDSH $HOST "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" sh -c \"$@\")"
2670         fi
2671     else
2672         $myPDSH $HOST "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" sh -c \"$@\")" | sed "s/^${HOST}: //"
2673     fi
2674     return ${PIPESTATUS[0]}
2675 }
2676
2677 do_nodev() {
2678     do_node --verbose "$@"
2679 }
2680
2681 single_local_node () {
2682    [ "$1" = "$HOSTNAME" ]
2683 }
2684
2685 # Outputs environment variable assignments that should be passed to remote nodes
2686 get_env_vars() {
2687         local var
2688         local value
2689         local facets=$(get_facets)
2690         local facet
2691
2692         for var in ${!MODOPTS_*}; do
2693                 value=${!var}
2694                 echo -n " ${var}=\"$value\""
2695         done
2696
2697         for facet in ${facets//,/ }; do
2698                 var=${facet}_FSTYPE
2699                 if [ -n "${!var}" ]; then
2700                         echo -n " $var=${!var}"
2701                 fi
2702         done
2703
2704         for var in MGSFSTYPE MDSFSTYPE OSTFSTYPE; do
2705                 if [ -n "${!var}" ]; then
2706                         echo -n " $var=${!var}"
2707                 fi
2708         done
2709
2710         if [ -n "$FSTYPE" ]; then
2711                 echo -n " FSTYPE=$FSTYPE"
2712         fi
2713 }
2714
2715 do_nodes() {
2716     local verbose=false
2717     # do not stripe off hostname if verbose, bug 19215
2718     if [ x$1 = x--verbose ]; then
2719         shift
2720         verbose=true
2721     fi
2722
2723     local rnodes=$1
2724     shift
2725
2726     if single_local_node $rnodes; then
2727         if $verbose; then
2728            do_nodev $rnodes "$@"
2729         else
2730            do_node $rnodes "$@"
2731         fi
2732         return $?
2733     fi
2734
2735     # This is part from do_node
2736     local myPDSH=$PDSH
2737
2738     [ -z "$myPDSH" -o "$myPDSH" = "no_dsh" -o "$myPDSH" = "rsh" ] && \
2739         echo "cannot run remote command on $rnodes with $myPDSH" && return 128
2740
2741     export FANOUT=$(get_node_count "${rnodes//,/ }")
2742     if $VERBOSE; then
2743         echo "CMD: $rnodes $@" >&2
2744         $myPDSH $rnodes "$LCTL mark \"$@\"" > /dev/null 2>&1 || :
2745     fi
2746
2747     # do not replace anything from pdsh output if -N is used
2748     # -N     Disable hostname: prefix on lines of output.
2749     if $verbose || [[ $myPDSH = *-N* ]]; then
2750         $myPDSH $rnodes "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" $(get_env_vars) sh -c \"$@\")"
2751     else
2752         $myPDSH $rnodes "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" $(get_env_vars) sh -c \"$@\")" | sed -re "s/^[^:]*: //g"
2753     fi
2754     return ${PIPESTATUS[0]}
2755 }
2756
2757 do_facet() {
2758     local facet=$1
2759     shift
2760     local HOST=`facet_active_host $facet`
2761     [ -z $HOST ] && echo No host defined for facet ${facet} && exit 1
2762     do_node $HOST "$@"
2763 }
2764
2765 # Function: do_facet_random_file $FACET $FILE $SIZE
2766 # Creates FILE with random content on the given FACET of given SIZE
2767
2768 do_facet_random_file() {
2769         local facet="$1"
2770         local fpath="$2"
2771         local fsize="$3"
2772         local cmd="dd if=/dev/urandom of='$fpath' bs=$fsize count=1"
2773         do_facet $facet "$cmd 2>/dev/null"
2774 }
2775
2776 do_facet_create_file() {
2777         local facet="$1"
2778         local fpath="$2"
2779         local fsize="$3"
2780         local cmd="dd if=/dev/zero of='$fpath' bs=$fsize count=1"
2781         do_facet $facet "$cmd 2>/dev/null"
2782 }
2783
2784 do_nodesv() {
2785     do_nodes --verbose "$@"
2786 }
2787
2788 add() {
2789         local facet=$1
2790         shift
2791         # make sure its not already running
2792         stop ${facet} -f
2793         rm -f $TMP/${facet}active
2794         [[ $facet = mds1 ]] && combined_mgs_mds && rm -f $TMP/mgsactive
2795         do_facet ${facet} $MKFS $* || return ${PIPESTATUS[0]}
2796
2797         if [[ $(facet_fstype $facet) == zfs ]]; then
2798                 #
2799                 # After formatting a ZFS target, "cachefile=none" property will
2800                 # be set on the ZFS storage pool so that the pool is not
2801                 # automatically imported on system startup. And then the pool
2802                 # will be exported so as to leave the importing and exporting
2803                 # operations handled by mount_facet() and stop() separately.
2804                 #
2805                 refresh_partition_table $facet $(facet_vdevice $facet)
2806                 disable_zpool_cache $facet
2807                 export_zpool $facet
2808         fi
2809 }
2810
2811 ostdevname() {
2812     num=$1
2813     DEVNAME=OSTDEV$num
2814
2815         local fstype=$(facet_fstype ost$num)
2816
2817         case $fstype in
2818                 ldiskfs )
2819                         #if $OSTDEVn isn't defined, default is $OSTDEVBASE + num
2820                         eval DEVPTR=${!DEVNAME:=${OSTDEVBASE}${num}};;
2821                 zfs )
2822                         #dataset name is independent of vdev device names
2823                         eval DEVPTR=${FSNAME}-ost${num}/ost${num};;
2824                 * )
2825                         error "unknown fstype!";;
2826         esac
2827
2828     echo -n $DEVPTR
2829 }
2830
2831 ostvdevname() {
2832         num=$1
2833         DEVNAME=OSTDEV$num
2834
2835         local fstype=$(facet_fstype ost$num)
2836
2837         case $fstype in
2838                 ldiskfs )
2839                         # vdevs are not supported by ldiskfs
2840                         eval VDEVPTR="";;
2841                 zfs )
2842                         #if $OSTDEVn isn't defined, default is $OSTDEVBASE + num
2843                         eval VDEVPTR=${!DEVNAME:=${OSTDEVBASE}${num}};;
2844                 * )
2845                         error "unknown fstype!";;
2846         esac
2847
2848         echo -n $VDEVPTR
2849 }
2850
2851 mdsdevname() {
2852     num=$1
2853     DEVNAME=MDSDEV$num
2854
2855         local fstype=$(facet_fstype mds$num)
2856
2857         case $fstype in
2858                 ldiskfs )
2859                         #if $MDSDEVn isn't defined, default is $MDSDEVBASE + num
2860                         eval DEVPTR=${!DEVNAME:=${MDSDEVBASE}${num}};;
2861                 zfs )
2862                         #dataset name is independent of vdev device names
2863                         eval DEVPTR=${FSNAME}-mdt${num}/mdt${num};;
2864                 * )
2865                         error "unknown fstype!";;
2866         esac
2867
2868         echo -n $DEVPTR
2869 }
2870
2871 mdsvdevname() {
2872         num=$1
2873         DEVNAME=MDSDEV$num
2874
2875         local fstype=$(facet_fstype mds$num)
2876
2877         case $fstype in
2878                 ldiskfs )
2879                         # vdevs are not supported by ldiskfs
2880                         eval VDEVPTR="";;
2881                 zfs )
2882                         #if $MDSDEVn isn't defined, default is $MDSDEVBASE + num
2883                         eval VDEVPTR=${!DEVNAME:=${MDSDEVBASE}${num}};;
2884                 * )
2885                         error "unknown fstype!";;
2886         esac
2887
2888         echo -n $VDEVPTR
2889 }
2890
2891 mgsdevname() {
2892         local DEVPTR
2893         local fstype=$(facet_fstype mgs)
2894
2895         case $fstype in
2896         ldiskfs )
2897                 if [ $(facet_host mgs) = $(facet_host mds1) ] &&
2898                    ( [ -z "$MGSDEV" ] || [ $MGSDEV = $(mdsdevname 1) ] ); then
2899                         DEVPTR=$(mdsdevname 1)
2900                 else
2901                         DEVPTR=$MGSDEV
2902                 fi;;
2903         zfs )
2904                 if [ $(facet_host mgs) = $(facet_host mds1) ] &&
2905                    ( [ -z "$MGSDEV" ] || [ $MGSDEV = $(mdsvdevname 1) ] ); then
2906                         DEVPTR=$(mdsdevname 1)
2907                 else
2908                         DEVPTR=${FSNAME}-mgs/mgs
2909                 fi;;
2910         * )
2911                 error "unknown fstype!";;
2912         esac
2913
2914         echo -n $DEVPTR
2915 }
2916
2917 mgsvdevname() {
2918         local VDEVPTR
2919         DEVNAME=MGSDEV
2920
2921         local fstype=$(facet_fstype mgs)
2922
2923         case $fstype in
2924         ldiskfs )
2925                 # vdevs are not supported by ldiskfs
2926                 ;;
2927         zfs )
2928                 if [ $(facet_host mgs) = $(facet_host mds1) ] &&
2929                    ( [ -z "$MGSDEV" ] || [ $MGSDEV = $(mdsvdevname 1) ] ); then
2930                         VDEVPTR=$(mdsvdevname 1)
2931                 else
2932                         VDEVPTR=$MGSDEV
2933                 fi;;
2934         * )
2935                 error "unknown fstype!";;
2936         esac
2937
2938         echo -n $VDEVPTR
2939 }
2940
2941 facet_mntpt () {
2942     local facet=$1
2943     [[ $facet = mgs ]] && combined_mgs_mds && facet="mds1"
2944
2945     local var=${facet}_MOUNT
2946     eval mntpt=${!var:-${MOUNT%/*}/$facet}
2947
2948     echo -n $mntpt
2949 }
2950
2951 ########
2952 ## MountConf setup
2953
2954 stopall() {
2955     # make sure we are using the primary server, so test-framework will
2956     # be able to clean up properly.
2957     activemds=`facet_active mds1`
2958     if [ $activemds != "mds1" ]; then
2959         fail mds1
2960     fi
2961
2962     local clients=$CLIENTS
2963     [ -z $clients ] && clients=$(hostname)
2964
2965     zconf_umount_clients $clients $MOUNT "$*" || true
2966     [ -n "$MOUNT2" ] && zconf_umount_clients $clients $MOUNT2 "$*" || true
2967
2968     [ "$CLIENTONLY" ] && return
2969     # The add fn does rm ${facet}active file, this would be enough
2970     # if we use do_facet <facet> only after the facet added, but
2971     # currently we use do_facet mds in local.sh
2972     for num in `seq $MDSCOUNT`; do
2973         stop mds$num -f
2974         rm -f ${TMP}/mds${num}active
2975     done
2976     combined_mgs_mds && rm -f $TMP/mgsactive
2977
2978     for num in `seq $OSTCOUNT`; do
2979         stop ost$num -f
2980         rm -f $TMP/ost${num}active
2981     done
2982
2983     if ! combined_mgs_mds ; then
2984         stop mgs
2985     fi
2986
2987     return 0
2988 }
2989
2990 cleanup_echo_devs () {
2991     local devs=$($LCTL dl | grep echo | awk '{print $4}')
2992
2993     for dev in $devs; do
2994         $LCTL --device $dev cleanup
2995         $LCTL --device $dev detach
2996     done
2997 }
2998
2999 cleanupall() {
3000     nfs_client_mode && return
3001
3002     stopall $*
3003     cleanup_echo_devs
3004
3005     unload_modules
3006     cleanup_gss
3007 }
3008
3009 combined_mgs_mds () {
3010         [[ "$(mdsdevname 1)" = "$(mgsdevname)" ]] &&
3011                 [[ "$(facet_host mds1)" = "$(facet_host mgs)" ]]
3012 }
3013
3014 lower() {
3015         echo -n "$1" | tr '[:upper:]' '[:lower:]'
3016 }
3017
3018 upper() {
3019         echo -n "$1" | tr '[:lower:]' '[:upper:]'
3020 }
3021
3022 mkfs_opts() {
3023         local facet=$1
3024         local dev=$2
3025         local fsname=${3:-"$FSNAME"}
3026         local type=$(facet_type $facet)
3027         local index=$(($(facet_number $facet) - 1))
3028         local fstype=$(facet_fstype $facet)
3029         local host=$(facet_host $facet)
3030         local opts
3031         local fs_mkfs_opts
3032         local var
3033
3034         if [ $type == MGS ] && combined_mgs_mds; then
3035                 return 1
3036         fi
3037
3038         if [ $type == MGS ] || ( [ $type == MDS ] &&
3039                                  [ "$dev" == $(mgsdevname) ] &&
3040                                  [ "$host" == "$(facet_host mgs)" ] ); then
3041                 opts="--mgs"
3042         else
3043                 opts="--mgsnode=$MGSNID"
3044         fi
3045
3046         if [ $type != MGS ]; then
3047                 opts+=" --fsname=$fsname --$(lower ${type/MDS/MDT}) \
3048                         --index=$index"
3049         fi
3050
3051         var=${facet}failover_HOST
3052         if [ -n "${!var}" ] && [ ${!var} != $(facet_host $facet) ]; then
3053                 opts+=" --failnode=$(h2$NETTYPE ${!var})"
3054         fi
3055
3056         opts+=${TIMEOUT:+" --param=sys.timeout=$TIMEOUT"}
3057         opts+=${LDLM_TIMEOUT:+" --param=sys.ldlm_timeout=$LDLM_TIMEOUT"}
3058
3059         if [ $type == MDS ]; then
3060                 opts+=${SECLEVEL:+" --param=mdt.sec_level"}
3061                 opts+=${MDSCAPA:+" --param-mdt.capa=$MDSCAPA"}
3062                 opts+=${STRIPE_BYTES:+" --param=lov.stripesize=$STRIPE_BYTES"}
3063                 opts+=${STRIPES_PER_OBJ:+" --param=lov.stripecount=$STRIPES_PER_OBJ"}
3064                 opts+=${L_GETIDENTITY:+" --param=mdt.identity_upcall=$L_GETIDENTITY"}
3065
3066                 if [ $fstype == ldiskfs ]; then
3067                         fs_mkfs_opts+=${MDSJOURNALSIZE:+" -J size=$MDSJOURNALSIZE"}
3068                         if [ ! -z $EJOURNAL ]; then
3069                                 fs_mkfs_opts+=${MDSJOURNALSIZE:+" device=$EJOURNAL"}
3070                         fi
3071                         fs_mkfs_opts+=${MDSISIZE:+" -i $MDSISIZE"}
3072                 fi
3073         fi
3074
3075         if [ $type == OST ]; then
3076                 opts+=${SECLEVEL:+" --param=ost.sec_level"}
3077                 opts+=${OSSCAPA:+" --param=ost.capa=$OSSCAPA"}
3078
3079                 if [ $fstype == ldiskfs ]; then
3080                         fs_mkfs_opts+=${OSTJOURNALSIZE:+" -J size=$OSTJOURNALSIZE"}
3081                 fi
3082         fi
3083
3084         opts+=" --backfstype=$fstype"
3085
3086         var=${type}SIZE
3087         if [ -n "${!var}" ]; then
3088                 opts+=" --device-size=${!var}"
3089         fi
3090
3091         var=$(upper $fstype)_MKFS_OPTS
3092         fs_mkfs_opts+=${!var:+" ${!var}"}
3093
3094         var=${type}_FS_MKFS_OPTS
3095         fs_mkfs_opts+=${!var:+" ${!var}"}
3096
3097         if [ -n "${fs_mkfs_opts## }" ]; then
3098                 opts+=" --mkfsoptions=\\\"${fs_mkfs_opts## }\\\""
3099         fi
3100
3101         var=${type}OPT
3102         opts+=${!var:+" ${!var}"}
3103
3104         echo -n "$opts"
3105 }
3106
3107 formatall() {
3108         local quiet
3109
3110         if ! $VERBOSE; then
3111                 quiet=yes
3112         fi
3113
3114         stopall
3115         # We need ldiskfs here, may as well load them all
3116         load_modules
3117         [ "$CLIENTONLY" ] && return
3118         echo Formatting mgs, mds, osts
3119         if ! combined_mgs_mds ; then
3120                 echo "Format mgs: $(mgsdevname)"
3121                 add mgs $(mkfs_opts mgs $(mgsdevname)) --reformat \
3122                         $(mgsdevname) $(mgsvdevname) ${quiet:+>/dev/null} ||
3123                         exit 10
3124         fi
3125
3126         for num in $(seq $MDSCOUNT); do
3127                 echo "Format mds$num: $(mdsdevname $num)"
3128                 add mds$num $(mkfs_opts mds$num $(mdsdevname ${num})) \
3129                         --reformat $(mdsdevname $num) $(mdsvdevname $num) \
3130                         ${quiet:+>/dev/null} || exit 10
3131         done
3132
3133         for num in $(seq $OSTCOUNT); do
3134                 echo "Format ost$num: $(ostdevname $num)"
3135                 add ost$num $(mkfs_opts ost$num $(ostdevname ${num})) \
3136                         --reformat $(ostdevname $num) $(ostvdevname ${num}) \
3137                         ${quiet:+>/dev/null} || exit 10
3138         done
3139 }
3140
3141 mount_client() {
3142     grep " $1 " /proc/mounts || zconf_mount $HOSTNAME $*
3143 }
3144
3145 umount_client() {
3146     grep " $1 " /proc/mounts && zconf_umount `hostname` $*
3147 }
3148
3149 # return value:
3150 # 0: success, the old identity set already.
3151 # 1: success, the old identity does not set.
3152 # 2: fail.
3153 switch_identity() {
3154     local num=$1
3155     local switch=$2
3156     local j=`expr $num - 1`
3157     local MDT="`(do_facet mds$num lctl get_param -N mdt.*MDT*$j 2>/dev/null | cut -d"." -f2 2>/dev/null) || true`"
3158
3159     if [ -z "$MDT" ]; then
3160         return 2
3161     fi
3162
3163     local old="`do_facet mds$num "lctl get_param -n mdt.$MDT.identity_upcall"`"
3164
3165     if $switch; then
3166         do_facet mds$num "lctl set_param -n mdt.$MDT.identity_upcall \"$L_GETIDENTITY\""
3167     else
3168         do_facet mds$num "lctl set_param -n mdt.$MDT.identity_upcall \"NONE\""
3169     fi
3170
3171     do_facet mds$num "lctl set_param -n mdt/$MDT/identity_flush=-1"
3172
3173     if [ $old = "NONE" ]; then
3174         return 1
3175     else
3176         return 0
3177     fi
3178 }
3179
3180 remount_client()
3181 {
3182         zconf_umount `hostname` $1 || error "umount failed"
3183         zconf_mount `hostname` $1 || error "mount failed"
3184 }
3185
3186 writeconf_facet() {
3187         local facet=$1
3188         local dev=$2
3189
3190         stop ${facet} -f
3191         rm -f $TMP/${facet}active
3192         do_facet ${facet} "$TUNEFS --quiet --writeconf $dev" || return 1
3193         return 0
3194 }
3195
3196 writeconf_all () {
3197         local mdt_count=${1:-$MDSCOUNT}
3198         local ost_count=${2:-$OSTCOUNT}
3199         local rc=0
3200
3201         for num in $(seq $mdt_count); do
3202                 DEVNAME=$(mdsdevname $num)
3203                 writeconf_facet mds$num $DEVNAME || rc=$?
3204         done
3205
3206         for num in $(seq $ost_count); do
3207                 DEVNAME=$(ostdevname $num)
3208                 writeconf_facet ost$num $DEVNAME || rc=$?
3209         done
3210         return $rc
3211 }
3212
3213 setupall() {
3214     nfs_client_mode && return
3215
3216     sanity_mount_check ||
3217         error "environments are insane!"
3218
3219     load_modules
3220
3221     if [ -z "$CLIENTONLY" ]; then
3222         echo Setup mgs, mdt, osts
3223         echo $WRITECONF | grep -q "writeconf" && \
3224             writeconf_all
3225         if ! combined_mgs_mds ; then
3226                         start mgs $(mgsdevname) $MGS_MOUNT_OPTS
3227         fi
3228
3229         for num in `seq $MDSCOUNT`; do
3230             DEVNAME=$(mdsdevname $num)
3231             start mds$num $DEVNAME $MDS_MOUNT_OPTS
3232
3233             # We started mds, now we should set failover variables properly.
3234             # Set mds${num}failover_HOST if it is not set (the default failnode).
3235             local varname=mds${num}failover_HOST
3236             if [ -z "${!varname}" ]; then
3237                 eval mds${num}failover_HOST=$(facet_host mds$num)
3238             fi
3239
3240             if [ $IDENTITY_UPCALL != "default" ]; then
3241                 switch_identity $num $IDENTITY_UPCALL
3242             fi
3243         done
3244         for num in `seq $OSTCOUNT`; do
3245             DEVNAME=$(ostdevname $num)
3246             start ost$num $DEVNAME $OST_MOUNT_OPTS
3247
3248             # We started ost$num, now we should set ost${num}failover variable properly.
3249             # Set ost${num}failover_HOST if it is not set (the default failnode).
3250             varname=ost${num}failover_HOST
3251             if [ -z "${!varname}" ]; then
3252                 eval ost${num}failover_HOST=$(facet_host ost${num})
3253             fi
3254
3255         done
3256     fi
3257
3258     init_gss
3259
3260     # wait a while to allow sptlrpc configuration be propogated to targets,
3261     # only needed when mounting new target devices.
3262     if $GSS; then
3263         sleep 10
3264     fi
3265
3266     [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
3267     mount_client $MOUNT
3268     [ -n "$CLIENTS" ] && zconf_mount_clients $CLIENTS $MOUNT
3269     clients_up
3270
3271     if [ "$MOUNT_2" ]; then
3272         mount_client $MOUNT2
3273         [ -n "$CLIENTS" ] && zconf_mount_clients $CLIENTS $MOUNT2
3274     fi
3275
3276     init_param_vars
3277
3278     # by remounting mdt before ost, initial connect from mdt to ost might
3279     # timeout because ost is not ready yet. wait some time to its fully
3280     # recovery. initial obd_connect timeout is 5s; in GSS case it's preceeded
3281     # by a context negotiation rpc with $TIMEOUT.
3282     # FIXME better by monitoring import status.
3283     if $GSS; then
3284         set_flavor_all $SEC
3285         sleep $((TIMEOUT + 5))
3286     else
3287         sleep 5
3288     fi
3289 }
3290
3291 mounted_lustre_filesystems() {
3292         awk '($3 ~ "lustre" && $1 ~ ":") { print $2 }' /proc/mounts
3293 }
3294
3295 init_facet_vars () {
3296         [ "$CLIENTONLY" ] && return 0
3297         local facet=$1
3298         shift
3299         local device=$1
3300
3301         shift
3302
3303         eval export ${facet}_dev=${device}
3304         eval export ${facet}_opt=\"$@\"
3305
3306         local dev=${facet}_dev
3307
3308         # We need to loop for the label
3309         # in case its not initialized yet.
3310         for wait_time in {0,1,3,5,10}; do
3311
3312                 if [ $wait_time -gt 0 ]; then
3313                         echo "${!dev} not yet initialized,"\
3314                                 "waiting ${wait_time} seconds."
3315                         sleep $wait_time
3316                 fi
3317
3318                 local label=$(devicelabel ${facet} ${!dev})
3319
3320                 # Check to make sure the label does
3321                 # not include ffff at the end of the label.
3322                 # This indicates it has not been initialized yet.
3323
3324                 if [[ $label =~ [f|F]{4}$ ]]; then
3325                         # label is not initialized, unset the result
3326                         # and either try again or fail
3327                         unset label
3328                 else
3329                         break
3330                 fi
3331         done
3332
3333         [ -z "$label" ] && echo no label for ${!dev} && exit 1
3334
3335         eval export ${facet}_svc=${label}
3336
3337         local varname=${facet}failover_HOST
3338         if [ -z "${!varname}" ]; then
3339                 eval export $varname=$(facet_host $facet)
3340         fi
3341
3342         varname=${facet}_HOST
3343         if [ -z "${!varname}" ]; then
3344                 eval export $varname=$(facet_host $facet)
3345         fi
3346
3347         # ${facet}failover_dev is set in cfg file
3348         varname=${facet}failover_dev
3349         if [ -n "${!varname}" ] ; then
3350                 eval export ${facet}failover_dev=${!varname}
3351         else
3352                 eval export ${facet}failover_dev=$device
3353         fi
3354
3355         # get mount point of already mounted device
3356         # is facet_dev is already mounted then use the real
3357         #  mount point of this facet; otherwise use $(facet_mntpt $facet)
3358         # i.e. ${facet}_MOUNT if specified by user or default
3359         local mntpt=$(do_facet ${facet} cat /proc/mounts | \
3360                         awk '"'${!dev}'" == $1 && $3 == "lustre" { print $2 }')
3361         if [ -z $mntpt ]; then
3362                 mntpt=$(facet_mntpt $facet)
3363         fi
3364         eval export ${facet}_MOUNT=$mntpt
3365 }
3366
3367 init_facets_vars () {
3368         local DEVNAME
3369
3370         if ! remote_mds_nodsh; then
3371                 for num in $(seq $MDSCOUNT); do
3372                         DEVNAME=`mdsdevname $num`
3373                         init_facet_vars mds$num $DEVNAME $MDS_MOUNT_OPTS
3374                 done
3375         fi
3376
3377         combined_mgs_mds || init_facet_vars mgs $(mgsdevname) $MGS_MOUNT_OPTS
3378
3379         if ! remote_ost_nodsh; then
3380                 for num in $(seq $OSTCOUNT); do
3381                         DEVNAME=$(ostdevname $num)
3382                         init_facet_vars ost$num $DEVNAME $OST_MOUNT_OPTS
3383                 done
3384         fi
3385 }
3386
3387 osc_ensure_active () {
3388     local facet=$1
3389     local timeout=$2
3390     local period=0
3391
3392     while [ $period -lt $timeout ]; do
3393         count=$(do_facet $facet "lctl dl | grep ' IN osc ' 2>/dev/null | wc -l")
3394         if [ $count -eq 0 ]; then
3395             break
3396         fi
3397
3398         echo "There are $count OST are inactive, wait $period seconds, and try again"
3399         sleep 3
3400         period=$((period+3))
3401     done
3402
3403     [ $period -lt $timeout ] || log "$count OST are inactive after $timeout seconds, give up"
3404 }
3405
3406 set_conf_param_and_check() {
3407         local myfacet=$1
3408         local TEST=$2
3409         local PARAM=$3
3410         local ORIG=$(do_facet $myfacet "$TEST")
3411         if [ $# -gt 3 ]; then
3412                 local FINAL=$4
3413         else
3414                 local -i FINAL
3415                 FINAL=$((ORIG + 5))
3416         fi
3417         echo "Setting $PARAM from $ORIG to $FINAL"
3418         do_facet mgs "$LCTL conf_param $PARAM='$FINAL'" ||
3419                 error "conf_param $PARAM failed"
3420
3421         wait_update $(facet_host $myfacet) "$TEST" "$FINAL" ||
3422                 error "check $PARAM failed!"
3423 }
3424
3425 init_param_vars () {
3426         remote_mds_nodsh ||
3427                 TIMEOUT=$(do_facet $SINGLEMDS "lctl get_param -n timeout")
3428
3429         log "Using TIMEOUT=$TIMEOUT"
3430
3431         osc_ensure_active $SINGLEMDS $TIMEOUT
3432         osc_ensure_active client $TIMEOUT
3433
3434         if [ -n "$(lctl get_param -n mdc.*.connect_flags|grep jobstats)" ]; then
3435                 local current_jobid_var=$($LCTL get_param -n jobid_var)
3436
3437                 if [ $JOBID_VAR = "existing" ]; then
3438                         echo "keeping jobstats as $current_jobid_var"
3439                 elif [ $current_jobid_var != $JOBID_VAR ]; then
3440                         echo "seting jobstats to $JOBID_VAR"
3441
3442                         set_conf_param_and_check client                 \
3443                                 "$LCTL get_param -n jobid_var"          \
3444                                 "$FSNAME.sys.jobid_var" $JOBID_VAR
3445                 fi
3446         else
3447                 echo "jobstats not supported by server"
3448         fi
3449
3450         if [ $QUOTA_AUTO -ne 0 ]; then
3451                 if [ "$ENABLE_QUOTA" ]; then
3452                         echo "enable quota as required"
3453                         setup_quota $MOUNT || return 2
3454                 else
3455                         echo "disable quota as required"
3456                         # $LFS quotaoff -ug $MOUNT > /dev/null 2>&1
3457                 fi
3458         fi
3459         return 0
3460 }
3461
3462 nfs_client_mode () {
3463     if [ "$NFSCLIENT" ]; then
3464         echo "NFSCLIENT mode: setup, cleanup, check config skipped"
3465         local clients=$CLIENTS
3466         [ -z $clients ] && clients=$(hostname)
3467
3468         # FIXME: remove hostname when 19215 fixed
3469         do_nodes $clients "echo \\\$(hostname); grep ' '$MOUNT' ' /proc/mounts"
3470         declare -a nfsexport=(`grep ' '$MOUNT' ' /proc/mounts | awk '{print $1}' | awk -F: '{print $1 " "  $2}'`)
3471         if [[ ${#nfsexport[@]} -eq 0 ]]; then
3472                 error_exit NFSCLIENT=$NFSCLIENT mode, but no NFS export found!
3473         fi
3474         do_nodes ${nfsexport[0]} "echo \\\$(hostname); df -T  ${nfsexport[1]}"
3475         return
3476     fi
3477     return 1
3478 }
3479
3480 check_config_client () {
3481     local mntpt=$1
3482
3483     local mounted=$(mount | grep " $mntpt ")
3484     if [ "$CLIENTONLY" ]; then
3485         # bug 18021
3486         # CLIENTONLY should not depend on *_HOST settings
3487         local mgc=$($LCTL device_list | awk '/MGC/ {print $4}')
3488         # in theory someone could create a new,
3489         # client-only config file that assumed lustre was already
3490         # configured and didn't set the MGSNID. If MGSNID is not set,
3491         # then we should use the mgs nid currently being used
3492         # as the default value. bug 18021
3493         [[ x$MGSNID = x ]] &&
3494             MGSNID=${mgc//MGC/}
3495
3496         if [[ x$mgc != xMGC$MGSNID ]]; then
3497             if [ "$mgs_HOST" ]; then
3498                 local mgc_ip=$(ping -q -c1 -w1 $mgs_HOST | grep PING | awk '{print $3}' | sed -e "s/(//g" -e "s/)//g")
3499 #                [[ x$mgc = xMGC$mgc_ip@$NETTYPE ]] ||
3500 #                    error_exit "MGSNID=$MGSNID, mounted: $mounted, MGC : $mgc"
3501             fi
3502         fi
3503         return 0
3504     fi
3505
3506     local myMGS_host=$mgs_HOST
3507     if [ "$NETTYPE" = "ptl" ]; then
3508         myMGS_host=$(h2ptl $mgs_HOST | sed -e s/@ptl//)
3509     fi
3510
3511     echo Checking config lustre mounted on $mntpt
3512     local mgshost=$(mount | grep " $mntpt " | awk -F@ '{print $1}')
3513     mgshost=$(echo $mgshost | awk -F: '{print $1}')
3514
3515 #    if [ "$mgshost" != "$myMGS_host" ]; then
3516 #            log "Bad config file: lustre is mounted with mgs $mgshost, but mgs_HOST=$mgs_HOST, NETTYPE=$NETTYPE
3517 #                   Please use correct config or set mds_HOST correctly!"
3518 #    fi
3519
3520 }
3521
3522 check_config_clients () {
3523         local clients=${CLIENTS:-$HOSTNAME}
3524         local mntpt=$1
3525
3526         nfs_client_mode && return
3527
3528         do_rpc_nodes "$clients" check_config_client $mntpt
3529
3530         sanity_mount_check || error "environments are insane!"
3531 }
3532
3533 check_timeout () {
3534     local mdstimeout=$(do_facet $SINGLEMDS "lctl get_param -n timeout")
3535     local cltimeout=$(lctl get_param -n timeout)
3536     if [ $mdstimeout -ne $TIMEOUT ] || [ $mdstimeout -ne $cltimeout ]; then
3537         error "timeouts are wrong! mds: $mdstimeout, client: $cltimeout, TIMEOUT=$TIMEOUT"
3538         return 1
3539     fi
3540 }
3541
3542 is_mounted () {
3543     local mntpt=$1
3544     [ -z $mntpt ] && return 1
3545     local mounted=$(mounted_lustre_filesystems)
3546
3547     echo $mounted' ' | grep -w -q $mntpt' '
3548 }
3549
3550 is_empty_dir() {
3551         [ $(find $1 -maxdepth 1 -print | wc -l) = 1 ] && return 0
3552         return 1
3553 }
3554
3555 # empty lustre filesystem may have empty directories lost+found and .lustre
3556 is_empty_fs() {
3557         # exclude .lustre & lost+found
3558         [ $(find $1 -maxdepth 1 -name lost+found -o -name .lustre -prune -o \
3559                 -print | wc -l) = 1 ] || return 1
3560         [ ! -d $1/lost+found ] || is_empty_dir $1/lost+found || return 1
3561         if [ $(lustre_version_code $SINGLEMDS) -gt $(version_code 2.4.0) ]; then
3562                 # exclude .lustre/fid (LU-2780)
3563                 [ $(find $1/.lustre -maxdepth 1 -name fid -prune -o \
3564                         -print | wc -l) = 1 ] || return 1
3565         else
3566                 [ ! -d $1/.lustre ] || is_empty_dir $1/.lustre || return 1
3567         fi
3568         return 0
3569 }
3570
3571 check_and_setup_lustre() {
3572     nfs_client_mode && return
3573
3574     local MOUNTED=$(mounted_lustre_filesystems)
3575
3576     local do_check=true
3577     # 1.
3578     # both MOUNT and MOUNT2 are not mounted
3579     if ! is_mounted $MOUNT && ! is_mounted $MOUNT2; then
3580         [ "$REFORMAT" ] && formatall
3581         # setupall mounts both MOUNT and MOUNT2 (if MOUNT_2 is set)
3582         setupall
3583         is_mounted $MOUNT || error "NAME=$NAME not mounted"
3584         export I_MOUNTED=yes
3585         do_check=false
3586     # 2.
3587     # MOUNT2 is mounted
3588     elif is_mounted $MOUNT2; then
3589             # 3.
3590             # MOUNT2 is mounted, while MOUNT_2 is not set
3591             if ! [ "$MOUNT_2" ]; then
3592                 cleanup_mount $MOUNT2
3593                 export I_UMOUNTED2=yes
3594
3595             # 4.
3596             # MOUNT2 is mounted, MOUNT_2 is set
3597             else
3598                 # FIXME: what to do if check_config failed?
3599                 # i.e. if:
3600                 # 1) remote client has mounted other Lustre fs ?
3601                 # 2) it has insane env ?
3602                 # let's try umount MOUNT2 on all clients and mount it again:
3603                 if ! check_config_clients $MOUNT2; then
3604                     cleanup_mount $MOUNT2
3605                     restore_mount $MOUNT2
3606                     export I_MOUNTED2=yes
3607                 fi
3608             fi
3609
3610     # 5.
3611     # MOUNT is mounted MOUNT2 is not mounted
3612     elif [ "$MOUNT_2" ]; then
3613         restore_mount $MOUNT2
3614         export I_MOUNTED2=yes
3615     fi
3616
3617     if $do_check; then
3618         # FIXME: what to do if check_config failed?
3619         # i.e. if:
3620         # 1) remote client has mounted other Lustre fs?
3621         # 2) lustre is mounted on remote_clients atall ?
3622         check_config_clients $MOUNT
3623         init_facets_vars
3624         init_param_vars
3625
3626         set_default_debug_nodes $(comma_list $(nodes_list))
3627     fi
3628
3629         if [ $(lower $OSD_TRACK_DECLARES_LBUG) == 'yes' ] ; then
3630                 local facets="$(get_facets OST),$(get_facets MDS),mgs"
3631                 local nodes="$(facets_hosts ${facets})"
3632                 if [ -n "$nodes" ] ; then
3633                         do_nodes $nodes "$LCTL set_param \
3634                                  osd-ldiskfs.track_declares_assert=1 || true"
3635                 fi
3636         fi
3637
3638         init_gss
3639         if $GSS; then
3640                 set_flavor_all $SEC
3641         fi
3642
3643         if [ "$ONLY" == "setup" ]; then
3644                 exit 0
3645         fi
3646 }
3647
3648 restore_mount () {
3649    local clients=${CLIENTS:-$HOSTNAME}
3650    local mntpt=$1
3651
3652    zconf_mount_clients $clients $mntpt
3653 }
3654
3655 cleanup_mount () {
3656     local clients=${CLIENTS:-$HOSTNAME}
3657     local mntpt=$1
3658
3659     zconf_umount_clients $clients $mntpt
3660 }
3661
3662 cleanup_and_setup_lustre() {
3663     if [ "$ONLY" == "cleanup" -o "`mount | grep $MOUNT`" ]; then
3664         lctl set_param debug=0 || true
3665         cleanupall
3666         if [ "$ONLY" == "cleanup" ]; then
3667             exit 0
3668         fi
3669     fi
3670     check_and_setup_lustre
3671 }
3672
3673 # Get all of the server target devices from a given server node and type.
3674 get_mnt_devs() {
3675         local node=$1
3676         local type=$2
3677         local devs
3678         local dev
3679
3680         if [ "$type" == ost ]; then
3681                 devs=$(get_osd_param $node "" mntdev)
3682         else
3683                 devs=$(do_node $node \
3684                        "lctl get_param -n osd-*.$FSNAME-M*.mntdev")
3685         fi
3686         for dev in $devs; do
3687                 case $dev in
3688                 *loop*) do_node $node "losetup $dev" | \
3689                                 sed -e "s/.*(//" -e "s/).*//" ;;
3690                 *) echo $dev ;;
3691                 esac
3692         done
3693 }
3694
3695 # Get all of the server target devices.
3696 get_svr_devs() {
3697     local i
3698
3699     # MDT device
3700     MDTDEV=$(get_mnt_devs $(mdts_nodes) mdt)
3701
3702     # OST devices
3703     i=0
3704     for node in $(osts_nodes); do
3705         OSTDEVS[i]=$(get_mnt_devs $node ost)
3706         i=$((i + 1))
3707     done
3708 }
3709
3710 # Run e2fsck on MDT or OST device.
3711 run_e2fsck() {
3712     local node=$1
3713     local target_dev=$2
3714     local extra_opts=$3
3715
3716     df > /dev/null      # update statfs data on disk
3717     local cmd="$E2FSCK -d -v -t -t -f $extra_opts $target_dev"
3718     echo $cmd
3719     local rc=0
3720     do_node $node $cmd || rc=$?
3721     [ $rc -le $FSCK_MAX_ERR ] || \
3722         error "$cmd returned $rc, should be <= $FSCK_MAX_ERR"
3723     return 0
3724 }
3725
3726 # verify a directory is shared among nodes.
3727 check_shared_dir() {
3728         local dir=$1
3729
3730         [ -z "$dir" ] && return 1
3731         do_rpc_nodes "$(comma_list $(nodes_list))" check_logdir $dir
3732         check_write_access $dir || return 1
3733         return 0
3734 }
3735
3736 # Run e2fsck on MDT and OST(s) to generate databases used for lfsck.
3737 generate_db() {
3738     local i
3739     local ostidx
3740     local dev
3741
3742         [[ $(lustre_version_code $SINGLEMDS) -ne $(version_code 2.2.0) ]] ||
3743                 { skip "Lustre 2.2.0 lacks the patch for LU-1255"; exit 0; }
3744
3745     check_shared_dir $SHARED_DIRECTORY ||
3746         error "$SHARED_DIRECTORY isn't a shared directory"
3747
3748     export MDSDB=$SHARED_DIRECTORY/mdsdb
3749     export OSTDB=$SHARED_DIRECTORY/ostdb
3750
3751     [ $MDSCOUNT -eq 1 ] || error "CMD is not supported"
3752
3753     run_e2fsck $(mdts_nodes) $MDTDEV "-n --mdsdb $MDSDB"
3754
3755     i=0
3756     ostidx=0
3757     OSTDB_LIST=""
3758     for node in $(osts_nodes); do
3759         for dev in ${OSTDEVS[i]}; do
3760             run_e2fsck $node $dev "-n --mdsdb $MDSDB --ostdb $OSTDB-$ostidx"
3761             OSTDB_LIST="$OSTDB_LIST $OSTDB-$ostidx"
3762             ostidx=$((ostidx + 1))
3763         done
3764         i=$((i + 1))
3765     done
3766 }
3767
3768 # Run lfsck on server node if lfsck can't be found on client (LU-2571)
3769 run_lfsck_remote() {
3770         local cmd="$LFSCK_BIN -c -l --mdsdb $MDSDB --ostdb $OSTDB_LIST $MOUNT"
3771         local client=$1
3772         local mounted=true
3773         local rc=0
3774
3775         #Check if lustre is already mounted
3776         do_rpc_nodes $client is_mounted $MOUNT || mounted=false
3777         if ! $mounted; then
3778                 zconf_mount $client $MOUNT ||
3779                         error "failed to mount Lustre on $client"
3780         fi
3781         #Run lfsck
3782         echo $cmd
3783         do_node $node $cmd || rc=$?
3784         #Umount if necessary
3785         if ! $mounted; then
3786                 zconf_umount $client $MOUNT ||
3787                         error "failed to unmount Lustre on $client"
3788         fi
3789
3790         [ $rc -le $FSCK_MAX_ERR ] ||
3791                 error "$cmd returned $rc, should be <= $FSCK_MAX_ERR"
3792         echo "lfsck finished with rc=$rc"
3793
3794         return $rc
3795 }
3796
3797 run_lfsck() {
3798         local facets="client $SINGLEMDS"
3799         local found=false
3800         local facet
3801         local node
3802         local rc=0
3803
3804         for facet in $facets; do
3805                 node=$(facet_active_host $facet)
3806                 if check_progs_installed $node $LFSCK_BIN; then
3807                         found=true
3808                         break
3809                 fi
3810         done
3811         ! $found && error "None of \"$facets\" supports lfsck"
3812
3813         run_lfsck_remote $node || rc=$?
3814
3815         rm -rvf $MDSDB* $OSTDB* || true
3816         return $rc
3817 }
3818
3819 check_and_cleanup_lustre() {
3820     if [ "$LFSCK_ALWAYS" = "yes" -a "$TESTSUITE" != "lfsck" ]; then
3821         get_svr_devs
3822         generate_db
3823         run_lfsck
3824     fi
3825
3826         if is_mounted $MOUNT; then
3827                 [ -n "$DIR" ] && rm -rf $DIR/[Rdfs][0-9]* ||
3828                         error "remove sub-test dirs failed"
3829                 [ "$ENABLE_QUOTA" ] && restore_quota || true
3830         fi
3831
3832     if [ "$I_UMOUNTED2" = "yes" ]; then
3833         restore_mount $MOUNT2 || error "restore $MOUNT2 failed"
3834     fi
3835
3836     if [ "$I_MOUNTED2" = "yes" ]; then
3837         cleanup_mount $MOUNT2
3838     fi
3839
3840     if [ "$I_MOUNTED" = "yes" ]; then
3841         cleanupall -f || error "cleanup failed"
3842         unset I_MOUNTED
3843     fi
3844 }
3845
3846 #######
3847 # General functions
3848
3849 wait_for_function () {
3850     local quiet=""
3851
3852     # suppress fn both stderr and stdout
3853     if [ "$1" = "--quiet" ]; then
3854         shift
3855         quiet=" > /dev/null 2>&1"
3856
3857     fi
3858
3859     local fn=$1
3860     local max=${2:-900}
3861     local sleep=${3:-5}
3862
3863     local wait=0
3864
3865     while true; do
3866
3867         eval $fn $quiet && return 0
3868
3869         wait=$((wait + sleep))
3870         [ $wait -lt $max ] || return 1
3871         echo waiting $fn, $((max - wait)) secs left ...
3872         sleep $sleep
3873     done
3874 }
3875
3876 check_network() {
3877     local host=$1
3878     local max=$2
3879     local sleep=${3:-5}
3880
3881     echo `date +"%H:%M:%S (%s)"` waiting for $host network $max secs ...
3882     if ! wait_for_function --quiet "ping -c 1 -w 3 $host" $max $sleep ; then
3883         echo "Network not available!"
3884         exit 1
3885     fi
3886
3887     echo `date +"%H:%M:%S (%s)"` network interface is UP
3888 }
3889
3890 no_dsh() {
3891     shift
3892     eval $@
3893 }
3894
3895 # Convert a space-delimited list to a comma-delimited list.  If the input is
3896 # only whitespace, ensure the output is empty (i.e. "") so [ -n $list ] works
3897 comma_list() {
3898         # echo is used to convert newlines to spaces, since it doesn't
3899         # introduce a trailing space as using "tr '\n' ' '" does
3900         echo $(tr -s " " "\n" <<< $* | sort -b -u) | tr ' ' ','
3901 }
3902
3903 list_member () {
3904     local list=$1
3905     local item=$2
3906     echo $list | grep -qw $item
3907 }
3908
3909 # list, excluded are the comma separated lists
3910 exclude_items_from_list () {
3911     local list=$1
3912     local excluded=$2
3913     local item
3914
3915     list=${list//,/ }
3916     for item in ${excluded//,/ }; do
3917         list=$(echo " $list " | sed -re "s/\s+$item\s+/ /g")
3918     done
3919     echo $(comma_list $list)
3920 }
3921
3922 # list, expand  are the comma separated lists
3923 expand_list () {
3924     local list=${1//,/ }
3925     local expand=${2//,/ }
3926     local expanded=
3927
3928     expanded=$(for i in $list $expand; do echo $i; done | sort -u)
3929     echo $(comma_list $expanded)
3930 }
3931
3932 testslist_filter () {
3933     local script=$LUSTRE/tests/${TESTSUITE}.sh
3934
3935     [ -f $script ] || return 0
3936
3937     local start_at=$START_AT
3938     local stop_at=$STOP_AT
3939
3940     local var=${TESTSUITE//-/_}_START_AT
3941     [ x"${!var}" != x ] && start_at=${!var}
3942     var=${TESTSUITE//-/_}_STOP_AT
3943     [ x"${!var}" != x ] && stop_at=${!var}
3944
3945     sed -n 's/^test_\([^ (]*\).*/\1/p' $script | \
3946         awk ' BEGIN { if ("'${start_at:-0}'" != 0) flag = 1 }
3947             /^'${start_at}'$/ {flag = 0}
3948             {if (flag == 1) print $0}
3949             /^'${stop_at}'$/ { flag = 1 }'
3950 }
3951
3952 absolute_path() {
3953     (cd `dirname $1`; echo $PWD/`basename $1`)
3954 }
3955
3956 get_facets () {
3957     local types=${1:-"OST MDS MGS"}
3958
3959     local list=""
3960
3961     for entry in $types; do
3962         local name=$(echo $entry | tr "[:upper:]" "[:lower:]")
3963         local type=$(echo $entry | tr "[:lower:]" "[:upper:]")
3964
3965         case $type in
3966                 MGS ) list="$list $name";;
3967             MDS|OST ) local count=${type}COUNT
3968                        for ((i=1; i<=${!count}; i++)) do
3969                           list="$list ${name}$i"
3970                       done;;
3971                   * ) error "Invalid facet type"
3972                  exit 1;;
3973         esac
3974     done
3975     echo $(comma_list $list)
3976 }
3977
3978 ##################################
3979 # Adaptive Timeouts funcs
3980
3981 at_is_enabled() {
3982     # only check mds, we assume at_max is the same on all nodes
3983     local at_max=$(do_facet $SINGLEMDS "lctl get_param -n at_max")
3984     if [ $at_max -eq 0 ]; then
3985         return 1
3986     else
3987         return 0
3988     fi
3989 }
3990
3991 at_get() {
3992     local facet=$1
3993     local at=$2
3994
3995     # suppose that all ost-s have the same $at value set
3996     [ $facet != "ost" ] || facet=ost1
3997
3998     do_facet $facet "lctl get_param -n $at"
3999 }
4000
4001 at_max_get() {
4002     at_get $1 at_max
4003 }
4004
4005 at_min_get() {
4006         at_get $1 at_min
4007 }
4008
4009 at_max_set() {
4010     local at_max=$1
4011     shift
4012
4013     local facet
4014     local hosts
4015     for facet in $@; do
4016         if [ $facet == "ost" ]; then
4017             facet=$(get_facets OST)
4018         elif [ $facet == "mds" ]; then
4019             facet=$(get_facets MDS)
4020         fi
4021         hosts=$(expand_list $hosts $(facets_hosts $facet))
4022     done
4023
4024     do_nodes $hosts lctl set_param at_max=$at_max
4025 }
4026
4027 ##################################
4028 # OBD_FAIL funcs
4029
4030 drop_request() {
4031 # OBD_FAIL_MDS_ALL_REQUEST_NET
4032     RC=0
4033     do_facet $SINGLEMDS lctl set_param fail_loc=0x123
4034     do_facet client "$1" || RC=$?
4035     do_facet $SINGLEMDS lctl set_param fail_loc=0
4036     return $RC
4037 }
4038
4039 drop_reply() {
4040 # OBD_FAIL_MDS_ALL_REPLY_NET
4041     RC=0
4042     do_facet $SINGLEMDS lctl set_param fail_loc=0x122
4043     do_facet client "$@" || RC=$?
4044     do_facet $SINGLEMDS lctl set_param fail_loc=0
4045     return $RC
4046 }
4047
4048 drop_reint_reply() {
4049 # OBD_FAIL_MDS_REINT_NET_REP
4050     RC=0
4051     do_facet $SINGLEMDS lctl set_param fail_loc=0x119
4052     do_facet client "$@" || RC=$?
4053     do_facet $SINGLEMDS lctl set_param fail_loc=0
4054     return $RC
4055 }
4056
4057 drop_update_reply() {
4058 # OBD_FAIL_UPDATE_OBJ_NET_REP
4059         local index=$1
4060         shift 1
4061         RC=0
4062         do_facet mds${index} lctl set_param fail_loc=0x1701
4063         do_facet client "$@" || RC=$?
4064         do_facet mds${index} lctl set_param fail_loc=0
4065         return $RC
4066 }
4067
4068 pause_bulk() {
4069 #define OBD_FAIL_OST_BRW_PAUSE_BULK      0x214
4070     RC=0
4071     do_facet ost1 lctl set_param fail_loc=0x214
4072     do_facet client "$1" || RC=$?
4073     do_facet client "sync"
4074     do_facet ost1 lctl set_param fail_loc=0
4075     return $RC
4076 }
4077
4078 drop_ldlm_cancel() {
4079 #define OBD_FAIL_LDLM_CANCEL_NET                        0x304
4080         local RC=0
4081         local list=$(comma_list $(mdts_nodes) $(osts_nodes))
4082         do_nodes $list lctl set_param fail_loc=0x304
4083
4084         do_facet client "$@" || RC=$?
4085
4086         do_nodes $list lctl set_param fail_loc=0
4087         return $RC
4088 }
4089
4090 drop_bl_callback() {
4091 #define OBD_FAIL_LDLM_BL_CALLBACK_NET                   0x305
4092         RC=0
4093         do_facet client lctl set_param fail_loc=0x80000305
4094         do_facet client "$@" || RC=$?
4095         do_facet client lctl set_param fail_loc=0
4096         return $RC
4097 }
4098
4099 drop_ldlm_reply() {
4100 #define OBD_FAIL_LDLM_REPLY              0x30c
4101     RC=0
4102     do_facet $SINGLEMDS lctl set_param fail_loc=0x30c
4103     do_facet client "$@" || RC=$?
4104     do_facet $SINGLEMDS lctl set_param fail_loc=0
4105     return $RC
4106 }
4107
4108 clear_failloc() {
4109     facet=$1
4110     pause=$2
4111     sleep $pause
4112     echo "clearing fail_loc on $facet"
4113     do_facet $facet "lctl set_param fail_loc=0 2>/dev/null || true"
4114 }
4115
4116 set_nodes_failloc () {
4117     do_nodes $(comma_list $1)  lctl set_param fail_loc=$2
4118 }
4119
4120 cancel_lru_locks() {
4121     $LCTL mark "cancel_lru_locks $1 start"
4122     for d in `lctl get_param -N ldlm.namespaces.*.lru_size | egrep -i $1`; do
4123         $LCTL set_param -n $d=clear
4124     done
4125     $LCTL get_param ldlm.namespaces.*.lock_unused_count | egrep -i $1 | grep -v '=0'
4126     $LCTL mark "cancel_lru_locks $1 stop"
4127 }
4128
4129 default_lru_size()
4130 {
4131         NR_CPU=$(grep -c "processor" /proc/cpuinfo)
4132         DEFAULT_LRU_SIZE=$((100 * NR_CPU))
4133         echo "$DEFAULT_LRU_SIZE"
4134 }
4135
4136 lru_resize_enable()
4137 {
4138     lctl set_param ldlm.namespaces.*$1*.lru_size=0
4139 }
4140
4141 lru_resize_disable()
4142 {
4143     lctl set_param ldlm.namespaces.*$1*.lru_size $(default_lru_size)
4144 }
4145
4146 pgcache_empty() {
4147     local FILE
4148     for FILE in `lctl get_param -N "llite.*.dump_page_cache"`; do
4149         if [ `lctl get_param -n $FILE | wc -l` -gt 1 ]; then
4150             echo there is still data in page cache $FILE ?
4151             lctl get_param -n $FILE
4152             return 1
4153         fi
4154     done
4155     return 0
4156 }
4157
4158 debugsave() {
4159     DEBUGSAVE="$(lctl get_param -n debug)"
4160 }
4161
4162 debugrestore() {
4163     [ -n "$DEBUGSAVE" ] && \
4164         do_nodes $(comma_list $(nodes_list)) "$LCTL set_param debug=\\\"${DEBUGSAVE}\\\";"
4165     DEBUGSAVE=""
4166 }
4167
4168 debug_size_save() {
4169     DEBUG_SIZE_SAVED="$(lctl get_param -n debug_mb)"
4170 }
4171
4172 debug_size_restore() {
4173     [ -n "$DEBUG_SIZE_SAVED" ] && \
4174         do_nodes $(comma_list $(nodes_list)) "$LCTL set_param debug_mb=$DEBUG_SIZE_SAVED"
4175     DEBUG_SIZE_SAVED=""
4176 }
4177
4178 start_full_debug_logging() {
4179     debugsave
4180     debug_size_save
4181
4182     local FULLDEBUG=-1
4183     local DEBUG_SIZE=150
4184
4185     do_nodes $(comma_list $(nodes_list)) "$LCTL set_param debug_mb=$DEBUG_SIZE"
4186     do_nodes $(comma_list $(nodes_list)) "$LCTL set_param debug=$FULLDEBUG;"
4187 }
4188
4189 stop_full_debug_logging() {
4190     debug_size_restore
4191     debugrestore
4192 }
4193
4194 # prints bash call stack
4195 log_trace_dump() {
4196         echo "  Trace dump:"
4197         for (( i=1; i < ${#BASH_LINENO[*]} ; i++ )) ; do
4198                 local s=${BASH_SOURCE[$i]}
4199                 local l=${BASH_LINENO[$i-1]}
4200                 local f=${FUNCNAME[$i]}
4201                 echo "  = $s:$l:$f()"
4202         done
4203 }
4204
4205 ##################################
4206 # Test interface
4207 ##################################
4208
4209 error_noexit() {
4210         local TYPE=${TYPE:-"FAIL"}
4211
4212         local dump=true
4213         # do not dump logs if $1=false
4214         if [ "x$1" = "xfalse" ]; then
4215                 shift
4216                 dump=false
4217         fi
4218
4219
4220         log " ${TESTSUITE} ${TESTNAME}: @@@@@@ ${TYPE}: $@ "
4221         log_trace_dump
4222
4223         mkdir -p $LOGDIR
4224         # We need to dump the logs on all nodes
4225         if $dump; then
4226                 gather_logs $(comma_list $(nodes_list))
4227         fi
4228
4229         debugrestore
4230         [ "$TESTSUITELOG" ] &&
4231                 echo "$TESTSUITE: $TYPE: $TESTNAME $@" >> $TESTSUITELOG
4232         if [ -z "$*" ]; then
4233                 echo "error() without useful message, please fix" > $LOGDIR/err
4234         else
4235                 echo "$@" > $LOGDIR/err
4236         fi
4237 }
4238
4239 exit_status () {
4240         local status=0
4241         local log=$TESTSUITELOG
4242
4243         [ -f "$log" ] && grep -q FAIL $log && status=1
4244         exit $status
4245 }
4246
4247 error() {
4248         error_noexit "$@"
4249         exit 1
4250 }
4251
4252 error_exit() {
4253         error "$@"
4254 }
4255
4256 # use only if we are ignoring failures for this test, bugno required.
4257 # (like ALWAYS_EXCEPT, but run the test and ignore the results.)
4258 # e.g. error_ignore 5494 "your message"
4259 error_ignore() {
4260         local TYPE="IGNORE (bz$1)"
4261         shift
4262         error_noexit "$@"
4263 }
4264
4265 error_and_remount() {
4266         error_noexit "$@"
4267         remount_client $MOUNT
4268         exit 1
4269 }
4270
4271 skip_env () {
4272         $FAIL_ON_SKIP_ENV && error false $@ || skip $@
4273 }
4274
4275 skip() {
4276         echo
4277         log " SKIP: $TESTSUITE $TESTNAME $@"
4278
4279         if [[ -n "$ALWAYS_SKIPPED" ]]; then
4280                 skip_logged $TESTNAME "$@"
4281         else
4282                 mkdir -p $LOGDIR
4283                 echo "$@" > $LOGDIR/skip
4284         fi
4285
4286         [[ -n "$TESTSUITELOG" ]] &&
4287                 echo "$TESTSUITE: SKIP: $TESTNAME $@" >> $TESTSUITELOG || true
4288 }
4289
4290 build_test_filter() {
4291     EXCEPT="$EXCEPT $(testslist_filter)"
4292
4293     [ "$ONLY" ] && log "only running test `echo $ONLY`"
4294     for O in $ONLY; do
4295         eval ONLY_${O}=true
4296     done
4297     [ "$EXCEPT$ALWAYS_EXCEPT" ] && \
4298         log "excepting tests: `echo $EXCEPT $ALWAYS_EXCEPT`"
4299     [ "$EXCEPT_SLOW" ] && \
4300         log "skipping tests SLOW=no: `echo $EXCEPT_SLOW`"
4301     for E in $EXCEPT; do
4302         eval EXCEPT_${E}=true
4303     done
4304     for E in $ALWAYS_EXCEPT; do
4305         eval EXCEPT_ALWAYS_${E}=true
4306     done
4307     for E in $EXCEPT_SLOW; do
4308         eval EXCEPT_SLOW_${E}=true
4309     done
4310     for G in $GRANT_CHECK_LIST; do
4311         eval GCHECK_ONLY_${G}=true
4312         done
4313 }
4314
4315 basetest() {
4316     if [[ $1 = [a-z]* ]]; then
4317         echo $1
4318     else
4319         echo ${1%%[a-z]*}
4320     fi
4321 }
4322
4323 # print a newline if the last test was skipped
4324 export LAST_SKIPPED=
4325 export ALWAYS_SKIPPED=
4326 #
4327 # Main entry into test-framework. This is called with the name and
4328 # description of a test. The name is used to find the function to run
4329 # the test using "test_$name".
4330 #
4331 # This supports a variety of methods of specifying specific test to
4332 # run or not run.  These need to be documented...
4333 #
4334 run_test() {
4335     assert_DIR
4336
4337     export base=`basetest $1`
4338     if [ ! -z "$ONLY" ]; then
4339         testname=ONLY_$1
4340         if [ ${!testname}x != x ]; then
4341             [ "$LAST_SKIPPED" ] && echo "" && LAST_SKIPPED=
4342             run_one_logged $1 "$2"
4343             return $?
4344         fi
4345         testname=ONLY_$base
4346         if [ ${!testname}x != x ]; then
4347             [ "$LAST_SKIPPED" ] && echo "" && LAST_SKIPPED=
4348             run_one_logged $1 "$2"
4349             return $?
4350         fi
4351         LAST_SKIPPED="y"
4352         return 0
4353     fi
4354
4355         LAST_SKIPPED="y"
4356         ALWAYS_SKIPPED="y"
4357     testname=EXCEPT_$1
4358     if [ ${!testname}x != x ]; then
4359         TESTNAME=test_$1 skip "skipping excluded test $1"
4360         return 0
4361     fi
4362     testname=EXCEPT_$base
4363     if [ ${!testname}x != x ]; then
4364         TESTNAME=test_$1 skip "skipping excluded test $1 (base $base)"
4365         return 0
4366     fi
4367     testname=EXCEPT_ALWAYS_$1
4368     if [ ${!testname}x != x ]; then
4369         TESTNAME=test_$1 skip "skipping ALWAYS excluded test $1"
4370         return 0
4371     fi
4372     testname=EXCEPT_ALWAYS_$base
4373     if [ ${!testname}x != x ]; then
4374         TESTNAME=test_$1 skip "skipping ALWAYS excluded test $1 (base $base)"
4375         return 0
4376     fi
4377     testname=EXCEPT_SLOW_$1
4378     if [ ${!testname}x != x ]; then
4379         TESTNAME=test_$1 skip "skipping SLOW test $1"
4380         return 0
4381     fi
4382     testname=EXCEPT_SLOW_$base
4383     if [ ${!testname}x != x ]; then
4384         TESTNAME=test_$1 skip "skipping SLOW test $1 (base $base)"
4385         return 0
4386     fi
4387
4388     LAST_SKIPPED=
4389     ALWAYS_SKIPPED=
4390     run_one_logged $1 "$2"
4391
4392     return $?
4393 }
4394
4395 log() {
4396     echo "$*"
4397     module_loaded lnet || load_modules
4398
4399     local MSG="$*"
4400     # Get rid of '
4401     MSG=${MSG//\'/\\\'}
4402     MSG=${MSG//\(/\\\(}
4403     MSG=${MSG//\)/\\\)}
4404     MSG=${MSG//\;/\\\;}
4405     MSG=${MSG//\|/\\\|}
4406     MSG=${MSG//\>/\\\>}
4407     MSG=${MSG//\</\\\<}
4408     MSG=${MSG//\//\\\/}
4409     do_nodes $(comma_list $(nodes_list)) $LCTL mark "$MSG" 2> /dev/null || true
4410 }
4411
4412 trace() {
4413         log "STARTING: $*"
4414         strace -o $TMP/$1.strace -ttt $*
4415         RC=$?
4416         log "FINISHED: $*: rc $RC"
4417         return 1
4418 }
4419
4420 complete () {
4421     local duration=$1
4422
4423     banner test complete, duration $duration sec
4424     [ -f "$TESTSUITELOG" ] && egrep .FAIL $TESTSUITELOG || true
4425     echo duration $duration >>$TESTSUITELOG
4426 }
4427
4428 pass() {
4429         # Set TEST_STATUS here. It will be used for logging the result.
4430         TEST_STATUS="PASS"
4431
4432         if [[ -f $LOGDIR/err ]]; then
4433                 TEST_STATUS="FAIL"
4434         elif [[ -f $LOGDIR/skip ]]; then
4435                 TEST_STATUS="SKIP"
4436         fi
4437         echo "$TEST_STATUS $@" 2>&1 | tee -a $TESTSUITELOG
4438 }
4439
4440 check_mds() {
4441     local FFREE=$(do_node $SINGLEMDS \
4442         lctl get_param -n osd*.*MDT*.filesfree | calc_sum)
4443     local FTOTAL=$(do_node $SINGLEMDS \
4444         lctl get_param -n osd*.*MDT*.filestotal | calc_sum)
4445
4446     [ $FFREE -ge $FTOTAL ] && error "files free $FFREE > total $FTOTAL" || true
4447 }
4448
4449 reset_fail_loc () {
4450     echo -n "Resetting fail_loc on all nodes..."
4451     do_nodes $(comma_list $(nodes_list)) "lctl set_param -n fail_loc=0 2>/dev/null || true"
4452     echo done.
4453 }
4454
4455
4456 #
4457 # Log a message (on all nodes) padded with "=" before and after.
4458 # Also appends a timestamp and prepends the testsuite name.
4459 #
4460
4461 EQUALS="===================================================================================================="
4462 banner() {
4463     msg="== ${TESTSUITE} $*"
4464     last=${msg: -1:1}
4465     [[ $last != "=" && $last != " " ]] && msg="$msg "
4466     msg=$(printf '%s%.*s'  "$msg"  $((${#EQUALS} - ${#msg})) $EQUALS )
4467     # always include at least == after the message
4468     log "$msg== $(date +"%H:%M:%S (%s)")"
4469 }
4470
4471 #
4472 # Run a single test function and cleanup after it.
4473 #
4474 # This function should be run in a subshell so the test func can
4475 # exit() without stopping the whole script.
4476 #
4477 run_one() {
4478     local testnum=$1
4479     local message=$2
4480     tfile=f.${TESTSUITE}.${testnum}
4481     export tdir=d0.${TESTSUITE}/d${base}
4482     export TESTNAME=test_$testnum
4483     local SAVE_UMASK=`umask`
4484     umask 0022
4485
4486     banner "test $testnum: $message"
4487     test_${testnum} || error "test_$testnum failed with $?"
4488     cd $SAVE_PWD
4489     reset_fail_loc
4490     check_grant ${testnum} || error "check_grant $testnum failed with $?"
4491     check_catastrophe || error "LBUG/LASSERT detected"
4492         if [ "$PARALLEL" != "yes" ]; then
4493                 ps auxww | grep -v grep | grep -q multiop &&
4494                                         error "multiop still running"
4495         fi
4496     unset TESTNAME
4497     unset tdir
4498     umask $SAVE_UMASK
4499     return 0
4500 }
4501
4502 #
4503 # Wrapper around run_one to ensure:
4504 #  - test runs in subshell
4505 #  - output of test is saved to separate log file for error reporting
4506 #  - test result is saved to data file
4507 #
4508 run_one_logged() {
4509         local BEFORE=`date +%s`
4510         local TEST_ERROR
4511         local name=${TESTSUITE}.test_${1}.test_log.$(hostname -s).log
4512         local test_log=$LOGDIR/$name
4513         rm -rf $LOGDIR/err
4514         rm -rf $LOGDIR/skip
4515         local SAVE_UMASK=`umask`
4516         umask 0022
4517
4518         echo
4519         log_sub_test_begin test_${1}
4520         (run_one $1 "$2") 2>&1 | tee -i $test_log
4521         local RC=${PIPESTATUS[0]}
4522
4523         [ $RC -ne 0 ] && [ ! -f $LOGDIR/err ] && \
4524                 echo "test_$1 returned $RC" | tee $LOGDIR/err
4525
4526         duration=$((`date +%s` - $BEFORE))
4527         pass "$1" "(${duration}s)"
4528
4529         if [[ -f $LOGDIR/err ]]; then
4530                 TEST_ERROR=$(cat $LOGDIR/err)
4531         elif [[ -f $LOGDIR/skip ]]; then
4532                 TEST_ERROR=$(cat $LOGDIR/skip)
4533         fi
4534         log_sub_test_end $TEST_STATUS $duration "$RC" "$TEST_ERROR"
4535
4536         if [ -f $LOGDIR/err ]; then
4537                 $FAIL_ON_ERROR && exit $RC
4538         fi
4539
4540         umask $SAVE_UMASK
4541
4542         return 0
4543 }
4544
4545 #
4546 # Print information of skipped tests to result.yml
4547 #
4548 skip_logged(){
4549         log_sub_test_begin $1
4550         shift
4551         log_sub_test_end "SKIP" "0" "0" "$@"
4552 }
4553
4554 canonical_path() {
4555     (cd `dirname $1`; echo $PWD/`basename $1`)
4556 }
4557
4558
4559 check_grant() {
4560     export base=`basetest $1`
4561     [ "$CHECK_GRANT" == "no" ] && return 0
4562
4563         testname=GCHECK_ONLY_${base}
4564         [ ${!testname}x == x ] && return 0
4565
4566     echo -n "checking grant......"
4567
4568         local clients=$CLIENTS
4569         [ -z $clients ] && clients=$(hostname)
4570
4571     # sync all the data and make sure no pending data on server
4572     do_nodes $clients sync
4573
4574     # get client grant
4575     client_grant=`do_nodes $clients \
4576                     "$LCTL get_param -n osc.${FSNAME}-*.cur_*grant_bytes" | \
4577                     awk '{total += $1} END{print total}'`
4578
4579     # get server grant
4580     server_grant=`do_nodes $(comma_list $(osts_nodes)) \
4581                     "$LCTL get_param -n obdfilter.${FSNAME}-OST*.tot_granted" |
4582                     awk '{total += $1} END{print total}'`
4583
4584     # check whether client grant == server grant
4585     if [ $client_grant -ne $server_grant ]; then
4586         echo "failed: client:${client_grant} server: ${server_grant}."
4587         do_nodes $(comma_list $(osts_nodes)) \
4588                    "$LCTL get_param obdfilter.${FSNAME}-OST*.tot*"
4589         do_nodes $clients "$LCTL get_param osc.${FSNAME}-*.cur_*_bytes"
4590         return 1
4591     else
4592         echo "pass: client:${client_grant} server: ${server_grant}"
4593     fi
4594
4595 }
4596
4597 ########################
4598 # helper functions
4599
4600 osc_to_ost()
4601 {
4602     osc=$1
4603     ost=`echo $1 | awk -F_ '{print $3}'`
4604     if [ -z $ost ]; then
4605         ost=`echo $1 | sed 's/-osc.*//'`
4606     fi
4607     echo $ost
4608 }
4609
4610 ostuuid_from_index()
4611 {
4612     $LFS osts $2 | sed -ne "/^$1: /s/.* \(.*\) .*$/\1/p"
4613 }
4614
4615 ostname_from_index() {
4616     local uuid=$(ostuuid_from_index $1)
4617     echo ${uuid/_UUID/}
4618 }
4619
4620 index_from_ostuuid()
4621 {
4622     $LFS osts $2 | sed -ne "/${1}/s/\(.*\): .* .*$/\1/p"
4623 }
4624
4625 mdtuuid_from_index()
4626 {
4627     $LFS mdts $2 | sed -ne "/^$1: /s/.* \(.*\) .*$/\1/p"
4628 }
4629
4630 # Description:
4631 #   Return unique identifier for given hostname
4632 host_id() {
4633         local host_name=$1
4634         echo $host_name | md5sum | cut -d' ' -f1
4635 }
4636
4637 # Description:
4638 #   Returns list of ip addresses for each interface
4639 local_addr_list() {
4640         ip addr | awk '/inet\ / {print $2}' | awk -F\/ '{print $1}'
4641 }
4642
4643 is_local_addr() {
4644         local addr=$1
4645         # Cache address list to avoid mutiple execution of local_addr_list
4646         LOCAL_ADDR_LIST=${LOCAL_ADDR_LIST:-$(local_addr_list)}
4647         local i
4648         for i in $LOCAL_ADDR_LIST ; do
4649                 [[ "$i" == "$addr" ]] && return 0
4650         done
4651         return 1
4652 }
4653
4654 local_node() {
4655         local host_name=$1
4656         local is_local="IS_LOCAL_$(host_id $host_name)"
4657         if [ -z "${!is_local-}" ] ; then
4658                 eval $is_local=0
4659                 local host_ip=$($LUSTRE/tests/resolveip $host_name)
4660                 is_local_addr "$host_ip" && eval $is_local=1
4661         fi
4662         [[ "${!is_local}" == "1" ]]
4663 }
4664
4665 remote_node () {
4666         local node=$1
4667         local_node $node && return 1
4668         return 0
4669 }
4670
4671 remote_mds ()
4672 {
4673     local node
4674     for node in $(mdts_nodes); do
4675         remote_node $node && return 0
4676     done
4677     return 1
4678 }
4679
4680 remote_mds_nodsh()
4681 {
4682     [ "$CLIENTONLY" ] && return 0 || true
4683     remote_mds && [ "$PDSH" = "no_dsh" -o -z "$PDSH" -o -z "$mds_HOST" ]
4684 }
4685
4686 require_dsh_mds()
4687 {
4688         remote_mds_nodsh && echo "SKIP: $TESTSUITE: remote MDS with nodsh" && \
4689             MSKIPPED=1 && return 1
4690         return 0
4691 }
4692
4693 remote_ost ()
4694 {
4695     local node
4696     for node in $(osts_nodes) ; do
4697         remote_node $node && return 0
4698     done
4699     return 1
4700 }
4701
4702 remote_ost_nodsh()
4703 {
4704     [ "$CLIENTONLY" ] && return 0 || true
4705     remote_ost && [ "$PDSH" = "no_dsh" -o -z "$PDSH" -o -z "$ost_HOST" ]
4706 }
4707
4708 require_dsh_ost()
4709 {
4710         remote_ost_nodsh && echo "SKIP: $TESTSUITE: remote OST with nodsh" && \
4711             OSKIPPED=1 && return 1
4712         return 0
4713 }
4714
4715 remote_mgs_nodsh()
4716 {
4717     local MGS
4718     MGS=$(facet_host mgs)
4719     remote_node $MGS && [ "$PDSH" = "no_dsh" -o -z "$PDSH" -o -z "$ost_HOST" ]
4720 }
4721
4722 local_mode ()
4723 {
4724     remote_mds_nodsh || remote_ost_nodsh || \
4725         $(single_local_node $(comma_list $(nodes_list)))
4726 }
4727
4728 remote_servers () {
4729     remote_ost && remote_mds
4730 }
4731
4732 # Get the active nodes for facets.
4733 facets_nodes () {
4734         local facets=$1
4735         local facet
4736         local nodes
4737         local nodes_sort
4738         local i
4739
4740         for facet in ${facets//,/ }; do
4741                 nodes="$nodes $(facet_active_host $facet)"
4742         done
4743
4744         nodes_sort=$(for i in $nodes; do echo $i; done | sort -u)
4745         echo -n $nodes_sort
4746 }
4747
4748 # Get all of the active MDS nodes.
4749 mdts_nodes () {
4750         echo -n $(facets_nodes $(get_facets MDS))
4751 }
4752
4753 # Get all of the active OSS nodes.
4754 osts_nodes () {
4755         echo -n $(facets_nodes $(get_facets OST))
4756 }
4757
4758 # Get all of the client nodes and active server nodes.
4759 nodes_list () {
4760         local nodes=$HOSTNAME
4761         local nodes_sort
4762         local i
4763
4764         # CLIENTS (if specified) contains the local client
4765         [ -n "$CLIENTS" ] && nodes=${CLIENTS//,/ }
4766
4767         if [ "$PDSH" -a "$PDSH" != "no_dsh" ]; then
4768                 nodes="$nodes $(facets_nodes $(get_facets))"
4769         fi
4770
4771         nodes_sort=$(for i in $nodes; do echo $i; done | sort -u)
4772         echo -n $nodes_sort
4773 }
4774
4775 # Get all of the remote client nodes and remote active server nodes.
4776 remote_nodes_list () {
4777         echo -n $(nodes_list) | sed -re "s/\<$HOSTNAME\>//g"
4778 }
4779
4780 # Get all of the MDS nodes, including active and passive nodes.
4781 all_mdts_nodes () {
4782         local host
4783         local failover_host
4784         local nodes
4785         local nodes_sort
4786         local i
4787
4788         for i in $(seq $MDSCOUNT); do
4789                 host=mds${i}_HOST
4790                 failover_host=mds${i}failover_HOST
4791                 nodes="$nodes ${!host} ${!failover_host}"
4792         done
4793
4794         nodes_sort=$(for i in $nodes; do echo $i; done | sort -u)
4795         echo -n $nodes_sort
4796 }
4797
4798 # Get all of the OSS nodes, including active and passive nodes.
4799 all_osts_nodes () {
4800         local host
4801         local failover_host
4802         local nodes
4803         local nodes_sort
4804         local i
4805
4806         for i in $(seq $OSTCOUNT); do
4807                 host=ost${i}_HOST
4808                 failover_host=ost${i}failover_HOST
4809                 nodes="$nodes ${!host} ${!failover_host}"
4810         done
4811
4812         nodes_sort=$(for i in $nodes; do echo $i; done | sort -u)
4813         echo -n $nodes_sort
4814 }
4815
4816 # Get all of the server nodes, including active and passive nodes.
4817 all_server_nodes () {
4818         local nodes
4819         local nodes_sort
4820         local i
4821
4822         nodes="$mgs_HOST $mgsfailover_HOST $(all_mdts_nodes) $(all_osts_nodes)"
4823
4824         nodes_sort=$(for i in $nodes; do echo $i; done | sort -u)
4825         echo -n $nodes_sort
4826 }
4827
4828 # Get all of the client and server nodes, including active and passive nodes.
4829 all_nodes () {
4830         local nodes=$HOSTNAME
4831         local nodes_sort
4832         local i
4833
4834         # CLIENTS (if specified) contains the local client
4835         [ -n "$CLIENTS" ] && nodes=${CLIENTS//,/ }
4836
4837         if [ "$PDSH" -a "$PDSH" != "no_dsh" ]; then
4838                 nodes="$nodes $(all_server_nodes)"
4839         fi
4840
4841         nodes_sort=$(for i in $nodes; do echo $i; done | sort -u)
4842         echo -n $nodes_sort
4843 }
4844
4845 init_clients_lists () {
4846     # Sanity check: exclude the local client from RCLIENTS
4847     local clients=$(hostlist_expand "$RCLIENTS")
4848     local rclients=$(exclude_items_from_list "$clients" $HOSTNAME)
4849
4850     # Sanity check: exclude the dup entries
4851     RCLIENTS=$(for i in ${rclients//,/ }; do echo $i; done | sort -u)
4852
4853     clients="$SINGLECLIENT $HOSTNAME $RCLIENTS"
4854
4855     # Sanity check: exclude the dup entries from CLIENTS
4856     # for those configs which has SINGLCLIENT set to local client
4857     clients=$(for i in $clients; do echo $i; done | sort -u)
4858
4859     CLIENTS=$(comma_list $clients)
4860     local -a remoteclients=($RCLIENTS)
4861     for ((i=0; $i<${#remoteclients[@]}; i++)); do
4862             varname=CLIENT$((i + 2))
4863             eval $varname=${remoteclients[i]}
4864     done
4865
4866     CLIENTCOUNT=$((${#remoteclients[@]} + 1))
4867 }
4868
4869 get_random_entry () {
4870     local rnodes=$1
4871
4872     rnodes=${rnodes//,/ }
4873
4874     local -a nodes=($rnodes)
4875     local num=${#nodes[@]}
4876     local i=$((RANDOM * num * 2 / 65536))
4877
4878     echo ${nodes[i]}
4879 }
4880
4881 client_only () {
4882     [ "$CLIENTONLY" ] || [ "$CLIENTMODSONLY" = yes ]
4883 }
4884
4885 is_patchless ()
4886 {
4887     lctl get_param version | grep -q patchless
4888 }
4889
4890 check_versions () {
4891     [ "$(lustre_version_code client)" = "$(lustre_version_code $SINGLEMDS)" -a \
4892       "$(lustre_version_code client)" = "$(lustre_version_code ost1)" ]
4893 }
4894
4895 get_node_count() {
4896     local nodes="$@"
4897     echo $nodes | wc -w || true
4898 }
4899
4900 mixed_ost_devs () {
4901     local nodes=$(osts_nodes)
4902     local osscount=$(get_node_count "$nodes")
4903     [ ! "$OSTCOUNT" = "$osscount" ]
4904 }
4905
4906 mixed_mdt_devs () {
4907     local nodes=$(mdts_nodes)
4908     local mdtcount=$(get_node_count "$nodes")
4909     [ ! "$MDSCOUNT" = "$mdtcount" ]
4910 }
4911
4912 generate_machine_file() {
4913     local nodes=${1//,/ }
4914     local machinefile=$2
4915     rm -f $machinefile
4916     for node in $nodes; do
4917         echo $node >>$machinefile || \
4918             { echo "can not generate machinefile $machinefile" && return 1; }
4919     done
4920 }
4921
4922 get_stripe () {
4923         local file=$1/stripe
4924
4925         touch $file
4926         $LFS getstripe -v $file || error "getstripe $file failed"
4927         rm -f $file
4928 }
4929
4930 setstripe_nfsserver () {
4931     local dir=$1
4932
4933     local nfsserver=$(awk '"'$dir'" ~ $2 && $3 ~ "nfs" && $2 != "/" \
4934                 { print $1 }' /proc/mounts | cut -f 1 -d : | head -1)
4935
4936     [ -z $nfsserver ] && echo "$dir is not nfs mounted" && return 1
4937
4938     do_nodev $nfsserver lfs setstripe "$@"
4939 }
4940
4941 # Check and add a test group.
4942 add_group() {
4943         local group_id=$1
4944         local group_name=$2
4945         local rc=0
4946
4947         local gid=$(getent group $group_name | cut -d: -f3)
4948         if [[ -n "$gid" ]]; then
4949                 [[ "$gid" -eq "$group_id" ]] || {
4950                         error_noexit "inconsistent group ID:" \
4951                                      "new: $group_id, old: $gid"
4952                         rc=1
4953                 }
4954         else
4955                 groupadd -g $group_id $group_name
4956                 rc=${PIPESTATUS[0]}
4957         fi
4958
4959         return $rc
4960 }
4961
4962 # Check and add a test user.
4963 add_user() {
4964         local user_id=$1
4965         shift
4966         local user_name=$1
4967         shift
4968         local group_name=$1
4969         shift
4970         local home=$1
4971         shift
4972         local opts="$@"
4973         local rc=0
4974
4975         local uid=$(getent passwd $user_name | cut -d: -f3)
4976         if [[ -n "$uid" ]]; then
4977                 if [[ "$uid" -eq "$user_id" ]]; then
4978                         local dir=$(getent passwd $user_name | cut -d: -f6)
4979                         if [[ "$dir" != "$home" ]]; then
4980                                 mkdir -p $home
4981                                 usermod -d $home $user_name
4982                                 rc=${PIPESTATUS[0]}
4983                         fi
4984                 else
4985                         error_noexit "inconsistent user ID:" \
4986                                      "new: $user_id, old: $uid"
4987                         rc=1
4988                 fi
4989         else
4990                 mkdir -p $home
4991                 useradd -M -u $user_id -d $home -g $group_name $opts $user_name
4992                 rc=${PIPESTATUS[0]}
4993         fi
4994
4995         return $rc
4996 }
4997
4998 check_runas_id_ret() {
4999     local myRC=0
5000     local myRUNAS_UID=$1
5001     local myRUNAS_GID=$2
5002     shift 2
5003     local myRUNAS=$@
5004     if [ -z "$myRUNAS" ]; then
5005         error_exit "myRUNAS command must be specified for check_runas_id"
5006     fi
5007     if $GSS_KRB5; then
5008         $myRUNAS krb5_login.sh || \
5009             error "Failed to refresh Kerberos V5 TGT for UID $myRUNAS_ID."
5010     fi
5011     mkdir $DIR/d0_runas_test
5012     chmod 0755 $DIR
5013     chown $myRUNAS_UID:$myRUNAS_GID $DIR/d0_runas_test
5014     $myRUNAS touch $DIR/d0_runas_test/f$$ || myRC=$?
5015     rm -rf $DIR/d0_runas_test
5016     return $myRC
5017 }
5018
5019 check_runas_id() {
5020     local myRUNAS_UID=$1
5021     local myRUNAS_GID=$2
5022     shift 2
5023     local myRUNAS=$@
5024     check_runas_id_ret $myRUNAS_UID $myRUNAS_GID $myRUNAS || \
5025         error "unable to write to $DIR/d0_runas_test as UID $myRUNAS_UID.
5026         Please set RUNAS_ID to some UID which exists on MDS and client or
5027         add user $myRUNAS_UID:$myRUNAS_GID on these nodes."
5028 }
5029
5030 # obtain the UID/GID for MPI_USER
5031 get_mpiuser_id() {
5032     local mpi_user=$1
5033
5034     MPI_USER_UID=$(do_facet client "getent passwd $mpi_user | cut -d: -f3;
5035 exit \\\${PIPESTATUS[0]}") || error_exit "failed to get the UID for $mpi_user"
5036
5037     MPI_USER_GID=$(do_facet client "getent passwd $mpi_user | cut -d: -f4;
5038 exit \\\${PIPESTATUS[0]}") || error_exit "failed to get the GID for $mpi_user"
5039 }
5040
5041 # obtain and cache Kerberos ticket-granting ticket
5042 refresh_krb5_tgt() {
5043     local myRUNAS_UID=$1
5044     local myRUNAS_GID=$2
5045     shift 2
5046     local myRUNAS=$@
5047     if [ -z "$myRUNAS" ]; then
5048         error_exit "myRUNAS command must be specified for refresh_krb5_tgt"
5049     fi
5050
5051     CLIENTS=${CLIENTS:-$HOSTNAME}
5052     do_nodes $CLIENTS "set -x
5053 if ! $myRUNAS krb5_login.sh; then
5054     echo "Failed to refresh Krb5 TGT for UID/GID $myRUNAS_UID/$myRUNAS_GID."
5055     exit 1
5056 fi"
5057 }
5058
5059 # Run multiop in the background, but wait for it to print
5060 # "PAUSING" to its stdout before returning from this function.
5061 multiop_bg_pause() {
5062     MULTIOP_PROG=${MULTIOP_PROG:-$MULTIOP}
5063     FILE=$1
5064     ARGS=$2
5065
5066     TMPPIPE=/tmp/multiop_open_wait_pipe.$$
5067     mkfifo $TMPPIPE
5068
5069     echo "$MULTIOP_PROG $FILE v$ARGS"
5070     $MULTIOP_PROG $FILE v$ARGS > $TMPPIPE &
5071
5072     echo "TMPPIPE=${TMPPIPE}"
5073     read -t 60 multiop_output < $TMPPIPE
5074     if [ $? -ne 0 ]; then
5075         rm -f $TMPPIPE
5076         return 1
5077     fi
5078     rm -f $TMPPIPE
5079     if [ "$multiop_output" != "PAUSING" ]; then
5080         echo "Incorrect multiop output: $multiop_output"
5081         kill -9 $PID
5082         return 1
5083     fi
5084
5085     return 0
5086 }
5087
5088 do_and_time () {
5089     local cmd=$1
5090     local rc
5091
5092     SECONDS=0
5093     eval '$cmd'
5094
5095     [ ${PIPESTATUS[0]} -eq 0 ] || rc=1
5096
5097     echo $SECONDS
5098     return $rc
5099 }
5100
5101 inodes_available () {
5102     local IFree=$($LFS df -i $MOUNT | grep ^$FSNAME | awk '{print $4}' | sort -un | head -1) || return 1
5103     echo $IFree
5104 }
5105
5106 mdsrate_inodes_available () {
5107     local min_inodes=$(inodes_available)
5108     echo $((min_inodes * 99 / 100))
5109 }
5110
5111 # reset llite stat counters
5112 clear_llite_stats(){
5113         lctl set_param -n llite.*.stats 0
5114 }
5115
5116 # sum llite stat items
5117 calc_llite_stats() {
5118         local res=$(lctl get_param -n llite.*.stats |
5119                     awk 'BEGIN {s = 0} END {print s} /^'"$1"'/ {s += $2}')
5120         echo $res
5121 }
5122
5123 # reset osc stat counters
5124 clear_osc_stats(){
5125         lctl set_param -n osc.*.osc_stats 0
5126 }
5127
5128 # sum osc stat items
5129 calc_osc_stats() {
5130         local res=$(lctl get_param -n osc.*.osc_stats |
5131                     awk 'BEGIN {s = 0} END {print s} /^'"$1"'/ {s += $2}')
5132         echo $res
5133 }
5134
5135 calc_sum () {
5136         awk 'BEGIN {s = 0}; {s += $1}; END {print s}'
5137 }
5138
5139 calc_osc_kbytes () {
5140         df $MOUNT > /dev/null
5141         $LCTL get_param -n osc.*[oO][sS][cC][-_][0-9a-f]*.$1 | calc_sum
5142 }
5143
5144 # save_lustre_params(comma separated facet list, parameter_mask)
5145 # generate a stream of formatted strings (<facet> <param name>=<param value>)
5146 save_lustre_params() {
5147         local facets=$1
5148         local facet
5149         local nodes
5150         local node
5151
5152         for facet in ${facets//,/ }; do
5153                 node=$(facet_active_host $facet)
5154                 [[ *\ $node\ * = " $nodes " ]] && continue
5155                 nodes="$nodes $node"
5156
5157                 do_node $node "$LCTL get_param $2 |
5158                         while read s; do echo $facet \\\$s; done"
5159         done
5160 }
5161
5162 # restore lustre parameters from input stream, produces by save_lustre_params
5163 restore_lustre_params() {
5164         local facet
5165         local name
5166         local val
5167
5168         while IFS=" =" read facet name val; do
5169                 do_facet $facet "$LCTL set_param -n $name $val"
5170         done
5171 }
5172
5173 check_catastrophe() {
5174         local rnodes=${1:-$(comma_list $(remote_nodes_list))}
5175         local C=$CATASTROPHE
5176         [ -f $C ] && [ $(cat $C) -ne 0 ] && return 1
5177
5178         [ -z "$rnodes" ] && return 0
5179
5180         local data
5181         data=$(do_nodes "$rnodes" "rc=\\\$([ -f $C ] &&
5182                 echo \\\$(< $C) || echo 0);
5183                 if [ \\\$rc -ne 0 ]; then echo \\\$(hostname): \\\$rc; fi
5184                 exit \\\$rc")
5185         local rc=$?
5186         if [ -n "$data" ]; then
5187             echo $data
5188             return $rc
5189         fi
5190         return 0
5191 }
5192
5193 # CMD: determine mds index where directory inode presents
5194 get_mds_dir () {
5195     local dir=$1
5196     local file=$dir/f0.get_mds_dir_tmpfile
5197
5198     mkdir -p $dir
5199     rm -f $file
5200     sleep 1
5201     local iused=$(lfs df -i $dir | grep MDT | awk '{print $3}')
5202     local -a oldused=($iused)
5203
5204     openfile -f O_CREAT:O_LOV_DELAY_CREATE -m 0644 $file > /dev/null
5205     sleep 1
5206     iused=$(lfs df -i $dir | grep MDT | awk '{print $3}')
5207     local -a newused=($iused)
5208
5209     local num=0
5210     for ((i=0; i<${#newused[@]}; i++)); do
5211          if [ ${oldused[$i]} -lt ${newused[$i]} ];  then
5212              echo $(( i + 1 ))
5213              rm -f $file
5214              return 0
5215          fi
5216     done
5217     error "mdt-s : inodes count OLD ${oldused[@]} NEW ${newused[@]}"
5218 }
5219
5220 mdsrate_cleanup () {
5221         if [ -d $4 ]; then
5222                 mpi_run -np $1 ${MACHINEFILE_OPTION} $2 ${MDSRATE} --unlink \
5223                         --nfiles $3 --dir $4 --filefmt $5 $6
5224                 rmdir $4
5225         fi
5226 }
5227
5228 delayed_recovery_enabled () {
5229     local var=${SINGLEMDS}_svc
5230     do_facet $SINGLEMDS lctl get_param -n mdd.${!var}.stale_export_age > /dev/null 2>&1
5231 }
5232
5233 ########################
5234
5235 convert_facet2label() {
5236     local facet=$1
5237
5238     if [ x$facet = xost ]; then
5239        facet=ost1
5240     fi
5241
5242     local varsvc=${facet}_svc
5243
5244     if [ -n ${!varsvc} ]; then
5245         echo ${!varsvc}
5246     else
5247         error "No lablel for $facet!"
5248     fi
5249 }
5250
5251 get_clientosc_proc_path() {
5252     echo "${1}-osc-*"
5253 }
5254
5255 get_lustre_version () {
5256     local facet=${1:-"$SINGLEMDS"}
5257     do_facet $facet $LCTL get_param -n version | awk '/^lustre:/ {print $2}'
5258 }
5259
5260 lustre_version_code() {
5261     local facet=${1:-"$SINGLEMDS"}
5262     version_code $(get_lustre_version $1)
5263 }
5264
5265 # If the 2.0 MDS was mounted on 1.8 device, then the OSC and LOV names
5266 # used by MDT would not be changed.
5267 # mdt lov: fsname-mdtlov
5268 # mdt osc: fsname-OSTXXXX-osc
5269 mds_on_old_device() {
5270     local mds=${1:-"$SINGLEMDS"}
5271
5272     if [ $(lustre_version_code $mds) -gt $(version_code 1.9.0) ]; then
5273         do_facet $mds "lctl list_param osc.$FSNAME-OST*-osc \
5274             > /dev/null 2>&1" && return 0
5275     fi
5276     return 1
5277 }
5278
5279 get_mdtosc_proc_path() {
5280     local mds_facet=$1
5281     local ost_label=${2:-"*OST*"}
5282
5283     [ "$mds_facet" = "mds" ] && mds_facet=$SINGLEMDS
5284     local mdt_label=$(convert_facet2label $mds_facet)
5285     local mdt_index=$(echo $mdt_label | sed -e 's/^.*-//')
5286
5287     if [ $(lustre_version_code $mds_facet) -le $(version_code 1.8.0) ] ||
5288        mds_on_old_device $mds_facet; then
5289         echo "${ost_label}-osc"
5290     else
5291         echo "${ost_label}-osc-${mdt_index}"
5292     fi
5293 }
5294
5295 get_osc_import_name() {
5296     local facet=$1
5297     local ost=$2
5298     local label=$(convert_facet2label $ost)
5299
5300     if [ "${facet:0:3}" = "mds" ]; then
5301         get_mdtosc_proc_path $facet $label
5302         return 0
5303     fi
5304
5305     get_clientosc_proc_path $label
5306     return 0
5307 }
5308
5309 _wait_import_state () {
5310     local expected=$1
5311     local CONN_PROC=$2
5312     local maxtime=${3:-$(max_recovery_time)}
5313     local CONN_STATE
5314     local i=0
5315
5316         CONN_STATE=$($LCTL get_param -n $CONN_PROC 2>/dev/null | cut -f2 | uniq)
5317     while [ "${CONN_STATE}" != "${expected}" ]; do
5318         if [ "${expected}" == "DISCONN" ]; then
5319             # for disconn we can check after proc entry is removed
5320             [ "x${CONN_STATE}" == "x" ] && return 0
5321             #  with AT enabled, we can have connect request timeout near of
5322             # reconnect timeout and test can't see real disconnect
5323             [ "${CONN_STATE}" == "CONNECTING" ] && return 0
5324         fi
5325         [ $i -ge $maxtime ] && \
5326             error "can't put import for $CONN_PROC into ${expected} state after $i sec, have ${CONN_STATE}" && \
5327             return 1
5328         sleep 1
5329         # Add uniq for multi-mount case
5330         CONN_STATE=$($LCTL get_param -n $CONN_PROC 2>/dev/null | cut -f2 | uniq)
5331         i=$(($i + 1))
5332     done
5333
5334     log "$CONN_PROC in ${CONN_STATE} state after $i sec"
5335     return 0
5336 }
5337
5338 wait_import_state() {
5339     local state=$1
5340     local params=$2
5341     local maxtime=${3:-$(max_recovery_time)}
5342     local param
5343
5344     for param in ${params//,/ }; do
5345         _wait_import_state $state $param $maxtime || return
5346     done
5347 }
5348
5349 wait_import_state_mount() {
5350         if ! is_mounted $MOUNT && ! is_mounted $MOUNT2; then
5351                 return 0
5352         fi
5353
5354         wait_import_state $*
5355 }
5356
5357 # One client request could be timed out because server was not ready
5358 # when request was sent by client.
5359 # The request timeout calculation details :
5360 # ptl_send_rpc ()
5361 #      /* We give the server rq_timeout secs to process the req, and
5362 #      add the network latency for our local timeout. */
5363 #      request->rq_deadline = request->rq_sent + request->rq_timeout +
5364 #           ptlrpc_at_get_net_latency(request) ;
5365 #
5366 # ptlrpc_connect_import ()
5367 #      request->rq_timeout = INITIAL_CONNECT_TIMEOUT
5368 #
5369 # init_imp_at () ->
5370 #   -> at_init(&at->iat_net_latency, 0, 0) -> iat_net_latency=0
5371 # ptlrpc_at_get_net_latency(request) ->
5372 #       at_get (max (iat_net_latency=0, at_min)) = at_min
5373 #
5374 # i.e.:
5375 # request->rq_timeout + ptlrpc_at_get_net_latency(request) =
5376 # INITIAL_CONNECT_TIMEOUT + at_min
5377 #
5378 # We will use obd_timeout instead of INITIAL_CONNECT_TIMEOUT
5379 # because we can not get this value in runtime,
5380 # the value depends on configure options, and it is not stored in /proc.
5381 # obd_support.h:
5382 # #define CONNECTION_SWITCH_MIN 5U
5383 # #define INITIAL_CONNECT_TIMEOUT max(CONNECTION_SWITCH_MIN,obd_timeout/20)
5384
5385 request_timeout () {
5386     local facet=$1
5387
5388     # request->rq_timeout = INITIAL_CONNECT_TIMEOUT
5389     local init_connect_timeout=$TIMEOUT
5390     [[ $init_connect_timeout -ge 5 ]] || init_connect_timeout=5
5391
5392     local at_min=$(at_get $facet at_min)
5393
5394     echo $(( init_connect_timeout + at_min ))
5395 }
5396
5397 _wait_osc_import_state() {
5398     local facet=$1
5399     local ost_facet=$2
5400     local expected=$3
5401     local ost=$(get_osc_import_name $facet $ost_facet)
5402
5403         local param="osc.${ost}.ost_server_uuid"
5404         local i=0
5405
5406     # 1. wait the deadline of client 1st request (it could be skipped)
5407     # 2. wait the deadline of client 2nd request
5408     local maxtime=$(( 2 * $(request_timeout $facet)))
5409
5410         #During setup time, the osc might not be setup, it need wait
5411         #until list_param can return valid value. And also if there
5412         #are mulitple osc entries we should list all of them before
5413         #go to wait.
5414         local params=$($LCTL list_param $param 2>/dev/null || true)
5415         while [ -z "$params" ]; do
5416                 if [ $i -ge $maxtime ]; then
5417                         echo "can't get $param by list_param in $maxtime secs"
5418                         if [[ $facet != client* ]]; then
5419                                 echo "Go with $param directly"
5420                                 params=$param
5421                                 break
5422                         else
5423                                 return 1
5424                         fi
5425                 fi
5426                 sleep 1
5427                 i=$((i + 1))
5428                 params=$($LCTL list_param $param 2>/dev/null || true)
5429         done
5430
5431         if ! do_rpc_nodes "$(facet_active_host $facet)" \
5432                         wait_import_state $expected "$params" $maxtime; then
5433                 error "import is not in ${expected} state"
5434                 return 1
5435         fi
5436
5437         return 0
5438 }
5439
5440 wait_osc_import_state() {
5441         local facet=$1
5442         local ost_facet=$2
5443         local expected=$3
5444         local num
5445
5446         if [[ $facet = mds ]]; then
5447                 for num in $(seq $MDSCOUNT); do
5448                         _wait_osc_import_state mds$num "$ost_facet" "$expected"
5449                 done
5450         else
5451                 _wait_osc_import_state "$facet" "$ost_facet" "$expected"
5452         fi
5453 }
5454
5455 get_clientmdc_proc_path() {
5456     echo "${1}-mdc-*"
5457 }
5458
5459 do_rpc_nodes () {
5460         local list=$1
5461         shift
5462
5463         [ -z "$list" ] && return 0
5464
5465         # Add paths to lustre tests for 32 and 64 bit systems.
5466         local LIBPATH="/usr/lib/lustre/tests:/usr/lib64/lustre/tests:"
5467         local TESTPATH="$RLUSTRE/tests:"
5468         local RPATH="PATH=${TESTPATH}${LIBPATH}${PATH}:/sbin:/bin:/usr/sbin:"
5469         do_nodesv $list "${RPATH} NAME=${NAME} sh rpc.sh $@ "
5470 }
5471
5472 wait_clients_import_state () {
5473     local list=$1
5474     local facet=$2
5475     local expected=$3
5476
5477     local facets=$facet
5478
5479     if [ "$FAILURE_MODE" = HARD ]; then
5480         facets=$(facets_on_host $(facet_active_host $facet))
5481     fi
5482
5483     for facet in ${facets//,/ }; do
5484     local label=$(convert_facet2label $facet)
5485     local proc_path
5486     case $facet in
5487         ost* ) proc_path="osc.$(get_clientosc_proc_path $label).ost_server_uuid" ;;
5488         mds* ) proc_path="mdc.$(get_clientmdc_proc_path $label).mds_server_uuid" ;;
5489         *) error "unknown facet!" ;;
5490     esac
5491     local params=$(expand_list $params $proc_path)
5492     done
5493
5494         if ! do_rpc_nodes "$list" wait_import_state_mount $expected $params; then
5495                 error "import is not in ${expected} state"
5496                 return 1
5497         fi
5498 }
5499
5500 oos_full() {
5501         local -a AVAILA
5502         local -a GRANTA
5503         local -a TOTALA
5504         local OSCFULL=1
5505         AVAILA=($(do_nodes $(comma_list $(osts_nodes)) \
5506                   $LCTL get_param obdfilter.*.kbytesavail))
5507         GRANTA=($(do_nodes $(comma_list $(osts_nodes)) \
5508                   $LCTL get_param -n obdfilter.*.tot_granted))
5509         TOTALA=($(do_nodes $(comma_list $(osts_nodes)) \
5510                   $LCTL get_param -n obdfilter.*.kbytestotal))
5511         for ((i=0; i<${#AVAILA[@]}; i++)); do
5512                 local -a AVAIL1=(${AVAILA[$i]//=/ })
5513                 local -a TOTAL=(${TOTALA[$i]//=/ })
5514                 GRANT=$((${GRANTA[$i]}/1024))
5515                 # allow 1% of total space in bavail because of delayed
5516                 # allocation with ZFS which might release some free space after
5517                 # txg commit.  For small devices, we set a mininum of 8MB
5518                 local LIMIT=$((${TOTAL} / 100 + 8000))
5519                 echo -n $(echo ${AVAIL1[0]} | cut -d"." -f2) avl=${AVAIL1[1]} \
5520                         grnt=$GRANT diff=$((AVAIL1[1] - GRANT)) limit=${LIMIT}
5521                 [ $((AVAIL1[1] - GRANT)) -lt $LIMIT ] && OSCFULL=0 && \
5522                         echo " FULL" || echo
5523         done
5524         return $OSCFULL
5525 }
5526
5527 pool_list () {
5528    do_facet mgs lctl pool_list $1
5529 }
5530
5531 create_pool() {
5532     local fsname=${1%%.*}
5533     local poolname=${1##$fsname.}
5534
5535     do_facet mgs lctl pool_new $1
5536     local RC=$?
5537     # get param should return err unless pool is created
5538     [[ $RC -ne 0 ]] && return $RC
5539
5540     wait_update $HOSTNAME "lctl get_param -n lov.$fsname-*.pools.$poolname \
5541         2>/dev/null || echo foo" "" || RC=1
5542     if [[ $RC -eq 0 ]]; then
5543         add_pool_to_list $1
5544     else
5545         error "pool_new failed $1"
5546     fi
5547     return $RC
5548 }
5549
5550 add_pool_to_list () {
5551     local fsname=${1%%.*}
5552     local poolname=${1##$fsname.}
5553
5554     local listvar=${fsname}_CREATED_POOLS
5555     eval export ${listvar}=$(expand_list ${!listvar} $poolname)
5556 }
5557
5558 remove_pool_from_list () {
5559     local fsname=${1%%.*}
5560     local poolname=${1##$fsname.}
5561
5562     local listvar=${fsname}_CREATED_POOLS
5563     eval export ${listvar}=$(exclude_items_from_list ${!listvar} $poolname)
5564 }
5565
5566 destroy_pool_int() {
5567     local ost
5568     local OSTS=$(do_facet $SINGLEMDS lctl pool_list $1 | \
5569         awk '$1 !~ /^Pool:/ {print $1}')
5570     for ost in $OSTS; do
5571         do_facet mgs lctl pool_remove $1 $ost
5572     done
5573     do_facet mgs lctl pool_destroy $1
5574 }
5575
5576 # <fsname>.<poolname> or <poolname>
5577 destroy_pool() {
5578     local fsname=${1%%.*}
5579     local poolname=${1##$fsname.}
5580
5581     [[ x$fsname = x$poolname ]] && fsname=$FSNAME
5582
5583     local RC
5584
5585     pool_list $fsname.$poolname || return $?
5586
5587     destroy_pool_int $fsname.$poolname
5588     RC=$?
5589     [[ $RC -ne 0 ]] && return $RC
5590
5591     wait_update $HOSTNAME "lctl get_param -n lov.$fsname-*.pools.$poolname \
5592       2>/dev/null || echo foo" "foo" || RC=1
5593
5594     if [[ $RC -eq 0 ]]; then
5595         remove_pool_from_list $fsname.$poolname
5596     else
5597         error "destroy pool failed $1"
5598     fi
5599     return $RC
5600 }
5601
5602 destroy_pools () {
5603     local fsname=${1:-$FSNAME}
5604     local poolname
5605     local listvar=${fsname}_CREATED_POOLS
5606
5607     pool_list $fsname
5608
5609     [ x${!listvar} = x ] && return 0
5610
5611     echo destroy the created pools: ${!listvar}
5612     for poolname in ${!listvar//,/ }; do
5613         destroy_pool $fsname.$poolname
5614     done
5615 }
5616
5617 cleanup_pools () {
5618     local fsname=${1:-$FSNAME}
5619     trap 0
5620     destroy_pools $fsname
5621 }
5622
5623 gather_logs () {
5624     local list=$1
5625
5626     local ts=$(date +%s)
5627     local docp=true
5628
5629     if [[ ! -f "$YAML_LOG" ]]; then
5630         # init_logging is not performed before gather_logs,
5631         # so the $LOGDIR needs to be checked here
5632         check_shared_dir $LOGDIR && touch $LOGDIR/shared
5633     fi
5634
5635     [ -f $LOGDIR/shared ] && docp=false
5636
5637     # dump lustre logs, dmesg
5638
5639     prefix="$TESTLOG_PREFIX.$TESTNAME"
5640     suffix="$ts.log"
5641     echo "Dumping lctl log to ${prefix}.*.${suffix}"
5642
5643     if [ "$CLIENTONLY" -o "$PDSH" == "no_dsh" ]; then
5644         echo "Dumping logs only on local client."
5645         $LCTL dk > ${prefix}.debug_log.$(hostname -s).${suffix}
5646         dmesg > ${prefix}.dmesg.$(hostname -s).${suffix}
5647         return
5648     fi
5649
5650     do_nodesv $list \
5651         "$LCTL dk > ${prefix}.debug_log.\\\$(hostname -s).${suffix};
5652          dmesg > ${prefix}.dmesg.\\\$(hostname -s).${suffix}"
5653     if [ ! -f $LOGDIR/shared ]; then
5654         do_nodes $list rsync -az "${prefix}.*.${suffix}" $HOSTNAME:$LOGDIR
5655     fi
5656 }
5657
5658 do_ls () {
5659     local mntpt_root=$1
5660     local num_mntpts=$2
5661     local dir=$3
5662     local i
5663     local cmd
5664     local pids
5665     local rc=0
5666
5667     for i in $(seq 0 $num_mntpts); do
5668         cmd="ls -laf ${mntpt_root}$i/$dir"
5669         echo + $cmd;
5670         $cmd > /dev/null &
5671         pids="$pids $!"
5672     done
5673     echo pids=$pids
5674     for pid in $pids; do
5675         wait $pid || rc=$?
5676     done
5677
5678     return $rc
5679 }
5680
5681 # target_start_and_reset_recovery_timer()
5682 #        service_time = at_est2timeout(service_time);
5683 #        service_time += 2 * (CONNECTION_SWITCH_MAX + CONNECTION_SWITCH_INC +
5684 #                             INITIAL_CONNECT_TIMEOUT);
5685 # CONNECTION_SWITCH_MAX : min(25U, max(CONNECTION_SWITCH_MIN,obd_timeout))
5686 #define CONNECTION_SWITCH_INC 1
5687 #define INITIAL_CONNECT_TIMEOUT max(CONNECTION_SWITCH_MIN,obd_timeout/20)
5688 #define CONNECTION_SWITCH_MIN 5U
5689
5690 max_recovery_time () {
5691     local init_connect_timeout=$(( TIMEOUT / 20 ))
5692     [[ $init_connect_timeout -ge 5 ]] || init_connect_timeout=5
5693
5694     local service_time=$(( $(at_max_get client) + $(( 2 * $(( 25 + 1  + init_connect_timeout)) )) ))
5695
5696     echo $service_time
5697 }
5698
5699 get_clients_mount_count () {
5700     local clients=${CLIENTS:-`hostname`}
5701
5702     # we need to take into account the clients mounts and
5703     # exclude mds/ost mounts if any;
5704     do_nodes $clients cat /proc/mounts | grep lustre | grep $MOUNT | wc -l
5705 }
5706
5707 # gss functions
5708 PROC_CLI="srpc_info"
5709
5710 combination()
5711 {
5712     local M=$1
5713     local N=$2
5714     local R=1
5715
5716     if [ $M -lt $N ]; then
5717         R=0
5718     else
5719         N=$((N + 1))
5720         while [ $N -lt $M ]; do
5721             R=$((R * N))
5722             N=$((N + 1))
5723         done
5724     fi
5725
5726     echo $R
5727     return 0
5728 }
5729
5730 calc_connection_cnt() {
5731     local dir=$1
5732
5733     # MDT->MDT = 2 * C(M, 2)
5734     # MDT->OST = M * O
5735     # CLI->OST = C * O
5736     # CLI->MDT = C * M
5737     comb_m2=$(combination $MDSCOUNT 2)
5738
5739     local num_clients=$(get_clients_mount_count)
5740
5741     local cnt_mdt2mdt=$((comb_m2 * 2))
5742     local cnt_mdt2ost=$((MDSCOUNT * OSTCOUNT))
5743     local cnt_cli2ost=$((num_clients * OSTCOUNT))
5744     local cnt_cli2mdt=$((num_clients * MDSCOUNT))
5745     local cnt_all2ost=$((cnt_mdt2ost + cnt_cli2ost))
5746     local cnt_all2mdt=$((cnt_mdt2mdt + cnt_cli2mdt))
5747     local cnt_all2all=$((cnt_mdt2ost + cnt_mdt2mdt + cnt_cli2ost + cnt_cli2mdt))
5748
5749     local var=cnt_$dir
5750     local res=${!var}
5751
5752     echo $res
5753 }
5754
5755 set_rule()
5756 {
5757     local tgt=$1
5758     local net=$2
5759     local dir=$3
5760     local flavor=$4
5761     local cmd="$tgt.srpc.flavor"
5762
5763     if [ $net == "any" ]; then
5764         net="default"
5765     fi
5766     cmd="$cmd.$net"
5767
5768     if [ $dir != "any" ]; then
5769         cmd="$cmd.$dir"
5770     fi
5771
5772     cmd="$cmd=$flavor"
5773     log "Setting sptlrpc rule: $cmd"
5774     do_facet mgs "$LCTL conf_param $cmd"
5775 }
5776
5777 count_flvr()
5778 {
5779     local output=$1
5780     local flavor=$2
5781     local count=0
5782
5783     rpc_flvr=`echo $flavor | awk -F - '{ print $1 }'`
5784     bulkspec=`echo $flavor | awk -F - '{ print $2 }'`
5785
5786     count=`echo "$output" | grep "rpc flavor" | grep $rpc_flvr | wc -l`
5787
5788     if [ "x$bulkspec" != "x" ]; then
5789         algs=`echo $bulkspec | awk -F : '{ print $2 }'`
5790
5791         if [ "x$algs" != "x" ]; then
5792             bulk_count=`echo "$output" | grep "bulk flavor" | grep $algs | wc -l`
5793         else
5794             bulk=`echo $bulkspec | awk -F : '{ print $1 }'`
5795             if [ $bulk == "bulkn" ]; then
5796                 bulk_count=`echo "$output" | grep "bulk flavor" \
5797                             | grep "null/null" | wc -l`
5798             elif [ $bulk == "bulki" ]; then
5799                 bulk_count=`echo "$output" | grep "bulk flavor" \
5800                             | grep "/null" | grep -v "null/" | wc -l`
5801             else
5802                 bulk_count=`echo "$output" | grep "bulk flavor" \
5803                             | grep -v "/null" | grep -v "null/" | wc -l`
5804             fi
5805         fi
5806
5807         [ $bulk_count -lt $count ] && count=$bulk_count
5808     fi
5809
5810     echo $count
5811 }
5812
5813 flvr_cnt_cli2mdt()
5814 {
5815     local flavor=$1
5816     local cnt
5817
5818     local clients=${CLIENTS:-`hostname`}
5819
5820     for c in ${clients//,/ }; do
5821         output=`do_node $c lctl get_param -n mdc.*-MDT*-mdc-*.$PROC_CLI 2>/dev/null`
5822         tmpcnt=`count_flvr "$output" $flavor`
5823         cnt=$((cnt + tmpcnt))
5824     done
5825     echo $cnt
5826 }
5827
5828 flvr_cnt_cli2ost()
5829 {
5830     local flavor=$1
5831     local cnt
5832
5833     local clients=${CLIENTS:-`hostname`}
5834
5835     for c in ${clients//,/ }; do
5836         output=`do_node $c lctl get_param -n osc.*OST*-osc-[^M][^D][^T]*.$PROC_CLI 2>/dev/null`
5837         tmpcnt=`count_flvr "$output" $flavor`
5838         cnt=$((cnt + tmpcnt))
5839     done
5840     echo $cnt
5841 }
5842
5843 flvr_cnt_mdt2mdt()
5844 {
5845     local flavor=$1
5846     local cnt=0
5847
5848     if [ $MDSCOUNT -le 1 ]; then
5849         echo 0
5850         return
5851     fi
5852
5853     for num in `seq $MDSCOUNT`; do
5854         output=`do_facet mds$num lctl get_param -n mdc.*-MDT*-mdc[0-9]*.$PROC_CLI 2>/dev/null`
5855         tmpcnt=`count_flvr "$output" $flavor`
5856         cnt=$((cnt + tmpcnt))
5857     done
5858     echo $cnt;
5859 }
5860
5861 flvr_cnt_mdt2ost()
5862 {
5863     local flavor=$1
5864     local cnt=0
5865     local mdtosc
5866
5867     for num in `seq $MDSCOUNT`; do
5868         mdtosc=$(get_mdtosc_proc_path mds$num)
5869         mdtosc=${mdtosc/-MDT*/-MDT\*}
5870         output=$(do_facet mds$num lctl get_param -n \
5871             osc.$mdtosc.$PROC_CLI 2>/dev/null)
5872         tmpcnt=`count_flvr "$output" $flavor`
5873         cnt=$((cnt + tmpcnt))
5874     done
5875     echo $cnt;
5876 }
5877
5878 flvr_cnt_mgc2mgs()
5879 {
5880     local flavor=$1
5881
5882     output=`do_facet client lctl get_param -n mgc.*.$PROC_CLI 2>/dev/null`
5883     count_flvr "$output" $flavor
5884 }
5885
5886 do_check_flavor()
5887 {
5888     local dir=$1        # from to
5889     local flavor=$2     # flavor expected
5890     local res=0
5891
5892     if [ $dir == "cli2mdt" ]; then
5893         res=`flvr_cnt_cli2mdt $flavor`
5894     elif [ $dir == "cli2ost" ]; then
5895         res=`flvr_cnt_cli2ost $flavor`
5896     elif [ $dir == "mdt2mdt" ]; then
5897         res=`flvr_cnt_mdt2mdt $flavor`
5898     elif [ $dir == "mdt2ost" ]; then
5899         res=`flvr_cnt_mdt2ost $flavor`
5900     elif [ $dir == "all2ost" ]; then
5901         res1=`flvr_cnt_mdt2ost $flavor`
5902         res2=`flvr_cnt_cli2ost $flavor`
5903         res=$((res1 + res2))
5904     elif [ $dir == "all2mdt" ]; then
5905         res1=`flvr_cnt_mdt2mdt $flavor`
5906         res2=`flvr_cnt_cli2mdt $flavor`
5907         res=$((res1 + res2))
5908     elif [ $dir == "all2all" ]; then
5909         res1=`flvr_cnt_mdt2ost $flavor`
5910         res2=`flvr_cnt_cli2ost $flavor`
5911         res3=`flvr_cnt_mdt2mdt $flavor`
5912         res4=`flvr_cnt_cli2mdt $flavor`
5913         res=$((res1 + res2 + res3 + res4))
5914     fi
5915
5916     echo $res
5917 }
5918
5919 wait_flavor()
5920 {
5921     local dir=$1        # from to
5922     local flavor=$2     # flavor expected
5923     local expect=${3:-$(calc_connection_cnt $dir)}     # number expected
5924
5925     local res=0
5926
5927     for ((i=0;i<20;i++)); do
5928         echo -n "checking $dir..."
5929         res=$(do_check_flavor $dir $flavor)
5930         echo "found $res/$expect $flavor connections"
5931         [ $res -ge $expect ] && return 0
5932         sleep 4
5933     done
5934
5935     echo "Error checking $flavor of $dir: expect $expect, actual $res"
5936     return 1
5937 }
5938
5939 restore_to_default_flavor()
5940 {
5941     local proc="mgs.MGS.live.$FSNAME"
5942
5943     echo "restoring to default flavor..."
5944
5945     nrule=`do_facet mgs lctl get_param -n $proc 2>/dev/null | grep ".srpc.flavor." | wc -l`
5946
5947     # remove all existing rules if any
5948     if [ $nrule -ne 0 ]; then
5949         echo "$nrule existing rules"
5950         for rule in `do_facet mgs lctl get_param -n $proc 2>/dev/null | grep ".srpc.flavor."`; do
5951             echo "remove rule: $rule"
5952             spec=`echo $rule | awk -F = '{print $1}'`
5953             do_facet mgs "$LCTL conf_param -d $spec"
5954         done
5955     fi
5956
5957     # verify no rules left
5958     nrule=`do_facet mgs lctl get_param -n $proc 2>/dev/null | grep ".srpc.flavor." | wc -l`
5959     [ $nrule -ne 0 ] && error "still $nrule rules left"
5960
5961     # wait for default flavor to be applied
5962     # currently default flavor for all connections are 'null'
5963     wait_flavor all2all null
5964     echo "now at default flavor settings"
5965 }
5966
5967 set_flavor_all()
5968 {
5969     local flavor=${1:-null}
5970
5971     echo "setting all flavor to $flavor"
5972
5973     # FIXME need parameter to this fn
5974     # and remove global vars
5975     local cnt_all2all=$(calc_connection_cnt all2all)
5976
5977     local res=$(do_check_flavor all2all $flavor)
5978     if [ $res -eq $cnt_all2all ]; then
5979         echo "already have total $res $flavor connections"
5980         return
5981     fi
5982
5983     echo "found $res $flavor out of total $cnt_all2all connections"
5984     restore_to_default_flavor
5985
5986     [[ $flavor = null ]] && return 0
5987
5988     set_rule $FSNAME any any $flavor
5989     wait_flavor all2all $flavor
5990 }
5991
5992
5993 check_logdir() {
5994     local dir=$1
5995     # Checking for shared logdir
5996     if [ ! -d $dir ]; then
5997         # Not found. Create local logdir
5998         mkdir -p $dir
5999     else
6000         touch $dir/check_file.$(hostname -s)
6001     fi
6002     return 0
6003 }
6004
6005 check_write_access() {
6006     local dir=$1
6007     local node
6008     local file
6009
6010     for node in $(nodes_list); do
6011         file=$dir/check_file.$(short_hostname $node)
6012         if [[ ! -f "$file" ]]; then
6013             # Logdir not accessible/writable from this node.
6014             return 1
6015         fi
6016         rm -f $file || return 1
6017     done
6018     return 0
6019 }
6020
6021 init_logging() {
6022     if [[ -n $YAML_LOG ]]; then
6023         return
6024     fi
6025     local SAVE_UMASK=`umask`
6026     umask 0000
6027
6028     export YAML_LOG=${LOGDIR}/results.yml
6029     mkdir -p $LOGDIR
6030     init_clients_lists
6031
6032     if [ ! -f $YAML_LOG ]; then       # If the yaml log already exists then we will just append to it
6033       if check_shared_dir $LOGDIR; then
6034           touch $LOGDIR/shared
6035           echo "Logging to shared log directory: $LOGDIR"
6036       else
6037           echo "Logging to local directory: $LOGDIR"
6038       fi
6039
6040       yml_nodes_file $LOGDIR >> $YAML_LOG
6041       yml_results_file >> $YAML_LOG
6042     fi
6043
6044     umask $SAVE_UMASK
6045 }
6046
6047 log_test() {
6048     yml_log_test $1 >> $YAML_LOG
6049 }
6050
6051 log_test_status() {
6052      yml_log_test_status $@ >> $YAML_LOG
6053 }
6054
6055 log_sub_test_begin() {
6056     yml_log_sub_test_begin "$@" >> $YAML_LOG
6057 }
6058
6059 log_sub_test_end() {
6060     yml_log_sub_test_end "$@" >> $YAML_LOG
6061 }
6062
6063 run_llverdev()
6064 {
6065         local dev=$1
6066         local llverdev_opts=$2
6067         local devname=$(basename $1)
6068         local size=$(grep "$devname"$ /proc/partitions | awk '{print $3}')
6069         # loop devices aren't in /proc/partitions
6070         [ "x$size" == "x" ] && local size=$(ls -l $dev | awk '{print $5}')
6071
6072         size=$(($size / 1024 / 1024)) # Gb
6073
6074         local partial_arg=""
6075         # Run in partial (fast) mode if the size
6076         # of a partition > 1 GB
6077         [ $size -gt 1 ] && partial_arg="-p"
6078
6079         llverdev --force $partial_arg $llverdev_opts $dev
6080 }
6081
6082 run_llverfs()
6083 {
6084         local dir=$1
6085         local llverfs_opts=$2
6086         local use_partial_arg=$3
6087         local partial_arg=""
6088         local size=$(df -B G $dir |tail -n 1 |awk '{print $2}' |sed 's/G//') #GB
6089
6090         # Run in partial (fast) mode if the size
6091         # of a partition > 1 GB
6092         [ "x$use_partial_arg" != "xno" ] && [ $size -gt 1 ] && partial_arg="-p"
6093
6094         llverfs $partial_arg $llverfs_opts $dir
6095 }
6096
6097 #Remove objects from OST
6098 remove_ost_objects() {
6099         local facet=$1
6100         local ostdev=$2
6101         local group=$3
6102         shift 3
6103         local objids="$@"
6104         local mntpt=$(facet_mntpt $facet)
6105         local opts=$OST_MOUNT_OPTS
6106         local i
6107         local rc
6108
6109         echo "removing objects from $ostdev on $facet: $objids"
6110         if ! test -b $ostdev; then
6111                 opts=$(csa_add "$opts" -o loop)
6112         fi
6113         mount -t $(facet_fstype $facet) $opts $ostdev $mntpt ||
6114                 return $?
6115         rc=0
6116         for i in $objids; do
6117                 rm $mntpt/O/$group/d$((i % 32))/$i || { rc=$?; break; }
6118         done
6119         umount -f $mntpt || return $?
6120         return $rc
6121 }
6122
6123 #Remove files from MDT
6124 remove_mdt_files() {
6125         local facet=$1
6126         local mdtdev=$2
6127         shift 2
6128         local files="$@"
6129         local mntpt=$(facet_mntpt $facet)
6130         local opts=$MDS_MOUNT_OPTS
6131
6132         echo "removing files from $mdtdev on $facet: $files"
6133         if [ $(facet_fstype $facet) == ldiskfs ] &&
6134            ! do_facet $facet test -b $mdtdev; then
6135                 opts=$(csa_add "$opts" -o loop)
6136         fi
6137         mount -t $(facet_fstype $facet) $opts $mdtdev $mntpt ||
6138                 return $?
6139         rc=0
6140         for f in $files; do
6141                 rm $mntpt/ROOT/$f || { rc=$?; break; }
6142         done
6143         umount -f $mntpt || return $?
6144         return $rc
6145 }
6146
6147 duplicate_mdt_files() {
6148         local facet=$1
6149         local mdtdev=$2
6150         shift 2
6151         local files="$@"
6152         local mntpt=$(facet_mntpt $facet)
6153         local opts=$MDS_MOUNT_OPTS
6154
6155         echo "duplicating files on $mdtdev on $facet: $files"
6156         mkdir -p $mntpt || return $?
6157         if [ $(facet_fstype $facet) == ldiskfs ] &&
6158            ! do_facet $facet test -b $mdtdev; then
6159                 opts=$(csa_add "$opts" -o loop)
6160         fi
6161         mount -t $(facet_fstype $facet) $opts $mdtdev $mntpt ||
6162                 return $?
6163
6164     do_umount() {
6165         trap 0
6166         popd > /dev/null
6167         rm $tmp
6168         umount -f $mntpt
6169     }
6170     trap do_umount EXIT
6171
6172     tmp=$(mktemp $TMP/setfattr.XXXXXXXXXX)
6173     pushd $mntpt/ROOT > /dev/null || return $?
6174     rc=0
6175     for f in $files; do
6176         touch $f.bad || return $?
6177         getfattr -n trusted.lov $f | sed "s#$f#&.bad#" > $tmp
6178         rc=${PIPESTATUS[0]}
6179         [ $rc -eq 0 ] || return $rc
6180         setfattr --restore $tmp || return $?
6181     done
6182     do_umount
6183 }
6184
6185 run_sgpdd () {
6186     local devs=${1//,/ }
6187     shift
6188     local params=$@
6189     local rslt=$TMP/sgpdd_survey
6190
6191     # sgpdd-survey cleanups ${rslt}.* files
6192
6193     local cmd="rslt=$rslt $params scsidevs=\"$devs\" $SGPDDSURVEY"
6194     echo + $cmd
6195     eval $cmd
6196     cat ${rslt}.detail
6197 }
6198
6199 # returns the canonical name for an ldiskfs device
6200 ldiskfs_canon() {
6201         local dev="$1"
6202         local facet="$2"
6203
6204         do_facet $facet "dv=\\\$(lctl get_param -n $dev);
6205 if foo=\\\$(lvdisplay -c \\\$dv 2>/dev/null); then
6206     echo dm-\\\${foo##*:};
6207 else
6208     echo \\\$(basename \\\$dv);
6209 fi;"
6210 }
6211
6212 is_sanity_benchmark() {
6213     local benchmarks="dbench bonnie iozone fsx"
6214     local suite=$1
6215     for b in $benchmarks; do
6216         if [ "$b" == "$suite" ]; then
6217             return 0
6218         fi
6219     done
6220     return 1
6221 }
6222
6223 min_ost_size () {
6224     $LCTL get_param -n osc.*.kbytesavail | sort -n | head -n1
6225 }
6226
6227 # Get the block size of the filesystem.
6228 get_block_size() {
6229     local facet=$1
6230     local device=$2
6231     local size
6232
6233     size=$(do_facet $facet "$DUMPE2FS -h $device 2>&1" |
6234            awk '/^Block size:/ {print $3}')
6235     echo $size
6236 }
6237
6238 # Check whether the "large_xattr" feature is enabled or not.
6239 large_xattr_enabled() {
6240         [[ $(facet_fstype $SINGLEMDS) == zfs ]] && return 0
6241
6242         local mds_dev=$(mdsdevname ${SINGLEMDS//mds/})
6243
6244         do_facet $SINGLEMDS "$DUMPE2FS -h $mds_dev 2>&1 |
6245                 grep -E -q '(ea_inode|large_xattr)'"
6246         return ${PIPESTATUS[0]}
6247 }
6248
6249 # Get the maximum xattr size supported by the filesystem.
6250 max_xattr_size() {
6251     local size
6252
6253     if large_xattr_enabled; then
6254         # include/linux/limits.h: #define XATTR_SIZE_MAX 65536
6255         size=65536
6256     else
6257         local mds_dev=$(mdsdevname ${SINGLEMDS//mds/})
6258         local block_size=$(get_block_size $SINGLEMDS $mds_dev)
6259
6260         # maximum xattr size = size of block - size of header -
6261         #                      size of 1 entry - 4 null bytes
6262         size=$((block_size - 32 - 32 - 4))
6263     fi
6264
6265     echo $size
6266 }
6267
6268 # Dump the value of the named xattr from a file.
6269 get_xattr_value() {
6270     local xattr_name=$1
6271     local file=$2
6272
6273     echo "$(getfattr -n $xattr_name --absolute-names --only-values $file)"
6274 }
6275
6276 # Generate a string with size of $size bytes.
6277 generate_string() {
6278     local size=${1:-1024} # in bytes
6279
6280     echo "$(head -c $size < /dev/zero | tr '\0' y)"
6281 }
6282
6283 reformat_external_journal() {
6284         local facet=$1
6285
6286         if [ ! -z ${EJOURNAL} ]; then
6287                 local rcmd="do_facet $facet"
6288
6289                 echo "reformat external journal on $facet:${EJOURNAL}"
6290                 ${rcmd} mke2fs -O journal_dev ${EJOURNAL} || return 1
6291         fi
6292 }
6293
6294 # MDT file-level backup/restore
6295 mds_backup_restore() {
6296         local facet=$1
6297         local igif=$2
6298         local devname=$(mdsdevname $(facet_number $facet))
6299         local mntpt=$(facet_mntpt brpt)
6300         local rcmd="do_facet $facet"
6301         local metaea=${TMP}/backup_restore.ea
6302         local metadata=${TMP}/backup_restore.tgz
6303         local opts=${MDS_MOUNT_OPTS}
6304         local svc=${facet}_svc
6305
6306         if ! ${rcmd} test -b ${devname}; then
6307                 opts=$(csa_add "$opts" -o loop)
6308         fi
6309
6310         echo "file-level backup/restore on $facet:${devname}"
6311
6312         # step 1: build mount point
6313         ${rcmd} mkdir -p $mntpt
6314         # step 2: cleanup old backup
6315         ${rcmd} rm -f $metaea $metadata
6316         # step 3: mount dev
6317         ${rcmd} mount -t ldiskfs $opts $devname $mntpt || return 1
6318         if [ ! -z $igif ]; then
6319                 # step 3.5: rm .lustre
6320                 ${rcmd} rm -rf $mntpt/ROOT/.lustre || return 1
6321         fi
6322         # step 4: backup metaea
6323         echo "backup EA"
6324         ${rcmd} "cd $mntpt && getfattr -R -d -m '.*' -P . > $metaea && cd -" ||
6325                 return 2
6326         # step 5: backup metadata
6327         echo "backup data"
6328         ${rcmd} tar zcf $metadata -C $mntpt/ . > /dev/null 2>&1 || return 3
6329         # step 6: umount
6330         ${rcmd} umount -d $mntpt || return 4
6331         # step 7: reformat external journal if needed
6332         reformat_external_journal $facet || return 5
6333         # step 8: reformat dev
6334         echo "reformat new device"
6335         add $facet $(mkfs_opts $facet ${devname}) --backfstype ldiskfs \
6336                 --reformat ${devname} $(mdsvdevname $(facet_number $facet)) \
6337                 > /dev/null || exit 6
6338         # step 9: mount dev
6339         ${rcmd} mount -t ldiskfs $opts $devname $mntpt || return 7
6340         # step 10: restore metadata
6341         echo "restore data"
6342         ${rcmd} tar zxfp $metadata -C $mntpt > /dev/null 2>&1 || return 8
6343         # step 11: restore metaea
6344         echo "restore EA"
6345         ${rcmd} "cd $mntpt && setfattr --restore=$metaea && cd - " || return 9
6346         # step 12: remove recovery logs
6347         echo "remove recovery logs"
6348         ${rcmd} rm -fv $mntpt/OBJECTS/* $mntpt/CATALOGS
6349         # step 13: umount dev
6350         ${rcmd} umount -d $mntpt || return 10
6351         # step 14: cleanup tmp backup
6352         ${rcmd} rm -f $metaea $metadata
6353         # step 15: reset device label - it's not virgin on
6354         ${rcmd} e2label $devname ${!svc}
6355 }
6356
6357 # remove OI files
6358 mds_remove_ois() {
6359         local facet=$1
6360         local idx=$2
6361         local devname=$(mdsdevname $(facet_number $facet))
6362         local mntpt=$(facet_mntpt brpt)
6363         local rcmd="do_facet $facet"
6364         local opts=${MDS_MOUNT_OPTS}
6365
6366         if ! ${rcmd} test -b ${devname}; then
6367                 opts=$(csa_add "$opts" -o loop)
6368         fi
6369
6370         echo "removing OI files on $facet: idx=${idx}"
6371
6372         # step 1: build mount point
6373         ${rcmd} mkdir -p $mntpt
6374         # step 2: mount dev
6375         ${rcmd} mount -t ldiskfs $opts $devname $mntpt || return 1
6376         if [ -z $idx ]; then
6377                 # step 3: remove all OI files
6378                 ${rcmd} rm -fv $mntpt/oi.16*
6379         elif [ $idx -lt 2 ]; then
6380                 ${rcmd} rm -fv $mntpt/oi.16.${idx}
6381         else
6382                 local i
6383
6384                 # others, rm oi.16.[idx, idx * idx, idx ** ...]
6385                 for ((i=${idx}; i<64; i=$((i * idx)))); do
6386                         ${rcmd} rm -fv $mntpt/oi.16.${i}
6387                 done
6388         fi
6389         # step 4: umount
6390         ${rcmd} umount -d $mntpt || return 2
6391         # OI files will be recreated when mounted as lustre next time.
6392 }
6393
6394 # generate maloo upload-able log file name
6395 # \param logname specify unique part of file name
6396 generate_logname() {
6397         local logname=${1:-"default_logname"}
6398
6399         echo "$TESTLOG_PREFIX.$TESTNAME.$logname.$(hostname -s).log"
6400 }
6401
6402 # make directory on different MDTs
6403 test_mkdir() {
6404         local option
6405         local parent
6406         local child
6407         local path
6408         local rc=0
6409
6410         case $# in
6411                 1) path=$1;;
6412                 2) option=$1
6413                    path=$2;;
6414                 *) error "Only creating single directory is supported";;
6415         esac
6416
6417         child=$(basename $path)
6418         parent=$(dirname $path)
6419
6420         if [ "$option" == "-p" -a -d $parent/$child ]; then
6421                 return $rc
6422         fi
6423
6424         if [ ! -d ${parent} ]; then
6425                 if [ "$option" == "-p" ]; then
6426                         mkdir -p ${parent}
6427                 else
6428                         return 1
6429                 fi
6430         fi
6431
6432         if [ $MDSCOUNT -le 1 ]; then
6433                 mkdir $option $parent/$child || rc=$?
6434         else
6435                 local mdt_idx=$($LFS getstripe -M $parent)
6436                 local test_num=$(echo $testnum | sed -e 's/[^0-9]*//g')
6437
6438                 if [ "$mdt_idx" -ne 0 ]; then
6439                         mkdir $option $parent/$child || rc=$?
6440                 else
6441                         mdt_idx=$((test_num % MDSCOUNT))
6442                         echo "mkdir $mdt_idx for $parent/$child"
6443                         $LFS setdirstripe -i $mdt_idx $parent/$child || rc=$?
6444                 fi
6445         fi
6446         return $rc
6447 }