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