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