Whamcloud - gitweb
LU-11425 quota: support quota for DoM
[fs/lustre-release.git] / 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