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