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         local device=$2
 411         shift 2
 412         local opts="$@"
 413
 414         # turn on pfsck if it is supported
 415         do_facet $facet $E2FSCK -h 2>&1 | grep -qw -- -m && opts+=" -m8"
 416         echo "Running e2fsck on the device $device on $facet..."
 417         do_facet $facet "$E2FSCK $opts $device"
 418         return ${PIPESTATUS[0]}
 419 }
 420
 421 # Check whether there are failover pairs for MDS and OSS servers.
 422 check_failover_pair() {
 423         [ "$MMP_MDS" = "$MMP_MDS_FAILOVER" -o "$MMP_OSS" = "$MMP_OSS_FAILOVER" ] &&
 424                 skip_env "failover pair is needed"
 425         return 0
 426 }
 427
 428 mmp_init
 429
 430 # Test 1 - two mounts at the same time.
 431 test_1() {
 432         check_failover_pair
 433
 434         mount_after_interval 0 0 || return ${PIPESTATUS[0]}
 435         stop_services primary || return ${PIPESTATUS[0]}
 436         stop_services failover || return ${PIPESTATUS[0]}
 437 }
 438 run_test 1 "two mounts at the same time"
 439
 440 # Test 2 - one mount delayed by mmp update interval.
 441 test_2() {
 442         check_failover_pair
 443
 444         local mdt_interval=$(get_mmp_update_interval $MMP_MDS $MMP_MDSDEV)
 445         local ost_interval=$(get_mmp_update_interval $MMP_OSS $MMP_OSTDEV)
 446
 447         mount_after_interval $mdt_interval $ost_interval ||
 448                 return ${PIPESTATUS[0]}
 449         stop_services primary || return ${PIPESTATUS[0]}
 450 }
 451 run_test 2 "one mount delayed by mmp update interval"
 452
 453 # Test 3 - one mount delayed by 2x mmp check interval.
 454 test_3() {
 455         check_failover_pair
 456
 457         local mdt_interval=$(get_mmp_check_interval $MMP_MDS $MMP_MDSDEV)
 458         local ost_interval=$(get_mmp_check_interval $MMP_OSS $MMP_OSTDEV)
 459
 460         mdt_interval=$((2 * $mdt_interval + 1))
 461         ost_interval=$((2 * $ost_interval + 1))
 462
 463         mount_after_interval $mdt_interval $ost_interval ||
 464                 return ${PIPESTATUS[0]}
 465         stop_services primary || return ${PIPESTATUS[0]}
 466 }
 467 run_test 3 "one mount delayed by 2x mmp check interval"
 468
 469 # Test 4 - one mount delayed by > 2x mmp check interval.
 470 test_4() {
 471         check_failover_pair
 472
 473         local mdt_interval=$(get_mmp_check_interval $MMP_MDS $MMP_MDSDEV)
 474         local ost_interval=$(get_mmp_check_interval $MMP_OSS $MMP_OSTDEV)
 475
 476         mdt_interval=$((4 * $mdt_interval))
 477         ost_interval=$((4 * $ost_interval))
 478
 479         mount_after_interval $mdt_interval $ost_interval ||
 480                 return ${PIPESTATUS[0]}
 481         stop_services primary || return ${PIPESTATUS[0]}
 482 }
 483 run_test 4 "one mount delayed by > 2x mmp check interval"
 484
 485 # Test 5 - mount during unmount of the first filesystem.
 486 test_5() {
 487         local rc=0
 488         check_failover_pair
 489
 490         mount_during_unmount $MMP_MDSDEV $MMP_MDS $MDS_MOUNT_OPTS ||
 491                 return ${PIPESTATUS[0]}
 492
 493         echo
 494         start $MMP_MDS $MMP_MDSDEV $MDS_MOUNT_OPTS || return ${PIPESTATUS[0]}
 495         mount_during_unmount $MMP_OSTDEV $MMP_OSS $OST_MOUNT_OPTS
 496         rc=${PIPESTATUS[0]}
 497         stop $MMP_MDS || return ${PIPESTATUS[0]}
 498         return $rc
 499 }
 500 run_test 5 "mount during unmount of the first filesystem"
 501
 502 # Test 6 - mount after clean unmount.
 503 test_6() {
 504         local rc=0
 505         check_failover_pair
 506
 507         mount_after_unmount $MMP_MDSDEV $MMP_MDS $MDS_MOUNT_OPTS ||
 508                 return ${PIPESTATUS[0]}
 509
 510         echo
 511         mount_after_unmount $MMP_OSTDEV $MMP_OSS $OST_MOUNT_OPTS
 512         rc=${PIPESTATUS[0]}
 513         if [ $rc -ne 0 ]; then
 514                 stop $MMP_MDS_FAILOVER || return ${PIPESTATUS[0]}
 515                 return $rc
 516         fi
 517
 518         stop_services failover || return ${PIPESTATUS[0]}
 519 }
 520 run_test 6 "mount after clean unmount"
 521
 522 # Test 7 - mount after reboot.
 523 test_7() {
 524         local rc=0
 525         check_failover_pair
 526
 527         mount_after_reboot $MMP_MDSDEV $MMP_MDS $MDS_MOUNT_OPTS ||
 528                 return ${PIPESTATUS[0]}
 529
 530         echo
 531         mount_after_reboot $MMP_OSTDEV $MMP_OSS $OST_MOUNT_OPTS
 532         rc=${PIPESTATUS[0]}
 533         if [ $rc -ne 0 ]; then
 534                 stop $MMP_MDS || return ${PIPESTATUS[0]}
 535                 stop $MMP_MDS_FAILOVER || return ${PIPESTATUS[0]}
 536                 return $rc
 537         fi
 538
 539         stop_services failover || return ${PIPESTATUS[0]}
 540         stop_services primary || return ${PIPESTATUS[0]}
 541 }
 542 run_test 7 "mount after reboot"
 543
 544 # Test 8 - mount during e2fsck (should never succeed).
 545 test_8() {
 546         local e2fsck_pid
 547         local saved_interval
 548         local new_interval
 549
 550         # After writing a new sequence number into the MMP block, e2fsck will
 551         # sleep at least (2 * new_interval + 1) seconds before it goes into
 552         # e2fsck passes.
 553         new_interval=30
 554
 555         # MDT
 556         saved_interval=$(get_mmp_update_interval $MMP_MDS $MMP_MDSDEV)
 557         set_mmp_update_interval $MMP_MDS $MMP_MDSDEV $new_interval
 558
 559         run_e2fsck $MMP_MDS $MMP_MDSDEV "-fy" &
 560         e2fsck_pid=$!
 561         sleep 5
 562
 563         if start $MMP_MDS_FAILOVER $MMP_MDSDEV $MDS_MOUNT_OPTS; then
 564                 error_noexit \
 565                         "mount $MMP_MDSDEV on $MMP_MDS_FAILOVER should fail"
 566                 stop $MMP_MDS_FAILOVER || return ${PIPESTATUS[0]}
 567                 set_mmp_update_interval $MMP_MDS $MMP_MDSDEV $saved_interval
 568                 return 1
 569         fi
 570
 571         wait $e2fsck_pid
 572         set_mmp_update_interval $MMP_MDS $MMP_MDSDEV $saved_interval
 573
 574         # OST
 575         echo
 576         saved_interval=$(get_mmp_update_interval $MMP_OSS $MMP_OSTDEV)
 577         set_mmp_update_interval $MMP_OSS $MMP_OSTDEV $new_interval
 578
 579         run_e2fsck $MMP_OSS $MMP_OSTDEV "-fy" &
 580         e2fsck_pid=$!
 581         sleep 5
 582
 583         if start $MMP_OSS_FAILOVER $MMP_OSTDEV $OST_MOUNT_OPTS; then
 584                 error_noexit \
 585                         "mount $MMP_OSTDEV on $MMP_OSS_FAILOVER should fail"
 586                 stop $MMP_OSS_FAILOVER || return ${PIPESTATUS[0]}
 587                 set_mmp_update_interval $MMP_OSS $MMP_OSTDEV $saved_interval
 588                 return 2
 589         fi
 590
 591         wait $e2fsck_pid
 592         set_mmp_update_interval $MMP_OSS $MMP_OSTDEV $saved_interval
 593         return 0
 594 }
 595 run_test 8 "mount during e2fsck"
 596
 597 # Test 9 - mount after aborted e2fsck (should never succeed).
 598 test_9() {
 599     start $MMP_MDS $MMP_MDSDEV $MDS_MOUNT_OPTS || return ${PIPESTATUS[0]}
 600     if ! start $MMP_OSS $MMP_OSTDEV $OST_MOUNT_OPTS; then
 601         local rc=${PIPESTATUS[0]}
 602         stop $MMP_MDS || return ${PIPESTATUS[0]}
 603         return $rc
 604     fi
 605     stop_services primary || return ${PIPESTATUS[0]}
 606
 607     mark_mmp_block $MMP_MDS $MMP_MDSDEV || return ${PIPESTATUS[0]}
 608
 609     log "Mounting $MMP_MDSDEV on $MMP_MDS..."
 610     if start $MMP_MDS $MMP_MDSDEV $MDS_MOUNT_OPTS; then
 611         error_noexit "mount $MMP_MDSDEV on $MMP_MDS should fail"
 612         stop $MMP_MDS || return ${PIPESTATUS[0]}
 613         return 1
 614     fi
 615
 616     reset_mmp_block $MMP_MDS $MMP_MDSDEV || return ${PIPESTATUS[0]}
 617
 618     mark_mmp_block $MMP_OSS $MMP_OSTDEV || return ${PIPESTATUS[0]}
 619
 620     log "Mounting $MMP_OSTDEV on $MMP_OSS..."
 621     if start $MMP_OSS $MMP_OSTDEV $OST_MOUNT_OPTS; then
 622         error_noexit "mount $MMP_OSTDEV on $MMP_OSS should fail"
 623         stop $MMP_OSS || return ${PIPESTATUS[0]}
 624         return 2
 625     fi
 626
 627     reset_mmp_block $MMP_OSS $MMP_OSTDEV || return ${PIPESTATUS[0]}
 628     return 0
 629 }
 630 run_test 9 "mount after aborted e2fsck"
 631
 632 # Test 10 - e2fsck with mounted filesystem.
 633 test_10() {
 634     local rc=0
 635
 636     log "Mounting $MMP_MDSDEV on $MMP_MDS..."
 637     start $MMP_MDS $MMP_MDSDEV $MDS_MOUNT_OPTS || return ${PIPESTATUS[0]}
 638
 639     run_e2fsck $MMP_MDS_FAILOVER $MMP_MDSDEV "-fn"
 640     rc=${PIPESTATUS[0]}
 641
 642     # e2fsck is called with -n option (Open the filesystem read-only), so
 643     # 0 (No errors) and 4 (File system errors left uncorrected) are the only
 644     # acceptable exit codes in this case
 645     if [ $rc -ne 0 ] && [ $rc -ne 4 ]; then
 646         error_noexit "e2fsck $MMP_MDSDEV on $MMP_MDS_FAILOVER returned $rc"
 647         stop $MMP_MDS || return ${PIPESTATUS[0]}
 648         return $rc
 649     fi
 650
 651     log "Mounting $MMP_OSTDEV on $MMP_OSS..."
 652     start $MMP_OSS $MMP_OSTDEV $OST_MOUNT_OPTS
 653     rc=${PIPESTATUS[0]}
 654     if [ $rc -ne 0 ]; then
 655         stop $MMP_MDS || return ${PIPESTATUS[0]}
 656         return $rc
 657     fi
 658
 659     run_e2fsck $MMP_OSS_FAILOVER $MMP_OSTDEV "-fn"
 660     rc=${PIPESTATUS[0]}
 661     if [ $rc -ne 0 ] && [ $rc -ne 4 ]; then
 662         error_noexit "e2fsck $MMP_OSTDEV on $MMP_OSS_FAILOVER returned $rc"
 663     fi
 664
 665     CLEANUP_DM_DEV=true stop_services primary || return ${PIPESTATUS[0]}
 666     return 0
 667 }
 668 run_test 10 "e2fsck with mounted filesystem"
 669
 670 mmp_fini
 671 FAIL_ON_ERROR=$SAVED_FAIL_ON_ERROR
 672
 673 complete $SECONDS
 674 $MMP_RESTORE_MOUNT && setupall
 675 check_and_cleanup_lustre
 676 exit_status