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