lustre/tests/conf-sanity.sh

   1 #!/bin/bash
   2 # requirement:
   3 #       add uml1 uml2 uml3 in your /etc/hosts
   4
   5 # FIXME - there is no reason to use all of these different
   6 #   return codes, espcially when most of them are mapped to something
   7 #   else anyway.  The combination of test number and return code
   8 #   figure out what failed.
   9
  10 set -e
  11
  12 ONLY=${ONLY:-"$*"}
  13
  14 # bug number for skipped test: 13739
  15 HEAD_EXCEPT="                  32a 32b "
  16
  17 # bug number for skipped test:
  18 ALWAYS_EXCEPT=" $CONF_SANITY_EXCEPT $HEAD_EXCEPT"
  19 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  20
  21 SRCDIR=`dirname $0`
  22 PATH=$PWD/$SRCDIR:$SRCDIR:$SRCDIR/../utils:$PATH
  23
  24 PTLDEBUG=${PTLDEBUG:--1}
  25 SAVE_PWD=$PWD
  26 LUSTRE=${LUSTRE:-`dirname $0`/..}
  27 RLUSTRE=${RLUSTRE:-$LUSTRE}
  28
  29 . $LUSTRE/tests/test-framework.sh
  30 init_test_env $@
  31 # STORED_MDSSIZE is used in test_18
  32 if [ -n "$MDSSIZE" ]; then
  33     STORED_MDSSIZE=$MDSSIZE
  34 fi
  35 # use small MDS + OST size to speed formatting time
  36 MDSSIZE=40000
  37 OSTSIZE=40000
  38 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
  39
  40 #
  41 [ "$SLOW" = "no" ] && EXCEPT_SLOW="0 1 2 3 6 7 15 18 24b 25 30 31 32 33 34a "
  42
  43 assert_DIR
  44
  45 reformat() {
  46         formatall
  47 }
  48
  49 writeconf() {
  50     local facet=$SINGLEMDS
  51     local dev=${facet}_dev
  52     shift
  53     stop ${facet} -f
  54     rm -f ${facet}active
  55     # who knows if/where $TUNEFS is installed?  Better reformat if it fails...
  56     do_facet ${facet} "$TUNEFS --writeconf ${!dev}" || echo "tunefs failed, reformatting instead" && reformat
  57 }
  58
  59 gen_config() {
  60         reformat
  61         # The MGS must be started before the OSTs for a new fs, so start
  62         # and stop to generate the startup logs.
  63         start_mds
  64         start_ost
  65         sleep 5
  66         stop_ost
  67         stop_mds
  68 }
  69
  70 start_mds() {
  71         local facet=$SINGLEMDS
  72         local dev=${facet}_dev
  73         echo "start mds service on `facet_active_host $facet`"
  74         start $facet ${!dev} $MDS_MOUNT_OPTS || return 94
  75 }
  76
  77 stop_mds() {
  78         echo "stop mds service on `facet_active_host $SINGLEMDS`"
  79         # These tests all use non-failover stop
  80         stop $SINGLEMDS -f  || return 97
  81 }
  82
  83 start_ost() {
  84         echo "start ost1 service on `facet_active_host ost1`"
  85         start ost1 `ostdevname 1` $OST_MOUNT_OPTS || return 95
  86 }
  87
  88 stop_ost() {
  89         echo "stop ost1 service on `facet_active_host ost1`"
  90         # These tests all use non-failover stop
  91         stop ost1 -f  || return 98
  92 }
  93
  94 start_ost2() {
  95         echo "start ost2 service on `facet_active_host ost2`"
  96         start ost2 `ostdevname 2` $OST_MOUNT_OPTS || return 92
  97 }
  98
  99 stop_ost2() {
 100         echo "stop ost2 service on `facet_active_host ost2`"
 101         # These tests all use non-failover stop
 102         stop ost2 -f  || return 93
 103 }
 104
 105 mount_client() {
 106         local MOUNTPATH=$1
 107         echo "mount $FSNAME on ${MOUNTPATH}....."
 108         zconf_mount `hostname` $MOUNTPATH  || return 96
 109 }
 110
 111 remount_client() {
 112         local SAVEMOUNTOPT=$MOUNTOPT
 113         MOUNTOPT="remount,$1"
 114         local MOUNTPATH=$2
 115         echo "remount '$1' lustre on ${MOUNTPATH}....."
 116         zconf_mount `hostname`  $MOUNTPATH  || return 96
 117         MOUNTOPT=$SAVEMOUNTOPT
 118 }
 119
 120 umount_client() {
 121         local MOUNTPATH=$1
 122         echo "umount lustre on ${MOUNTPATH}....."
 123         zconf_umount `hostname` $MOUNTPATH || return 97
 124 }
 125
 126 manual_umount_client(){
 127         echo "manual umount lustre on ${MOUNT}...."
 128         do_facet client "umount -d $MOUNT"
 129 }
 130
 131 setup() {
 132         start_ost
 133         start_mds
 134         mount_client $MOUNT
 135 }
 136
 137 cleanup_nocli() {
 138         stop_mds || return 201
 139         stop_ost || return 202
 140         unload_modules || return 203
 141 }
 142
 143 cleanup() {
 144         umount_client $MOUNT || return 200
 145         cleanup_nocli || return $?
 146 }
 147
 148 check_mount() {
 149         do_facet client "cp /etc/passwd $DIR/a" || return 71
 150         do_facet client "rm $DIR/a" || return 72
 151         # make sure lustre is actually mounted (touch will block,
 152         # but grep won't, so do it after)
 153         do_facet client "grep $MOUNT' ' /proc/mounts > /dev/null" || return 73
 154         echo "setup single mount lustre success"
 155 }
 156
 157 check_mount2() {
 158         do_facet client "touch $DIR/a" || return 71
 159         do_facet client "rm $DIR/a" || return 72
 160         do_facet client "touch $DIR2/a" || return 73
 161         do_facet client "rm $DIR2/a" || return 74
 162         echo "setup double mount lustre success"
 163 }
 164
 165 build_test_filter
 166
 167 if [ "$ONLY" == "setup" ]; then
 168         setup
 169         exit
 170 fi
 171
 172 if [ "$ONLY" == "cleanup" ]; then
 173         cleanup
 174         exit
 175 fi
 176
 177 #create single point mountpoint
 178
 179 gen_config
 180
 181 init_gss
 182
 183 test_0() {
 184         setup
 185         check_mount || return 41
 186         cleanup || return $?
 187 }
 188 run_test 0 "single mount setup"
 189
 190 test_1() {
 191         start_ost
 192         echo "start ost second time..."
 193         setup
 194         check_mount || return 42
 195         cleanup || return $?
 196 }
 197 run_test 1 "start up ost twice (should return errors)"
 198
 199 test_2() {
 200         start_ost
 201         start_mds
 202         echo "start mds second time.."
 203         start_mds
 204         mount_client $MOUNT
 205         check_mount || return 43
 206         cleanup || return $?
 207 }
 208 run_test 2 "start up mds twice (should return err)"
 209
 210 test_3() {
 211         setup
 212         #mount.lustre returns an error if already in mtab
 213         mount_client $MOUNT && return $?
 214         check_mount || return 44
 215         cleanup || return $?
 216 }
 217 run_test 3 "mount client twice (should return err)"
 218
 219 test_4() {
 220         setup
 221         touch $DIR/$tfile || return 85
 222         stop_ost -f
 223         cleanup
 224         eno=$?
 225         # ok for ost to fail shutdown
 226         if [ 202 -ne $eno ]; then
 227                 return $eno;
 228         fi
 229         return 0
 230 }
 231 run_test 4 "force cleanup ost, then cleanup"
 232
 233 test_5a() {     # was test_5
 234         setup
 235         touch $DIR/$tfile || return 1
 236         fuser -m -v $MOUNT && echo "$MOUNT is in use by user space process."
 237
 238         stop_mds -f || return 2
 239
 240         # cleanup may return an error from the failed
 241         # disconnects; for now I'll consider this successful
 242         # if all the modules have unloaded.
 243         umount -d $MOUNT &
 244         UMOUNT_PID=$!
 245         sleep 6
 246         echo "killing umount"
 247         kill -TERM $UMOUNT_PID
 248         echo "waiting for umount to finish"
 249         wait $UMOUNT_PID
 250         if grep " $MOUNT " /proc/mounts; then
 251                 echo "test 5: /proc/mounts after failed umount"
 252                 umount $MOUNT &
 253                 UMOUNT_PID=$!
 254                 sleep 2
 255                 echo "killing umount"
 256                 kill -TERM $UMOUNT_PID
 257                 echo "waiting for umount to finish"
 258                 wait $UMOUNT_PID
 259                 grep " $MOUNT " /proc/mounts && echo "test 5: /proc/mounts after second umount" && return 11
 260         fi
 261
 262         manual_umount_client
 263         # stop_mds is a no-op here, and should not fail
 264         cleanup_nocli || return $?
 265         # df may have lingering entry
 266         manual_umount_client
 267         # mtab may have lingering entry
 268         local WAIT=0
 269         local MAX_WAIT=20
 270         local sleep=1
 271         while [ "$WAIT" -ne "$MAX_WAIT" ]; do
 272                 sleep $sleep
 273                 grep -q $MOUNT" " /etc/mtab || break
 274                 echo "Waiting /etc/mtab updated ... "
 275                 WAIT=$(( WAIT + sleep))
 276         done
 277         [ "$WAIT" -eq "$MAX_WAIT" ] && error "/etc/mtab is not updated in $WAIT secs"
 278         echo "/etc/mtab updated in $WAIT secs"
 279 }
 280 run_test 5a "force cleanup mds, then cleanup"
 281
 282 test_5b() {
 283         start_ost
 284         [ -d $MOUNT ] || mkdir -p $MOUNT
 285         grep " $MOUNT " /etc/mtab && echo "test 5b: mtab before mount" && return 10
 286         mount_client $MOUNT && return 1
 287         grep " $MOUNT " /etc/mtab && echo "test 5b: mtab after failed mount" && return 11
 288         umount_client $MOUNT
 289         # stop_mds is a no-op here, and should not fail
 290         cleanup_nocli || return $?
 291         return 0
 292 }
 293 run_test 5b "mds down, cleanup after failed mount (bug 2712) (should return errs)"
 294
 295 test_5c() {
 296         start_ost
 297         start_mds
 298         [ -d $MOUNT ] || mkdir -p $MOUNT
 299         grep " $MOUNT " /etc/mtab && echo "test 5c: mtab before mount" && return 10
 300         local oldfs="${FSNAME}"
 301         FSNAME="wrong.${FSNAME}"
 302         mount_client $MOUNT || :
 303         FSNAME=${oldfs}
 304         grep " $MOUNT " /etc/mtab && echo "test 5c: mtab after failed mount" && return 11
 305         umount_client $MOUNT
 306         cleanup_nocli  || return $?
 307 }
 308 run_test 5c "cleanup after failed mount (bug 2712) (should return errs)"
 309
 310 test_5d() {
 311         start_ost
 312         start_mds
 313         stop_ost -f
 314         grep " $MOUNT " /etc/mtab && echo "test 5d: mtab before mount" && return 10
 315         mount_client $MOUNT || return 1
 316         cleanup  || return $?
 317         grep " $MOUNT " /etc/mtab && echo "test 5d: mtab after unmount" && return 11
 318         return 0
 319 }
 320 run_test 5d "mount with ost down"
 321
 322 test_5e() {
 323         start_ost
 324         start_mds
 325
 326 #define OBD_FAIL_PTLRPC_DELAY_SEND       0x506
 327         do_facet client "lctl set_param fail_loc=0x80000506"
 328         grep " $MOUNT " /etc/mtab && echo "test 5e: mtab before mount" && return 10
 329         mount_client $MOUNT || echo "mount failed (not fatal)"
 330         cleanup  || return $?
 331         grep " $MOUNT " /etc/mtab && echo "test 5e: mtab after unmount" && return 11
 332         return 0
 333 }
 334 run_test 5e "delayed connect, don't crash (bug 10268)"
 335
 336 test_6() {
 337         setup
 338         manual_umount_client
 339         mount_client ${MOUNT} || return 87
 340         touch $DIR/a || return 86
 341         cleanup  || return $?
 342 }
 343 run_test 6 "manual umount, then mount again"
 344
 345 test_7() {
 346         setup
 347         manual_umount_client
 348         cleanup_nocli || return $?
 349 }
 350 run_test 7 "manual umount, then cleanup"
 351
 352 test_8() {
 353         setup
 354         mount_client $MOUNT2
 355         check_mount2 || return 45
 356         umount_client $MOUNT2
 357         cleanup  || return $?
 358 }
 359 run_test 8 "double mount setup"
 360
 361 test_9() {
 362         start_ost
 363
 364         do_facet ost1 lctl set_param debug=\'inode trace\' || return 1
 365         do_facet ost1 lctl set_param subsystem_debug=\'mds ost\' || return 1
 366
 367         CHECK_PTLDEBUG="`do_facet ost1 lctl get_param -n debug`"
 368         if [ "$CHECK_PTLDEBUG" ] && [ "$CHECK_PTLDEBUG" = "trace inode" ];then
 369            echo "lnet.debug success"
 370         else
 371            echo "lnet.debug: want 'trace inode', have '$CHECK_PTLDEBUG'"
 372            return 1
 373         fi
 374         CHECK_SUBSYS="`do_facet ost1 lctl get_param -n subsystem_debug`"
 375         if [ "$CHECK_SUBSYS" ] && [ "$CHECK_SUBSYS" = "mds ost" ]; then
 376            echo "lnet.subsystem_debug success"
 377         else
 378            echo "lnet.subsystem_debug: want 'mds ost', have '$CHECK_SUBSYS'"
 379            return 1
 380         fi
 381         stop_ost || return $?
 382 }
 383
 384 run_test 9 "test ptldebug and subsystem for mkfs"
 385
 386 # LOGS/PENDING do not exist anymore since CMD3
 387 test_16() {
 388         local TMPMTPT="${TMP}/conf16"
 389         local dev=${SINGLEMDS}_dev
 390         local MDSDEV=${!dev}
 391         if [ ! -e "$MDSDEV" ]; then
 392             log "no $MDSDEV existing, so mount Lustre to create one"
 393             setup
 394             check_mount || return 41
 395             cleanup || return $?
 396         fi
 397
 398         [ -f "$MDSDEV" ] && LOOPOPT="-o loop"
 399
 400         log "change the mode of $MDSDEV/OBJECTS to 555"
 401         do_facet $SINGLEMDS "mkdir -p $TMPMTPT &&
 402                       mount $LOOPOPT -t $FSTYPE $MDSDEV $TMPMTPT &&
 403                       chmod 555 $TMPMTPT/OBJECTS &&
 404                       umount $TMPMTPT" || return $?
 405
 406         log "mount Lustre to change the mode of OBJECTS, then umount Lustre"
 407         setup
 408         check_mount || return 41
 409         cleanup || return $?
 410
 411         log "read the mode of OBJECTS and check if they has been changed properly"
 412         EXPECTEDOBJECTSMODE=`do_facet $SINGLEMDS "debugfs -R 'stat OBJECTS' $MDSDEV 2> /dev/null" | grep 'Mode: ' | sed -e "s/.*Mode: *//" -e "s/ *Flags:.*//"`
 413
 414         if [ "$EXPECTEDOBJECTSMODE" = "0777" ]; then
 415                 log "Success:Lustre change the mode of OBJECTS correctly"
 416         else
 417                 error "Lustre does not change mode of OBJECTS properly"
 418         fi
 419 }
 420 run_test 16 "verify that lustre will correct the mode of OBJECTS"
 421
 422 test_17() {
 423         local dev=${SINGLEMDS}_dev
 424         local MDSDEV=${!dev}
 425
 426         if [ ! -e "$MDSDEV" ]; then
 427             echo "no $MDSDEV existing, so mount Lustre to create one"
 428             setup
 429             check_mount || return 41
 430             cleanup || return $?
 431         fi
 432
 433         echo "Remove mds config log"
 434         do_facet $SINGLEMDS "debugfs -w -R 'unlink CONFIGS/$FSNAME-MDT0000' $MDSDEV || return \$?" || return $?
 435
 436         start_ost
 437         start_mds && return 42
 438         gen_config
 439 }
 440 run_test 17 "Verify failed mds_postsetup won't fail assertion (2936) (should return errs)"
 441
 442 test_18() {
 443         [ "$FSTYPE" != "ldiskfs" ] && skip "not needed for FSTYPE=$FSTYPE" && return
 444
 445         local dev=${SINGLEMDS}_dev
 446         local MDSDEV=${!dev}
 447
 448         local MIN=2000000
 449
 450         local OK=
 451         # check if current MDSSIZE is large enough
 452         [ $MDSSIZE -ge $MIN ] && OK=1 && myMDSSIZE=$MDSSIZE && \
 453                 log "use MDSSIZE=$MDSSIZE"
 454
 455         # check if the global config has a large enough MDSSIZE
 456         [ -z "$OK" -a ! -z "$STORED_MDSSIZE" ] && [ $STORED_MDSSIZE -ge $MIN ] && \
 457                 OK=1 && myMDSSIZE=$STORED_MDSSIZE && \
 458                 log "use STORED_MDSSIZE=$STORED_MDSSIZE"
 459
 460         # check if the block device is large enough
 461         [ -z "$OK" -a -b $MDSDEV ] && \
 462                 [ "$(dd if=$MDSDEV of=/dev/null bs=1k count=1 skip=$MIN 2>&1 |
 463                      awk '($3 == "in") { print $1 }')" = "1+0" ] && OK=1 && \
 464                 myMDSSIZE=$MIN && log "use device $MDSDEV with MIN=$MIN"
 465
 466         # check if a loopback device has enough space for fs metadata (5%)
 467         [ -z "$OK" ] && [ -f $MDSDEV -o ! -e $MDSDEV ] &&
 468                 SPACE=$(df -P $(dirname $MDSDEV) |
 469                         awk '($1 != "Filesystem") {print $4}') &&
 470                 [ $SPACE -gt $((MIN / 20)) ] && OK=1 && myMDSSIZE=$MIN && \
 471                         log "use file $MDSDEV with MIN=$MIN"
 472
 473         [ -z "$OK" ] && skip "$MDSDEV too small for ${MIN}kB MDS" && return
 474
 475
 476         echo "mount mds with large journal..."
 477         local OLD_MDS_MKFS_OPTS=$MDS_MKFS_OPTS
 478
 479         MDS_MKFS_OPTS="--mgs --mdt --fsname=$FSNAME --device-size=$myMDSSIZE --param sys.timeout=$TIMEOUT $MDSOPT"
 480
 481         gen_config
 482         echo "mount lustre system..."
 483         setup
 484         check_mount || return 41
 485
 486         echo "check journal size..."
 487         local FOUNDSIZE=`do_facet mds "debugfs -c -R 'stat <8>' $MDSDEV" | awk '/Size: / { print $NF; exit;}'`
 488         if [ $FOUNDSIZE -gt $((32 * 1024 * 1024)) ]; then
 489                 log "Success: mkfs creates large journals. Size: $((FOUNDSIZE >> 20))M"
 490         else
 491                 error "expected journal size > 32M, found $((FOUNDSIZE >> 20))M"
 492         fi
 493
 494         cleanup || return $?
 495
 496         MDS_MKFS_OPTS=$OLD_MDS_MKFS_OPTS
 497         gen_config
 498 }
 499 run_test 18 "check mkfs creates large journals"
 500
 501 test_19a() {
 502         start_mds || return 1
 503         stop_mds -f || return 2
 504 }
 505 run_test 19a "start/stop MDS without OSTs"
 506
 507 test_19b() {
 508         start_ost || return 1
 509         stop_ost -f || return 2
 510 }
 511 run_test 19b "start/stop OSTs without MDS"
 512
 513 test_20() {
 514         # first format the ost/mdt
 515         start_ost
 516         start_mds
 517         mount_client $MOUNT
 518         check_mount || return 43
 519         rm -f $DIR/$tfile
 520         remount_client ro $MOUNT || return 44
 521         touch $DIR/$tfile && echo "$DIR/$tfile created incorrectly" && return 45
 522         [ -e $DIR/$tfile ] && echo "$DIR/$tfile exists incorrectly" && return 46
 523         remount_client rw $MOUNT || return 47
 524         touch $DIR/$tfile
 525         [ ! -f $DIR/$tfile ] && echo "$DIR/$tfile missing" && return 48
 526         MCNT=`grep -c $MOUNT /etc/mtab`
 527         [ "$MCNT" -ne 1 ] && echo "$MOUNT in /etc/mtab $MCNT times" && return 49
 528         umount_client $MOUNT
 529         stop_mds
 530         stop_ost
 531 }
 532 run_test 20 "remount ro,rw mounts work and doesn't break /etc/mtab"
 533
 534 test_21a() {
 535         start_mds
 536         start_ost
 537         stop_ost
 538         stop_mds
 539 }
 540 run_test 21a "start mds before ost, stop ost first"
 541
 542 test_21b() {
 543         start_ost
 544         start_mds
 545         stop_mds
 546         stop_ost
 547 }
 548 run_test 21b "start ost before mds, stop mds first"
 549
 550 test_21c() {
 551         start_ost
 552         start_mds
 553         start_ost2
 554         stop_ost
 555         stop_ost2
 556         stop_mds
 557 }
 558 run_test 21c "start mds between two osts, stop mds last"
 559
 560 test_22() {
 561         #reformat to remove all logs
 562         reformat
 563         start_mds
 564         echo Client mount before any osts are in the logs
 565         mount_client $MOUNT
 566         check_mount && return 41
 567         pass
 568
 569         echo Client mount with ost in logs, but none running
 570         start_ost
 571         stop_ost
 572         mount_client $MOUNT
 573         # check_mount will block trying to contact ost
 574         umount_client $MOUNT
 575         pass
 576
 577         echo Client mount with a running ost
 578         start_ost
 579         if $GSS; then
 580                 # if gss enabled, wait full time to let connection from
 581                 # mds to ost be established, due to the mismatch between
 582                 # initial connect timeout and gss context negotiation timeout.
 583                 # This perhaps could be remove after AT landed.
 584                 echo "sleep $((TIMEOUT + TIMEOUT + TIMEOUT))s"
 585                 sleep $((TIMEOUT + TIMEOUT + TIMEOUT))
 586         fi
 587         mount_client $MOUNT
 588         check_mount || return 41
 589         pass
 590
 591         cleanup
 592 }
 593 run_test 22 "start a client before osts (should return errs)"
 594
 595 test_23a() {    # was test_23
 596         setup
 597         # fail mds
 598         stop $SINGLEMDS
 599         # force down client so that recovering mds waits for reconnect
 600         local running=$(grep -c $MOUNT /proc/mounts) || true
 601         if [ $running -ne 0 ]; then
 602                 echo "Stopping client $MOUNT (opts: -f)"
 603                 umount -f $MOUNT
 604         fi
 605
 606         # enter recovery on mds
 607         start_mds
 608         # try to start a new client
 609         mount_client $MOUNT &
 610         sleep 5
 611         MOUNT_PID=$(ps -ef | grep "t lustre" | grep -v grep | awk '{print $2}')
 612         MOUNT_LUSTRE_PID=`ps -ef | grep mount.lustre | grep -v grep | awk '{print $2}'`
 613         echo mount pid is ${MOUNT_PID}, mount.lustre pid is ${MOUNT_LUSTRE_PID}
 614         ps --ppid $MOUNT_PID
 615         ps --ppid $MOUNT_LUSTRE_PID
 616         # FIXME why o why can't I kill these? Manual "ctrl-c" works...
 617         kill -TERM $MOUNT_LUSTRE_PID
 618         echo "waiting for mount to finish"
 619         ps -ef | grep mount
 620         # we can not wait $MOUNT_PID because it is not a child of this shell
 621         local PID1
 622         local PID2
 623         local WAIT=0
 624         local MAX_WAIT=20
 625         local sleep=1
 626         while [ "$WAIT" -lt "$MAX_WAIT" ]; do
 627                 sleep $sleep
 628                 PID1=$(ps -ef | awk '{print $2}' | grep -w $MOUNT_PID)
 629                 PID2=$(ps -ef | awk '{print $2}' | grep -w $MOUNT_LUSTRE_PID)
 630                 echo PID1=$PID1
 631                 echo PID2=$PID2
 632                 [ -z "$PID1" -a -z "$PID2" ] && break
 633                 echo "waiting for mount to finish ... "
 634                 WAIT=$(( WAIT + sleep))
 635         done
 636         [ "$WAIT" -eq "$MAX_WAIT" ] && error "MOUNT_PID $MOUNT_PID and \
 637                 MOUNT__LUSTRE_PID $MOUNT__LUSTRE_PID still not killed in $WAIT secs"
 638         ps -ef | grep mount
 639         stop_mds || error
 640         stop_ost || error
 641 }
 642 run_test 23a "interrupt client during recovery mount delay"
 643
 644 umount_client $MOUNT
 645 cleanup_nocli
 646
 647 test_23b() {    # was test_23
 648         start_ost
 649         start_mds
 650         # Simulate -EINTR during mount OBD_FAIL_LDLM_CLOSE_THREAD
 651         lctl set_param fail_loc=0x80000313
 652         mount_client $MOUNT
 653         cleanup
 654 }
 655 run_test 23b "Simulate -EINTR during mount"
 656
 657 fs2mds_HOST=$mds_HOST
 658 fs2ost_HOST=$ost_HOST
 659
 660 cleanup_24a() {
 661         trap 0
 662         echo "umount $MOUNT2 ..."
 663         umount $MOUNT2 || true
 664         echo "stopping fs2mds ..."
 665         stop fs2mds -f || true
 666         echo "stopping fs2ost ..."
 667         stop fs2ost -f || true
 668 }
 669
 670 test_24a() {
 671         #set up fs1
 672         gen_config
 673         #set up fs2
 674         [ -n "$ost1_HOST" ] && fs2ost_HOST=$ost1_HOST
 675         if [ -z "$fs2ost_DEV" -o -z "$fs2mds_DEV" ]; then
 676                 do_facet $SINGLEMDS [ -b "$MDSDEV" ] && \
 677                 skip "mixed loopback and real device not working" && return
 678         fi
 679
 680         local fs2mdsdev=${fs2mds_DEV:-${MDSDEV}_2}
 681         local fs2ostdev=${fs2ost_DEV:-$(ostdevname 1)_2}
 682
 683         # test 8-char fsname as well
 684         local FSNAME2=test1234
 685         add fs2mds $MDS_MKFS_OPTS --fsname=${FSNAME2} --nomgs --mgsnode=$MGSNID --reformat $fs2mdsdev || exit 10
 686
 687         add fs2ost $OST_MKFS_OPTS --fsname=${FSNAME2} --reformat $fs2ostdev || exit 10
 688
 689         setup
 690         start fs2mds $fs2mdsdev $MDS_MOUNT_OPTS && trap cleanup_24a EXIT INT
 691         start fs2ost $fs2ostdev $OST_MOUNT_OPTS
 692         mkdir -p $MOUNT2
 693         mount -t lustre $MGSNID:/${FSNAME2} $MOUNT2 || return 1
 694         # 1 still works
 695         check_mount || return 2
 696         # files written on 1 should not show up on 2
 697         cp /etc/passwd $DIR/$tfile
 698         sleep 10
 699         [ -e $MOUNT2/$tfile ] && error "File bleed" && return 7
 700         # 2 should work
 701         sleep 5
 702         cp /etc/passwd $MOUNT2/b || return 3
 703         rm $MOUNT2/b || return 4
 704         # 2 is actually mounted
 705         grep $MOUNT2' ' /proc/mounts > /dev/null || return 5
 706         # failover
 707         facet_failover fs2mds
 708         facet_failover fs2ost
 709         df
 710         umount_client $MOUNT
 711         # the MDS must remain up until last MDT
 712         stop_mds
 713         MDS=$(do_facet $SINGLEMDS "lctl get_param -n devices" | awk '($3 ~ "mdt" && $4 ~ "MDT") { print $4 }' | head -1)
 714         [ -z "$MDS" ] && error "No MDT" && return 8
 715         cleanup_24a
 716         cleanup_nocli || return 6
 717 }
 718 run_test 24a "Multiple MDTs on a single node"
 719
 720 test_24b() {
 721         if [ -z "$fs2mds_DEV" ]; then
 722                 do_facet $SINGLEMDS [ -b "$MDSDEV" ] && \
 723                 skip "mixed loopback and real device not working" && return
 724         fi
 725
 726         local fs2mdsdev=${fs2mds_DEV:-${MDSDEV}_2}
 727
 728         add fs2mds $MDS_MKFS_OPTS --fsname=${FSNAME}2 --mgs --reformat $fs2mdsdev || exit 10
 729         setup
 730         start fs2mds $fs2mdsdev $MDS_MOUNT_OPTS && return 2
 731         cleanup || return 6
 732 }
 733 run_test 24b "Multiple MGSs on a single node (should return err)"
 734
 735 test_25() {
 736         setup
 737         check_mount || return 2
 738         local MODULES=$($LCTL modules | awk '{ print $2 }')
 739         rmmod $MODULES 2>/dev/null || true
 740         cleanup || return 6
 741 }
 742 run_test 25 "Verify modules are referenced"
 743
 744 test_26() {
 745     load_modules
 746     # we need modules before mount for sysctl, so make sure...
 747     do_facet $SINGLEMDS "lsmod | grep -q lustre || modprobe lustre"
 748 #define OBD_FAIL_MDS_FS_SETUP            0x135
 749     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000135"
 750     start_mds && echo MDS started && return 1
 751     lctl get_param -n devices
 752     DEVS=$(lctl get_param -n devices | wc -l)
 753     [ $DEVS -gt 0 ] && return 2
 754     unload_modules || return 203
 755 }
 756 run_test 26 "MDT startup failure cleans LOV (should return errs)"
 757
 758 set_and_check() {
 759         local myfacet=$1
 760         local TEST=$2
 761         local PARAM=$3
 762         local ORIG=$(do_facet $myfacet "$TEST")
 763         if [ $# -gt 3 ]; then
 764             local FINAL=$4
 765         else
 766             local -i FINAL
 767             FINAL=$(($ORIG + 5))
 768         fi
 769         echo "Setting $PARAM from $ORIG to $FINAL"
 770         do_facet $SINGLEMDS "$LCTL conf_param $PARAM=$FINAL" || error conf_param failed
 771         local RESULT
 772         local MAX=90
 773         local WAIT=0
 774         while [ 1 ]; do
 775             sleep 5
 776             RESULT=$(do_facet $myfacet "$TEST")
 777             if [ $RESULT -eq $FINAL ]; then
 778                 echo "Updated config after $WAIT sec (got $RESULT)"
 779                 break
 780             fi
 781             WAIT=$((WAIT + 5))
 782             if [ $WAIT -eq $MAX ]; then
 783                 echo "Config update not seen: wanted $FINAL got $RESULT"
 784                 return 3
 785             fi
 786             echo "Waiting $(($MAX - $WAIT)) secs for config update"
 787         done
 788 }
 789
 790 test_27a() {
 791         start_ost || return 1
 792         start_mds || return 2
 793         echo "Requeue thread should have started: "
 794         ps -e | grep ll_cfg_requeue
 795         set_and_check ost1 "lctl get_param -n obdfilter.$FSNAME-OST0000.client_cache_seconds" "$FSNAME-OST0000.ost.client_cache_seconds" || return 3
 796         cleanup_nocli
 797 }
 798 run_test 27a "Reacquire MGS lock if OST started first"
 799
 800 test_27b() {
 801         # FIXME. ~grev
 802         setup
 803         local device=$(do_facet $SINGLEMDS "lctl get_param -n devices" | awk '($3 ~ "mdt" && $4 ~ "MDT") { print $4 }')
 804
 805         facet_failover $SINGLEMDS
 806         set_and_check $SINGLEMDS "lctl get_param -n mdt.$device.identity_acquire_expire" "$device.mdt.identity_acquire_expire" || return 3
 807         set_and_check client "lctl get_param -n mdc.$device-mdc-*.max_rpcs_in_flight" "$device.mdc.max_rpcs_in_flight" || return 4
 808         check_mount
 809         cleanup
 810 }
 811 run_test 27b "Reacquire MGS lock after failover"
 812
 813 test_28() {
 814         setup
 815         TEST="lctl get_param -n llite.$FSNAME-*.max_read_ahead_whole_mb"
 816         PARAM="$FSNAME.llite.max_read_ahead_whole_mb"
 817         ORIG=$($TEST)
 818         FINAL=$(($ORIG + 1))
 819         set_and_check client "$TEST" "$PARAM" $FINAL || return 3
 820         FINAL=$(($FINAL + 1))
 821         set_and_check client "$TEST" "$PARAM" $FINAL || return 4
 822         umount_client $MOUNT || return 200
 823         mount_client $MOUNT
 824         RESULT=$($TEST)
 825         if [ $RESULT -ne $FINAL ]; then
 826             echo "New config not seen: wanted $FINAL got $RESULT"
 827             return 4
 828         else
 829             echo "New config success: got $RESULT"
 830         fi
 831         set_and_check client "$TEST" "$PARAM" $ORIG || return 5
 832         cleanup
 833 }
 834 run_test 28 "permanent parameter setting"
 835
 836 test_29() {
 837         [ "$OSTCOUNT" -lt "2" ] && skip "$OSTCOUNT < 2, skipping" && return
 838         setup > /dev/null 2>&1
 839         start_ost2
 840         sleep 10
 841
 842         local PARAM="$FSNAME-OST0001.osc.active"
 843         local PROC_ACT="osc.$FSNAME-OST0001-osc-[^M]*.active"
 844         local PROC_UUID="osc.$FSNAME-OST0001-osc-[^M]*.ost_server_uuid"
 845
 846         ACTV=$(lctl get_param -n $PROC_ACT)
 847         DEAC=$((1 - $ACTV))
 848         set_and_check client "lctl get_param -n $PROC_ACT" "$PARAM" $DEAC || return 2
 849         # also check ost_server_uuid status
 850         RESULT=$(lctl get_param -n $PROC_UUID | grep DEACTIV)
 851         if [ -z "$RESULT" ]; then
 852             echo "Live client not deactivated: $(lctl get_param -n $PROC_UUID)"
 853             return 3
 854         else
 855             echo "Live client success: got $RESULT"
 856         fi
 857
 858         # check MDT too
 859         local MPROC="osc.$FSNAME-OST0001-osc-[M]*.active"
 860         local MAX=30
 861         local WAIT=0
 862         while [ 1 ]; do
 863             sleep 5
 864             RESULT=`do_facet $SINGLEMDS " lctl get_param -n $MPROC"`
 865             [ ${PIPESTATUS[0]} = 0 ] || error "Can't read $MPROC"
 866             if [ $RESULT -eq $DEAC ]; then
 867                 echo "MDT deactivated also after $WAIT sec (got $RESULT)"
 868                 break
 869             fi
 870             WAIT=$((WAIT + 5))
 871             if [ $WAIT -eq $MAX ]; then
 872                 echo "MDT not deactivated: wanted $DEAC got $RESULT"
 873                 return 4
 874             fi
 875             echo "Waiting $(($MAX - $WAIT)) secs for MDT deactivated"
 876         done
 877
 878         # test new client starts deactivated
 879         umount_client $MOUNT || return 200
 880         mount_client $MOUNT
 881         RESULT=$(lctl get_param -n $PROC_UUID | grep DEACTIV | grep NEW)
 882         if [ -z "$RESULT" ]; then
 883             echo "New client not deactivated from start: $(lctl get_param -n $PROC_UUID)"
 884             return 5
 885         else
 886             echo "New client success: got $RESULT"
 887         fi
 888
 889         # make sure it reactivates
 890         set_and_check client "lctl get_param -n $PROC_ACT" "$PARAM" $ACTV || return 6
 891
 892         umount_client $MOUNT
 893         stop_ost2
 894         cleanup_nocli
 895         #writeconf to remove all ost2 traces for subsequent tests
 896         writeconf
 897         start_mds
 898         start_ost
 899         cleanup
 900 }
 901 run_test 29 "permanently remove an OST"
 902
 903 test_30() {
 904         setup
 905
 906         TEST="lctl get_param -n llite.$FSNAME-*.max_read_ahead_whole_mb"
 907         ORIG=$($TEST)
 908         LIST=(1 2 3 4 5 4 3 2 1 2 3 4 5 4 3 2 1 2 3 4 5)
 909         for i in ${LIST[@]}; do
 910             set_and_check client "$TEST" "$FSNAME.llite.max_read_ahead_whole_mb" $i || return 3
 911         done
 912         # make sure client restart still works
 913         umount_client $MOUNT
 914         mount_client $MOUNT || return 4
 915         [ "$($TEST)" -ne "$i" ] && return 5
 916         set_and_check client "$TEST" "$FSNAME.llite.max_read_ahead_whole_mb" $ORIG || return 6
 917         cleanup
 918 }
 919 run_test 30 "Big config llog"
 920
 921 test_31() { # bug 10734
 922         # ipaddr must not exist
 923         mount -t lustre 4.3.2.1@tcp:/lustre $MOUNT || true
 924         cleanup
 925 }
 926 run_test 31 "Connect to non-existent node (shouldn't crash)"
 927
 928 test_32a() {
 929         # XXX - make this run on client-only systems with real hardware on
 930         #       the OST and MDT
 931         #       there appears to be a lot of assumption here about loopback
 932         #       devices
 933         # or maybe this test is just totally useless on a client-only system
 934         [ "$NETTYPE" = "tcp" ] || { skip "NETTYPE != tcp" && return 0; }
 935         [ "$mds_HOST" = "`hostname`" ] || { skip "remote MDS" && return 0; }
 936         [ "$ost_HOST" = "`hostname`" -o "$ost1_HOST" = "`hostname`" ] || \
 937                 { skip "remote OST" && return 0; }
 938
 939         [ -z "$TUNEFS" ] && skip "No tunefs" && return
 940         local DISK1_4=$LUSTRE/tests/disk1_4.zip
 941         [ ! -r $DISK1_4 ] && skip "Cant find $DISK1_4, skipping" && return
 942
 943         local tmpdir=$TMP/conf32a
 944         unzip -o -j -d $tmpdir $DISK1_4 || { skip "Cant unzip $DISK1_4, skipping" && return ; }
 945         load_modules
 946         lctl set_param debug=$PTLDEBUG
 947
 948         $TUNEFS $tmpdir/mds || error "tunefs failed"
 949         # nids are wrong, so client wont work, but server should start
 950         start mds $tmpdir/mds "-o loop,exclude=lustre-OST0000" || return 3
 951         local UUID=$(lctl get_param -n mdt.lustre-MDT0000.uuid)
 952         echo MDS uuid $UUID
 953         [ "$UUID" == "mdsA_UUID" ] || error "UUID is wrong: $UUID"
 954
 955         $TUNEFS --mgsnode=`hostname` $tmpdir/ost1 || error "tunefs failed"
 956         start ost1 $tmpdir/ost1 "-o loop" || return 5
 957         UUID=$(lctl get_param -n obdfilter.lustre-OST0000.uuid)
 958         echo OST uuid $UUID
 959         [ "$UUID" == "ost1_UUID" ] || error "UUID is wrong: $UUID"
 960
 961         local NID=$($LCTL list_nids | head -1)
 962
 963         echo "OSC changes should return err:"
 964         $LCTL conf_param lustre-OST0000.osc.max_dirty_mb=15 && return 7
 965         $LCTL conf_param lustre-OST0000.failover.node=$NID && return 8
 966         echo "ok."
 967         echo "MDC changes should succeed:"
 968         $LCTL conf_param lustre-MDT0000.mdc.max_rpcs_in_flight=9 || return 9
 969         $LCTL conf_param lustre-MDT0000.failover.node=$NID || return 10
 970         echo "ok."
 971
 972         # With a new good MDT failover nid, we should be able to mount a client
 973         # (but it cant talk to OST)
 974         local OLDMOUNTOPT=$MOUNTOPT
 975         MOUNTOPT="exclude=lustre-OST0000"
 976         mount_client $MOUNT
 977         MOUNTOPT=$OLDMOUNTOPT
 978         set_and_check client "lctl get_param -n mdc.*.max_rpcs_in_flight" "lustre-MDT0000.mdc.max_rpcs_in_flight" ||
 979                 return 11
 980
 981         zconf_umount `hostname` $MOUNT -f
 982         cleanup_nocli
 983         load_modules
 984
 985         # mount a second time to make sure we didnt leave upgrade flag on
 986         load_modules
 987         $TUNEFS --dryrun $tmpdir/mds || error "tunefs failed"
 988         load_modules
 989         start mds $tmpdir/mds "-o loop,exclude=lustre-OST0000" || return 12
 990         cleanup_nocli
 991
 992         rm -rf $tmpdir || true  # true is only for TMP on NFS
 993 }
 994 run_test 32a "Upgrade from 1.4 (not live)"
 995
 996 test_32b() {
 997         # XXX - make this run on client-only systems with real hardware on
 998         #       the OST and MDT
 999         #       there appears to be a lot of assumption here about loopback
1000         #       devices
1001         # or maybe this test is just totally useless on a client-only system
1002         [ "$NETTYPE" = "tcp" ] || { skip "NETTYPE != tcp" && return 0; }
1003         [ "$mds_HOST" = "`hostname`" ] || { skip "remote MDS" && return 0; }
1004         [ "$ost_HOST" = "`hostname`" -o "$ost1_HOST" = "`hostname`" ] || \
1005                 { skip "remote OST" && return 0; }
1006
1007         [ -z "$TUNEFS" ] && skip "No tunefs" && return
1008         local DISK1_4=$LUSTRE/tests/disk1_4.zip
1009         [ ! -r $DISK1_4 ] && skip "Cant find $DISK1_4, skipping" && return
1010
1011         local tmpdir=$TMP/conf32b
1012         unzip -o -j -d $tmpdir $DISK1_4 || { skip "Cant unzip $DISK1_4, skipping" && return ; }
1013         load_modules
1014         lctl set_param debug=$PTLDEBUG
1015         NEWNAME=sofia
1016
1017         # writeconf will cause servers to register with their current nids
1018         $TUNEFS --writeconf --fsname=$NEWNAME $tmpdir/mds || error "tunefs failed"
1019         start mds $tmpdir/mds "-o loop" || return 3
1020         local UUID=$(lctl get_param -n mdt.${NEWNAME}-MDT0000.uuid)
1021         echo MDS uuid $UUID
1022         [ "$UUID" == "mdsA_UUID" ] || error "UUID is wrong: $UUID"
1023
1024         $TUNEFS --mgsnode=`hostname` --fsname=$NEWNAME --writeconf $tmpdir/ost1 || error "tunefs failed"
1025         start ost1 $tmpdir/ost1 "-o loop" || return 5
1026         UUID=$(lctl get_param -n obdfilter.${NEWNAME}-OST0000.uuid)
1027         echo OST uuid $UUID
1028         [ "$UUID" == "ost1_UUID" ] || error "UUID is wrong: $UUID"
1029
1030         echo "OSC changes should succeed:"
1031         $LCTL conf_param ${NEWNAME}-OST0000.osc.max_dirty_mb=15 || return 7
1032         $LCTL conf_param ${NEWNAME}-OST0000.failover.node=$NID || return 8
1033         echo "ok."
1034         echo "MDC changes should succeed:"
1035         $LCTL conf_param ${NEWNAME}-MDT0000.mdc.max_rpcs_in_flight=9 || return 9
1036         echo "ok."
1037
1038         # MDT and OST should have registered with new nids, so we should have
1039         # a fully-functioning client
1040         echo "Check client and old fs contents"
1041         OLDFS=$FSNAME
1042         FSNAME=$NEWNAME
1043         mount_client $MOUNT
1044         FSNAME=$OLDFS
1045         set_and_check client "lctl get_param -n mdc.*.max_rpcs_in_flight" "${NEWNAME}-MDT0000.mdc.max_rpcs_in_flight" || return 11
1046         [ "$(cksum $MOUNT/passwd | cut -d' ' -f 1,2)" == "2479747619 779" ] || return 12
1047         echo "ok."
1048
1049         cleanup
1050         rm -rf $tmpdir || true  # true is only for TMP on NFS
1051 }
1052 run_test 32b "Upgrade from 1.4 with writeconf"
1053
1054 test_33a() { # bug 12333, was test_33
1055         local rc=0
1056         local FSNAME2=test-123
1057         [ -n "$ost1_HOST" ] && fs2ost_HOST=$ost1_HOST
1058
1059         if [ -z "$fs2ost_DEV" -o -z "$fs2mds_DEV" ]; then
1060                 do_facet $SINGLEMDS [ -b "$MDSDEV" ] && \
1061                 skip "mixed loopback and real device not working" && return
1062         fi
1063
1064         local fs2mdsdev=${fs2mds_DEV:-${MDSDEV}_2}
1065         local fs2ostdev=${fs2ost_DEV:-$(ostdevname 1)_2}
1066         add fs2mds $MDS_MKFS_OPTS --fsname=${FSNAME2} --reformat $fs2mdsdev || exit 10
1067         add fs2ost $OST_MKFS_OPTS --fsname=${FSNAME2} --index=8191 --mgsnode=$MGSNID --reformat $fs2ostdev || exit 10
1068
1069         start fs2mds $fs2mdsdev $MDS_MOUNT_OPTS && trap cleanup_24a EXIT INT
1070         start fs2ost $fs2ostdev $OST_MOUNT_OPTS
1071         do_facet $SINGLEMDS "$LCTL conf_param $FSNAME2.sys.timeout=200" || rc=1
1072         mkdir -p $MOUNT2
1073         mount -t lustre $MGSNID:/${FSNAME2} $MOUNT2 || rc=2
1074         echo "ok."
1075
1076         cp /etc/hosts $MOUNT2/ || rc=3
1077         $LFS getstripe $MOUNT2/hosts
1078
1079         umount -d $MOUNT2
1080         stop fs2ost -f
1081         stop fs2mds -f
1082         rm -rf $MOUNT2 $fs2mdsdev $fs2ostdev
1083         cleanup_nocli || rc=6
1084         return $rc
1085 }
1086 run_test 33a "Mount ost with a large index number"
1087
1088 test_33b() {    # was test_34
1089         setup
1090
1091         do_facet client dd if=/dev/zero of=$MOUNT/24 bs=1024k count=1
1092         # Drop lock cancelation reply during umount
1093         #define OBD_FAIL_LDLM_CANCEL             0x304
1094         do_facet client lctl set_param fail_loc=0x80000304
1095         #lctl set_param debug=-1
1096         umount_client $MOUNT
1097         cleanup
1098 }
1099 run_test 33b "Drop cancel during umount"
1100
1101 test_34a() {
1102         setup
1103         do_facet client "sh runmultiop_bg_pause $DIR/file O_c"
1104         manual_umount_client
1105         rc=$?
1106         do_facet client killall -USR1 multiop
1107         if [ $rc -eq 0 ]; then
1108                 error "umount not fail!"
1109         fi
1110         sleep 1
1111         cleanup
1112 }
1113 run_test 34a "umount with opened file should be fail"
1114
1115
1116 test_34b() {
1117         setup
1118         touch $DIR/$tfile || return 1
1119         stop_mds --force || return 2
1120
1121         manual_umount_client --force
1122         rc=$?
1123         if [ $rc -ne 0 ]; then
1124                 error "mtab after failed umount - rc $rc"
1125         fi
1126
1127         cleanup
1128         return 0
1129 }
1130 run_test 34b "force umount with failed mds should be normal"
1131
1132 test_34c() {
1133         setup
1134         touch $DIR/$tfile || return 1
1135         stop_ost --force || return 2
1136
1137         manual_umount_client --force
1138         rc=$?
1139         if [ $rc -ne 0 ]; then
1140                 error "mtab after failed umount - rc $rc"
1141         fi
1142
1143         cleanup
1144         return 0
1145 }
1146 run_test 34c "force umount with failed ost should be normal"
1147
1148 test_35() { # bug 12459
1149         setup
1150
1151         DBG_SAVE="`lctl get_param -n debug`"
1152         lctl set_param debug="ha"
1153
1154         log "Set up a fake failnode for the MDS"
1155         FAKENID="127.0.0.2"
1156         local device=$(do_facet $SINGLEMDS "lctl get_param -n devices" | awk '($3 ~ "mdt" && $4 ~ "MDT") { print $4 }' | head -1)
1157         do_facet $SINGLEMDS $LCTL conf_param ${device}.failover.node=$FAKENID || return 4
1158
1159         log "Wait for RECONNECT_INTERVAL seconds (10s)"
1160         sleep 10
1161
1162         MSG="conf-sanity.sh test_35 `date +%F%kh%Mm%Ss`"
1163         $LCTL clear
1164         log "$MSG"
1165         log "Stopping the MDT:"
1166         stop_mds || return 5
1167
1168         df $MOUNT > /dev/null 2>&1 &
1169         DFPID=$!
1170         log "Restarting the MDT:"
1171         start_mds || return 6
1172         log "Wait for df ($DFPID) ... "
1173         wait $DFPID
1174         log "done"
1175         lctl set_param debug="$DBG_SAVE"
1176
1177         # retrieve from the log the first server that the client tried to
1178         # contact after the connection loss
1179         $LCTL dk $TMP/lustre-log-$TESTNAME.log
1180         NEXTCONN=`awk "/${MSG}/ {start = 1;}
1181                        /import_select_connection.$device-mdc.* using connection/ {
1182                                 if (start) {
1183                                         if (\\\$NF ~ /$FAKENID/)
1184                                                 print \\\$NF;
1185                                         else
1186                                                 print 0;
1187                                         exit;
1188                                 }
1189                        }" $TMP/lustre-log-$TESTNAME.log`
1190         [ "$NEXTCONN" != "0" ] && log "The client didn't try to reconnect to the last active server (tried ${NEXTCONN} instead)" && return 7
1191         cleanup
1192 }
1193 run_test 35 "Reconnect to the last active server first"
1194
1195 test_36() { # 12743
1196         local rc
1197         local FSNAME2=test1234
1198         local fs3ost_HOST=$ost_HOST
1199
1200         [ -n "$ost1_HOST" ] && fs2ost_HOST=$ost1_HOST && fs3ost_HOST=$ost1_HOST
1201         rc=0
1202
1203         if [ -z "$fs2ost_DEV" -o -z "$fs2mds_DEV" -o -z "$fs3ost_DEV" ]; then
1204                 do_facet $SINGLEMDS [ -b "$MDSDEV" ] && \
1205                 skip "mixed loopback and real device not working" && return
1206         fi
1207         [ $OSTCOUNT -lt 2 ] && skip "skipping test for single OST" && return
1208
1209         [ "$ost_HOST" = "`hostname`" -o "$ost1_HOST" = "`hostname`" ] || \
1210                 { skip "remote OST" && return 0; }
1211
1212         local fs2mdsdev=${fs2mds_DEV:-${MDSDEV}_2}
1213         local fs2ostdev=${fs2ost_DEV:-$(ostdevname 1)_2}
1214         local fs3ostdev=${fs3ost_DEV:-$(ostdevname 2)_2}
1215         add fs2mds $MDS_MKFS_OPTS --fsname=${FSNAME2} --reformat $fs2mdsdev || exit 10
1216         # XXX after we support non 4K disk blocksize, change following --mkfsoptions with
1217         # other argument
1218         add fs2ost $OST_MKFS_OPTS --mkfsoptions='-b4096' --fsname=${FSNAME2} --mgsnode=$MGSNID --reformat $fs2ostdev || exit 10
1219         add fs3ost $OST_MKFS_OPTS --mkfsoptions='-b4096' --fsname=${FSNAME2} --mgsnode=$MGSNID --reformat $fs3ostdev || exit 10
1220
1221         start fs2mds $fs2mdsdev $MDS_MOUNT_OPTS
1222         start fs2ost $fs2ostdev $OST_MOUNT_OPTS
1223         start fs3ost $fs3ostdev $OST_MOUNT_OPTS
1224         mkdir -p $MOUNT2
1225         mount -t lustre $MGSNID:/${FSNAME2} $MOUNT2 || return 1
1226
1227         sleep 5 # until 11778 fixed
1228
1229         dd if=/dev/zero of=$MOUNT2/$tfile bs=1M count=7 || return 2
1230
1231         BKTOTAL=`lctl get_param -n obdfilter.*.kbytestotal | awk 'BEGIN{total=0}; {total+=$1}; END{print total}'`
1232         BKFREE=`lctl get_param -n obdfilter.*.kbytesfree | awk 'BEGIN{free=0}; {free+=$1}; END{print free}'`
1233         BKAVAIL=`lctl get_param -n obdfilter.*.kbytesavail | awk 'BEGIN{avail=0}; {avail+=$1}; END{print avail}'`
1234         STRING=`df -P $MOUNT2 | tail -n 1 | awk '{print $2","$3","$4}'`
1235         DFTOTAL=`echo $STRING | cut -d, -f1`
1236         DFUSED=`echo $STRING  | cut -d, -f2`
1237         DFAVAIL=`echo $STRING | cut -d, -f3`
1238         DFFREE=$(($DFTOTAL - $DFUSED))
1239
1240         ALLOWANCE=$((64 * $OSTCOUNT))
1241
1242         if [ $DFTOTAL -lt $(($BKTOTAL - $ALLOWANCE)) ] ||
1243            [ $DFTOTAL -gt $(($BKTOTAL + $ALLOWANCE)) ] ; then
1244                 echo "**** FAIL: df total($DFTOTAL) mismatch OST total($BKTOTAL)"
1245                 rc=1
1246         fi
1247         if [ $DFFREE -lt $(($BKFREE - $ALLOWANCE)) ] ||
1248            [ $DFFREE -gt $(($BKFREE + $ALLOWANCE)) ] ; then
1249                 echo "**** FAIL: df free($DFFREE) mismatch OST free($BKFREE)"
1250                 rc=2
1251         fi
1252         if [ $DFAVAIL -lt $(($BKAVAIL - $ALLOWANCE)) ] ||
1253            [ $DFAVAIL -gt $(($BKAVAIL + $ALLOWANCE)) ] ; then
1254                 echo "**** FAIL: df avail($DFAVAIL) mismatch OST avail($BKAVAIL)"
1255                 rc=3
1256        fi
1257
1258         umount -d $MOUNT2
1259         stop fs3ost -f || return 200
1260         stop fs2ost -f || return 201
1261         stop fs2mds -f || return 202
1262         rm -rf $MOUNT2 $fs2mdsdev $fs2ostdev $fs3ostdev
1263         unload_modules || return 203
1264         return $rc
1265 }
1266 run_test 36 "df report consistency on OSTs with different block size"
1267
1268 test_37() {
1269         [ -n "$CLIENTONLY" -o -n "$CLIENTMODSONLY" ] && skip "client only testing" && return 0
1270         LOCAL_MDSDEV="$TMP/mdt.img"
1271         SYM_MDSDEV="$TMP/sym_mdt.img"
1272
1273         echo "MDS :     $LOCAL_MDSDEV"
1274         echo "SYMLINK : $SYM_MDSDEV"
1275         rm -f $LOCAL_MDSDEV
1276
1277         touch $LOCAL_MDSDEV
1278         mkfs.lustre --reformat --fsname=lustre --mdt --mgs --device-size=9000 $LOCAL_MDSDEV ||
1279                 error "mkfs.lustre $LOCAL_MDSDEV failed"
1280         ln -s $LOCAL_MDSDEV $SYM_MDSDEV
1281
1282         echo "mount symlink device - $SYM_MDSDEV"
1283
1284         mount_op=`mount -v -t lustre -o loop $SYM_MDSDEV ${MOUNT%/*}/mds 2>&1 | grep "unable to set tunable"`
1285         umount -d ${MOUNT%/*}/mds
1286         rm -f $LOCAL_MDSDEV $SYM_MDSDEV
1287
1288         if [ -n "$mount_op" ]; then
1289                 error "**** FAIL: set tunables failed for symlink device"
1290         fi
1291         return 0
1292 }
1293 run_test 37 "verify set tunables works for symlink device"
1294
1295 test_38() { # bug 14222
1296         setup
1297         # like runtests
1298         COUNT=10
1299         SRC="/etc /bin"
1300         FILES=`find $SRC -type f -mtime +1 | head -n $COUNT`
1301         log "copying $(echo $FILES | wc -w) files to $DIR/$tdir"
1302         mkdir -p $DIR/$tdir
1303         tar cf - $FILES | tar xf - -C $DIR/$tdir || \
1304                 error "copying $SRC to $DIR/$tdir"
1305         sync
1306         umount_client $MOUNT
1307         stop_mds
1308         log "rename lov_objid file on MDS"
1309         rm -f $TMP/lov_objid.orig
1310
1311         local dev=${SINGLEMDS}_dev
1312         local MDSDEV=${!dev}
1313         do_facet $SINGLEMDS "debugfs -c -R \\\"dump lov_objid $TMP/lov_objid.orig\\\" $MDSDEV"
1314         do_facet $SINGLEMDS "debugfs -w -R \\\"rm lov_objid\\\" $MDSDEV"
1315
1316         do_facet $SINGLEMDS "od -Ax -td8 $TMP/lov_objid.orig"
1317         # check create in mds_lov_connect
1318         start_mds
1319         mount_client $MOUNT
1320         for f in $FILES; do
1321                 [ $V ] && log "verifying $DIR/$tdir/$f"
1322                 diff -q $f $DIR/$tdir/$f || ERROR=y
1323         done
1324         do_facet $SINGLEMDS "debugfs -c -R \\\"dump lov_objid $TMP/lov_objid.new\\\"  $MDSDEV"
1325         do_facet $SINGLEMDS "od -Ax -td8 $TMP/lov_objid.new"
1326         [ "$ERROR" = "y" ] && error "old and new files are different after connect" || true
1327
1328         # check it's updates in sync
1329         umount_client $MOUNT
1330         stop_mds
1331
1332         do_facet $SINGLEMDS dd if=/dev/zero of=$TMP/lov_objid.clear bs=4096 count=1
1333         do_facet $SINGLEMDS "debugfs -w -R \\\"rm lov_objid\\\" $MDSDEV"
1334         do_facet $SINGLEMDS "debugfs -w -R \\\"write $TMP/lov_objid.clear lov_objid\\\" $MDSDEV "
1335
1336         start_mds
1337         mount_client $MOUNT
1338         for f in $FILES; do
1339                 [ $V ] && log "verifying $DIR/$tdir/$f"
1340                 diff -q $f $DIR/$tdir/$f || ERROR=y
1341         done
1342         do_facet $SINGLEMDS "debugfs -c -R \\\"dump lov_objid $TMP/lov_objid.new1\\\" $MDSDEV"
1343         do_facet $SINGLEMDS "od -Ax -td8 $TMP/lov_objid.new1"
1344         umount_client $MOUNT
1345         stop_mds
1346         [ "$ERROR" = "y" ] && error "old and new files are different after sync" || true
1347
1348         log "files compared the same"
1349         cleanup
1350 }
1351 run_test 38 "MDS recreates missing lov_objid file from OST data"
1352
1353 test_39() {
1354         PTLDEBUG=+malloc
1355         setup
1356         cleanup
1357         perl $SRCDIR/leak_finder.pl $TMP/debug 2>&1 | egrep '*** Leak:' &&
1358                 error "memory leak detected" || true
1359 }
1360 run_test 39 "leak_finder recognizes both LUSTRE and LNET malloc messages"
1361
1362 test_40() { # bug 15759
1363         start_ost
1364         #define OBD_FAIL_TGT_TOOMANY_THREADS     0x706
1365         do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000706"
1366         start_mds
1367         cleanup
1368 }
1369 run_test 40 "race during service thread startup"
1370
1371 test_41() { #bug 14134
1372         local rc
1373         local dev=${SINGLEMDS}_dev
1374         local MDSDEV=${!dev}
1375
1376         start $SINGLEMDS $MDSDEV $MDS_MOUNT_OPTS -o nosvc -n
1377         start ost1 `ostdevname 1` $OST_MOUNT_OPTS
1378         start $SINGLEMDS $MDSDEV $MDS_MOUNT_OPTS -o nomgs
1379         mkdir -p $MOUNT
1380         mount_client $MOUNT || return 1
1381         sleep 5
1382
1383         echo "blah blah" > $MOUNT/$tfile
1384         cat $MOUNT/$tfile
1385
1386         umount_client $MOUNT
1387         stop ost1 -f || return 201
1388         stop_mds -f || return 202
1389         stop_mds -f || return 203
1390         unload_modules || return 204
1391         return $rc
1392 }
1393 run_test 41 "mount mds with --nosvc and --nomgs"
1394
1395 test_42() { #bug 14693
1396         setup
1397         check_mount || return 2
1398         do_facet client lctl conf_param lustre.llite.some_wrong_param=10
1399         umount_client $MOUNT
1400         mount_client $MOUNT || return 1
1401         cleanup
1402         return 0
1403 }
1404 run_test 42 "invalid config param should not prevent client from mounting"
1405
1406 umount_client $MOUNT
1407 cleanup_nocli
1408 cleanup_gss
1409
1410 equals_msg `basename $0`: test complete
1411 [ -f "$TESTSUITELOG" ] && cat $TESTSUITELOG || true