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 "$DEBUGFS -c -R dump_mmp $device 2>/dev/null \
 144                 | grep 'MMP Update Interval' | cut -d' ' -f4")
 145     [ -z "$interval" ] && interval=1
 146
 147     echo $interval
 148 }
 149
 150 # Get MMP check interval (in seconds) from the Lustre server target.
 151 get_mmp_check_interval() {
 152     local facet=$1
 153     local device=$2
 154     local interval
 155
 156     interval=$(do_facet $facet "$DEBUGFS -c -R dump_mmp $device 2>/dev/null \
 157                 | grep 'MMP Check Interval' | cut -d' ' -f4")
 158     [ -z "$interval" ] && interval=5
 159
 160     echo $interval
 161 }
 162
 163 # Enable the MMP feature on the Lustre server targets.
 164 mmp_init() {
 165         init_vars
 166
 167         if [ $(facet_fstype $MMP_MDS) != ldiskfs ]; then
 168                 skip "Only applicable to ldiskfs-based MDTs"
 169                 exit
 170         fi
 171
 172         if [ $(facet_fstype $MMP_OSS) != ldiskfs ]; then
 173                 skip "Only applicable to ldiskfs-based OSTs"
 174                 exit
 175         fi
 176
 177     # The MMP feature is automatically enabled by mkfs.lustre for
 178     # new file system at format time if failover is being used.
 179     # Otherwise, the Lustre administrator has to manually enable
 180     # this feature when the file system is unmounted.
 181
 182     local var=${MMP_MDS}failover_HOST
 183     if [ -z "${!var}" ]; then
 184         log "Failover is not used on MDS, enabling MMP manually..."
 185         enable_mmp $MMP_MDS $MMP_MDSDEV || \
 186             error "failed to enable MMP on $MMP_MDSDEV on $MMP_MDS"
 187     fi
 188
 189     var=${MMP_OSS}failover_HOST
 190     if [ -z "${!var}" ]; then
 191         log "Failover is not used on OSS, enabling MMP manually..."
 192         enable_mmp $MMP_OSS $MMP_OSTDEV || \
 193             error "failed to enable MMP on $MMP_OSTDEV on $MMP_OSS"
 194     fi
 195
 196     # check whether the MMP feature is enabled or not
 197     mmp_is_enabled $MMP_MDS $MMP_MDSDEV || \
 198         error "MMP was not enabled on $MMP_MDSDEV on $MMP_MDS"
 199
 200     mmp_is_enabled $MMP_OSS $MMP_OSTDEV || \
 201         error "MMP was not enabled on $MMP_OSTDEV on $MMP_OSS"
 202 }
 203
 204 # Disable the MMP feature on the Lustre server targets
 205 # which did not use failover.
 206 mmp_fini() {
 207
 208     local var=${MMP_MDS}failover_HOST
 209     if [ -z "${!var}" ]; then
 210         log "Failover is not used on MDS, disabling MMP manually..."
 211         disable_mmp $MMP_MDS $MMP_MDSDEV || \
 212             error "failed to disable MMP on $MMP_MDSDEV on $MMP_MDS"
 213         mmp_is_enabled $MMP_MDS $MMP_MDSDEV && \
 214             error "MMP was not disabled on $MMP_MDSDEV on $MMP_MDS"
 215     fi
 216
 217     var=${MMP_OSS}failover_HOST
 218     if [ -z "${!var}" ]; then
 219         log "Failover is not used on OSS, disabling MMP manually..."
 220         disable_mmp $MMP_OSS $MMP_OSTDEV || \
 221             error "failed to disable MMP on $MMP_OSTDEV on $MMP_OSS"
 222         mmp_is_enabled $MMP_OSS $MMP_OSTDEV && \
 223             error "MMP was not disabled on $MMP_OSTDEV on $MMP_OSS"
 224     fi
 225
 226     return 0
 227 }
 228
 229 # Mount the shared target on the failover server after some interval it's
 230 # mounted on the primary server.
 231 mount_after_interval_sub() {
 232     local interval=$1
 233     shift
 234     local device=$1
 235     shift
 236     local facet=$1
 237     shift
 238     local opts="$@"
 239     local failover_facet=$(get_failover_facet $facet)
 240
 241     local mount_pid
 242     local first_mount_rc=0
 243     local second_mount_rc=0
 244
 245     log "Mounting $device on $facet..."
 246     start $facet $device $opts &
 247     mount_pid=$!
 248
 249     if [ $interval -ne 0 ]; then
 250         log "sleep $interval..."
 251         sleep $interval
 252     fi
 253
 254     log "Mounting $device on $failover_facet..."
 255     start $failover_facet $device $opts
 256     second_mount_rc=${PIPESTATUS[0]}
 257
 258     wait $mount_pid
 259     first_mount_rc=${PIPESTATUS[0]}
 260
 261     if [ $second_mount_rc -eq 0 -a $first_mount_rc -eq 0 ]; then
 262         error_noexit "one mount delayed by mmp interval $interval should fail"
 263         stop $facet || return ${PIPESTATUS[0]}
 264         [ "$failover_facet" != "$facet" ] && stop $failover_facet || \
 265             return ${PIPESTATUS[0]}
 266         return 1
 267     elif [ $second_mount_rc -ne 0 -a $first_mount_rc -ne 0 ]; then
 268         error_noexit "mount failure on failover pair $facet,$failover_facet"
 269         return $first_mount_rc
 270     fi
 271
 272     return 0
 273 }
 274
 275 mount_after_interval() {
 276     local mdt_interval=$1
 277     local ost_interval=$2
 278     local rc=0
 279
 280     mount_after_interval_sub $mdt_interval $MMP_MDSDEV $MMP_MDS \
 281         $MDS_MOUNT_OPTS || return ${PIPESTATUS[0]}
 282
 283     echo
 284     mount_after_interval_sub $ost_interval $MMP_OSTDEV $MMP_OSS $OST_MOUNT_OPTS
 285     rc=${PIPESTATUS[0]}
 286     if [ $rc -ne 0 ]; then
 287         stop $MMP_MDS
 288         return $rc
 289     fi
 290
 291     return 0
 292 }
 293
 294 # Mount the shared target on the failover server
 295 # during unmounting it on the primary server.
 296 mount_during_unmount() {
 297     local device=$1
 298     shift
 299     local facet=$1
 300     shift
 301     local mnt_opts="$@"
 302     local failover_facet=$(get_failover_facet $facet)
 303
 304     local unmount_pid
 305     local unmount_rc=0
 306     local mount_rc=0
 307
 308     log "Mounting $device on $facet..."
 309     start $facet $device $mnt_opts || return ${PIPESTATUS[0]}
 310
 311     log "Unmounting $device on $facet..."
 312     stop $facet &
 313     unmount_pid=$!
 314
 315     log "Mounting $device on $failover_facet..."
 316     start $failover_facet $device $mnt_opts
 317     mount_rc=${PIPESTATUS[0]}
 318
 319     wait $unmount_pid
 320     unmount_rc=${PIPESTATUS[0]}
 321
 322     if [ $mount_rc -eq 0 ]; then
 323         error_noexit "mount during unmount of the first filesystem should fail"
 324         stop $failover_facet || return ${PIPESTATUS[0]}
 325         return 1
 326     fi
 327
 328     if [ $unmount_rc -ne 0 ]; then
 329         error_noexit "unmount the $device on $facet should succeed"
 330         return $unmount_rc
 331     fi
 332
 333     return 0
 334 }
 335
 336 # Mount the shared target on the failover server
 337 # after clean unmounting it on the primary server.
 338 mount_after_unmount() {
 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
 346     log "Mounting $device on $facet..."
 347     start $facet $device $mnt_opts || return ${PIPESTATUS[0]}
 348
 349     log "Unmounting $device on $facet..."
 350     stop $facet || return ${PIPESTATUS[0]}
 351
 352     log "Mounting $device on $failover_facet..."
 353     start $failover_facet $device $mnt_opts || return ${PIPESTATUS[0]}
 354
 355     return 0
 356 }
 357
 358 # Mount the shared target on the failover server after rebooting
 359 # the primary server.
 360 mount_after_reboot() {
 361     local device=$1
 362     shift
 363     local facet=$1
 364     shift
 365     local mnt_opts="$@"
 366     local failover_facet=$(get_failover_facet $facet)
 367     local rc=0
 368
 369     log "Mounting $device on $facet..."
 370     start $facet $device $mnt_opts || return ${PIPESTATUS[0]}
 371
 372     if [ "$FAILURE_MODE" = "HARD" ]; then
 373         shutdown_facet $facet
 374         reboot_facet $facet
 375         wait_for_facet $facet
 376     else
 377         replay_barrier_nodf $facet
 378     fi
 379
 380     log "Mounting $device on $failover_facet..."
 381     start $failover_facet $device $mnt_opts
 382     rc=${PIPESTATUS[0]}
 383     if [ $rc -ne 0 ]; then
 384         error_noexit "mount $device on $failover_facet should succeed"
 385         stop $facet || return ${PIPESTATUS[0]}
 386         return $rc
 387     fi
 388
 389     return 0
 390 }
 391
 392 # Run e2fsck on the Lustre server target.
 393 run_e2fsck() {
 394     local facet=$1
 395     shift
 396     local device=$1
 397     shift
 398     local opts="$@"
 399
 400     log "Running e2fsck on the device $device on $facet..."
 401     do_facet $facet "$E2FSCK $opts $device"
 402     return ${PIPESTATUS[0]}
 403 }
 404
 405 # Run delayed e2fsck on the Lustre server target.
 406 run_delay_e2fsck() {
 407         local facet=$1
 408         shift
 409         local device=$1
 410
 411         do_facet $facet "$LUSTRE/tests/e2fsck.exp $device"
 412         return ${PIPESTATUS[0]}
 413 }
 414
 415 # Check whether there are failover pairs for MDS and OSS servers.
 416 check_failover_pair() {
 417     [ "$MMP_MDS" = "$MMP_MDS_FAILOVER" -o "$MMP_OSS" = "$MMP_OSS_FAILOVER" ] \
 418         && { skip_env "failover pair is needed" && return 1; }
 419     return 0
 420 }
 421
 422 mmp_init
 423
 424 # Test 1 - two mounts at the same time.
 425 test_1() {
 426     check_failover_pair || return 0
 427
 428     mount_after_interval 0 0 || return ${PIPESTATUS[0]}
 429     stop_services primary || return ${PIPESTATUS[0]}
 430 }
 431 run_test 1 "two mounts at the same time"
 432
 433 # Test 2 - one mount delayed by mmp update interval.
 434 test_2() {
 435     check_failover_pair || return 0
 436
 437     local mdt_interval=$(get_mmp_update_interval $MMP_MDS $MMP_MDSDEV)
 438     local ost_interval=$(get_mmp_update_interval $MMP_OSS $MMP_OSTDEV)
 439
 440     mount_after_interval $mdt_interval $ost_interval || return ${PIPESTATUS[0]}
 441     stop_services primary || return ${PIPESTATUS[0]}
 442 }
 443 run_test 2 "one mount delayed by mmp update interval"
 444
 445 # Test 3 - one mount delayed by 2x mmp check interval.
 446 test_3() {
 447     check_failover_pair || return 0
 448
 449     local mdt_interval=$(get_mmp_check_interval $MMP_MDS $MMP_MDSDEV)
 450     local ost_interval=$(get_mmp_check_interval $MMP_OSS $MMP_OSTDEV)
 451
 452     mdt_interval=$((2 * $mdt_interval + 1))
 453     ost_interval=$((2 * $ost_interval + 1))
 454
 455     mount_after_interval $mdt_interval $ost_interval || return ${PIPESTATUS[0]}
 456     stop_services primary || return ${PIPESTATUS[0]}
 457 }
 458 run_test 3 "one mount delayed by 2x mmp check interval"
 459
 460 # Test 4 - one mount delayed by > 2x mmp check interval.
 461 test_4() {
 462     check_failover_pair || return 0
 463
 464     local mdt_interval=$(get_mmp_check_interval $MMP_MDS $MMP_MDSDEV)
 465     local ost_interval=$(get_mmp_check_interval $MMP_OSS $MMP_OSTDEV)
 466
 467     mdt_interval=$((4 * $mdt_interval))
 468     ost_interval=$((4 * $ost_interval))
 469
 470     mount_after_interval $mdt_interval $ost_interval || return ${PIPESTATUS[0]}
 471     stop_services primary || return ${PIPESTATUS[0]}
 472 }
 473 run_test 4 "one mount delayed by > 2x mmp check interval"
 474
 475 # Test 5 - mount during unmount of the first filesystem.
 476 test_5() {
 477     local rc=0
 478     check_failover_pair || return 0
 479
 480     mount_during_unmount $MMP_MDSDEV $MMP_MDS $MDS_MOUNT_OPTS || \
 481         return ${PIPESTATUS[0]}
 482
 483     echo
 484     start $MMP_MDS $MMP_MDSDEV $MDS_MOUNT_OPTS || return ${PIPESTATUS[0]}
 485     mount_during_unmount $MMP_OSTDEV $MMP_OSS $OST_MOUNT_OPTS
 486     rc=${PIPESTATUS[0]}
 487     if [ $rc -ne 0 ]; then
 488         stop $MMP_MDS || return ${PIPESTATUS[0]}
 489         return $rc
 490     fi
 491
 492     stop $MMP_MDS || return ${PIPESTATUS[0]}
 493 }
 494 run_test 5 "mount during unmount of the first filesystem"
 495
 496 # Test 6 - mount after clean unmount.
 497 test_6() {
 498     local rc=0
 499     check_failover_pair || return 0
 500
 501     mount_after_unmount $MMP_MDSDEV $MMP_MDS $MDS_MOUNT_OPTS || \
 502         return ${PIPESTATUS[0]}
 503
 504     echo
 505     mount_after_unmount $MMP_OSTDEV $MMP_OSS $OST_MOUNT_OPTS
 506     rc=${PIPESTATUS[0]}
 507     if [ $rc -ne 0 ]; then
 508         stop $MMP_MDS_FAILOVER || return ${PIPESTATUS[0]}
 509         return $rc
 510     fi
 511
 512     stop_services failover || return ${PIPESTATUS[0]}
 513 }
 514 run_test 6 "mount after clean unmount"
 515
 516 # Test 7 - mount after reboot.
 517 test_7() {
 518     local rc=0
 519     check_failover_pair || return 0
 520
 521     mount_after_reboot $MMP_MDSDEV $MMP_MDS $MDS_MOUNT_OPTS || \
 522         return ${PIPESTATUS[0]}
 523
 524     echo
 525     mount_after_reboot $MMP_OSTDEV $MMP_OSS $OST_MOUNT_OPTS
 526     rc=${PIPESTATUS[0]}
 527     if [ $rc -ne 0 ]; then
 528         stop $MMP_MDS || return ${PIPESTATUS[0]}
 529         stop $MMP_MDS_FAILOVER || return ${PIPESTATUS[0]}
 530         return $rc
 531     fi
 532
 533     stop_services failover || return ${PIPESTATUS[0]}
 534     stop_services primary || return ${PIPESTATUS[0]}
 535 }
 536 run_test 7 "mount after reboot"
 537
 538 # Test 8 - mount during e2fsck (should never succeed).
 539 test_8() {
 540         local e2fsck_pid
 541
 542         log "Force e2fsck checking on device $MMP_MDSDEV on $MMP_MDS"
 543         do_facet $MMP_MDS "$DEBUGFS -w -R 'ssv free_blocks_count 0' $MMP_MDSDEV"
 544         run_delay_e2fsck $MMP_MDS $MMP_MDSDEV &
 545         e2fsck_pid=$!
 546         sleep 5
 547
 548         if start $MMP_MDS_FAILOVER $MMP_MDSDEV $MDS_MOUNT_OPTS; then
 549                 error_noexit \
 550                         "mount $MMP_MDSDEV on $MMP_MDS_FAILOVER should fail"
 551                 stop $MMP_MDS_FAILOVER || return ${PIPESTATUS[0]}
 552                 return 1
 553         fi
 554
 555         wait $e2fsck_pid
 556
 557         echo
 558         log "Force e2fsck checking on device $MMP_OSTDEV on $MMP_OSS"
 559         do_facet $MMP_OSS "$DEBUGFS -w -R 'ssv free_blocks_count 0' $MMP_OSTDEV"
 560         run_delay_e2fsck $MMP_OSS $MMP_OSTDEV &
 561         e2fsck_pid=$!
 562         sleep 5
 563
 564         if start $MMP_OSS_FAILOVER $MMP_OSTDEV $OST_MOUNT_OPTS; then
 565                 error_noexit \
 566                         "mount $MMP_OSTDEV on $MMP_OSS_FAILOVER should fail"
 567                 stop $MMP_OSS_FAILOVER || return ${PIPESTATUS[0]}
 568                 return 2
 569         fi
 570
 571         wait $e2fsck_pid
 572         return 0
 573 }
 574 run_test 8 "mount during e2fsck"
 575
 576 # Test 9 - mount after aborted e2fsck (should never succeed).
 577 test_9() {
 578     start $MMP_MDS $MMP_MDSDEV $MDS_MOUNT_OPTS || return ${PIPESTATUS[0]}
 579     if ! start $MMP_OSS $MMP_OSTDEV $OST_MOUNT_OPTS; then
 580         local rc=${PIPESTATUS[0]}
 581         stop $MMP_MDS || return ${PIPESTATUS[0]}
 582         return $rc
 583     fi
 584     stop_services primary || return ${PIPESTATUS[0]}
 585
 586     mark_mmp_block $MMP_MDS $MMP_MDSDEV || return ${PIPESTATUS[0]}
 587
 588     log "Mounting $MMP_MDSDEV on $MMP_MDS..."
 589     if start $MMP_MDS $MMP_MDSDEV $MDS_MOUNT_OPTS; then
 590         error_noexit "mount $MMP_MDSDEV on $MMP_MDS should fail"
 591         stop $MMP_MDS || return ${PIPESTATUS[0]}
 592         return 1
 593     fi
 594
 595     reset_mmp_block $MMP_MDS $MMP_MDSDEV || return ${PIPESTATUS[0]}
 596
 597     mark_mmp_block $MMP_OSS $MMP_OSTDEV || return ${PIPESTATUS[0]}
 598
 599     log "Mounting $MMP_OSTDEV on $MMP_OSS..."
 600     if start $MMP_OSS $MMP_OSTDEV $OST_MOUNT_OPTS; then
 601         error_noexit "mount $MMP_OSTDEV on $MMP_OSS should fail"
 602         stop $MMP_OSS || return ${PIPESTATUS[0]}
 603         return 2
 604     fi
 605
 606     reset_mmp_block $MMP_OSS $MMP_OSTDEV || return ${PIPESTATUS[0]}
 607     return 0
 608 }
 609 run_test 9 "mount after aborted e2fsck"
 610
 611 # Test 10 - e2fsck with mounted filesystem.
 612 test_10() {
 613     local rc=0
 614
 615     log "Mounting $MMP_MDSDEV on $MMP_MDS..."
 616     start $MMP_MDS $MMP_MDSDEV $MDS_MOUNT_OPTS || return ${PIPESTATUS[0]}
 617
 618     run_e2fsck $MMP_MDS_FAILOVER $MMP_MDSDEV "-fn"
 619     rc=${PIPESTATUS[0]}
 620
 621     # e2fsck is called with -n option (Open the filesystem read-only), so
 622     # 0 (No errors) and 4 (File system errors left uncorrected) are the only
 623     # acceptable exit codes in this case
 624     if [ $rc -ne 0 ] && [ $rc -ne 4 ]; then
 625         error_noexit "e2fsck $MMP_MDSDEV on $MMP_MDS_FAILOVER returned $rc"
 626         stop $MMP_MDS || return ${PIPESTATUS[0]}
 627         return $rc
 628     fi
 629
 630     log "Mounting $MMP_OSTDEV on $MMP_OSS..."
 631     start $MMP_OSS $MMP_OSTDEV $OST_MOUNT_OPTS
 632     rc=${PIPESTATUS[0]}
 633     if [ $rc -ne 0 ]; then
 634         stop $MMP_MDS || return ${PIPESTATUS[0]}
 635         return $rc
 636     fi
 637
 638     run_e2fsck $MMP_OSS_FAILOVER $MMP_OSTDEV "-fn"
 639     rc=${PIPESTATUS[0]}
 640     if [ $rc -ne 0 ] && [ $rc -ne 4 ]; then
 641         error_noexit "e2fsck $MMP_OSTDEV on $MMP_OSS_FAILOVER returned $rc"
 642     fi
 643
 644     stop_services primary || return ${PIPESTATUS[0]}
 645     return 0
 646 }
 647 run_test 10 "e2fsck with mounted filesystem"
 648
 649 mmp_fini
 650 FAIL_ON_ERROR=$SAVED_FAIL_ON_ERROR
 651
 652 complete $(basename $0) $SECONDS
 653 $MMP_RESTORE_MOUNT && setupall
 654 exit_status