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