Whamcloud - gitweb
New tag 2.14.52
[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 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