Whamcloud - gitweb
ffc5253edfc0867922a60dc6594e4413bad02baf
[fs/lustre-release.git] / 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 LANG=en_US
9 export REFORMAT=${REFORMAT:-""}
10 export WRITECONF=${WRITECONF:-""}
11 export VERBOSE=${VERBOSE:-false}
12 export GSS=false
13 export GSS_KRB5=false
14 export GSS_PIPEFS=false
15 export IDENTITY_UPCALL=default
16 export QUOTA_AUTO=1
17 # specify environment variable containing batch job name for server statistics
18 export JOBID_VAR=${JOBID_VAR:-"procname_uid"}  # or "existing" or "disable"
19
20 #export PDSH="pdsh -S -Rssh -w"
21 export MOUNT_CMD=${MOUNT_CMD:-"mount -t lustre"}
22 export UMOUNT=${UMOUNT:-"umount -d"}
23 # sles12 umount has a issue with -d option
24 [ -e /etc/SuSE-release ] && grep -w VERSION /etc/SuSE-release | grep -wq 12 && {
25         export UMOUNT="umount"
26 }
27
28 # function used by scripts run on remote nodes
29 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
30 . $LUSTRE/tests/functions.sh
31 . $LUSTRE/tests/yaml.sh
32
33 export LD_LIBRARY_PATH=${LUSTRE}/utils:${LD_LIBRARY_PATH}
34
35 LUSTRE_TESTS_CFG_DIR=${LUSTRE_TESTS_CFG_DIR:-${LUSTRE}/tests/cfg}
36
37 EXCEPT_LIST_FILE=${EXCEPT_LIST_FILE:-${LUSTRE_TESTS_CFG_DIR}/tests-to-skip.sh}
38
39 if [ -f "$EXCEPT_LIST_FILE" ]; then
40     echo "Reading test skip list from $EXCEPT_LIST_FILE"
41     cat $EXCEPT_LIST_FILE
42     . $EXCEPT_LIST_FILE
43 fi
44
45 # check config files for options in decreasing order of preference
46 [ -z "$MODPROBECONF" -a -f /etc/modprobe.d/lustre.conf ] &&
47     MODPROBECONF=/etc/modprobe.d/lustre.conf
48 [ -z "$MODPROBECONF" -a -f /etc/modprobe.d/Lustre ] &&
49     MODPROBECONF=/etc/modprobe.d/Lustre
50 [ -z "$MODPROBECONF" -a -f /etc/modprobe.conf ] &&
51     MODPROBECONF=/etc/modprobe.conf
52
53 sanitize_parameters() {
54         for i in DIR DIR1 DIR2 MOUNT MOUNT1 MOUNT2
55         do
56                 local path=${!i}
57                 if [ -d "$path" ]; then
58                         eval export $i=$(echo $path | sed -r 's/\/+$//g')
59                 fi
60         done
61 }
62 assert_DIR () {
63         local failed=""
64         [[ $DIR/ = $MOUNT/* ]] ||
65                 { failed=1 && echo "DIR=$DIR not in $MOUNT. Aborting."; }
66         [[ $DIR1/ = $MOUNT1/* ]] ||
67                 { failed=1 && echo "DIR1=$DIR1 not in $MOUNT1. Aborting."; }
68         [[ $DIR2/ = $MOUNT2/* ]] ||
69                 { failed=1 && echo "DIR2=$DIR2 not in $MOUNT2. Aborting"; }
70
71         [ -n "$failed" ] && exit 99 || true
72 }
73
74 usage() {
75     echo "usage: $0 [-r] [-f cfgfile]"
76     echo "       -r: reformat"
77
78     exit
79 }
80
81 print_summary () {
82     trap 0
83         [ -z "$DEFAULT_SUITES"] && return 0
84     [ -n "$ONLY" ] && echo "WARNING: ONLY is set to $(echo $ONLY)"
85     local details
86     local form="%-13s %-17s %-9s %s %s\n"
87     printf "$form" "status" "script" "Total(sec)" "E(xcluded) S(low)"
88     echo "------------------------------------------------------------------------------------"
89     for O in $DEFAULT_SUITES; do
90         O=$(echo $O  | tr "-" "_" | tr "[:lower:]" "[:upper:]")
91         [ "${!O}" = "no" ] && continue || true
92         local o=$(echo $O  | tr "[:upper:]_" "[:lower:]-")
93         local log=${TMP}/${o}.log
94         if is_sanity_benchmark $o; then
95             log=${TMP}/sanity-benchmark.log
96         fi
97         local slow=
98         local skipped=
99         local total=
100         local status=Unfinished
101         if [ -f $log ]; then
102                 skipped=$(grep excluded $log | awk '{ printf " %s", $3 }' |
103                         sed 's/test_//g')
104                 slow=$(egrep "^PASS|^FAIL" $log | tr -d "("| sed s/s\)$//g |
105                         sort -nr -k 3  | head -n5 |  awk '{ print $2":"$3"s" }')
106                 total=$(grep duration $log | awk '{ print $2 }')
107                 if [ "${!O}" = "done" ]; then
108                         status=Done
109                 fi
110                 if $DDETAILS; then
111                         local durations=$(egrep "^PASS|^FAIL" $log |
112                                 tr -d "("| sed s/s\)$//g |
113                                 awk '{ print $2":"$3"|" }')
114                         details=$(printf "%s\n%s %s %s\n" "$details" \
115                                 "DDETAILS" "$O" "$(echo $durations)")
116                 fi
117         fi
118         printf "$form" $status "$O" "${total}" "E=$skipped"
119         printf "$form" "-" "-" "-" "S=$(echo $slow)"
120     done
121
122     for O in $DEFAULT_SUITES; do
123         O=$(echo $O  | tr "-" "_" | tr "[:lower:]" "[:upper:]")
124         if [ "${!O}" = "no" ]; then
125             printf "$form" "Skipped" "$O" ""
126         fi
127     done
128
129     # print the detailed tests durations if DDETAILS=true
130     if $DDETAILS; then
131         echo "$details"
132     fi
133 }
134
135 init_test_env() {
136         export LUSTRE=$(absolute_path $LUSTRE)
137         export TESTSUITE=$(basename $0 .sh)
138         export TEST_FAILED=false
139         export FAIL_ON_SKIP_ENV=${FAIL_ON_SKIP_ENV:-false}
140         export RPC_MODE=${RPC_MODE:-false}
141         export DO_CLEANUP=${DO_CLEANUP:-true}
142
143     export MKE2FS=$MKE2FS
144     if [ -z "$MKE2FS" ]; then
145         if which mkfs.ldiskfs >/dev/null 2>&1; then
146             export MKE2FS=mkfs.ldiskfs
147         else
148             export MKE2FS=mke2fs
149         fi
150     fi
151
152     export DEBUGFS=$DEBUGFS
153     if [ -z "$DEBUGFS" ]; then
154         if which debugfs.ldiskfs >/dev/null 2>&1; then
155             export DEBUGFS=debugfs.ldiskfs
156         else
157             export DEBUGFS=debugfs
158         fi
159     fi
160
161     export TUNE2FS=$TUNE2FS
162     if [ -z "$TUNE2FS" ]; then
163         if which tunefs.ldiskfs >/dev/null 2>&1; then
164             export TUNE2FS=tunefs.ldiskfs
165         else
166             export TUNE2FS=tune2fs
167         fi
168     fi
169
170     export E2LABEL=$E2LABEL
171     if [ -z "$E2LABEL" ]; then
172         if which label.ldiskfs >/dev/null 2>&1; then
173             export E2LABEL=label.ldiskfs
174         else
175             export E2LABEL=e2label
176         fi
177     fi
178
179     export DUMPE2FS=$DUMPE2FS
180     if [ -z "$DUMPE2FS" ]; then
181         if which dumpfs.ldiskfs >/dev/null 2>&1; then
182             export DUMPE2FS=dumpfs.ldiskfs
183         else
184             export DUMPE2FS=dumpe2fs
185         fi
186     fi
187
188     export E2FSCK=$E2FSCK
189     if [ -z "$E2FSCK" ]; then
190         if which fsck.ldiskfs >/dev/null 2>&1; then
191             export E2FSCK=fsck.ldiskfs
192         else
193             export E2FSCK=e2fsck
194         fi
195     fi
196
197         export RESIZE2FS=$RESIZE2FS
198         if [ -z "$RESIZE2FS" ]; then
199                 if which resizefs.ldiskfs >/dev/null 2>&1; then
200                         export RESIZE2FS=resizefs.ldiskfs
201                 else
202                         export RESIZE2FS=resize2fs
203                 fi
204         fi
205
206         export LFSCK_ALWAYS=${LFSCK_ALWAYS:-"no"} # check fs after test suite
207         export FSCK_MAX_ERR=4   # File system errors left uncorrected
208
209         export ZFS=${ZFS:-zfs}
210         export ZPOOL=${ZPOOL:-zpool}
211         export ZDB=${ZDB:-zdb}
212         export PARTPROBE=${PARTPROBE:-partprobe}
213
214     #[ -d /r ] && export ROOT=${ROOT:-/r}
215     export TMP=${TMP:-$ROOT/tmp}
216     export TESTSUITELOG=${TMP}/${TESTSUITE}.log
217     export LOGDIR=${LOGDIR:-${TMP}/test_logs/$(date +%s)}
218     export TESTLOG_PREFIX=$LOGDIR/$TESTSUITE
219
220     export HOSTNAME=${HOSTNAME:-$(hostname -s)}
221     if ! echo $PATH | grep -q $LUSTRE/utils; then
222         export PATH=$LUSTRE/utils:$PATH
223     fi
224     if ! echo $PATH | grep -q $LUSTRE/utils/gss; then
225         export PATH=$LUSTRE/utils/gss:$PATH
226     fi
227     if ! echo $PATH | grep -q $LUSTRE/tests; then
228         export PATH=$LUSTRE/tests:$PATH
229     fi
230     if ! echo $PATH | grep -q $LUSTRE/../lustre-iokit/sgpdd-survey; then
231         export PATH=$LUSTRE/../lustre-iokit/sgpdd-survey:$PATH
232     fi
233     export LST=${LST:-"$LUSTRE/../lnet/utils/lst"}
234     [ ! -f "$LST" ] && export LST=$(which lst)
235     export SGPDDSURVEY=${SGPDDSURVEY:-"$LUSTRE/../lustre-iokit/sgpdd-survey/sgpdd-survey")}
236     [ ! -f "$SGPDDSURVEY" ] && export SGPDDSURVEY=$(which sgpdd-survey)
237         export MCREATE=${MCREATE:-mcreate}
238     # Ubuntu, at least, has a truncate command in /usr/bin
239     # so fully path our truncate command.
240     export TRUNCATE=${TRUNCATE:-$LUSTRE/tests/truncate}
241         export FSX=${FSX:-$LUSTRE/tests/fsx}
242     export MDSRATE=${MDSRATE:-"$LUSTRE/tests/mpi/mdsrate"}
243     [ ! -f "$MDSRATE" ] && export MDSRATE=$(which mdsrate 2> /dev/null)
244     if ! echo $PATH | grep -q $LUSTRE/tests/racer; then
245         export PATH=$LUSTRE/tests/racer:$PATH:
246     fi
247     if ! echo $PATH | grep -q $LUSTRE/tests/mpi; then
248         export PATH=$LUSTRE/tests/mpi:$PATH
249     fi
250     export RSYNC_RSH=${RSYNC_RSH:-rsh}
251
252     export LCTL=${LCTL:-"$LUSTRE/utils/lctl"}
253     [ ! -f "$LCTL" ] && export LCTL=$(which lctl)
254     export LFS=${LFS:-"$LUSTRE/utils/lfs"}
255     [ ! -f "$LFS" ] && export LFS=$(which lfs)
256     SETSTRIPE=${SETSTRIPE:-"$LFS setstripe"}
257     GETSTRIPE=${GETSTRIPE:-"$LFS getstripe"}
258
259     export L_GETIDENTITY=${L_GETIDENTITY:-"$LUSTRE/utils/l_getidentity"}
260     if [ ! -f "$L_GETIDENTITY" ]; then
261         if `which l_getidentity > /dev/null 2>&1`; then
262             export L_GETIDENTITY=$(which l_getidentity)
263         else
264             export L_GETIDENTITY=NONE
265         fi
266     fi
267     export LL_DECODE_FILTER_FID=${LL_DECODE_FILTER_FID:-"$LUSTRE/utils/ll_decode_filter_fid"}
268     [ ! -f "$LL_DECODE_FILTER_FID" ] && export LL_DECODE_FILTER_FID="ll_decode_filter_fid"
269     export LL_DECODE_LINKEA=${LL_DECODE_LINKEA:-"$LUSTRE/utils/ll_decode_linkea"}
270     [ ! -f "$LL_DECODE_LINKEA" ] && export LL_DECODE_LINKEA="ll_decode_linkea"
271     export MKFS=${MKFS:-"$LUSTRE/utils/mkfs.lustre"}
272     [ ! -f "$MKFS" ] && export MKFS="mkfs.lustre"
273     export TUNEFS=${TUNEFS:-"$LUSTRE/utils/tunefs.lustre"}
274     [ ! -f "$TUNEFS" ] && export TUNEFS="tunefs.lustre"
275     export CHECKSTAT="${CHECKSTAT:-"checkstat -v"} "
276     export LUSTRE_RMMOD=${LUSTRE_RMMOD:-$LUSTRE/scripts/lustre_rmmod}
277     [ ! -f "$LUSTRE_RMMOD" ] &&
278         export LUSTRE_RMMOD=$(which lustre_rmmod 2> /dev/null)
279     export LFS_MIGRATE=${LFS_MIGRATE:-$LUSTRE/scripts/lfs_migrate}
280     [ ! -f "$LFS_MIGRATE" ] &&
281         export LFS_MIGRATE=$(which lfs_migrate 2> /dev/null)
282     export LR_READER=${LR_READER:-"$LUSTRE/utils/lr_reader"}
283     [ ! -f "$LR_READER" ] && export LR_READER=$(which lr_reader 2> /dev/null)
284     [ -z "$LR_READER" ] && export LR_READER="/usr/sbin/lr_reader"
285     export NAME=${NAME:-local}
286     export LGSSD=${LGSSD:-"$LUSTRE/utils/gss/lgssd"}
287     [ "$GSS_PIPEFS" = "true" ] && [ ! -f "$LGSSD" ] && \
288         export LGSSD=$(which lgssd)
289     export LSVCGSSD=${LSVCGSSD:-"$LUSTRE/utils/gss/lsvcgssd"}
290     [ ! -f "$LSVCGSSD" ] && export LSVCGSSD=$(which lsvcgssd 2> /dev/null)
291     export KRB5DIR=${KRB5DIR:-"/usr/kerberos"}
292     export DIR2
293     export SAVE_PWD=${SAVE_PWD:-$LUSTRE/tests}
294     export AT_MAX_PATH
295     export LDEV=${LDEV:-"$LUSTRE/scripts/ldev"}
296     [ ! -f "$LDEV" ] && export LDEV=$(which ldev 2> /dev/null)
297
298     if [ "$ACCEPTOR_PORT" ]; then
299         export PORT_OPT="--port $ACCEPTOR_PORT"
300     fi
301
302     case "x$SEC" in
303         xkrb5*)
304             echo "Using GSS/krb5 ptlrpc security flavor"
305             which lgss_keyring > /dev/null 2>&1 || \
306                 error_exit "built with gss disabled! SEC=$SEC"
307             GSS=true
308             GSS_KRB5=true
309             ;;
310     esac
311
312     case "x$IDUP" in
313         xtrue)
314             IDENTITY_UPCALL=true
315             ;;
316         xfalse)
317             IDENTITY_UPCALL=false
318             ;;
319     esac
320
321     export LOAD_MODULES_REMOTE=${LOAD_MODULES_REMOTE:-false}
322
323     # Paths on remote nodes, if different
324     export RLUSTRE=${RLUSTRE:-$LUSTRE}
325     export RPWD=${RPWD:-$PWD}
326     export I_MOUNTED=${I_MOUNTED:-"no"}
327         if [ ! -f /lib/modules/$(uname -r)/kernel/fs/lustre/mdt.ko -a \
328              ! -f /lib/modules/$(uname -r)/updates/kernel/fs/lustre/mdt.ko -a \
329              ! -f /lib/modules/$(uname -r)/extra/kernel/fs/lustre/mdt.ko -a \
330              ! -f $LUSTRE/mdt/mdt.ko ]; then
331             export CLIENTMODSONLY=yes
332         fi
333
334         export SHUTDOWN_ATTEMPTS=${SHUTDOWN_ATTEMPTS:-3}
335         export OSD_TRACK_DECLARES_LBUG=${OSD_TRACK_DECLARES_LBUG:-"yes"}
336
337         # command line
338
339         while getopts "rvwf:" opt $*; do
340                 case $opt in
341                         f) CONFIG=$OPTARG;;
342                         r) REFORMAT=yes;;
343                         v) VERBOSE=true;;
344                         w) WRITECONF=writeconf;;
345                         \?) usage;;
346                 esac
347         done
348
349         shift $((OPTIND - 1))
350         ONLY=${ONLY:-$*}
351
352         # print the durations of each test if "true"
353         DDETAILS=${DDETAILS:-false}
354         [ "$TESTSUITELOG" ] && rm -f $TESTSUITELOG || true
355         if ! $RPC_MODE; then
356                 rm -f $TMP/*active
357         fi
358
359         export TF_FAIL=${TF_FAIL:-$TMP/tf.fail}
360 }
361
362 check_cpt_number() {
363         local facet=$1
364         local ncpts
365
366         ncpts=$(do_facet $facet "lctl get_param -n " \
367                 "cpu_partition_table 2>/dev/null| wc -l" || echo 1)
368
369         if [ $ncpts -eq 0 ]; then
370                 echo "1"
371         else
372                 echo $ncpts
373         fi
374 }
375
376 # Return a numeric version code based on a version string.  The version
377 # code is useful for comparison two version strings to see which is newer.
378 version_code() {
379         # split arguments like "1.8.6-wc3" into "1", "8", "6", "wc3"
380         eval set -- $(tr "[:punct:]" " " <<< $*)
381
382         echo -n "$((($1 << 16) | ($2 << 8) | $3))"
383 }
384
385 export LINUX_VERSION=$(uname -r | sed -e "s/\([0-9]*\.[0-9]*\.[0-9]*\).*/\1/")
386 export LINUX_VERSION_CODE=$(version_code ${LINUX_VERSION//\./ })
387
388 # Report the Lustre build version string (e.g. 1.8.7.3 or 2.4.1).
389 #
390 # usage: lustre_build_version
391 #
392 # All Lustre versions support "lctl get_param" to report the version of the
393 # code running in the kernel (what our tests are interested in), but it
394 # doesn't work without modules loaded.  If that fails, use "lctl version"
395 # instead, which is easy to parse and works without the kernel modules,
396 # but was only added in 2.6.50.  If that also fails, fall back to calling
397 # "lctl lustre_build_version" which prints either (or both) the userspace
398 # and kernel build versions, but is deprecated and should eventually be
399 # removed.
400 #
401 # output: prints version string to stdout in dotted-decimal format
402 lustre_build_version() {
403         local facet=${1:-client}
404
405         # lustre: 2.8.52
406         local VER=$(do_facet $facet $LCTL get_param -n version 2> /dev/null |
407                     awk '/lustre: / { print $2 }')
408         # lctl 2.6.50
409         [ -z "$VER" ] && VER=$(do_facet $facet $LCTL --version 2>/dev/null |
410                                awk '{ print $2 }')
411         # Lustre version: 2.5.3-gfcfd782-CHANGED-2.6.32.26-175.fc12.x86_64
412         # lctl   version: 2.5.3-gfcfd782-CHANGED-2.6.32.26-175.fc12.x86_64
413         [ -z "$VER" ] && VER=$(do_facet $facet $LCTL lustre_build_version |
414                                awk '/version:/ { print $3; exit; }')
415         sed -e 's/^v//' -e 's/-.*//' -e 's/_/./g' <<<$VER
416 }
417
418 # Report the Lustre numeric build version code for the supplied facet.
419 lustre_version_code() {
420         version_code $(lustre_build_version $1)
421 }
422
423 module_loaded () {
424         /sbin/lsmod | grep -q "^\<$1\>"
425 }
426
427 # Load a module on the system where this is running.
428 #
429 # usage: load_module module_name [module arguments for insmod/modprobe]
430 #
431 # If module arguments are not given but MODOPTS_<MODULE> is set, then its value
432 # will be used as the arguments.  Otherwise arguments will be obtained from
433 # /etc/modprobe.conf, from /etc/modprobe.d/Lustre, or else none will be used.
434 #
435 load_module() {
436     local optvar
437     EXT=".ko"
438     module=$1
439     shift
440     BASE=$(basename $module $EXT)
441
442     module_loaded ${BASE} && return
443
444     # If no module arguments were passed, get them from $MODOPTS_<MODULE>,
445     # else from modprobe.conf
446     if [ $# -eq 0 ]; then
447         # $MODOPTS_<MODULE>; we could use associative arrays, but that's not in
448         # Bash until 4.x, so we resort to eval.
449         optvar="MODOPTS_$(basename $module | tr a-z A-Z)"
450         eval set -- \$$optvar
451         if [ $# -eq 0 -a -n "$MODPROBECONF" ]; then
452                 # Nothing in $MODOPTS_<MODULE>; try modprobe.conf
453                 local opt
454                 opt=$(awk -v var="^options $BASE" '$0 ~ var \
455                         {gsub("'"options $BASE"'",""); print}' $MODPROBECONF)
456                 set -- $(echo -n $opt)
457
458                 # Ensure we have accept=all for lnet
459                 if [ $(basename $module) = lnet ]; then
460                         # OK, this is a bit wordy...
461                         local arg accept_all_present=false
462
463                         for arg in "$@"; do
464                                 [ "$arg" = accept=all ] && \
465                                         accept_all_present=true
466                         done
467                         $accept_all_present || set -- "$@" accept=all
468                 fi
469                 export $optvar="$*"
470         fi
471     fi
472
473     [ $# -gt 0 ] && echo "${module} options: '$*'"
474
475         # Note that insmod will ignore anything in modprobe.conf, which is why
476         # we're passing options on the command-line.
477         if [[ "$BASE" == "lnet_selftest" ]] &&
478                 [[ -f ${LUSTRE}/../lnet/selftest/${module}${EXT} ]]; then
479                 insmod ${LUSTRE}/../lnet/selftest/${module}${EXT}
480         elif [[ -f ${LUSTRE}/${module}${EXT} ]]; then
481                 [[ "$BASE" != "ptlrpc_gss" ]] || modprobe sunrpc
482                 insmod ${LUSTRE}/${module}${EXT} "$@"
483         else
484                 # must be testing a "make install" or "rpm" installation
485                 # note failed to load ptlrpc_gss is considered not fatal
486                 if [[ "$BASE" == "ptlrpc_gss" ]]; then
487                         modprobe $BASE "$@" 2>/dev/null ||
488                                 echo "gss/krb5 is not supported"
489                 else
490                         modprobe $BASE "$@"
491                 fi
492         fi
493 }
494
495 load_modules_local() {
496         if [ -n "$MODPROBE" ]; then
497                 # use modprobe
498                 echo "Using modprobe to load modules"
499                 return 0
500         fi
501
502         echo Loading modules from $LUSTRE
503
504         local ncpus
505
506         if [ -f /sys/devices/system/cpu/online ]; then
507                 ncpus=$(($(cut -d "-" -f 2 /sys/devices/system/cpu/online) + 1))
508                 echo "detected $ncpus online CPUs by sysfs"
509         else
510                 ncpus=$(getconf _NPROCESSORS_CONF 2>/dev/null)
511                 local rc=$?
512                 if [ $rc -eq 0 ]; then
513                         echo "detected $ncpus online CPUs by getconf"
514                 else
515                         echo "Can't detect number of CPUs"
516                         ncpus=1
517                 fi
518         fi
519
520         # if there is only one CPU core, libcfs can only create one partition
521         # if there is more than 4 CPU cores, libcfs should create multiple CPU
522         # partitions. So we just force libcfs to create 2 partitions for
523         # system with 2 or 4 cores
524         if [ $ncpus -le 4 ] && [ $ncpus -gt 1 ]; then
525                 # force to enable multiple CPU partitions
526                 echo "Force libcfs to create 2 CPU partitions"
527                 MODOPTS_LIBCFS="cpu_npartitions=2 $MODOPTS_LIBCFS"
528         else
529                 echo "libcfs will create CPU partition based on online CPUs"
530         fi
531
532         load_module ../libcfs/libcfs/libcfs
533         # Prevent local MODOPTS_LIBCFS being passed as part of environment
534         # variable to remote nodes
535         unset MODOPTS_LIBCFS
536
537     [ "$PTLDEBUG" ] && lctl set_param debug="$PTLDEBUG"
538     [ "$SUBSYSTEM" ] && lctl set_param subsystem_debug="${SUBSYSTEM# }"
539     load_module ../lnet/lnet/lnet
540         case $NETTYPE in
541         o2ib)
542                 LNETLND="o2iblnd/ko2iblnd"
543                 ;;
544         *)
545                 ;;
546         esac
547     LNETLND=${LNETLND:-"socklnd/ksocklnd"}
548     load_module ../lnet/klnds/$LNETLND
549     load_module obdclass/obdclass
550     load_module ptlrpc/ptlrpc
551     load_module ptlrpc/gss/ptlrpc_gss
552     load_module fld/fld
553     load_module fid/fid
554     load_module lmv/lmv
555     load_module mdc/mdc
556     load_module osc/osc
557     load_module lov/lov
558     load_module mgc/mgc
559     load_module obdecho/obdecho
560         if ! client_only; then
561                 SYMLIST=/proc/kallsyms
562                 grep -q crc16 $SYMLIST ||
563                         { modprobe crc16 2>/dev/null || true; }
564                 grep -q -w jbd2 $SYMLIST ||
565                         { modprobe jbd2 2>/dev/null || true; }
566                 load_module lfsck/lfsck
567                 [ "$LQUOTA" != "no" ] &&
568                         load_module quota/lquota $LQUOTAOPTS
569                 if [[ $(node_fstypes $HOSTNAME) == *zfs* ]]; then
570                         modprobe zfs
571                         load_module osd-zfs/osd_zfs
572                 fi
573                 if [[ $(node_fstypes $HOSTNAME) == *ldiskfs* ]]; then
574                         grep -q exportfs_decode_fh $SYMLIST ||
575                                 { modprobe exportfs 2> /dev/null || true; }
576                         grep -q -w mbcache $SYMLIST ||
577                                 { modprobe mbcache 2>/dev/null || true; }
578                         load_module ../ldiskfs/ldiskfs
579                         load_module osd-ldiskfs/osd_ldiskfs
580                 fi
581                 load_module mgs/mgs
582                 load_module mdd/mdd
583                 load_module mdt/mdt
584                 load_module ost/ost
585                 load_module lod/lod
586                 load_module osp/osp
587                 load_module ofd/ofd
588                 load_module osp/osp
589         fi
590
591         load_module llite/lustre
592         [ -d /r ] && OGDB=${OGDB:-"/r/tmp"}
593         OGDB=${OGDB:-$TMP}
594         rm -f $OGDB/ogdb-$HOSTNAME
595         $LCTL modules > $OGDB/ogdb-$HOSTNAME
596
597         # 'mount' doesn't look in $PATH, just sbin
598         local mount_lustre=$LUSTRE/utils/mount.lustre
599         if [ -f $mount_lustre ]; then
600                 local sbin_mount=$(readlink -f /sbin)/mount.lustre
601                 if grep -qw "$sbin_mount" /proc/mounts; then
602                         cmp -s $mount_lustre $sbin_mount || umount $sbin_mount
603                 fi
604                 if ! grep -qw "$sbin_mount" /proc/mounts; then
605                         [ ! -f "$sbin_mount" ] && touch "$sbin_mount"
606                         if [ ! -s "$sbin_mount" -a -w "$sbin_mount" ]; then
607                                 cat <<- EOF > "$sbin_mount"
608                                 #!/bin/sh
609                                 #STUB MARK
610                                 echo "This $sbin_mount just a mountpoint." 1>&2
611                                 echo "It is never supposed to be run." 1>&2
612                                 logger -p emerg -- "using stub $sbin_mount $@"
613                                 exit 1
614                                 EOF
615                                 chmod a+x $sbin_mount
616                         fi
617                         mount --bind $mount_lustre $sbin_mount ||
618                                 error "can't bind $mount_lustre to $sbin_mount"
619                 fi
620         fi
621 }
622
623 load_modules () {
624         load_modules_local
625         # bug 19124
626         # load modules on remote nodes optionally
627         # lustre-tests have to be installed on these nodes
628         if $LOAD_MODULES_REMOTE; then
629                 local list=$(comma_list $(remote_nodes_list))
630                 if [ -n "$list" ]; then
631                         echo "loading modules on: '$list'"
632                         do_rpc_nodes "$list" load_modules_local
633                 fi
634         fi
635 }
636
637 check_mem_leak () {
638     LEAK_LUSTRE=$(dmesg | tail -n 30 | grep "obd_memory.*leaked" || true)
639     LEAK_PORTALS=$(dmesg | tail -n 20 | grep "Portals memory leaked" || true)
640     if [ "$LEAK_LUSTRE" -o "$LEAK_PORTALS" ]; then
641         echo "$LEAK_LUSTRE" 1>&2
642         echo "$LEAK_PORTALS" 1>&2
643         mv $TMP/debug $TMP/debug-leak.`date +%s` || true
644         echo "Memory leaks detected"
645         [ -n "$IGNORE_LEAK" ] && { echo "ignoring leaks" && return 0; } || true
646         return 1
647     fi
648 }
649
650 unload_modules() {
651         wait_exit_ST client # bug 12845
652
653         $LUSTRE_RMMOD ldiskfs || return 2
654
655         if $LOAD_MODULES_REMOTE; then
656                 local list=$(comma_list $(remote_nodes_list))
657                 if [ -n "$list" ]; then
658                         echo "unloading modules on: '$list'"
659                         do_rpc_nodes "$list" $LUSTRE_RMMOD ldiskfs
660                         do_rpc_nodes "$list" check_mem_leak
661                 fi
662         fi
663
664         local sbin_mount=$(readlink -f /sbin)/mount.lustre
665         if grep -qe "$sbin_mount " /proc/mounts; then
666                 umount $sbin_mount || true
667                 [ -s $sbin_mount ] && ! grep -q "STUB MARK" $sbin_mount ||
668                         rm -f $sbin_mount
669         fi
670
671         check_mem_leak || return 254
672
673         echo "modules unloaded."
674         return 0
675 }
676
677 fs_log_size() {
678         local facet=${1:-$SINGLEMDS}
679         local fstype=$(facet_fstype $facet)
680         local size=0
681         case $fstype in
682                 ldiskfs) size=50;; # largest seen is 44, leave some headroom
683                 zfs)     size=400;; # largest seen is 384
684         esac
685
686         echo -n $size
687 }
688
689 fs_inode_ksize() {
690         local facet=${1:-$SINGLEMDS}
691         local fstype=$(facet_fstype $facet)
692         local size=0
693         case $fstype in
694                 ldiskfs) size=4;;  # ~4KB per inode
695                 zfs)     size=11;; # 10 to 11KB per inode
696         esac
697
698         echo -n $size
699 }
700
701 check_gss_daemon_nodes() {
702     local list=$1
703     dname=$2
704
705     do_nodesv $list "num=\\\$(ps -o cmd -C $dname | grep $dname | wc -l);
706 if [ \\\"\\\$num\\\" -ne 1 ]; then
707     echo \\\$num instance of $dname;
708     exit 1;
709 fi; "
710 }
711
712 check_gss_daemon_facet() {
713     facet=$1
714     dname=$2
715
716     num=`do_facet $facet ps -o cmd -C $dname | grep $dname | wc -l`
717     if [ $num -ne 1 ]; then
718         echo "$num instance of $dname on $facet"
719         return 1
720     fi
721     return 0
722 }
723
724 send_sigint() {
725     local list=$1
726     shift
727     echo Stopping $@ on $list
728     do_nodes $list "killall -2 $@ 2>/dev/null || true"
729 }
730
731 # start gss daemons on all nodes, or
732 # "daemon" on "list" if set
733 start_gss_daemons() {
734     local list=$1
735     local daemon=$2
736
737     if [ "$list" ] && [ "$daemon" ] ; then
738         echo "Starting gss daemon on nodes: $list"
739         do_nodes $list "$daemon" || return 8
740         return 0
741     fi
742
743     local list=$(comma_list $(mdts_nodes))
744     echo "Starting gss daemon on mds: $list"
745     do_nodes $list "$LSVCGSSD -v" || return 1
746     if $GSS_PIPEFS; then
747         do_nodes $list "$LGSSD -v" || return 2
748     fi
749
750     list=$(comma_list $(osts_nodes))
751     echo "Starting gss daemon on ost: $list"
752     do_nodes $list "$LSVCGSSD -v" || return 3
753     # starting on clients
754
755     local clients=${CLIENTS:-`hostname`}
756     if $GSS_PIPEFS; then
757         echo "Starting $LGSSD on clients $clients "
758         do_nodes $clients  "$LGSSD -v" || return 4
759     fi
760
761     # wait daemons entering "stable" status
762     sleep 5
763
764     #
765     # check daemons are running
766     #
767     list=$(comma_list $(mdts_nodes) $(osts_nodes))
768     check_gss_daemon_nodes $list lsvcgssd || return 5
769     if $GSS_PIPEFS; then
770         list=$(comma_list $(mdts_nodes))
771         check_gss_daemon_nodes $list lgssd || return 6
772     fi
773     if $GSS_PIPEFS; then
774         check_gss_daemon_nodes $clients lgssd || return 7
775     fi
776 }
777
778 stop_gss_daemons() {
779     local list=$(comma_list $(mdts_nodes))
780
781     send_sigint $list lsvcgssd lgssd
782
783     list=$(comma_list $(osts_nodes))
784     send_sigint $list lsvcgssd
785
786     list=${CLIENTS:-`hostname`}
787     send_sigint $list lgssd
788 }
789
790 init_gss() {
791     if $GSS; then
792         if ! module_loaded ptlrpc_gss; then
793             load_module ptlrpc/gss/ptlrpc_gss
794             module_loaded ptlrpc_gss ||
795                 error_exit "init_gss : GSS=$GSS, but gss/krb5 is not supported!"
796         fi
797         if $GSS_KRB5; then
798                 start_gss_daemons || error_exit "start gss daemon failed! rc=$?"
799         fi
800
801         if [ -n "$LGSS_KEYRING_DEBUG" ]; then
802                 lctl set_param -n \
803                     sptlrpc.gss.lgss_keyring.debug_level=$LGSS_KEYRING_DEBUG
804         fi
805     fi
806 }
807
808 cleanup_gss() {
809     if $GSS; then
810         stop_gss_daemons
811         # maybe cleanup credential cache?
812     fi
813 }
814
815 facet_svc() {
816         local facet=$1
817         local var=${facet}_svc
818
819         echo -n ${!var}
820 }
821
822 facet_type() {
823         local facet=$1
824
825         echo -n $facet | sed -e 's/^fs[0-9]\+//' -e 's/[0-9_]\+//' |
826                 tr '[:lower:]' '[:upper:]'
827 }
828
829 facet_number() {
830         local facet=$1
831
832         if [ $facet == mgs ] || [ $facet == client ]; then
833                 return 1
834         fi
835
836         echo -n $facet | sed -e 's/^fs[0-9]\+//' | sed -e 's/^[a-z]\+//'
837 }
838
839 facet_fstype() {
840         local facet=$1
841         local var
842
843         var=${facet}_FSTYPE
844         if [ -n "${!var}" ]; then
845                 echo -n ${!var}
846                 return
847         fi
848
849         var=$(facet_type $facet)FSTYPE
850         if [ -n "${!var}" ]; then
851                 echo -n ${!var}
852                 return
853         fi
854
855         if [ -n "$FSTYPE" ]; then
856                 echo -n $FSTYPE
857                 return
858         fi
859
860         if [[ $facet == mgs ]] && combined_mgs_mds; then
861                 facet_fstype mds1
862                 return
863         fi
864
865         return 1
866 }
867
868 node_fstypes() {
869         local node=$1
870         local fstypes
871         local fstype
872         local facets=$(get_facets)
873         local facet
874
875         for facet in ${facets//,/ }; do
876                 if [ $node == $(facet_host $facet) ] ||
877                    [ $node == "$(facet_failover_host $facet)" ]; then
878                         fstype=$(facet_fstype $facet)
879                         if [[ $fstypes != *$fstype* ]]; then
880                                 fstypes+="${fstypes:+,}$fstype"
881                         fi
882                 fi
883         done
884         echo -n $fstypes
885 }
886
887 facet_index() {
888         local facet=$1
889         local num=$(facet_number $facet)
890         local index
891
892         if [[ $(facet_type $facet) = OST ]]; then
893                 index=OSTINDEX${num}
894                 if [[ -n "${!index}" ]]; then
895                         echo -n ${!index}
896                         return
897                 fi
898
899                 index=${OST_INDICES[num - 1]}
900         fi
901
902         [[ -n "$index" ]] || index=$((num - 1))
903         echo -n $index
904 }
905
906 devicelabel() {
907         local facet=$1
908         local dev=$2
909         local label
910         local fstype=$(facet_fstype $facet)
911
912         case $fstype in
913         ldiskfs)
914                 label=$(do_facet ${facet} "$E2LABEL ${dev} 2>/dev/null");;
915         zfs)
916                 label=$(do_facet ${facet} "$ZFS get -H -o value lustre:svname \
917                                            ${dev} 2>/dev/null");;
918         *)
919                 error "unknown fstype!";;
920         esac
921
922         echo -n $label
923 }
924
925 mdsdevlabel() {
926         local num=$1
927         local device=$(mdsdevname $num)
928         local label=$(devicelabel mds$num ${device} | grep -v "CMD: ")
929         echo -n $label
930 }
931
932 ostdevlabel() {
933         local num=$1
934         local device=$(ostdevname $num)
935         local label=$(devicelabel ost$num ${device} | grep -v "CMD: ")
936         echo -n $label
937 }
938
939 #
940 # Get the device of a facet.
941 #
942 facet_device() {
943         local facet=$1
944         local device
945
946         case $facet in
947                 mgs) device=$(mgsdevname) ;;
948                 mds*) device=$(mdsdevname $(facet_number $facet)) ;;
949                 ost*) device=$(ostdevname $(facet_number $facet)) ;;
950                 fs2mds) device=$(mdsdevname 1_2) ;;
951                 fs2ost) device=$(ostdevname 1_2) ;;
952                 fs3ost) device=$(ostdevname 2_2) ;;
953                 *) ;;
954         esac
955
956         echo -n $device
957 }
958
959 #
960 # Get the virtual device of a facet.
961 #
962 facet_vdevice() {
963         local facet=$1
964         local device
965
966         case $facet in
967                 mgs) device=$(mgsvdevname) ;;
968                 mds*) device=$(mdsvdevname $(facet_number $facet)) ;;
969                 ost*) device=$(ostvdevname $(facet_number $facet)) ;;
970                 fs2mds) device=$(mdsvdevname 1_2) ;;
971                 fs2ost) device=$(ostvdevname 1_2) ;;
972                 fs3ost) device=$(ostvdevname 2_2) ;;
973                 *) ;;
974         esac
975
976         echo -n $device
977 }
978
979 running_in_vm() {
980         local virt=$(virt-what 2> /dev/null)
981
982         [ $? -eq 0 ] && [ -n "$virt" ] && { echo $virt; return; }
983
984         virt=$(dmidecode -s system-product-name | awk '{print $1}')
985
986         case $virt in
987                 VMware|KVM|VirtualBox|Parallels)
988                         echo $virt | tr '[A-Z]' '[a-z]' ;;
989                 *) ;;
990         esac
991 }
992
993 #
994 # Re-read the partition table on failover partner host.
995 # After a ZFS storage pool is created on a shared device, the partition table
996 # on the device may change. However, the operating system on the failover
997 # host may not notice the change automatically. Without the up-to-date partition
998 # block devices, 'zpool import ..' cannot find the labels, whose positions are
999 # relative to partition rather than disk beginnings.
1000 #
1001 # This function performs partprobe on the failover host to make it re-read the
1002 # partition table.
1003 #
1004 refresh_partition_table() {
1005         local facet=$1
1006         local device=$2
1007         local host
1008
1009         host=$(facet_passive_host $facet)
1010         if [[ -n "$host" ]]; then
1011                 do_node $host "$PARTPROBE $device"
1012         fi
1013 }
1014
1015 #
1016 # Get ZFS storage pool name.
1017 #
1018 zpool_name() {
1019         local facet=$1
1020         local device
1021         local poolname
1022
1023         device=$(facet_device $facet)
1024         # poolname is string before "/"
1025         poolname="${device%%/*}"
1026
1027         echo -n $poolname
1028 }
1029
1030 #
1031 # Create ZFS storage pool.
1032 #
1033 create_zpool() {
1034         local facet=$1
1035         local poolname=$2
1036         local vdev=$3
1037         shift 3
1038         local opts=${@:-"-o cachefile=none"}
1039
1040         do_facet $facet "modprobe zfs;
1041                 $ZPOOL list -H $poolname >/dev/null 2>&1 ||
1042                 $ZPOOL create -f $opts $poolname $vdev"
1043 }
1044
1045 #
1046 # Create ZFS file system.
1047 #
1048 create_zfs() {
1049         local facet=$1
1050         local dataset=$2
1051         shift 2
1052         local opts=${@:-"-o mountpoint=legacy"}
1053
1054         do_facet $facet "$ZFS list -H $dataset >/dev/null 2>&1 ||
1055                 $ZFS create $opts $dataset"
1056 }
1057
1058 #
1059 # Export ZFS storage pool.
1060 # Before exporting the pool, all datasets within the pool should be unmounted.
1061 #
1062 export_zpool() {
1063         local facet=$1
1064         shift
1065         local opts="$@"
1066         local poolname
1067
1068         poolname=$(zpool_name $facet)
1069
1070         if [[ -n "$poolname" ]]; then
1071                 do_facet $facet "! $ZPOOL list -H $poolname >/dev/null 2>&1 ||
1072                         grep -q ^$poolname/ /proc/mounts ||
1073                         $ZPOOL export $opts $poolname"
1074         fi
1075 }
1076
1077 #
1078 # Destroy ZFS storage pool.
1079 # Destroy the given pool and free up any devices for other use. This command
1080 # tries to unmount any active datasets before destroying the pool.
1081 # -f    Force any active datasets contained within the pool to be unmounted.
1082 #
1083 destroy_zpool() {
1084         local facet=$1
1085         local poolname=${2:-$(zpool_name $facet)}
1086
1087         if [[ -n "$poolname" ]]; then
1088                 do_facet $facet "! $ZPOOL list -H $poolname >/dev/null 2>&1 ||
1089                         $ZPOOL destroy -f $poolname"
1090         fi
1091 }
1092
1093 #
1094 # Import ZFS storage pool.
1095 # Force importing, even if the pool appears to be potentially active.
1096 #
1097 import_zpool() {
1098         local facet=$1
1099         shift
1100         local opts=${@:-"-o cachefile=none"}
1101         local poolname
1102
1103         poolname=$(zpool_name $facet)
1104
1105         if [[ -n "$poolname" ]]; then
1106                 opts+=" -d $(dirname $(facet_vdevice $facet))"
1107                 do_facet $facet "modprobe zfs;
1108                         $ZPOOL list -H $poolname >/dev/null 2>&1 ||
1109                         $ZPOOL import -f $opts $poolname"
1110         fi
1111 }
1112
1113 #
1114 # Set the "cachefile=none" property on ZFS storage pool so that the pool
1115 # is not automatically imported on system startup.
1116 #
1117 # In a failover environment, this will provide resource level fencing which
1118 # will ensure that the same ZFS storage pool will not be imported concurrently
1119 # on different nodes.
1120 #
1121 disable_zpool_cache() {
1122         local facet=$1
1123         local poolname
1124
1125         poolname=$(zpool_name $facet)
1126
1127         if [[ -n "$poolname" ]]; then
1128                 do_facet $facet "$ZPOOL set cachefile=none $poolname"
1129         fi
1130 }
1131
1132 #
1133 # This and set_osd_param() shall be used to access OSD parameters
1134 # once existed under "obdfilter":
1135 #
1136 #   mntdev
1137 #   stats
1138 #   read_cache_enable
1139 #   writethrough_cache_enable
1140 #
1141 get_osd_param() {
1142         local nodes=$1
1143         local device=${2:-$FSNAME-OST*}
1144         local name=$3
1145
1146         do_nodes $nodes "$LCTL get_param -n obdfilter.$device.$name \
1147                 osd-*.$device.$name 2>&1" | grep -v 'error:'
1148 }
1149
1150 set_osd_param() {
1151         local nodes=$1
1152         local device=${2:-$FSNAME-OST*}
1153         local name=$3
1154         local value=$4
1155
1156         do_nodes $nodes "$LCTL set_param -n obdfilter.$device.$name=$value \
1157                 osd-*.$device.$name=$value 2>&1" | grep -v 'error:'
1158 }
1159
1160 set_debug_size () {
1161     local dz=${1:-$DEBUG_SIZE}
1162
1163     if [ -f /sys/devices/system/cpu/possible ]; then
1164         local cpus=$(($(cut -d "-" -f 2 /sys/devices/system/cpu/possible)+1))
1165     else
1166         local cpus=$(getconf _NPROCESSORS_CONF 2>/dev/null)
1167     fi
1168
1169     # bug 19944, adjust size to be -gt num_possible_cpus()
1170     # promise 2MB for every cpu at least
1171     if [ -n "$cpus" ] && [ $((cpus * 2)) -gt $dz ]; then
1172         dz=$((cpus * 2))
1173     fi
1174     lctl set_param debug_mb=$dz
1175 }
1176
1177 set_default_debug () {
1178     local debug=${1:-"$PTLDEBUG"}
1179     local subsys=${2:-"$SUBSYSTEM"}
1180     local debug_size=${3:-$DEBUG_SIZE}
1181
1182     [ -n "$debug" ] && lctl set_param debug="$debug" >/dev/null
1183     [ -n "$subsys" ] && lctl set_param subsystem_debug="${subsys# }" >/dev/null
1184
1185     [ -n "$debug_size" ] && set_debug_size $debug_size > /dev/null
1186 }
1187
1188 set_default_debug_nodes () {
1189         local nodes="$1"
1190
1191         if [[ ,$nodes, = *,$HOSTNAME,* ]]; then
1192                 nodes=$(exclude_items_from_list "$nodes" "$HOSTNAME")
1193                 set_default_debug
1194         fi
1195
1196         do_rpc_nodes "$nodes" set_default_debug \
1197                 \\\"$PTLDEBUG\\\" \\\"$SUBSYSTEM\\\" $DEBUG_SIZE || true
1198 }
1199
1200 set_default_debug_facet () {
1201     local facet=$1
1202     local node=$(facet_active_host $facet)
1203     [ -z "$node" ] && echo "No host defined for facet $facet" && exit 1
1204
1205     set_default_debug_nodes $node
1206 }
1207
1208 set_hostid () {
1209     local hostid=${1:-$(hostid)}
1210
1211     if [ ! -s /etc/hostid ]; then
1212         printf $(echo -n $hostid |
1213             sed 's/\(..\)\(..\)\(..\)\(..\)/\\x\4\\x\3\\x\2\\x\1/') >/etc/hostid
1214     fi
1215 }
1216
1217 # Facet functions
1218 mount_facets () {
1219         local facets=${1:-$(get_facets)}
1220         local facet
1221
1222         for facet in ${facets//,/ }; do
1223                 mount_facet $facet
1224                 local RC=$?
1225                 [ $RC -eq 0 ] && continue
1226
1227                 if [ "$TESTSUITE.$TESTNAME" = "replay-dual.test_0a" ]; then
1228                         skip "Restart of $facet failed!." && touch $LU482_FAILED
1229                 else
1230                         error "Restart of $facet failed!"
1231                 fi
1232                 return $RC
1233         done
1234 }
1235
1236 #
1237 # Add argument "arg" (e.g., "loop") to the comma-separated list
1238 # of arguments for option "opt" (e.g., "-o") on command
1239 # line "opts" (e.g., "-o flock").
1240 #
1241 csa_add() {
1242         local opts=$1
1243         local opt=$2
1244         local arg=$3
1245         local opt_pattern="\([[:space:]]\+\|^\)$opt"
1246
1247         if echo "$opts" | grep -q $opt_pattern; then
1248                 opts=$(echo "$opts" | sed -e \
1249                         "s/$opt_pattern[[:space:]]*[^[:space:]]\+/&,$arg/")
1250         else
1251                 opts+="${opts:+ }$opt $arg"
1252         fi
1253         echo -n "$opts"
1254 }
1255
1256 mount_facet() {
1257         local facet=$1
1258         shift
1259         local dev=$(facet_active $facet)_dev
1260         local opt=${facet}_opt
1261         local mntpt=$(facet_mntpt $facet)
1262         local opts="${!opt} $@"
1263         local fstype=$(facet_fstype $facet)
1264         local devicelabel
1265
1266         module_loaded lustre || load_modules
1267
1268         if [ $(facet_fstype $facet) == ldiskfs ] &&
1269            ! do_facet $facet test -b ${!dev}; then
1270                 opts=$(csa_add "$opts" -o loop)
1271         fi
1272
1273         if [[ $(facet_fstype $facet) == zfs ]]; then
1274                 # import ZFS storage pool
1275                 import_zpool $facet || return ${PIPESTATUS[0]}
1276         fi
1277
1278         case $fstype in
1279         ldiskfs)
1280                 devicelabel=$(do_facet ${facet} "$E2LABEL ${!dev}");;
1281         zfs)
1282                 devicelabel=$(do_facet ${facet} "$ZFS get -H -o value \
1283                                                 lustre:svname ${!dev}");;
1284         *)
1285                 error "unknown fstype!";;
1286         esac
1287
1288         echo "Starting ${facet}: $opts ${!dev} $mntpt"
1289         # for testing LU-482 error handling in mount_facets() and test_0a()
1290         if [ -f $TMP/test-lu482-trigger ]; then
1291                 RC=2
1292         else
1293                 do_facet ${facet} "mkdir -p $mntpt; $MOUNT_CMD $opts \
1294                                    ${!dev} $mntpt"
1295                 RC=${PIPESTATUS[0]}
1296         fi
1297
1298         if [ $RC -ne 0 ]; then
1299                 echo "Start of ${!dev} on ${facet} failed ${RC}"
1300                 return $RC
1301         fi
1302
1303         health=$(do_facet ${facet} "$LCTL get_param -n health_check")
1304         if [[ "$health" != "healthy" ]]; then
1305                 error "$facet is in a unhealthy state"
1306         fi
1307
1308         set_default_debug_facet $facet
1309
1310         if [[ $facet == mds* ]]; then
1311                 do_facet $facet \
1312                 lctl set_param -n mdt.${FSNAME}*.enable_remote_dir=1 2>/dev/null
1313         fi
1314
1315         if [[ $opts =~ .*nosvc.* ]]; then
1316                 echo "Start ${!dev} without service"
1317         else
1318
1319                 case $fstype in
1320                 ldiskfs)
1321                         wait_update_facet ${facet} "$E2LABEL ${!dev} \
1322                                 2>/dev/null | grep -E ':[a-zA-Z]{3}[0-9]{4}'" \
1323                                 "" || error "${!dev} failed to initialize!";;
1324                 zfs)
1325                         wait_update_facet ${facet} "$ZFS get -H -o value \
1326                                 lustre:svname ${!dev} 2>/dev/null | \
1327                                 grep -E ':[a-zA-Z]{3}[0-9]{4}'" "" ||
1328                                 error "${!dev} failed to initialize!";;
1329
1330                 *)
1331                         error "unknown fstype!";;
1332                 esac
1333         fi
1334
1335         # commit the device label change to disk
1336         if [[ $devicelabel =~ (:[a-zA-Z]{3}[0-9]{4}) ]]; then
1337                 echo "Commit the device label on ${!dev}"
1338                 do_facet $facet "sync; sync; sync"
1339                 sleep 5
1340         fi
1341
1342
1343         label=$(devicelabel ${facet} ${!dev})
1344         [ -z "$label" ] && echo no label for ${!dev} && exit 1
1345         eval export ${facet}_svc=${label}
1346         echo Started ${label}
1347
1348         return $RC
1349 }
1350
1351 # start facet device options
1352 start() {
1353         local facet=$1
1354         shift
1355         local device=$1
1356         shift
1357         eval export ${facet}_dev=${device}
1358         eval export ${facet}_opt=\"$@\"
1359
1360         local varname=${facet}failover_dev
1361         if [ -n "${!varname}" ] ; then
1362                 eval export ${facet}failover_dev=${!varname}
1363         else
1364                 eval export ${facet}failover_dev=$device
1365         fi
1366
1367         local mntpt=$(facet_mntpt $facet)
1368         do_facet ${facet} mkdir -p $mntpt
1369         eval export ${facet}_MOUNT=$mntpt
1370         mount_facet ${facet}
1371         RC=$?
1372
1373         if [[ $facet == mds* ]]; then
1374                 do_facet $facet \
1375                         lctl set_param -n mdt.${FSNAME}*.enable_remote_dir=1 \
1376                                 2>/dev/null
1377         fi
1378
1379         return $RC
1380 }
1381
1382 stop() {
1383     local running
1384     local facet=$1
1385     shift
1386     local HOST=`facet_active_host $facet`
1387     [ -z $HOST ] && echo stop: no host for $facet && return 0
1388
1389     local mntpt=$(facet_mntpt $facet)
1390     running=$(do_facet ${facet} "grep -c $mntpt' ' /proc/mounts") || true
1391     if [ ${running} -ne 0 ]; then
1392         echo "Stopping $mntpt (opts:$@) on $HOST"
1393         do_facet ${facet} $UMOUNT $@ $mntpt
1394     fi
1395
1396         # umount should block, but we should wait for unrelated obd's
1397         # like the MGS or MGC to also stop.
1398         wait_exit_ST ${facet} || return ${PIPESTATUS[0]}
1399
1400         if [[ $(facet_fstype $facet) == zfs ]]; then
1401                 # export ZFS storage pool
1402                 export_zpool $facet
1403         fi
1404 }
1405
1406 # save quota version (both administrative and operational quotas)
1407 # add an additional parameter if mountpoint is ever different from $MOUNT
1408 #
1409 # XXX This function is kept for interoperability with old server (< 2.3.50),
1410 #     it should be removed whenever we drop the interoperability for such
1411 #     server.
1412 quota_save_version() {
1413     local fsname=${2:-$FSNAME}
1414     local spec=$1
1415     local ver=$(tr -c -d "123" <<< $spec)
1416     local type=$(tr -c -d "ug" <<< $spec)
1417
1418     [ -n "$ver" -a "$ver" != "3" ] && error "wrong quota version specifier"
1419
1420     [ -n "$type" ] && { $LFS quotacheck -$type $MOUNT || error "quotacheck has failed"; }
1421
1422     do_facet mgs "lctl conf_param ${fsname}-MDT*.mdd.quota_type=$spec"
1423     local varsvc
1424     local osts=$(get_facets OST)
1425     for ost in ${osts//,/ }; do
1426         varsvc=${ost}_svc
1427         do_facet mgs "lctl conf_param ${!varsvc}.ost.quota_type=$spec"
1428     done
1429 }
1430
1431 # client could mount several lustre
1432 #
1433 # XXX This function is kept for interoperability with old server (< 2.3.50),
1434 #     it should be removed whenever we drop the interoperability for such
1435 #     server.
1436 quota_type() {
1437         local fsname=${1:-$FSNAME}
1438         local rc=0
1439         do_facet $SINGLEMDS lctl get_param mdd.${fsname}-MDT*.quota_type ||
1440                 rc=$?
1441         do_nodes $(comma_list $(osts_nodes)) \
1442                 lctl get_param obdfilter.${fsname}-OST*.quota_type || rc=$?
1443         return $rc
1444 }
1445
1446 # get mdt quota type
1447 mdt_quota_type() {
1448         local varsvc=${SINGLEMDS}_svc
1449         do_facet $SINGLEMDS $LCTL get_param -n \
1450                 osd-$(facet_fstype $SINGLEMDS).${!varsvc}.quota_slave.enabled
1451 }
1452
1453 # get ost quota type
1454 ost_quota_type() {
1455         # All OSTs should have same quota type
1456         local varsvc=ost1_svc
1457         do_facet ost1 $LCTL get_param -n \
1458                 osd-$(facet_fstype ost1).${!varsvc}.quota_slave.enabled
1459 }
1460
1461 # restore old quota type settings
1462 restore_quota() {
1463         if [ "$old_MDT_QUOTA_TYPE" ]; then
1464                 do_facet mgs $LCTL conf_param \
1465                         $FSNAME.quota.mdt=$old_MDT_QUOTA_TYPE
1466         fi
1467         if [ "$old_OST_QUOTA_TYPE" ]; then
1468                 do_facet mgs $LCTL conf_param \
1469                         $FSNAME.quota.ost=$old_OST_QUOTA_TYPE
1470         fi
1471 }
1472
1473 # Handle the case when there is a space in the lfs df
1474 # "filesystem summary" line the same as when there is no space.
1475 # This will allow fixing the "lfs df" summary line in the future.
1476 lfs_df() {
1477         $LFS df $* | sed -e 's/filesystem /filesystem_/'
1478 }
1479
1480 # Get free inodes on the MDT specified by mdt index, free indoes on
1481 # the whole filesystem will be returned when index == -1.
1482 mdt_free_inodes() {
1483         local index=$1
1484         local free_inodes
1485         local mdt_uuid
1486
1487         if [ $index -eq -1 ]; then
1488                 mdt_uuid="summary"
1489         else
1490                 mdt_uuid=$(mdtuuid_from_index $index)
1491         fi
1492
1493         free_inodes=$(lfs_df -i $MOUNT | grep $mdt_uuid | awk '{print $4}')
1494         echo $free_inodes
1495 }
1496
1497 setup_quota(){
1498         local mntpt=$1
1499
1500         # save old quota type & set new quota type
1501         local mdt_qtype=$(mdt_quota_type)
1502         local ost_qtype=$(ost_quota_type)
1503
1504         echo "[HOST:$HOSTNAME] [old_mdt_qtype:$mdt_qtype]" \
1505                 "[old_ost_qtype:$ost_qtype] [new_qtype:$QUOTA_TYPE]"
1506
1507         export old_MDT_QUOTA_TYPE=$mdt_qtype
1508         export old_OST_QUOTA_TYPE=$ost_qtype
1509
1510         do_facet mgs $LCTL conf_param $FSNAME.quota.mdt=$QUOTA_TYPE ||
1511                 error "set mdt quota type failed"
1512         do_facet mgs $LCTL conf_param $FSNAME.quota.ost=$QUOTA_TYPE ||
1513                 error "set ost quota type failed"
1514
1515         local quota_usrs=$QUOTA_USERS
1516
1517         # get_filesystem_size
1518         local disksz=$(lfs_df $mntpt | grep "summary" | awk '{print $2}')
1519         local blk_soft=$((disksz + 1024))
1520         local blk_hard=$((blk_soft + blk_soft / 20)) # Go 5% over
1521
1522         local inodes=$(lfs_df -i $mntpt | grep "summary" | awk '{print $2}')
1523         local i_soft=$inodes
1524         local i_hard=$((i_soft + i_soft / 20))
1525
1526         echo "Total disk size: $disksz  block-softlimit: $blk_soft" \
1527                 "block-hardlimit: $blk_hard inode-softlimit: $i_soft" \
1528                 "inode-hardlimit: $i_hard"
1529
1530         local cmd
1531         for usr in $quota_usrs; do
1532                 echo "Setting up quota on $HOSTNAME:$mntpt for $usr..."
1533                 for type in u g; do
1534                         cmd="$LFS setquota -$type $usr -b $blk_soft"
1535                         cmd="$cmd -B $blk_hard -i $i_soft -I $i_hard $mntpt"
1536                         echo "+ $cmd"
1537                         eval $cmd || error "$cmd FAILED!"
1538                 done
1539                 # display the quota status
1540                 echo "Quota settings for $usr : "
1541                 $LFS quota -v -u $usr $mntpt || true
1542         done
1543 }
1544
1545 zconf_mount() {
1546         local client=$1
1547         local mnt=$2
1548         local opts=${3:-$MOUNT_OPTS}
1549         opts=${opts:+-o $opts}
1550         local flags=${4:-$MOUNT_FLAGS}
1551
1552         local device=$MGSNID:/$FSNAME$FILESET
1553         if [ -z "$mnt" -o -z "$FSNAME" ]; then
1554                 echo "Bad mount command: opt=$flags $opts dev=$device " \
1555                      "mnt=$mnt"
1556                 exit 1
1557         fi
1558
1559         echo "Starting client: $client: $flags $opts $device $mnt"
1560         do_node $client mkdir -p $mnt
1561         if [ -n "$FILESET" -a -z "$SKIP_FILESET" ];then
1562                 do_node $client $MOUNT_CMD $flags $opts $MGSNID:/$FSNAME \
1563                         $mnt || return 1
1564                 #disable FILESET if not supported
1565                 do_nodes $client lctl get_param -n \
1566                         mdc.$FSNAME-MDT0000*.import | grep -q subtree ||
1567                                 device=$MGSNID:/$FSNAME
1568                 do_node $client mkdir -p $mnt/$FILESET
1569                 do_node $client "! grep -q $mnt' ' /proc/mounts ||
1570                         umount $mnt"
1571         fi
1572         do_node $client $MOUNT_CMD $flags $opts $device $mnt || return 1
1573
1574         set_default_debug_nodes $client
1575
1576         return 0
1577 }
1578
1579 zconf_umount() {
1580     local client=$1
1581     local mnt=$2
1582     local force
1583     local busy
1584     local need_kill
1585
1586     [ "$3" ] && force=-f
1587     local running=$(do_node $client "grep -c $mnt' ' /proc/mounts") || true
1588     if [ $running -ne 0 ]; then
1589         echo "Stopping client $client $mnt (opts:$force)"
1590         do_node $client lsof -t $mnt || need_kill=no
1591         if [ "x$force" != "x" -a "x$need_kill" != "xno" ]; then
1592             pids=$(do_node $client lsof -t $mnt | sort -u);
1593             if [ -n $pids ]; then
1594                 do_node $client kill -9 $pids || true
1595             fi
1596         fi
1597
1598         busy=$(do_node $client "umount $force $mnt 2>&1" | grep -c "busy") || true
1599         if [ $busy -ne 0 ] ; then
1600             echo "$mnt is still busy, wait one second" && sleep 1
1601             do_node $client umount $force $mnt
1602         fi
1603     fi
1604 }
1605
1606 # nodes is comma list
1607 sanity_mount_check_nodes () {
1608     local nodes=$1
1609     shift
1610     local mnts="$@"
1611     local mnt
1612
1613     # FIXME: assume that all cluster nodes run the same os
1614     [ "$(uname)" = Linux ] || return 0
1615
1616     local rc=0
1617     for mnt in $mnts ; do
1618         do_nodes $nodes "running=\\\$(grep -c $mnt' ' /proc/mounts);
1619 mpts=\\\$(mount | grep -c $mnt' ');
1620 if [ \\\$running -ne \\\$mpts ]; then
1621     echo \\\$(hostname) env are INSANE!;
1622     exit 1;
1623 fi"
1624     [ $? -eq 0 ] || rc=1
1625     done
1626     return $rc
1627 }
1628
1629 sanity_mount_check_servers () {
1630     [ -n "$CLIENTONLY" ] &&
1631         { echo "CLIENTONLY mode, skip mount_check_servers"; return 0; } || true
1632     echo Checking servers environments
1633
1634     # FIXME: modify get_facets to display all facets wo params
1635     local facets="$(get_facets OST),$(get_facets MDS),mgs"
1636     local node
1637     local mntpt
1638     local facet
1639     for facet in ${facets//,/ }; do
1640         node=$(facet_host ${facet})
1641         mntpt=$(facet_mntpt $facet)
1642         sanity_mount_check_nodes $node $mntpt ||
1643             { error "server $node environments are insane!"; return 1; }
1644     done
1645 }
1646
1647 sanity_mount_check_clients () {
1648     local clients=${1:-$CLIENTS}
1649     local mntpt=${2:-$MOUNT}
1650     local mntpt2=${3:-$MOUNT2}
1651
1652     [ -z $clients ] && clients=$(hostname)
1653     echo Checking clients $clients environments
1654
1655     sanity_mount_check_nodes $clients $mntpt $mntpt2 ||
1656        error "clients environments are insane!"
1657 }
1658
1659 sanity_mount_check () {
1660     sanity_mount_check_servers || return 1
1661     sanity_mount_check_clients || return 2
1662 }
1663
1664 # mount clients if not mouted
1665 zconf_mount_clients() {
1666         local clients=$1
1667         local mnt=$2
1668         local opts=${3:-$MOUNT_OPTS}
1669         opts=${opts:+-o $opts}
1670         local flags=${4:-$MOUNT_FLAGS}
1671
1672         local device=$MGSNID:/$FSNAME$FILESET
1673         if [ -z "$mnt" -o -z "$FSNAME" ]; then
1674                 echo "Bad conf mount command: opt=$flags $opts dev=$device " \
1675                      "mnt=$mnt"
1676                 exit 1
1677         fi
1678
1679         echo "Starting client $clients: $flags $opts $device $mnt"
1680         if [ -n "$FILESET" -a ! -n "$SKIP_FILESET" ]; then
1681                 do_nodes $clients "! grep -q $mnt' ' /proc/mounts ||
1682                         umount $mnt"
1683                 do_nodes $clients $MOUNT_CMD $flags $opts $MGSNID:/$FSNAME \
1684                         $mnt || return 1
1685                 #disable FILESET if not supported
1686                 do_nodes $clients lctl get_param -n \
1687                         mdc.$FSNAME-MDT0000*.import | grep -q subtree ||
1688                                 device=$MGSNID:/$FSNAME
1689                 do_nodes $clients mkdir -p $mnt/$FILESET
1690                 do_nodes $clients "! grep -q $mnt' ' /proc/mounts ||
1691                         umount $mnt"
1692         fi
1693
1694         do_nodes $clients "
1695 running=\\\$(mount | grep -c $mnt' ');
1696 rc=0;
1697 if [ \\\$running -eq 0 ] ; then
1698     mkdir -p $mnt;
1699     $MOUNT_CMD $flags $opts $device $mnt;
1700     rc=\\\$?;
1701 fi;
1702 exit \\\$rc" || return ${PIPESTATUS[0]}
1703
1704         echo "Started clients $clients: "
1705         do_nodes $clients "mount | grep $mnt' '"
1706
1707         set_default_debug_nodes $clients
1708
1709         return 0
1710 }
1711
1712 zconf_umount_clients() {
1713     local clients=$1
1714     local mnt=$2
1715     local force
1716
1717     [ "$3" ] && force=-f
1718
1719     echo "Stopping clients: $clients $mnt (opts:$force)"
1720     do_nodes $clients "running=\\\$(grep -c $mnt' ' /proc/mounts);
1721 if [ \\\$running -ne 0 ] ; then
1722 echo Stopping client \\\$(hostname) $mnt opts:$force;
1723 lsof $mnt || need_kill=no;
1724 if [ "x$force" != "x" -a "x\\\$need_kill" != "xno" ]; then
1725     pids=\\\$(lsof -t $mnt | sort -u);
1726     if [ -n \\\"\\\$pids\\\" ]; then
1727              kill -9 \\\$pids;
1728     fi
1729 fi;
1730 while umount $force $mnt 2>&1 | grep -q "busy"; do
1731     echo "$mnt is still busy, wait one second" && sleep 1;
1732 done;
1733 fi"
1734 }
1735
1736 shutdown_node () {
1737     local node=$1
1738     echo + $POWER_DOWN $node
1739     $POWER_DOWN $node
1740 }
1741
1742 shutdown_node_hard () {
1743     local host=$1
1744     local attempts=$SHUTDOWN_ATTEMPTS
1745
1746     for i in $(seq $attempts) ; do
1747         shutdown_node $host
1748         sleep 1
1749         wait_for_function --quiet "! ping -w 3 -c 1 $host" 5 1 && return 0
1750         echo "waiting for $host to fail attempts=$attempts"
1751         [ $i -lt $attempts ] || \
1752             { echo "$host still pingable after power down! attempts=$attempts" && return 1; }
1753     done
1754 }
1755
1756 shutdown_client() {
1757     local client=$1
1758     local mnt=${2:-$MOUNT}
1759     local attempts=3
1760
1761     if [ "$FAILURE_MODE" = HARD ]; then
1762         shutdown_node_hard $client
1763     else
1764        zconf_umount_clients $client $mnt -f
1765     fi
1766 }
1767
1768 facets_on_host () {
1769     local host=$1
1770     local facets="$(get_facets OST),$(get_facets MDS)"
1771     local affected
1772
1773     combined_mgs_mds || facets="$facets,mgs"
1774
1775     for facet in ${facets//,/ }; do
1776         if [ $(facet_active_host $facet) == $host ]; then
1777            affected="$affected $facet"
1778         fi
1779     done
1780
1781     echo $(comma_list $affected)
1782 }
1783
1784 facet_up() {
1785         local facet=$1
1786         local host=${2:-$(facet_host $facet)}
1787
1788         local label=$(convert_facet2label $facet)
1789         do_node $host $LCTL dl | awk '{ print $4 }' | grep -q "^$label\$"
1790 }
1791
1792 facets_up_on_host () {
1793     local host=$1
1794     local facets=$(facets_on_host $host)
1795     local affected_up
1796
1797     for facet in ${facets//,/ }; do
1798         if $(facet_up $facet $host); then
1799             affected_up="$affected_up $facet"
1800         fi
1801     done
1802
1803     echo $(comma_list $affected_up)
1804 }
1805
1806 shutdown_facet() {
1807     local facet=$1
1808
1809     if [ "$FAILURE_MODE" = HARD ]; then
1810         shutdown_node_hard $(facet_active_host $facet)
1811     else
1812         stop $facet
1813     fi
1814 }
1815
1816 reboot_node() {
1817     local node=$1
1818     echo + $POWER_UP $node
1819     $POWER_UP $node
1820 }
1821
1822 remount_facet() {
1823     local facet=$1
1824
1825     stop $facet
1826     mount_facet $facet
1827 }
1828
1829 reboot_facet() {
1830         local facet=$1
1831         if [ "$FAILURE_MODE" = HARD ]; then
1832                 reboot_node $(facet_active_host $facet)
1833         else
1834                 sleep 10
1835         fi
1836 }
1837
1838 boot_node() {
1839     local node=$1
1840     if [ "$FAILURE_MODE" = HARD ]; then
1841        reboot_node $node
1842        wait_for_host $node
1843     fi
1844 }
1845
1846 facets_hosts () {
1847     local facets=$1
1848     local hosts
1849
1850     for facet in ${facets//,/ }; do
1851         hosts=$(expand_list $hosts $(facet_host $facet) )
1852     done
1853
1854     echo $hosts
1855 }
1856
1857 _check_progs_installed () {
1858     local progs=$@
1859     local rc=0
1860
1861     for prog in $progs; do
1862         if ! [ "$(which $prog)"  -o  "${!prog}" ]; then
1863            echo $prog missing on $(hostname)
1864            rc=1
1865         fi
1866     done
1867     return $rc
1868 }
1869
1870 check_progs_installed () {
1871         local nodes=$1
1872         shift
1873
1874         do_rpc_nodes "$nodes" _check_progs_installed $@
1875 }
1876
1877 # recovery-scale functions
1878 node_var_name() {
1879     echo __$(echo $1 | tr '-' '_' | tr '.' '_')
1880 }
1881
1882 start_client_load() {
1883     local client=$1
1884     local load=$2
1885     local var=$(node_var_name $client)_load
1886     eval export ${var}=$load
1887
1888     do_node $client "PATH=$PATH MOUNT=$MOUNT ERRORS_OK=$ERRORS_OK \
1889 BREAK_ON_ERROR=$BREAK_ON_ERROR \
1890 END_RUN_FILE=$END_RUN_FILE \
1891 LOAD_PID_FILE=$LOAD_PID_FILE \
1892 TESTLOG_PREFIX=$TESTLOG_PREFIX \
1893 TESTNAME=$TESTNAME \
1894 DBENCH_LIB=$DBENCH_LIB \
1895 DBENCH_SRC=$DBENCH_SRC \
1896 CLIENT_COUNT=$((CLIENTCOUNT - 1)) \
1897 LFS=$LFS \
1898 run_${load}.sh" &
1899     local ppid=$!
1900     log "Started client load: ${load} on $client"
1901
1902     # get the children process IDs
1903     local pids=$(ps --ppid $ppid -o pid= | xargs)
1904     CLIENT_LOAD_PIDS="$CLIENT_LOAD_PIDS $ppid $pids"
1905     return 0
1906 }
1907
1908 start_client_loads () {
1909     local -a clients=(${1//,/ })
1910     local numloads=${#CLIENT_LOADS[@]}
1911     local testnum
1912
1913     for ((nodenum=0; nodenum < ${#clients[@]}; nodenum++ )); do
1914         testnum=$((nodenum % numloads))
1915         start_client_load ${clients[nodenum]} ${CLIENT_LOADS[testnum]}
1916     done
1917     # bug 22169: wait the background threads to start
1918     sleep 2
1919 }
1920
1921 # only for remote client
1922 check_client_load () {
1923         local client=$1
1924         local var=$(node_var_name $client)_load
1925         local testload=run_${!var}.sh
1926
1927         ps auxww | grep -v grep | grep $client | grep -q $testload || return 1
1928
1929         # bug 18914: try to connect several times not only when
1930         # check ps, but  while check_node_health also
1931
1932         local tries=3
1933         local RC=254
1934         while [ $RC = 254 -a $tries -gt 0 ]; do
1935                 let tries=$tries-1
1936                 # assume success
1937                 RC=0
1938                 if ! check_node_health $client; then
1939                         RC=${PIPESTATUS[0]}
1940                         if [ $RC -eq 254 ]; then
1941                                 # FIXME: not sure how long we shuold sleep here
1942                                 sleep 10
1943                                 continue
1944                         fi
1945                         echo "check node health failed: RC=$RC "
1946                         return $RC
1947                 fi
1948         done
1949         # We can continue try to connect if RC=254
1950         # Just print the warning about this
1951         if [ $RC = 254 ]; then
1952                 echo "got a return status of $RC from do_node while checking " \
1953                 "node health on $client"
1954         fi
1955
1956         # see if the load is still on the client
1957         tries=3
1958         RC=254
1959         while [ $RC = 254 -a $tries -gt 0 ]; do
1960                 let tries=$tries-1
1961                 # assume success
1962                 RC=0
1963                 if ! do_node $client \
1964                         "ps auxwww | grep -v grep | grep -q $testload"; then
1965                         RC=${PIPESTATUS[0]}
1966                         sleep 30
1967                 fi
1968         done
1969         if [ $RC = 254 ]; then
1970                 echo "got a return status of $RC from do_node while checking " \
1971                 "(node health and 'ps') the client load on $client"
1972                 # see if we can diagnose a bit why this is
1973         fi
1974
1975         return $RC
1976 }
1977 check_client_loads () {
1978    local clients=${1//,/ }
1979    local client=
1980    local rc=0
1981
1982    for client in $clients; do
1983       check_client_load $client
1984       rc=${PIPESTATUS[0]}
1985       if [ "$rc" != 0 ]; then
1986         log "Client load failed on node $client, rc=$rc"
1987         return $rc
1988       fi
1989    done
1990 }
1991
1992 restart_client_loads () {
1993     local clients=${1//,/ }
1994     local expectedfail=${2:-""}
1995     local client=
1996     local rc=0
1997
1998     for client in $clients; do
1999         check_client_load $client
2000         rc=${PIPESTATUS[0]}
2001         if [ "$rc" != 0 -a "$expectedfail" ]; then
2002             local var=$(node_var_name $client)_load
2003             start_client_load $client ${!var}
2004             echo "Restarted client load ${!var}: on $client. Checking ..."
2005             check_client_load $client
2006             rc=${PIPESTATUS[0]}
2007             if [ "$rc" != 0 ]; then
2008                 log "Client load failed to restart on node $client, rc=$rc"
2009                 # failure one client load means test fail
2010                 # we do not need to check other
2011                 return $rc
2012             fi
2013         else
2014             return $rc
2015         fi
2016     done
2017 }
2018
2019 # Start vmstat and save its process ID in a file.
2020 start_vmstat() {
2021     local nodes=$1
2022     local pid_file=$2
2023
2024     [ -z "$nodes" -o -z "$pid_file" ] && return 0
2025
2026     do_nodes $nodes \
2027         "vmstat 1 > $TESTLOG_PREFIX.$TESTNAME.vmstat.\\\$(hostname -s).log \
2028         2>/dev/null </dev/null & echo \\\$! > $pid_file"
2029 }
2030
2031 # Display the nodes on which client loads failed.
2032 print_end_run_file() {
2033     local file=$1
2034     local node
2035
2036     [ -s $file ] || return 0
2037
2038     echo "Found the END_RUN_FILE file: $file"
2039     cat $file
2040
2041     # A client load will stop if it finds the END_RUN_FILE file.
2042     # That does not mean the client load actually failed though.
2043     # The first node in END_RUN_FILE is the one we are interested in.
2044     read node < $file
2045
2046     if [ -n "$node" ]; then
2047         local var=$(node_var_name $node)_load
2048
2049         local prefix=$TESTLOG_PREFIX
2050         [ -n "$TESTNAME" ] && prefix=$prefix.$TESTNAME
2051         local stdout_log=$prefix.run_${!var}_stdout.$node.log
2052         local debug_log=$(echo $stdout_log | sed 's/\(.*\)stdout/\1debug/')
2053
2054         echo "Client load ${!var} failed on node $node:"
2055         echo "$stdout_log"
2056         echo "$debug_log"
2057     fi
2058 }
2059
2060 # Stop the process which had its PID saved in a file.
2061 stop_process() {
2062     local nodes=$1
2063     local pid_file=$2
2064
2065     [ -z "$nodes" -o -z "$pid_file" ] && return 0
2066
2067     do_nodes $nodes "test -f $pid_file &&
2068         { kill -s TERM \\\$(cat $pid_file); rm -f $pid_file; }" || true
2069 }
2070
2071 # Stop all client loads.
2072 stop_client_loads() {
2073     local nodes=${1:-$CLIENTS}
2074     local pid_file=$2
2075
2076     # stop the client loads
2077     stop_process $nodes $pid_file
2078
2079     # clean up the processes that started them
2080     [ -n "$CLIENT_LOAD_PIDS" ] && kill -9 $CLIENT_LOAD_PIDS 2>/dev/null || true
2081 }
2082 # End recovery-scale functions
2083
2084 # verify that lustre actually cleaned up properly
2085 cleanup_check() {
2086         VAR=$(lctl get_param -n catastrophe 2>&1)
2087         if [ $? = 0 ] ; then
2088                 if [ $VAR != 0 ]; then
2089                         error "LBUG/LASSERT detected"
2090                 fi
2091         fi
2092         BUSY=$(dmesg | grep -i destruct || true)
2093         if [ -n "$BUSY" ]; then
2094                 echo "$BUSY" 1>&2
2095                 [ -e $TMP/debug ] && mv $TMP/debug $TMP/debug-busy.$(date +%s)
2096                 exit 205
2097         fi
2098
2099         check_mem_leak || exit 204
2100
2101         [[ $($LCTL dl 2>/dev/null | wc -l) -gt 0 ]] && $LCTL dl &&
2102                 echo "$TESTSUITE: lustre didn't clean up..." 1>&2 &&
2103                 return 202 || true
2104
2105         if module_loaded lnet || module_loaded libcfs; then
2106                 echo "$TESTSUITE: modules still loaded..." 1>&2
2107                 /sbin/lsmod 1>&2
2108                 return 203
2109         fi
2110         return 0
2111 }
2112
2113 wait_update () {
2114         local verbose=false
2115         if [[ "$1" == "--verbose" ]]; then
2116                 shift
2117                 verbose=true
2118         fi
2119
2120         local node=$1
2121         local TEST=$2
2122         local FINAL=$3
2123         local MAX=${4:-90}
2124         local RESULT
2125         local PREV_RESULT
2126         local WAIT=0
2127         local sleep=1
2128         local print=10
2129
2130         PREV_RESULT=$(do_node $node "$TEST")
2131         while [ true ]; do
2132                 RESULT=$(do_node $node "$TEST")
2133                 if [[ "$RESULT" == "$FINAL" ]]; then
2134                         [[ -z "$RESULT" || $WAIT -le $sleep ]] ||
2135                                 echo "Updated after ${WAIT}s: wanted '$FINAL'"\
2136                                      "got '$RESULT'"
2137                         return 0
2138                 fi
2139                 if [[ $verbose && "$RESULT" != "$PREV_RESULT" ]]; then
2140                         echo "Changed after ${WAIT}s: from '$PREV_RESULT'"\
2141                              "to '$RESULT'"
2142                         PREV_RESULT=$RESULT
2143                 fi
2144                 [[ $WAIT -ge $MAX ]] && break
2145                 [[ $((WAIT % print)) -eq 0 ]] &&
2146                         echo "Waiting $((MAX - WAIT)) secs for update"
2147                 WAIT=$((WAIT + sleep))
2148                 sleep $sleep
2149         done
2150         echo "Update not seen after ${MAX}s: wanted '$FINAL' got '$RESULT'"
2151         return 3
2152 }
2153
2154 wait_update_facet() {
2155         local verbose=
2156         [ "$1" = "--verbose" ] && verbose="$1" && shift
2157
2158         local facet=$1
2159         shift
2160         wait_update $verbose $(facet_active_host $facet) "$@"
2161 }
2162
2163 sync_all_data() {
2164         do_nodes $(comma_list $(mdts_nodes)) \
2165             "lctl set_param -n osd*.*MDT*.force_sync=1"
2166         do_nodes $(comma_list $(osts_nodes)) \
2167             "lctl set_param -n osd*.*OS*.force_sync=1" 2>&1 |
2168                 grep -v 'Found no match'
2169 }
2170
2171 wait_zfs_commit() {
2172         # the occupied disk space will be released
2173         # only after DMUs are committed
2174         if [[ $(facet_fstype $1) == zfs ]]; then
2175                 echo "sleep $2 for ZFS OSD"
2176                 sleep $2
2177         fi
2178 }
2179
2180 wait_delete_completed_mds() {
2181         local MAX_WAIT=${1:-20}
2182         # for ZFS, waiting more time for DMUs to be committed
2183         local ZFS_WAIT=${2:-5}
2184         local mds2sync=""
2185         local stime=$(date +%s)
2186         local etime
2187         local node
2188         local changes
2189
2190         # find MDS with pending deletions
2191         for node in $(mdts_nodes); do
2192                 changes=$(do_node $node "$LCTL get_param -n osc.*MDT*.sync_*" \
2193                         2>/dev/null | calc_sum)
2194                 if [[ $changes -eq 0 ]]; then
2195                         continue
2196                 fi
2197                 mds2sync="$mds2sync $node"
2198         done
2199         if [ -z "$mds2sync" ]; then
2200                 wait_zfs_commit $SINGLEMDS $ZFS_WAIT
2201                 return
2202         fi
2203         mds2sync=$(comma_list $mds2sync)
2204
2205         # sync MDS transactions
2206         do_nodes $mds2sync "$LCTL set_param -n osd*.*MD*.force_sync 1"
2207
2208         # wait till all changes are sent and commmitted by OSTs
2209         # for ldiskfs space is released upon execution, but DMU
2210         # do this upon commit
2211
2212         local WAIT=0
2213         while [[ $WAIT -ne $MAX_WAIT ]]; do
2214                 changes=$(do_nodes $mds2sync \
2215                         "$LCTL get_param -n osc.*MDT*.sync_*" | calc_sum)
2216                 #echo "$node: $changes changes on all"
2217                 if [[ $changes -eq 0 ]]; then
2218                         wait_zfs_commit $SINGLEMDS $ZFS_WAIT
2219                         return
2220                 fi
2221                 sleep 1
2222                 WAIT=$(( WAIT + 1))
2223         done
2224
2225         etime=$(date +%s)
2226         echo "Delete is not completed in $((etime - stime)) seconds"
2227         do_nodes $mds2sync "$LCTL get_param osc.*MDT*.sync_*"
2228 }
2229
2230 wait_for_host() {
2231     local hostlist=$1
2232
2233     # we can use "for" here because we are waiting the slowest
2234     for host in ${hostlist//,/ }; do
2235         check_network "$host" 900
2236     done
2237     while ! do_nodes $hostlist hostname  > /dev/null; do sleep 5; done
2238 }
2239
2240 wait_for_facet() {
2241     local facetlist=$1
2242     local hostlist
2243
2244     for facet in ${facetlist//,/ }; do
2245         hostlist=$(expand_list $hostlist $(facet_active_host $facet))
2246     done
2247     wait_for_host $hostlist
2248 }
2249
2250 _wait_recovery_complete () {
2251     local param=$1
2252
2253     # Use default policy if $2 is not passed by caller.
2254     local MAX=${2:-$(max_recovery_time)}
2255
2256     local WAIT=0
2257     local STATUS=
2258
2259     while [ $WAIT -lt $MAX ]; do
2260         STATUS=$(lctl get_param -n $param | grep status)
2261         echo $param $STATUS
2262         [[ $STATUS = "status: COMPLETE" || $STATUS = "status: INACTIVE" ]] && return 0
2263         sleep 5
2264         WAIT=$((WAIT + 5))
2265         echo "Waiting $((MAX - WAIT)) secs for $param recovery done. $STATUS"
2266     done
2267     echo "$param recovery not done in $MAX sec. $STATUS"
2268     return 1
2269 }
2270
2271 wait_recovery_complete () {
2272     local facet=$1
2273
2274     # with an assumption that at_max is the same on all nodes
2275     local MAX=${2:-$(max_recovery_time)}
2276
2277     local facets=$facet
2278     if [ "$FAILURE_MODE" = HARD ]; then
2279         facets=$(facets_on_host $(facet_active_host $facet))
2280     fi
2281     echo affected facets: $facets
2282
2283         # we can use "for" here because we are waiting the slowest
2284         for facet in ${facets//,/ }; do
2285                 local var_svc=${facet}_svc
2286                 local param="*.${!var_svc}.recovery_status"
2287
2288                 local host=$(facet_active_host $facet)
2289                 do_rpc_nodes "$host" _wait_recovery_complete $param $MAX
2290         done
2291 }
2292
2293 wait_mds_ost_sync () {
2294         # just because recovery is done doesn't mean we've finished
2295         # orphan cleanup. Wait for llogs to get synchronized.
2296         echo "Waiting for orphan cleanup..."
2297         # MAX value includes time needed for MDS-OST reconnection
2298         local MAX=$(( TIMEOUT * 2 ))
2299         local WAIT_TIMEOUT=${1:-$MAX}
2300         local WAIT=0
2301         local new_wait=true
2302         local list=$(comma_list $(mdts_nodes))
2303         local cmd="$LCTL get_param -n osp.*osc*.old_sync_processed"
2304         if ! do_facet $SINGLEMDS \
2305                 "$LCTL list_param osp.*osc*.old_sync_processed 2> /dev/null"
2306         then
2307                 # old way, use mds_sync
2308                 new_wait=false
2309                 list=$(comma_list $(osts_nodes))
2310                 cmd="$LCTL get_param -n obdfilter.*.mds_sync"
2311         fi
2312
2313         echo "wait $WAIT_TIMEOUT secs maximumly for $list mds-ost sync done."
2314         while [ $WAIT -lt $WAIT_TIMEOUT ]; do
2315                 local -a sync=($(do_nodes $list "$cmd"))
2316                 local con=1
2317                 local i
2318                 for ((i=0; i<${#sync[@]}; i++)); do
2319                         if $new_wait; then
2320                                 [ ${sync[$i]} -eq 1 ] && continue
2321                         else
2322                                 [ ${sync[$i]} -eq 0 ] && continue
2323                         fi
2324                         # there is a not finished MDS-OST synchronization
2325                         con=0
2326                         break;
2327                 done
2328                 sleep 2 # increase waiting time and cover statfs cache
2329                 [ ${con} -eq 1 ] && return 0
2330                 echo "Waiting $WAIT secs for $list $i mds-ost sync done."
2331                 WAIT=$((WAIT + 2))
2332         done
2333
2334         # show which nodes are not finished.
2335         do_nodes $list "$cmd"
2336         echo "$facet recovery node $i not done in $WAIT_TIMEOUT sec. $STATUS"
2337         return 1
2338 }
2339
2340 wait_destroy_complete () {
2341         echo "Waiting for local destroys to complete"
2342         # MAX value shouldn't be big as this mean server responsiveness
2343         # never increase this just to make test pass but investigate
2344         # why it takes so long time
2345         local MAX=5
2346         local WAIT=0
2347         while [ $WAIT -lt $MAX ]; do
2348                 local -a RPCs=($($LCTL get_param -n osc.*.destroys_in_flight))
2349                 local con=1
2350                 local i
2351
2352                 for ((i=0; i<${#RPCs[@]}; i++)); do
2353                         [ ${RPCs[$i]} -eq 0 ] && continue
2354                         # there are still some destroy RPCs in flight
2355                         con=0
2356                         break;
2357                 done
2358                 sleep 1
2359                 [ ${con} -eq 1 ] && return 0 # done waiting
2360                 echo "Waiting ${WAIT}s for local destroys to complete"
2361                 WAIT=$((WAIT + 1))
2362         done
2363         echo "Local destroys weren't done in $MAX sec."
2364         return 1
2365 }
2366
2367 wait_delete_completed() {
2368         wait_delete_completed_mds $1 || return $?
2369         wait_destroy_complete
2370 }
2371
2372 wait_exit_ST () {
2373     local facet=$1
2374
2375     local WAIT=0
2376     local INTERVAL=1
2377     local running
2378     # conf-sanity 31 takes a long time cleanup
2379     while [ $WAIT -lt 300 ]; do
2380         running=$(do_facet ${facet} "lsmod | grep lnet > /dev/null && lctl dl | grep ' ST '") || true
2381         [ -z "${running}" ] && return 0
2382         echo "waited $WAIT for${running}"
2383         [ $INTERVAL -lt 64 ] && INTERVAL=$((INTERVAL + INTERVAL))
2384         sleep $INTERVAL
2385         WAIT=$((WAIT + INTERVAL))
2386     done
2387     echo "service didn't stop after $WAIT seconds.  Still running:"
2388     echo ${running}
2389     return 1
2390 }
2391
2392 wait_remote_prog () {
2393    local prog=$1
2394    local WAIT=0
2395    local INTERVAL=5
2396    local rc=0
2397
2398    [ "$PDSH" = "no_dsh" ] && return 0
2399
2400    while [ $WAIT -lt $2 ]; do
2401         running=$(ps uax | grep "$PDSH.*$prog.*$MOUNT" | grep -v grep) || true
2402         [ -z "${running}" ] && return 0 || true
2403         echo "waited $WAIT for: "
2404         echo "$running"
2405         [ $INTERVAL -lt 60 ] && INTERVAL=$((INTERVAL + INTERVAL))
2406         sleep $INTERVAL
2407         WAIT=$((WAIT + INTERVAL))
2408     done
2409     local pids=$(ps  uax | grep "$PDSH.*$prog.*$MOUNT" | grep -v grep | awk '{print $2}')
2410     [ -z "$pids" ] && return 0
2411     echo "$PDSH processes still exists after $WAIT seconds.  Still running: $pids"
2412     # FIXME: not portable
2413     for pid in $pids; do
2414         cat /proc/${pid}/status || true
2415         cat /proc/${pid}/wchan || true
2416         echo "Killing $pid"
2417         kill -9 $pid || true
2418         sleep 1
2419         ps -P $pid && rc=1
2420     done
2421
2422     return $rc
2423 }
2424
2425 lfs_df_check() {
2426         local clients=${1:-$CLIENTS}
2427
2428         if [ -z "$clients" ]; then
2429                 $LFS df $MOUNT
2430         else
2431                 $PDSH $clients "$LFS df $MOUNT" > /dev/null
2432         fi
2433 }
2434
2435
2436 clients_up() {
2437         # not every config has many clients
2438         sleep 1
2439         lfs_df_check
2440 }
2441
2442 client_up() {
2443         # usually checked on particular client or locally
2444         sleep 1
2445         lfs_df_check $1
2446 }
2447
2448 client_evicted() {
2449     ! client_up $1
2450 }
2451
2452 client_reconnect_try() {
2453         local f=$MOUNT/recon
2454
2455         uname -n >> $f
2456         if [ -z "$CLIENTS" ]; then
2457                 $LFS df $MOUNT; uname -n >> $f
2458         else
2459                 do_nodes $CLIENTS "$LFS df $MOUNT; uname -n >> $f" > /dev/null
2460         fi
2461         echo "Connected clients: $(cat $f)"
2462         ls -l $f > /dev/null
2463         rm $f
2464 }
2465
2466 client_reconnect() {
2467         # one client_reconnect_try call does not always do the job...
2468         while true ; do
2469                 client_reconnect_try && break
2470                 sleep 1
2471         done
2472 }
2473
2474 affected_facets () {
2475     local facet=$1
2476
2477     local host=$(facet_active_host $facet)
2478     local affected=$facet
2479
2480     if [ "$FAILURE_MODE" = HARD ]; then
2481         affected=$(facets_up_on_host $host)
2482     fi
2483     echo $affected
2484 }
2485
2486 facet_failover() {
2487         local E2FSCK_ON_MDT0=false
2488         if [ "$1" == "--fsck" ]; then
2489                 shift
2490                 [ $(facet_fstype $SINGLEMDS) == ldiskfs ] &&
2491                         E2FSCK_ON_MDT0=true
2492         fi
2493
2494         local facets=$1
2495         local sleep_time=$2
2496         local -a affecteds
2497         local facet
2498         local total=0
2499         local index=0
2500         local skip
2501
2502         #Because it will only get up facets, we need get affected
2503         #facets before shutdown
2504         #For HARD Failure mode, it needs make sure facets on the same
2505         #HOST will only be shutdown and reboot once
2506         for facet in ${facets//,/ }; do
2507                 local affected_facet
2508                 skip=0
2509                 #check whether facet has been included in other affected facets
2510                 for ((index=0; index<$total; index++)); do
2511                         [[ *,$facet,* == ,${affecteds[index]}, ]] && skip=1
2512                 done
2513
2514                 if [ $skip -eq 0 ]; then
2515                         affecteds[$total]=$(affected_facets $facet)
2516                         total=$((total+1))
2517                 fi
2518         done
2519
2520         for ((index=0; index<$total; index++)); do
2521                 facet=$(echo ${affecteds[index]} | tr -s " " | cut -d"," -f 1)
2522                 local host=$(facet_active_host $facet)
2523                 echo "Failing ${affecteds[index]} on $host"
2524                 shutdown_facet $facet
2525         done
2526
2527         $E2FSCK_ON_MDT0 && (run_e2fsck $(facet_active_host $SINGLEMDS) \
2528                 $(mdsdevname 1) "-n" || error "Running e2fsck")
2529
2530         for ((index=0; index<$total; index++)); do
2531                 facet=$(echo ${affecteds[index]} | tr -s " " | cut -d"," -f 1)
2532                 echo reboot facets: ${affecteds[index]}
2533
2534                 reboot_facet $facet
2535
2536                 change_active ${affecteds[index]}
2537
2538                 wait_for_facet ${affecteds[index]}
2539                 # start mgs first if it is affected
2540                 if ! combined_mgs_mds &&
2541                         list_member ${affecteds[index]} mgs; then
2542                         mount_facet mgs || error "Restart of mgs failed"
2543                 fi
2544                 # FIXME; has to be changed to mount all facets concurrently
2545                 affected=$(exclude_items_from_list ${affecteds[index]} mgs)
2546                 echo mount facets: ${affecteds[index]}
2547                 mount_facets ${affecteds[index]}
2548         done
2549 }
2550
2551 obd_name() {
2552     local facet=$1
2553 }
2554
2555 replay_barrier() {
2556         local facet=$1
2557         do_facet $facet "sync; sync; sync"
2558         $LFS df $MOUNT
2559
2560         # make sure there will be no seq change
2561         local clients=${CLIENTS:-$HOSTNAME}
2562         local f=fsa-\\\$\(hostname\)
2563         do_nodes $clients "mcreate $MOUNT/$f; rm $MOUNT/$f"
2564         do_nodes $clients "if [ -d $MOUNT2 ]; then mcreate $MOUNT2/$f; rm $MOUNT2/$f; fi"
2565
2566         local svc=${facet}_svc
2567         do_facet $facet $LCTL --device ${!svc} notransno
2568         #
2569         # If a ZFS OSD is made read-only here, its pool is "freezed". This
2570         # in-memory state has to be cleared by either rebooting the host or
2571         # exporting and reimporting the pool.
2572         #
2573         # Although the uberblocks are not updated when a pool is freezed,
2574         # transactions are still written to the disks. Modified blocks may be
2575         # cached in memory when tests try reading them back. The
2576         # export-and-reimport process also evicts any cached pool data from
2577         # memory to provide the correct "data loss" semantics.
2578         #
2579         # In the test framework, the exporting and importing operations are
2580         # handled by stop() and mount_facet() separately, which are used
2581         # inside fail() and fail_abort().
2582         #
2583         do_facet $facet $LCTL --device ${!svc} readonly
2584         do_facet $facet $LCTL mark "$facet REPLAY BARRIER on ${!svc}"
2585         $LCTL mark "local REPLAY BARRIER on ${!svc}"
2586 }
2587
2588 replay_barrier_nodf() {
2589         local facet=$1    echo running=${running}
2590         do_facet $facet "sync; sync; sync"
2591         local svc=${facet}_svc
2592         echo Replay barrier on ${!svc}
2593         do_facet $facet $LCTL --device ${!svc} notransno
2594         do_facet $facet $LCTL --device ${!svc} readonly
2595         do_facet $facet $LCTL mark "$facet REPLAY BARRIER on ${!svc}"
2596         $LCTL mark "local REPLAY BARRIER on ${!svc}"
2597 }
2598
2599 replay_barrier_nosync() {
2600         local facet=$1    echo running=${running}
2601         local svc=${facet}_svc
2602         echo Replay barrier on ${!svc}
2603         do_facet $facet $LCTL --device ${!svc} notransno
2604         do_facet $facet $LCTL --device ${!svc} readonly
2605         do_facet $facet $LCTL mark "$facet REPLAY BARRIER on ${!svc}"
2606         $LCTL mark "local REPLAY BARRIER on ${!svc}"
2607 }
2608
2609 #
2610 # Get Lustre client uuid for a given Lustre mount point.
2611 #
2612 get_client_uuid() {
2613         local mntpnt=${1:-$MOUNT}
2614
2615         local name=$($LFS getname $mntpnt | cut -d' ' -f1)
2616         local uuid=$($LCTL get_param -n llite.$name.uuid)
2617
2618         echo -n $uuid
2619 }
2620
2621 mds_evict_client() {
2622         local mntpnt=${1:-$MOUNT}
2623         local uuid=$(get_client_uuid $mntpnt)
2624
2625         do_facet $SINGLEMDS \
2626                 "$LCTL set_param -n mdt.${mds1_svc}.evict_client $uuid"
2627 }
2628
2629 ost_evict_client() {
2630         local mntpnt=${1:-$MOUNT}
2631         local uuid=$(get_client_uuid $mntpnt)
2632
2633         do_facet ost1 \
2634                 "$LCTL set_param -n obdfilter.${ost1_svc}.evict_client $uuid"
2635 }
2636
2637 fail() {
2638         local facets=$1
2639         local clients=${CLIENTS:-$HOSTNAME}
2640
2641         facet_failover $* || error "failover: $?"
2642         wait_clients_import_state "$clients" "$facets" FULL
2643         clients_up || error "post-failover stat: $?"
2644 }
2645
2646 fail_nodf() {
2647         local facet=$1
2648         facet_failover $facet
2649 }
2650
2651 fail_abort() {
2652         local facet=$1
2653         stop $facet
2654         change_active $facet
2655         wait_for_facet $facet
2656         mount_facet $facet -o abort_recovery
2657         clients_up || echo "first stat failed: $?"
2658         clients_up || error "post-failover stat: $?"
2659 }
2660
2661 do_lmc() {
2662     echo There is no lmc.  This is mountconf, baby.
2663     exit 1
2664 }
2665
2666 host_nids_address() {
2667     local nodes=$1
2668     local kind=$2
2669
2670     if [ -n "$kind" ]; then
2671         nids=$(do_nodes $nodes "$LCTL list_nids | grep $kind | cut -f 1 -d '@'")
2672     else
2673         nids=$(do_nodes $nodes "$LCTL list_nids all | cut -f 1 -d '@'")
2674     fi
2675     echo $nids
2676 }
2677
2678 h2name_or_ip() {
2679         if [ "$1" = "'*'" ]; then echo \'*\'; else
2680                 echo $1"@$2"
2681         fi
2682 }
2683
2684 h2ptl() {
2685         if [ "$1" = "'*'" ]; then echo \'*\'; else
2686                 ID=`xtprocadmin -n $1 2>/dev/null | egrep -v 'NID' | \
2687                                                         awk '{print $1}'`
2688                 if [ -z "$ID" ]; then
2689                         echo "Could not get a ptl id for $1..."
2690                         exit 1
2691                 fi
2692                 echo $ID"@ptl"
2693         fi
2694 }
2695 declare -fx h2ptl
2696
2697 h2tcp() {
2698         h2name_or_ip "$1" "tcp"
2699 }
2700 declare -fx h2tcp
2701
2702 h2elan() {
2703         if [ "$1" = "'*'" ]; then echo \'*\'; else
2704                 if type __h2elan >/dev/null 2>&1; then
2705                         ID=$(__h2elan $1)
2706                 else
2707                         ID=`echo $1 | sed 's/[^0-9]*//g'`
2708                 fi
2709                 echo $ID"@elan"
2710         fi
2711 }
2712 declare -fx h2elan
2713
2714 h2o2ib() {
2715         h2name_or_ip "$1" "o2ib"
2716 }
2717 declare -fx h2o2ib
2718
2719 # This enables variables in cfg/"setup".sh files to support the pdsh HOSTLIST
2720 # expressions format. As a bonus we can then just pass in those variables
2721 # to pdsh. What this function does is take a HOSTLIST type string and
2722 # expand it into a space deliminated list for us.
2723 hostlist_expand() {
2724     local hostlist=$1
2725     local offset=$2
2726     local myList
2727     local item
2728     local list
2729
2730     [ -z "$hostlist" ] && return
2731
2732     # Translate the case of [..],..,[..] to [..] .. [..]
2733     list="${hostlist/],/] }"
2734     front=${list%%[*}
2735     [[ "$front" == *,* ]] && {
2736         new="${list%,*} "
2737         old="${list%,*},"
2738         list=${list/${old}/${new}}
2739     }
2740
2741     for item in $list; do
2742         # Test if we have any []'s at all
2743         if [ "$item" != "${item/\[/}" ]; then {
2744             # Expand the [*] into list
2745             name=${item%%[*}
2746             back=${item#*]}
2747
2748             if [ "$name" != "$item" ]; then
2749                 group=${item#$name[*}
2750                 group=${group%%]*}
2751
2752                 for range in ${group//,/ }; do
2753                     begin=${range%-*}
2754                     end=${range#*-}
2755
2756                     # Number of leading zeros
2757                     padlen=${#begin}
2758                     padlen2=${#end}
2759                     end=$(echo $end | sed 's/0*//')
2760                     [[ -z "$end" ]] && end=0
2761                     [[ $padlen2 -gt $padlen ]] && {
2762                         [[ $padlen2 -eq ${#end} ]] && padlen2=0
2763                         padlen=$padlen2
2764                     }
2765                     begin=$(echo $begin | sed 's/0*//')
2766                     [ -z $begin ] && begin=0
2767
2768                     for num in $(seq -f "%0${padlen}g" $begin $end); do
2769                         value="${name#*,}${num}${back}"
2770                         [ "$value" != "${value/\[/}" ] && {
2771                             value=$(hostlist_expand "$value")
2772                         }
2773                         myList="$myList $value"
2774                     done
2775                 done
2776             fi
2777         } else {
2778             myList="$myList $item"
2779         } fi
2780     done
2781     myList=${myList//,/ }
2782     myList=${myList:1} # Remove first character which is a space
2783
2784     # Filter any duplicates without sorting
2785     list="$myList "
2786     myList="${list%% *}"
2787
2788     while [[ "$list" != ${myList##* } ]]; do
2789         list=${list//${list%% *} /}
2790         myList="$myList ${list%% *}"
2791     done
2792     myList="${myList%* }";
2793
2794     # We can select an object at an offset in the list
2795     [ $# -eq 2 ] && {
2796         cnt=0
2797         for item in $myList; do
2798             let cnt=cnt+1
2799             [ $cnt -eq $offset ] && {
2800                 myList=$item
2801             }
2802         done
2803         [ $(get_node_count $myList) -ne 1 ] && myList=""
2804     }
2805     echo $myList
2806 }
2807
2808 facet_host() {
2809         local facet=$1
2810         local varname
2811
2812         [ "$facet" == client ] && echo -n $HOSTNAME && return
2813         varname=${facet}_HOST
2814         if [ -z "${!varname}" ]; then
2815                 if [ "${facet:0:3}" == "ost" ]; then
2816                         local fh=${facet%failover}_HOST
2817                         eval export ${facet}_HOST=${!fh}
2818                         if [ -z "${!varname}" ]; then
2819                                 eval export ${facet}_HOST=${ost_HOST}
2820                         fi
2821                 elif [ "${facet:0:3}" == "mdt" -o \
2822                         "${facet:0:3}" == "mds" -o \
2823                         "${facet:0:3}" == "mgs" ]; then
2824                         eval export ${facet}_HOST=${mds_HOST}
2825                 fi
2826         fi
2827         echo -n ${!varname}
2828 }
2829
2830 facet_failover_host() {
2831         local facet=$1
2832         local varname
2833
2834         var=${facet}failover_HOST
2835         if [ -n "${!var}" ]; then
2836                 echo ${!var}
2837                 return
2838         fi
2839
2840         if [ "${facet:0:3}" == "mdt" -o "${facet:0:3}" == "mds" -o \
2841              "${facet:0:3}" == "mgs" ]; then
2842
2843                 eval export ${facet}failover_host=${mds_HOST}
2844                 echo ${mds_HOST}
2845                 return
2846         fi
2847
2848         if [[ $facet == ost* ]]; then
2849                 eval export ${facet}failover_host=${ost_HOST}
2850                 echo ${ost_HOST}
2851                 return
2852         fi
2853 }
2854
2855 facet_active() {
2856     local facet=$1
2857     local activevar=${facet}active
2858
2859     if [ -f $TMP/${facet}active ] ; then
2860         source $TMP/${facet}active
2861     fi
2862
2863     active=${!activevar}
2864     if [ -z "$active" ] ; then
2865         echo -n ${facet}
2866     else
2867         echo -n ${active}
2868     fi
2869 }
2870
2871 facet_active_host() {
2872         facet_host $(facet_active $1)
2873 }
2874
2875 # Get the passive failover partner host of facet.
2876 facet_passive_host() {
2877         local facet=$1
2878         [[ $facet = client ]] && return
2879
2880         local host=${facet}_HOST
2881         local failover_host=${facet}failover_HOST
2882         local active_host=$(facet_active_host $facet)
2883
2884         [[ -z ${!failover_host} || ${!failover_host} = ${!host} ]] && return
2885
2886         if [[ $active_host = ${!host} ]]; then
2887                 echo -n ${!failover_host}
2888         else
2889                 echo -n ${!host}
2890         fi
2891 }
2892
2893 change_active() {
2894     local facetlist=$1
2895     local facet
2896
2897     facetlist=$(exclude_items_from_list $facetlist mgs)
2898
2899     for facet in ${facetlist//,/ }; do
2900     local failover=${facet}failover
2901     local host=`facet_host $failover`
2902     [ -z "$host" ] && return
2903
2904     local curactive=`facet_active $facet`
2905     if [ -z "${curactive}" -o "$curactive" == "$failover" ] ; then
2906         eval export ${facet}active=$facet
2907     else
2908         eval export ${facet}active=$failover
2909     fi
2910     # save the active host for this facet
2911     local activevar=${facet}active
2912     echo "$activevar=${!activevar}" > $TMP/$activevar
2913     [[ $facet = mds1 ]] && combined_mgs_mds && \
2914         echo "mgsactive=${!activevar}" > $TMP/mgsactive
2915     local TO=`facet_active_host $facet`
2916     echo "Failover $facet to $TO"
2917     done
2918 }
2919
2920 do_node() {
2921     local verbose=false
2922     # do not stripe off hostname if verbose, bug 19215
2923     if [ x$1 = x--verbose ]; then
2924         shift
2925         verbose=true
2926     fi
2927
2928     local HOST=$1
2929     shift
2930     local myPDSH=$PDSH
2931     if [ "$HOST" = "$HOSTNAME" ]; then
2932         myPDSH="no_dsh"
2933     elif [ -z "$myPDSH" -o "$myPDSH" = "no_dsh" ]; then
2934         echo "cannot run remote command on $HOST with $myPDSH"
2935         return 128
2936     fi
2937     if $VERBOSE; then
2938         echo "CMD: $HOST $@" >&2
2939         $myPDSH $HOST "$LCTL mark \"$@\"" > /dev/null 2>&1 || :
2940     fi
2941
2942     if [ "$myPDSH" = "rsh" ]; then
2943 # we need this because rsh does not return exit code of an executed command
2944         local command_status="$TMP/cs"
2945         rsh $HOST ":> $command_status"
2946         rsh $HOST "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin;
2947                     cd $RPWD; LUSTRE=\"$RLUSTRE\" sh -c \"$@\") ||
2948                     echo command failed >$command_status"
2949         [ -n "$($myPDSH $HOST cat $command_status)" ] && return 1 || true
2950         return 0
2951     fi
2952
2953     if $verbose ; then
2954         # print HOSTNAME for myPDSH="no_dsh"
2955         if [[ $myPDSH = no_dsh ]]; then
2956             $myPDSH $HOST "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" sh -c \"$@\")" | sed -e "s/^/${HOSTNAME}: /"
2957         else
2958             $myPDSH $HOST "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" sh -c \"$@\")"
2959         fi
2960     else
2961         $myPDSH $HOST "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" sh -c \"$@\")" | sed "s/^${HOST}: //"
2962     fi
2963     return ${PIPESTATUS[0]}
2964 }
2965
2966 do_nodev() {
2967     do_node --verbose "$@"
2968 }
2969
2970 single_local_node () {
2971    [ "$1" = "$HOSTNAME" ]
2972 }
2973
2974 # Outputs environment variable assignments that should be passed to remote nodes
2975 get_env_vars() {
2976         local var
2977         local value
2978         local facets=$(get_facets)
2979         local facet
2980
2981         for var in ${!MODOPTS_*}; do
2982                 value=${!var//\"/\\\"}
2983                 echo -n " ${var}=\"$value\""
2984         done
2985
2986         for facet in ${facets//,/ }; do
2987                 var=${facet}_FSTYPE
2988                 if [ -n "${!var}" ]; then
2989                         echo -n " $var=${!var}"
2990                 fi
2991         done
2992
2993         for var in MGSFSTYPE MDSFSTYPE OSTFSTYPE; do
2994                 if [ -n "${!var}" ]; then
2995                         echo -n " $var=${!var}"
2996                 fi
2997         done
2998
2999         for var in VERBOSE; do
3000                 if [ -n "${!var}" ]; then
3001                         echo -n " $var=${!var}"
3002                 fi
3003         done
3004
3005         if [ -n "$FSTYPE" ]; then
3006                 echo -n " FSTYPE=$FSTYPE"
3007         fi
3008
3009         for var in LNETLND NETTYPE; do
3010                 if [ -n "${!var}" ]; then
3011                         echo -n " $var=${!var}"
3012                 fi
3013         done
3014 }
3015
3016 do_nodes() {
3017     local verbose=false
3018     # do not stripe off hostname if verbose, bug 19215
3019     if [ x$1 = x--verbose ]; then
3020         shift
3021         verbose=true
3022     fi
3023
3024     local rnodes=$1
3025     shift
3026
3027     if single_local_node $rnodes; then
3028         if $verbose; then
3029            do_nodev $rnodes "$@"
3030         else
3031            do_node $rnodes "$@"
3032         fi
3033         return $?
3034     fi
3035
3036     # This is part from do_node
3037     local myPDSH=$PDSH
3038
3039     [ -z "$myPDSH" -o "$myPDSH" = "no_dsh" -o "$myPDSH" = "rsh" ] && \
3040         echo "cannot run remote command on $rnodes with $myPDSH" && return 128
3041
3042     export FANOUT=$(get_node_count "${rnodes//,/ }")
3043     if $VERBOSE; then
3044         echo "CMD: $rnodes $@" >&2
3045         $myPDSH $rnodes "$LCTL mark \"$@\"" > /dev/null 2>&1 || :
3046     fi
3047
3048     # do not replace anything from pdsh output if -N is used
3049     # -N     Disable hostname: prefix on lines of output.
3050     if $verbose || [[ $myPDSH = *-N* ]]; then
3051         $myPDSH $rnodes "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" $(get_env_vars) sh -c \"$@\")"
3052     else
3053         $myPDSH $rnodes "(PATH=\$PATH:$RLUSTRE/utils:$RLUSTRE/tests:/sbin:/usr/sbin; cd $RPWD; LUSTRE=\"$RLUSTRE\" $(get_env_vars) sh -c \"$@\")" | sed -re "s/^[^:]*: //g"
3054     fi
3055     return ${PIPESTATUS[0]}
3056 }
3057
3058 ##
3059 # Execute commands on a single service's host
3060 #
3061 # The \a facet (service) may be on a local or remote node, which is
3062 # determined at the time the command is run.
3063 #
3064 # usage: do_facet $facet command [arg ...]
3065 do_facet() {
3066         local facet=$1
3067         shift
3068         local HOST=$(facet_active_host $facet)
3069         [ -z $HOST ] && echo "No host defined for facet ${facet}" && exit 1
3070         do_node $HOST "$@"
3071 }
3072
3073 # Function: do_facet_random_file $FACET $FILE $SIZE
3074 # Creates FILE with random content on the given FACET of given SIZE
3075
3076 do_facet_random_file() {
3077         local facet="$1"
3078         local fpath="$2"
3079         local fsize="$3"
3080         local cmd="dd if=/dev/urandom of='$fpath' bs=$fsize count=1"
3081         do_facet $facet "$cmd 2>/dev/null"
3082 }
3083
3084 do_facet_create_file() {
3085         local facet="$1"
3086         local fpath="$2"
3087         local fsize="$3"
3088         local cmd="dd if=/dev/zero of='$fpath' bs=$fsize count=1"
3089         do_facet $facet "$cmd 2>/dev/null"
3090 }
3091
3092 do_nodesv() {
3093     do_nodes --verbose "$@"
3094 }
3095
3096 add() {
3097         local facet=$1
3098         shift
3099         # make sure its not already running
3100         stop ${facet} -f
3101         rm -f $TMP/${facet}active
3102         [[ $facet = mds1 ]] && combined_mgs_mds && rm -f $TMP/mgsactive
3103         do_facet ${facet} $MKFS $* || return ${PIPESTATUS[0]}
3104
3105         if [[ $(facet_fstype $facet) == zfs ]]; then
3106                 #
3107                 # After formatting a ZFS target, "cachefile=none" property will
3108                 # be set on the ZFS storage pool so that the pool is not
3109                 # automatically imported on system startup. And then the pool
3110                 # will be exported so as to leave the importing and exporting
3111                 # operations handled by mount_facet() and stop() separately.
3112                 #
3113                 refresh_partition_table $facet $(facet_vdevice $facet)
3114                 disable_zpool_cache $facet
3115                 export_zpool $facet
3116         fi
3117 }
3118
3119 # Device formatted as ost
3120 ostdevname() {
3121         local num=$1
3122         local DEVNAME=OSTDEV$num
3123
3124         local fstype=$(facet_fstype ost$num)
3125
3126         case $fstype in
3127                 ldiskfs )
3128                         #if $OSTDEVn isn't defined, default is $OSTDEVBASE + num
3129                         eval DEVPTR=${!DEVNAME:=${OSTDEVBASE}${num}};;
3130                 zfs )
3131                         #try $OSTZFSDEVn - independent of vdev
3132                         DEVNAME=OSTZFSDEV$num
3133                         eval DEVPTR=${!DEVNAME:=${FSNAME}-ost${num}/ost${num}};;
3134                 * )
3135                         error "unknown fstype!";;
3136         esac
3137
3138     echo -n $DEVPTR
3139 }
3140
3141 # Physical device location of data
3142 ostvdevname() {
3143         local num=$1
3144         local DEVNAME
3145         local VDEVPTR
3146
3147         local fstype=$(facet_fstype ost$num)
3148
3149         case $fstype in
3150                 ldiskfs )
3151                         # vdevs are not supported by ldiskfs
3152                         eval VDEVPTR="";;
3153                 zfs )
3154                         #if $OSTDEVn isn't defined, default is $OSTDEVBASE{n}
3155                         # Device formatted by zfs
3156                         DEVNAME=OSTDEV$num
3157                         eval VDEVPTR=${!DEVNAME:=${OSTDEVBASE}${num}};;
3158                 * )
3159                         error "unknown fstype!";;
3160         esac
3161
3162         echo -n $VDEVPTR
3163 }
3164
3165 # Logical device formatted for lustre
3166 mdsdevname() {
3167         local num=$1
3168         local DEVNAME=MDSDEV$num
3169
3170         local fstype=$(facet_fstype mds$num)
3171
3172         case $fstype in
3173                 ldiskfs )
3174                         #if $MDSDEVn isn't defined, default is $MDSDEVBASE{n}
3175                         eval DEVPTR=${!DEVNAME:=${MDSDEVBASE}${num}};;
3176                 zfs )
3177                         # try $MDSZFSDEVn - independent of vdev
3178                         DEVNAME=MDSZFSDEV$num
3179                         eval DEVPTR=${!DEVNAME:=${FSNAME}-mdt${num}/mdt${num}};;
3180                 * )
3181                         error "unknown fstype!";;
3182         esac
3183
3184         echo -n $DEVPTR
3185 }
3186
3187 # Physical location of data
3188 mdsvdevname() {
3189         local VDEVPTR=""
3190         local num=$1
3191         local fstype=$(facet_fstype mds$num)
3192
3193         case $fstype in
3194                 ldiskfs )
3195                         # vdevs are not supported by ldiskfs
3196                         eval VDEVPTR="";;
3197                 zfs )
3198                         # if $MDSDEVn isn't defined, default is $MDSDEVBASE{n}
3199                         # Device formatted by ZFS
3200                         local DEVNAME=MDSDEV$num
3201                         eval VDEVPTR=${!DEVNAME:=${MDSDEVBASE}${num}};;
3202                 * )
3203                         error "unknown fstype!";;
3204         esac
3205
3206         echo -n $VDEVPTR
3207 }
3208
3209 mgsdevname() {
3210         local DEVPTR
3211         local fstype=$(facet_fstype mgs)
3212
3213         case $fstype in
3214         ldiskfs )
3215                 if [ $(facet_host mgs) = $(facet_host mds1) ] &&
3216                    ( [ -z "$MGSDEV" ] || [ $MGSDEV = $(mdsdevname 1) ] ); then
3217                         DEVPTR=$(mdsdevname 1)
3218                 else
3219                         DEVPTR=$MGSDEV
3220                 fi;;
3221         zfs )
3222                 if [ $(facet_host mgs) = $(facet_host mds1) ] &&
3223                     ( [ -z "$MGSZFSDEV" ] &&
3224                         [ -z "$MGSDEV" -o "$MGSDEV" = $(mdsvdevname 1) ] ); then
3225                         DEVPTR=$(mdsdevname 1)
3226                 else
3227                         DEVPTR=${MGSZFSDEV:-${FSNAME}-mgs/mgs}
3228                 fi;;
3229         * )
3230                 error "unknown fstype!";;
3231         esac
3232
3233         echo -n $DEVPTR
3234 }
3235
3236 mgsvdevname() {
3237         local VDEVPTR=""
3238
3239         local fstype=$(facet_fstype mgs)
3240
3241         case $fstype in
3242         ldiskfs )
3243                 # vdevs are not supported by ldiskfs
3244                 ;;
3245         zfs )
3246                 if [ $(facet_host mgs) = $(facet_host mds1) ] &&
3247                    ( [ -z "$MGSDEV" ] &&
3248                        [ -z "$MGSZFSDEV" -o "$MGSZFSDEV" = $(mdsdevname 1) ]); then
3249                         VDEVPTR=$(mdsvdevname 1)
3250                 elif [ -n "$MGSDEV" ]; then
3251                         VDEVPTR=$MGSDEV
3252                 fi;;
3253         * )
3254                 error "unknown fstype!";;
3255         esac
3256
3257         echo -n $VDEVPTR
3258 }
3259
3260 facet_mntpt () {
3261     local facet=$1
3262     [[ $facet = mgs ]] && combined_mgs_mds && facet="mds1"
3263
3264     local var=${facet}_MOUNT
3265     eval mntpt=${!var:-${MOUNT}-$facet}
3266
3267     echo -n $mntpt
3268 }
3269
3270 mount_ldiskfs() {
3271         local facet=$1
3272         local dev=$(facet_device $facet)
3273         local mnt=${2:-$(facet_mntpt $facet)}
3274         local opts
3275
3276         if ! do_facet $facet test -b $dev; then
3277                 opts="-o loop"
3278         fi
3279         do_facet $facet mount -t ldiskfs $opts $dev $mnt
3280 }
3281
3282 unmount_ldiskfs() {
3283         local facet=$1
3284         local dev=$(facet_device $facet)
3285         local mnt=${2:-$(facet_mntpt $facet)}
3286
3287         do_facet $facet $UMOUNT $mnt
3288 }
3289
3290 var_name() {
3291         echo -n "$1" | tr -c '[:alnum:]\n' '_'
3292 }
3293
3294 mount_zfs() {
3295         local facet=$1
3296         local ds=$(facet_device $facet)
3297         local mnt=${2:-$(facet_mntpt $facet)}
3298         local canmnt
3299         local mntpt
3300
3301         import_zpool $facet
3302         canmnt=$(do_facet $facet $ZFS get -H -o value canmount $ds)
3303         mntpt=$(do_facet $facet $ZFS get -H -o value mountpoint $ds)
3304         do_facet $facet $ZFS set canmount=noauto $ds
3305         #
3306         # The "legacy" mount method is used here because "zfs unmount $mnt"
3307         # calls stat(2) on $mnt/../*, which may include $MOUNT.  If certain
3308         # targets are not available at the time, the stat(2) on $MOUNT will
3309         # hang.
3310         #
3311         do_facet $facet $ZFS set mountpoint=legacy $ds
3312         do_facet $facet mount -t zfs $ds $mnt
3313         eval export mz_$(var_name ${facet}_$ds)_canmount=$canmnt
3314         eval export mz_$(var_name ${facet}_$ds)_mountpoint=$mntpt
3315 }
3316
3317 unmount_zfs() {
3318         local facet=$1
3319         local ds=$(facet_device $facet)
3320         local mnt=${2:-$(facet_mntpt $facet)}
3321         local var_mntpt=mz_$(var_name ${facet}_$ds)_mountpoint
3322         local var_canmnt=mz_$(var_name ${facet}_$ds)_canmount
3323         local mntpt=${!var_mntpt}
3324         local canmnt=${!var_canmnt}
3325
3326         unset $var_mntpt
3327         unset $var_canmnt
3328         do_facet $facet umount $mnt
3329         do_facet $facet $ZFS set mountpoint=$mntpt $ds
3330         do_facet $facet $ZFS set canmount=$canmnt $ds
3331         export_zpool $facet
3332 }
3333
3334 mount_fstype() {
3335         local facet=$1
3336         local mnt=$2
3337         local fstype=$(facet_fstype $facet)
3338
3339         mount_$fstype $facet $mnt
3340 }
3341
3342 unmount_fstype() {
3343         local facet=$1
3344         local mnt=$2
3345         local fstype=$(facet_fstype $facet)
3346
3347         unmount_$fstype $facet $mnt
3348 }
3349
3350 ########
3351 ## MountConf setup
3352
3353 stopall() {
3354     # make sure we are using the primary server, so test-framework will
3355     # be able to clean up properly.
3356     activemds=`facet_active mds1`
3357     if [ $activemds != "mds1" ]; then
3358         fail mds1
3359     fi
3360
3361     local clients=$CLIENTS
3362     [ -z $clients ] && clients=$(hostname)
3363
3364     zconf_umount_clients $clients $MOUNT "$*" || true
3365     [ -n "$MOUNT2" ] && zconf_umount_clients $clients $MOUNT2 "$*" || true
3366
3367     [ -n "$CLIENTONLY" ] && return
3368
3369     # The add fn does rm ${facet}active file, this would be enough
3370     # if we use do_facet <facet> only after the facet added, but
3371     # currently we use do_facet mds in local.sh
3372     for num in `seq $MDSCOUNT`; do
3373         stop mds$num -f
3374         rm -f ${TMP}/mds${num}active
3375     done
3376     combined_mgs_mds && rm -f $TMP/mgsactive
3377
3378     for num in `seq $OSTCOUNT`; do
3379         stop ost$num -f
3380         rm -f $TMP/ost${num}active
3381     done
3382
3383     if ! combined_mgs_mds ; then
3384         stop mgs
3385     fi
3386
3387     return 0
3388 }
3389
3390 cleanup_echo_devs () {
3391         trap 0
3392         local dev
3393         local devs=$($LCTL dl | grep echo | awk '{print $4}')
3394
3395         for dev in $devs; do
3396                 $LCTL --device $dev cleanup
3397                 $LCTL --device $dev detach
3398         done
3399 }
3400
3401 cleanupall() {
3402     nfs_client_mode && return
3403         cifs_client_mode && return