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