lustre/tests/mmp.sh

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