lustre/tests/mmp.sh

   1 #!/bin/bash
   2 # -*- mode: Bash; tab-width: 4; indent-tabs-mode: t; -*-
   3 # vim:shiftwidth=4:softtabstop=4:tabstop=4:
   4 #
   5 # Tests for multiple mount protection (MMP) feature.
   6 #
   7 # Run select tests by setting ONLY, or as arguments to the script.
   8 # Skip specific tests by setting EXCEPT.
   9 #
  10 # e.g. ONLY="5 6" or ONLY="`seq 8 11`" or EXCEPT="7"
  11 set -e
  12
  13 ONLY=${ONLY:-"$*"}
  14
  15 # bug number for skipped test:
  16 ALWAYS_EXCEPT=${ALWAYS_EXCEPT:-"$MMP_EXCEPT"}
  17 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  18
  19 SRCDIR=$(cd $(dirname $0); echo $PWD)
  20 export PATH=$PWD/$SRCDIR:$SRCDIR:$SRCDIR/../utils:$PATH:/sbin
  21
  22 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
  23 . $LUSTRE/tests/test-framework.sh
  24 init_test_env $@
  25 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
  26 init_logging
  27
  28 remote_mds_nodsh && skip "remote MDS with nodsh" && exit 0
  29 remote_ost_nodsh && skip "remote OST with nodsh" && exit 0
  30
  31 # unmount and cleanup the Lustre filesystem
  32 MMP_RESTORE_MOUNT=false
  33 if is_mounted $MOUNT || is_mounted $MOUNT2; then
  34     cleanupall
  35     MMP_RESTORE_MOUNT=true
  36 fi
  37
  38 SAVED_FAIL_ON_ERROR=$FAIL_ON_ERROR
  39 FAIL_ON_ERROR=false
  40
  41 build_test_filter
  42
  43 # Get the failover facet.
  44 get_failover_facet() {
  45     local facet=$1
  46     local failover_facet=${facet}failover
  47
  48     local host=$(facet_host $facet)
  49     local failover_host=$(facet_host $failover_facet)
  50
  51     [ -z "$failover_host" -o "$host" = "$failover_host" ] && \
  52         failover_facet=$facet
  53
  54     echo $failover_facet
  55 }
  56
  57 # Initiate the variables for Lustre servers and targets.
  58 init_vars() {
  59     MMP_MDS=${MMP_MDS:-$SINGLEMDS}
  60     MMP_MDS_FAILOVER=$(get_failover_facet $MMP_MDS)
  61
  62     local mds_num=$(echo $MMP_MDS | tr -d "mds")
  63     MMP_MDSDEV=$(mdsdevname $mds_num)
  64
  65     MMP_OSS=${MMP_OSS:-ost1}
  66     MMP_OSS_FAILOVER=$(get_failover_facet $MMP_OSS)
  67
  68     local oss_num=$(echo $MMP_OSS | tr -d "ost")
  69     MMP_OSTDEV=$(ostdevname $oss_num)
  70 }
  71
  72 # Stop the MDS and OSS services on the primary or failover servers.
  73 stop_services() {
  74     local flavor=$1
  75     shift
  76     local opts="$@"
  77     local mds_facet
  78     local oss_facet
  79
  80     if [ "$flavor" = "failover" ]; then
  81         mds_facet=$MMP_MDS_FAILOVER
  82         oss_facet=$MMP_OSS_FAILOVER
  83     else
  84         mds_facet=$MMP_MDS
  85         oss_facet=$MMP_OSS
  86     fi
  87
  88     stop $mds_facet $opts || return ${PIPESTATUS[0]}
  89     stop $oss_facet $opts || return ${PIPESTATUS[0]}
  90 }
  91
  92 # Enable the MMP feature.
  93 enable_mmp() {
  94     local facet=$1
  95     local device=$2
  96
  97     do_facet $facet "$TUNE2FS -O mmp $device"
  98     return ${PIPESTATUS[0]}
  99 }
 100
 101 # Disable the MMP feature.
 102 disable_mmp() {
 103     local facet=$1
 104     local device=$2
 105
 106     do_facet $facet "$TUNE2FS -O ^mmp $device"
 107     return ${PIPESTATUS[0]}
 108 }
 109
 110 # Set the MMP block to 'fsck' state
 111 mark_mmp_block() {
 112     local facet=$1
 113     local device=$2
 114
 115     do_facet $facet "$LUSTRE/tests/mmp_mark.sh $device"
 116     return ${PIPESTATUS[0]}
 117 }
 118
 119 # Reset the MMP block (if any) back to the clean state.
 120 reset_mmp_block() {
 121     local facet=$1
 122     local device=$2
 123
 124     do_facet $facet "$TUNE2FS -f -E clear-mmp $device"
 125     return ${PIPESTATUS[0]}
 126 }
 127
 128 # Check whether the MMP feature is enabled or not.
 129 mmp_is_enabled() {
 130     local facet=$1
 131     local device=$2
 132
 133     do_facet $facet "$DUMPE2FS -h $device | grep mmp"
 134     return ${PIPESTATUS[0]}
 135 }
 136
 137 # Get MMP update interval (in seconds) from the Lustre server target.
 138 get_mmp_update_interval() {
 139         local facet=$1
 140         local device=$2
 141         local interval
 142
 143         interval=$(do_facet $facet \
 144                    "$DEBUGFS -c -R dump_mmp $device 2>$TMP/mmp.debugfs.msg" |
 145                    awk 'tolower($0) ~ /update.interval/ { print $NF }')
 146         [ -z "$interval" ] && interval=5 &&
 147                 do_facet $facet cat $TMP/mmp.debugfs.msg &&
 148                 echo "$facet:$device: assume update interval=$interval" 1>&2 ||
 149                 echo "$facet:$device: got actual update interval=$interval" 1>&2
 150
 151         echo $interval
 152 }
 153
 154 # Get MMP check interval (in seconds) from the Lustre server target.
 155 get_mmp_check_interval() {
 156         local facet=$1
 157         local device=$2
 158         local interval
 159
 160         interval=$(do_facet $facet \
 161                    "$DEBUGFS -c -R dump_mmp $device 2>$TMP/mmp.debugfs.msg" |
 162                    awk 'tolower($0) ~ /check.interval/ { print $NF }')
 163         [ -z "$interval" ] && interval=5 &&
 164                 do_facet $facet cat $TMP/mmp.debugfs.msg &&
 165                 echo "$facet:$device: assume check interval=$interval" 1>&2 ||
 166                 echo "$facet:$device: got actual check interval=$interval" 1>&2
 167
 168         echo $interval
 169 }
 170
 171 # Adjust the MMP update interval (in seconds) on the Lustre server target.
 172 # Specifying an interval of 0 means to use the default interval.
 173 set_mmp_update_interval() {
 174         local facet=$1
 175         local device=$2
 176         local interval=${3:-0}
 177
 178         do_facet $facet "$TUNE2FS -E mmp_update_interval=$interval $device"
 179         return ${PIPESTATUS[0]}
 180 }
 181
 182 # Enable the MMP feature on the Lustre server targets.
 183 mmp_init() {
 184         init_vars
 185
 186         if [ $(facet_fstype $MMP_MDS) != ldiskfs ]; then
 187                 skip "Only applicable to ldiskfs-based MDTs"
 188                 exit
 189         fi
 190
 191         if [ $(facet_fstype $MMP_OSS) != ldiskfs ]; then
 192                 skip "Only applicable to ldiskfs-based OSTs"
 193                 exit
 194         fi
 195
 196     # The MMP feature is automatically enabled by mkfs.lustre for
 197     # new file system at format time if failover is being used.
 198     # Otherwise, the Lustre administrator has to manually enable
 199     # this feature when the file system is unmounted.
 200
 201     local var=${MMP_MDS}failover_HOST
 202     if [ -z "${!var}" ]; then
 203         log "Failover is not used on MDS, enabling MMP manually..."
 204         enable_mmp $MMP_MDS $MMP_MDSDEV || \
 205             error "failed to enable MMP on $MMP_MDSDEV on $MMP_MDS"
 206     fi
 207
 208     var=${MMP_OSS}failover_HOST
 209     if [ -z "${!var}" ]; then
 210         log "Failover is not used on OSS, enabling MMP manually..."
 211         enable_mmp $MMP_OSS $MMP_OSTDEV || \
 212             error "failed to enable MMP on $MMP_OSTDEV on $MMP_OSS"
 213     fi
 214
 215     # check whether the MMP feature is enabled or not
 216     mmp_is_enabled $MMP_MDS $MMP_MDSDEV || \
 217         error "MMP was not enabled on $MMP_MDSDEV on $MMP_MDS"
 218
 219         mmp_is_enabled $MMP_OSS $MMP_OSTDEV || \
 220         {
 221                 do_facet $MMP_OSS "$DUMPE2FS -h $MMP_OSTDEV"
 222                 log "Try to enable again:"
 223                 enable_mmp $MMP_OSS $MMP_OSTDEV
 224                 log "Verify again:"
 225                 do_facet $MMP_OSS "$DUMPE2FS -h $MMP_OSTDEV"
 226                 error "MMP was not enabled on $MMP_OSTDEV on $MMP_OSS"
 227         }
 228 }
 229
 230 # Disable the MMP feature on the Lustre server targets
 231 # which did not use failover.
 232 mmp_fini() {
 233
 234     local var=${MMP_MDS}failover_HOST
 235     if [ -z "${!var}" ]; then
 236         log "Failover is not used on MDS, disabling MMP manually..."
 237         disable_mmp $MMP_MDS $MMP_MDSDEV || \
 238             error "failed to disable MMP on $MMP_MDSDEV on $MMP_MDS"
 239         mmp_is_enabled $MMP_MDS $MMP_MDSDEV && \
 240             error "MMP was not disabled on $MMP_MDSDEV on $MMP_MDS"
 241     fi
 242
 243     var=${MMP_OSS}failover_HOST
 244     if [ -z "${!var}" ]; then
 245         log "Failover is not used on OSS, disabling MMP manually..."
 246         disable_mmp $MMP_OSS $MMP_OSTDEV || \
 247             error "failed to disable MMP on $MMP_OSTDEV on $MMP_OSS"
 248         mmp_is_enabled $MMP_OSS $MMP_OSTDEV && \
 249             error "MMP was not disabled on $MMP_OSTDEV on $MMP_OSS"
 250     fi
 251
 252     return 0
 253 }
 254
 255 # Mount the shared target on the failover server after some interval it's
 256 # mounted on the primary server.
 257 mount_after_interval_sub() {
 258     local interval=$1
 259     shift
 260     local device=$1
 261     shift
 262     local facet=$1
 263     shift
 264     local opts="$@"
 265     local failover_facet=$(get_failover_facet $facet)
 266
 267     local mount_pid
 268     local first_mount_rc=0
 269     local second_mount_rc=0
 270
 271     log "Mounting $device on $facet..."
 272     start $facet $device $opts &
 273     mount_pid=$!
 274
 275     if [ $interval -ne 0 ]; then
 276         log "sleep $interval..."
 277         sleep $interval
 278     fi
 279
 280     log "Mounting $device on $failover_facet..."
 281     start $failover_facet $device $opts
 282     second_mount_rc=${PIPESTATUS[0]}
 283
 284     wait $mount_pid
 285     first_mount_rc=${PIPESTATUS[0]}
 286
 287     if [ $second_mount_rc -eq 0 -a $first_mount_rc -eq 0 ]; then
 288         error_noexit "one mount delayed by mmp interval $interval should fail"
 289         stop $facet || return ${PIPESTATUS[0]}
 290         [ "$failover_facet" != "$facet" ] && stop $failover_facet || \
 291             return ${PIPESTATUS[0]}
 292         return 1
 293     elif [ $second_mount_rc -ne 0 -a $first_mount_rc -ne 0 ]; then
 294         error_noexit "mount failure on failover pair $facet,$failover_facet"
 295         return $first_mount_rc
 296     fi
 297
 298     return 0
 299 }
 300
 301 mount_after_interval() {
 302     local mdt_interval=$1
 303     local ost_interval=$2
 304     local rc=0
 305
 306     mount_after_interval_sub $mdt_interval $MMP_MDSDEV $MMP_MDS \
 307         $MDS_MOUNT_OPTS || return ${PIPESTATUS[0]}
 308
 309     echo
 310     mount_after_interval_sub $ost_interval $MMP_OSTDEV $MMP_OSS $OST_MOUNT_OPTS
 311     rc=${PIPESTATUS[0]}
 312     if [ $rc -ne 0 ]; then
 313         stop $MMP_MDS
 314         return $rc
 315     fi
 316
 317     return 0
 318 }
 319
 320 # Mount the shared target on the failover server
 321 # during unmounting it on the primary server.
 322 mount_during_unmount() {
 323     local device=$1
 324     shift
 325     local facet=$1
 326     shift
 327     local mnt_opts="$@"
 328     local failover_facet=$(get_failover_facet $facet)
 329
 330     local unmount_pid
 331     local unmount_rc=0
 332     local mount_rc=0
 333
 334     log "Mounting $device on $facet..."
 335     start $facet $device $mnt_opts || return ${PIPESTATUS[0]}
 336
 337     log "Unmounting $device on $facet..."
 338     stop $facet &
 339     unmount_pid=$!
 340
 341     log "Mounting $device on $failover_facet..."
 342     start $failover_facet $device $mnt_opts
 343     mount_rc=${PIPESTATUS[0]}
 344
 345     wait $unmount_pid
 346     unmount_rc=${PIPESTATUS[0]}
 347
 348     if [ $mount_rc -eq 0 ]; then
 349         error_noexit "mount during unmount of the first filesystem should fail"
 350         stop $failover_facet || return ${PIPESTATUS[0]}
 351         return 1
 352     fi
 353
 354     if [ $unmount_rc -ne 0 ]; then
 355         error_noexit "unmount the $device on $facet should succeed"
 356         return $unmount_rc
 357     fi
 358
 359     return 0
 360 }
 361
 362 # Mount the shared target on the failover server
 363 # after clean unmounting it on the primary server.
 364 mount_after_unmount() {
 365     local device=$1
 366     shift
 367     local facet=$1
 368     shift
 369     local mnt_opts="$@"
 370     local failover_facet=$(get_failover_facet $facet)
 371
 372     log "Mounting $device on $facet..."
 373     start $facet $device $mnt_opts || return ${PIPESTATUS[0]}
 374
 375     log "Unmounting $device on $facet..."
 376     stop $facet || return ${PIPESTATUS[0]}
 377
 378     log "Mounting $device on $failover_facet..."
 379     start $failover_facet $device $mnt_opts || return ${PIPESTATUS[0]}
 380
 381     return 0
 382 }
 383
 384 # Mount the shared target on the failover server after rebooting
 385 # the primary server.
 386 mount_after_reboot() {
 387     local device=$1
 388     shift
 389     local facet=$1
 390     shift
 391     local mnt_opts="$@"
 392     local failover_facet=$(get_failover_facet $facet)
 393     local rc=0
 394
 395     log "Mounting $device on $facet..."
 396     start $facet $device $mnt_opts || return ${PIPESTATUS[0]}
 397
 398     if [ "$FAILURE_MODE" = "HARD" ]; then
 399         shutdown_facet $facet
 400         reboot_facet $facet
 401         wait_for_facet $facet
 402     else
 403         replay_barrier_nodf $facet
 404     fi
 405
 406     log "Mounting $device on $failover_facet..."
 407     start $failover_facet $device $mnt_opts
 408     rc=${PIPESTATUS[0]}
 409     if [ $rc -ne 0 ]; then
 410         error_noexit "mount $device on $failover_facet should succeed"
 411         stop $facet || return ${PIPESTATUS[0]}
 412         return $rc
 413     fi
 414
 415     return 0
 416 }
 417
 418 # Run e2fsck on the Lustre server target.
 419 run_e2fsck() {
 420         local facet=$1
 421         shift
 422         local device=$1
 423         shift
 424         local opts="$@"
 425
 426         echo "Running e2fsck on the device $device on $facet..."
 427         do_facet $facet "$E2FSCK $opts $device"
 428         return ${PIPESTATUS[0]}
 429 }
 430
 431 # Check whether there are failover pairs for MDS and OSS servers.
 432 check_failover_pair() {
 433     [ "$MMP_MDS" = "$MMP_MDS_FAILOVER" -o "$MMP_OSS" = "$MMP_OSS_FAILOVER" ] \
 434         && { skip_env "failover pair is needed" && return 1; }
 435     return 0
 436 }
 437
 438 mmp_init
 439
 440 # Test 1 - two mounts at the same time.
 441 test_1() {
 442     check_failover_pair || return 0
 443
 444     mount_after_interval 0 0 || return ${PIPESTATUS[0]}
 445     stop_services primary || return ${PIPESTATUS[0]}
 446 }
 447 run_test 1 "two mounts at the same time"
 448
 449 # Test 2 - one mount delayed by mmp update interval.
 450 test_2() {
 451     check_failover_pair || return 0
 452
 453     local mdt_interval=$(get_mmp_update_interval $MMP_MDS $MMP_MDSDEV)
 454     local ost_interval=$(get_mmp_update_interval $MMP_OSS $MMP_OSTDEV)
 455
 456     mount_after_interval $mdt_interval $ost_interval || return ${PIPESTATUS[0]}
 457     stop_services primary || return ${PIPESTATUS[0]}
 458 }
 459 run_test 2 "one mount delayed by mmp update interval"
 460
 461 # Test 3 - one mount delayed by 2x mmp check interval.
 462 test_3() {
 463     check_failover_pair || return 0
 464
 465     local mdt_interval=$(get_mmp_check_interval $MMP_MDS $MMP_MDSDEV)
 466     local ost_interval=$(get_mmp_check_interval $MMP_OSS $MMP_OSTDEV)
 467
 468     mdt_interval=$((2 * $mdt_interval + 1))
 469     ost_interval=$((2 * $ost_interval + 1))
 470
 471     mount_after_interval $mdt_interval $ost_interval || return ${PIPESTATUS[0]}
 472     stop_services primary || return ${PIPESTATUS[0]}
 473 }
 474 run_test 3 "one mount delayed by 2x mmp check interval"
 475
 476 # Test 4 - one mount delayed by > 2x mmp check interval.
 477 test_4() {
 478     check_failover_pair || return 0
 479
 480     local mdt_interval=$(get_mmp_check_interval $MMP_MDS $MMP_MDSDEV)
 481     local ost_interval=$(get_mmp_check_interval $MMP_OSS $MMP_OSTDEV)
 482
 483     mdt_interval=$((4 * $mdt_interval))
 484     ost_interval=$((4 * $ost_interval))
 485
 486     mount_after_interval $mdt_interval $ost_interval || return ${PIPESTATUS[0]}
 487     stop_services primary || return ${PIPESTATUS[0]}
 488 }
 489 run_test 4 "one mount delayed by > 2x mmp check interval"
 490
 491 # Test 5 - mount during unmount of the first filesystem.
 492 test_5() {
 493     local rc=0
 494     check_failover_pair || return 0
 495
 496     mount_during_unmount $MMP_MDSDEV $MMP_MDS $MDS_MOUNT_OPTS || \
 497         return ${PIPESTATUS[0]}
 498
 499     echo
 500     start $MMP_MDS $MMP_MDSDEV $MDS_MOUNT_OPTS || return ${PIPESTATUS[0]}
 501     mount_during_unmount $MMP_OSTDEV $MMP_OSS $OST_MOUNT_OPTS
 502     rc=${PIPESTATUS[0]}
 503     if [ $rc -ne 0 ]; then
 504         stop $MMP_MDS || return ${PIPESTATUS[0]}
 505         return $rc
 506     fi
 507
 508     stop $MMP_MDS || return ${PIPESTATUS[0]}
 509 }
 510 run_test 5 "mount during unmount of the first filesystem"
 511
 512 # Test 6 - mount after clean unmount.
 513 test_6() {
 514     local rc=0
 515     check_failover_pair || return 0
 516
 517     mount_after_unmount $MMP_MDSDEV $MMP_MDS $MDS_MOUNT_OPTS || \
 518         return ${PIPESTATUS[0]}
 519
 520     echo
 521     mount_after_unmount $MMP_OSTDEV $MMP_OSS $OST_MOUNT_OPTS
 522     rc=${PIPESTATUS[0]}
 523     if [ $rc -ne 0 ]; then
 524         stop $MMP_MDS_FAILOVER || return ${PIPESTATUS[0]}
 525         return $rc
 526     fi
 527
 528     stop_services failover || return ${PIPESTATUS[0]}
 529 }
 530 run_test 6 "mount after clean unmount"
 531
 532 # Test 7 - mount after reboot.
 533 test_7() {
 534     local rc=0
 535     check_failover_pair || return 0
 536
 537     mount_after_reboot $MMP_MDSDEV $MMP_MDS $MDS_MOUNT_OPTS || \
 538         return ${PIPESTATUS[0]}
 539
 540     echo
 541     mount_after_reboot $MMP_OSTDEV $MMP_OSS $OST_MOUNT_OPTS
 542     rc=${PIPESTATUS[0]}
 543     if [ $rc -ne 0 ]; then
 544         stop $MMP_MDS || return ${PIPESTATUS[0]}
 545         stop $MMP_MDS_FAILOVER || return ${PIPESTATUS[0]}
 546         return $rc
 547     fi
 548
 549     stop_services failover || return ${PIPESTATUS[0]}
 550     stop_services primary || return ${PIPESTATUS[0]}
 551 }
 552 run_test 7 "mount after reboot"
 553
 554 # Test 8 - mount during e2fsck (should never succeed).
 555 test_8() {
 556         local e2fsck_pid
 557         local saved_interval
 558         local new_interval
 559
 560         # After writing a new sequence number into the MMP block, e2fsck will
 561         # sleep at least (2 * new_interval + 1) seconds before it goes into
 562         # e2fsck passes.
 563         new_interval=30
 564
 565         # MDT
 566         saved_interval=$(get_mmp_update_interval $MMP_MDS $MMP_MDSDEV)
 567         set_mmp_update_interval $MMP_MDS $MMP_MDSDEV $new_interval
 568
 569         run_e2fsck $MMP_MDS $MMP_MDSDEV "-fy" &
 570         e2fsck_pid=$!
 571         sleep 5
 572
 573         if start $MMP_MDS_FAILOVER $MMP_MDSDEV $MDS_MOUNT_OPTS; then
 574                 error_noexit \
 575                         "mount $MMP_MDSDEV on $MMP_MDS_FAILOVER should fail"
 576                 stop $MMP_MDS_FAILOVER || return ${PIPESTATUS[0]}
 577                 set_mmp_update_interval $MMP_MDS $MMP_MDSDEV $saved_interval
 578                 return 1
 579         fi
 580
 581         wait $e2fsck_pid
 582         set_mmp_update_interval $MMP_MDS $MMP_MDSDEV $saved_interval
 583
 584         # OST
 585         echo
 586         saved_interval=$(get_mmp_update_interval $MMP_OSS $MMP_OSTDEV)
 587         set_mmp_update_interval $MMP_OSS $MMP_OSTDEV $new_interval
 588
 589         run_e2fsck $MMP_OSS $MMP_OSTDEV "-fy" &
 590         e2fsck_pid=$!
 591         sleep 5
 592
 593         if start $MMP_OSS_FAILOVER $MMP_OSTDEV $OST_MOUNT_OPTS; then
 594                 error_noexit \
 595                         "mount $MMP_OSTDEV on $MMP_OSS_FAILOVER should fail"
 596                 stop $MMP_OSS_FAILOVER || return ${PIPESTATUS[0]}
 597                 set_mmp_update_interval $MMP_OSS $MMP_OSTDEV $saved_interval
 598                 return 2
 599         fi
 600
 601         wait $e2fsck_pid
 602         set_mmp_update_interval $MMP_OSS $MMP_OSTDEV $saved_interval
 603         return 0
 604 }
 605 run_test 8 "mount during e2fsck"
 606
 607 # Test 9 - mount after aborted e2fsck (should never succeed).
 608 test_9() {
 609     start $MMP_MDS $MMP_MDSDEV $MDS_MOUNT_OPTS || return ${PIPESTATUS[0]}
 610     if ! start $MMP_OSS $MMP_OSTDEV $OST_MOUNT_OPTS; then
 611         local rc=${PIPESTATUS[0]}
 612         stop $MMP_MDS || return ${PIPESTATUS[0]}
 613         return $rc
 614     fi
 615     stop_services primary || return ${PIPESTATUS[0]}
 616
 617     mark_mmp_block $MMP_MDS $MMP_MDSDEV || return ${PIPESTATUS[0]}
 618
 619     log "Mounting $MMP_MDSDEV on $MMP_MDS..."
 620     if start $MMP_MDS $MMP_MDSDEV $MDS_MOUNT_OPTS; then
 621         error_noexit "mount $MMP_MDSDEV on $MMP_MDS should fail"
 622         stop $MMP_MDS || return ${PIPESTATUS[0]}
 623         return 1
 624     fi
 625
 626     reset_mmp_block $MMP_MDS $MMP_MDSDEV || return ${PIPESTATUS[0]}
 627
 628     mark_mmp_block $MMP_OSS $MMP_OSTDEV || return ${PIPESTATUS[0]}
 629
 630     log "Mounting $MMP_OSTDEV on $MMP_OSS..."
 631     if start $MMP_OSS $MMP_OSTDEV $OST_MOUNT_OPTS; then
 632         error_noexit "mount $MMP_OSTDEV on $MMP_OSS should fail"
 633         stop $MMP_OSS || return ${PIPESTATUS[0]}
 634         return 2
 635     fi
 636
 637     reset_mmp_block $MMP_OSS $MMP_OSTDEV || return ${PIPESTATUS[0]}
 638     return 0
 639 }
 640 run_test 9 "mount after aborted e2fsck"
 641
 642 # Test 10 - e2fsck with mounted filesystem.
 643 test_10() {
 644     local rc=0
 645
 646     log "Mounting $MMP_MDSDEV on $MMP_MDS..."
 647     start $MMP_MDS $MMP_MDSDEV $MDS_MOUNT_OPTS || return ${PIPESTATUS[0]}
 648
 649     run_e2fsck $MMP_MDS_FAILOVER $MMP_MDSDEV "-fn"
 650     rc=${PIPESTATUS[0]}
 651
 652     # e2fsck is called with -n option (Open the filesystem read-only), so
 653     # 0 (No errors) and 4 (File system errors left uncorrected) are the only
 654     # acceptable exit codes in this case
 655     if [ $rc -ne 0 ] && [ $rc -ne 4 ]; then
 656         error_noexit "e2fsck $MMP_MDSDEV on $MMP_MDS_FAILOVER returned $rc"
 657         stop $MMP_MDS || return ${PIPESTATUS[0]}
 658         return $rc
 659     fi
 660
 661     log "Mounting $MMP_OSTDEV on $MMP_OSS..."
 662     start $MMP_OSS $MMP_OSTDEV $OST_MOUNT_OPTS
 663     rc=${PIPESTATUS[0]}
 664     if [ $rc -ne 0 ]; then
 665         stop $MMP_MDS || return ${PIPESTATUS[0]}
 666         return $rc
 667     fi
 668
 669     run_e2fsck $MMP_OSS_FAILOVER $MMP_OSTDEV "-fn"
 670     rc=${PIPESTATUS[0]}
 671     if [ $rc -ne 0 ] && [ $rc -ne 4 ]; then
 672         error_noexit "e2fsck $MMP_OSTDEV on $MMP_OSS_FAILOVER returned $rc"
 673     fi
 674
 675     stop_services primary || return ${PIPESTATUS[0]}
 676     return 0
 677 }
 678 run_test 10 "e2fsck with mounted filesystem"
 679
 680 mmp_fini
 681 FAIL_ON_ERROR=$SAVED_FAIL_ON_ERROR
 682
 683 complete $SECONDS
 684 $MMP_RESTORE_MOUNT && setupall
 685 exit_status