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