lustre/tests/mmp.sh

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