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