Whamcloud - gitweb
New tag 2.14.52
[fs/lustre-release.git] / lustre / tests / replay-dual.sh
1 #!/bin/bash
2
3 set -e
4
5 PTLDEBUG=${PTLDEBUG:--1}
6 MOUNT_2=${MOUNT_2:-"yes"}
7
8 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
9 . $LUSTRE/tests/test-framework.sh
10 init_test_env $@
11 init_logging
12
13 remote_mds_nodsh && skip "remote MDS with nodsh" && exit 0
14
15 ALWAYS_EXCEPT="$REPLAY_DUAL_EXCEPT "
16 # bug number for skipped test:  LU-2012 LU-8333 LU-7372
17 ALWAYS_EXCEPT+="                14b     21b     26 "
18 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
19
20 [[ "$mds1_FSTYPE" == zfs ]] &&
21 # bug number for skipped test:        LU-2230
22         ALWAYS_EXCEPT="$ALWAYS_EXCEPT 21b"
23
24 #                                   7  (min)"
25 [ "$SLOW" = "no" ] && EXCEPT_SLOW="21b "
26
27 build_test_filter
28 check_and_setup_lustre
29
30 MOUNTED=$(mounted_lustre_filesystems)
31 if ! $(echo $MOUNTED' ' | grep -w -q $MOUNT2' '); then
32         zconf_mount $HOSTNAME $MOUNT2
33         MOUNTED2=yes
34 fi
35
36 assert_DIR
37 rm -rf $DIR/[df][0-9]*
38
39 [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
40
41 # if there is no CLIENT1 defined, some tests can be ran on localhost
42 CLIENT1=${CLIENT1:-$HOSTNAME}
43 # if CLIENT2 doesn't exist then use CLIENT1 instead
44 # All tests should use CLIENT2 with MOUNT2 only therefore it will work if
45 # $CLIENT2 == CLIENT1
46 # Exception is the test which need two separate nodes
47 CLIENT2=${CLIENT2:-$CLIENT1}
48
49 # LU-482 Avert LVM and VM inability to flush caches in pre .33 kernels
50 if [ $LINUX_VERSION_CODE -lt $(version_code 2.6.33) ]; then
51         sync
52         do_facet $SINGLEMDS "sync; sleep 10; sync; sleep 10; sync"
53 fi
54
55 LU482_FAILED=$(mktemp -u $TMP/$TESTSUITE.lu482.XXXXXX)
56 test_0a() {
57         echo "Check file is LU482_FAILED=$LU482_FAILED"
58         touch $MOUNT2/$tfile-A # force sync FLD/SEQ update before barrier
59         replay_barrier $SINGLEMDS
60 #define OBD_FAIL_PTLRPC_FINISH_REPLAY | OBD_FAIL_ONCE
61         touch $MOUNT2/$tfile
62         createmany -o $MOUNT1/$tfile- 50
63         $LCTL set_param fail_loc=0x80000514
64         facet_failover $SINGLEMDS
65         [ -f "$LU482_FAILED" ] && skip "LU-482 failure" && return 0
66         client_up || return 1
67         umount -f $MOUNT2
68         client_up || return 1
69         zconf_mount `hostname` $MOUNT2 || error "mount2 fais"
70         unlinkmany $MOUNT1/$tfile- 50 || return 2
71         rm $MOUNT2/$tfile || return 3
72         rm $MOUNT2/$tfile-A || return 4
73 }
74 run_test 0a "expired recovery with lost client"
75
76 if [ -f "$LU482_FAILED" ]; then
77         log "Found check file $LU482_FAILED, aborting test script"
78         rm -vf "$LU482_FAILED"
79         complete $SECONDS
80         do_nodes $CLIENTS umount -f $MOUNT2 || true
81         do_nodes $CLIENTS umount -f $MOUNT || true
82         # copied from stopall, but avoid the MDS recovery
83     for num in `seq $OSTCOUNT`; do
84         stop ost$num -f
85         rm -f $TMP/ost${num}active
86     done
87     if ! combined_mgs_mds ; then
88         stop mgs
89     fi
90
91         exit_status
92 fi
93
94 test_0b() {
95     replay_barrier $SINGLEMDS
96     touch $MOUNT2/$tfile
97     touch $MOUNT1/$tfile-2
98     umount $MOUNT2
99     facet_failover $SINGLEMDS
100     umount -f $MOUNT1
101     zconf_mount `hostname` $MOUNT1 || error "mount1 fais"
102     zconf_mount `hostname` $MOUNT2 || error "mount2 fais"
103     # it is uncertain if file-2 exists or not, remove it if it does
104     checkstat $MOUNT1/$tfile-2 && rm $MOUNT1/$tfile-2
105     checkstat $MOUNT2/$tfile && return 2
106     return 0
107 }
108 run_test 0b "lost client during waiting for next transno"
109
110 test_1() {
111     touch $MOUNT1/a
112     replay_barrier $SINGLEMDS
113     touch $MOUNT2/b
114
115     fail $SINGLEMDS
116     checkstat $MOUNT2/a || return 1
117     checkstat $MOUNT1/b || return 2
118     rm $MOUNT2/a $MOUNT1/b
119     checkstat $MOUNT1/a && return 3
120     checkstat $MOUNT2/b && return 4
121     return 0
122 }
123
124 run_test 1 "|X| simple create"
125
126
127 test_2() {
128     replay_barrier $SINGLEMDS
129     mkdir $MOUNT1/adir
130
131     fail $SINGLEMDS
132     checkstat $MOUNT2/adir || return 1
133     rmdir $MOUNT2/adir
134     checkstat $MOUNT2/adir && return 2
135     return 0
136 }
137 run_test 2 "|X| mkdir adir"
138
139 test_3() {
140     replay_barrier $SINGLEMDS
141     mkdir $MOUNT1/adir
142     mkdir $MOUNT2/adir/bdir
143
144     fail $SINGLEMDS
145     checkstat $MOUNT2/adir      || return 1
146     checkstat $MOUNT1/adir/bdir || return 2
147     rmdir $MOUNT2/adir/bdir $MOUNT1/adir
148     checkstat $MOUNT1/adir      && return 3
149     checkstat $MOUNT2/adir/bdir && return 4
150     return 0
151 }
152 run_test 3 "|X| mkdir adir, mkdir adir/bdir "
153
154 test_4() {
155     mkdir $MOUNT1/adir
156     replay_barrier $SINGLEMDS
157     mkdir $MOUNT1/adir  && return 1
158     mkdir $MOUNT2/adir/bdir
159
160     fail $SINGLEMDS
161     checkstat $MOUNT2/adir      || return 2
162     checkstat $MOUNT1/adir/bdir || return 3
163
164     rmdir $MOUNT2/adir/bdir $MOUNT1/adir
165     checkstat $MOUNT1/adir      && return 4
166     checkstat $MOUNT2/adir/bdir && return 5
167     return 0
168 }
169 run_test 4 "|X| mkdir adir (-EEXIST), mkdir adir/bdir "
170
171
172 test_5() {
173     # multiclient version of replay_single.sh/test_8
174     mcreate $MOUNT1/a
175     multiop_bg_pause $MOUNT2/a o_tSc || return  1
176     pid=$!
177     rm -f $MOUNT1/a
178     replay_barrier $SINGLEMDS
179     kill -USR1 $pid
180     wait $pid || return 1
181
182     fail $SINGLEMDS
183     [ -e $MOUNT2/a ] && return 2
184     return 0
185 }
186 run_test 5 "open, unlink |X| close"
187
188
189 test_6() {
190     mcreate $MOUNT1/a
191     multiop_bg_pause $MOUNT2/a o_c || return 1
192     pid1=$!
193     multiop_bg_pause $MOUNT1/a o_c || return 1
194     pid2=$!
195     rm -f $MOUNT1/a
196     replay_barrier $SINGLEMDS
197     kill -USR1 $pid1
198     wait $pid1 || return 1
199
200     fail $SINGLEMDS
201     kill -USR1 $pid2
202     wait $pid2 || return 1
203     [ -e $MOUNT2/a ] && return 2
204     return 0
205 }
206 run_test 6 "open1, open2, unlink |X| close1 [fail $SINGLEMDS] close2"
207
208 test_8() {
209     replay_barrier $SINGLEMDS
210     drop_reint_reply "mcreate $MOUNT1/$tfile"    || return 1
211     fail $SINGLEMDS
212     checkstat $MOUNT2/$tfile || return 2
213     rm $MOUNT1/$tfile || return 3
214
215     return 0
216 }
217 run_test 8 "replay of resent request"
218
219 test_9() {
220     replay_barrier $SINGLEMDS
221     mcreate $MOUNT1/$tfile-1
222     mcreate $MOUNT2/$tfile-2
223     # drop first reint reply
224     do_facet $SINGLEMDS lctl set_param fail_loc=0x80000119
225     fail $SINGLEMDS
226     do_facet $SINGLEMDS lctl set_param fail_loc=0
227
228     rm $MOUNT1/$tfile-[1,2] || return 1
229
230     return 0
231 }
232 run_test 9 "resending a replayed create"
233
234 test_10() {
235     mcreate $MOUNT1/$tfile-1
236     replay_barrier $SINGLEMDS
237     munlink $MOUNT1/$tfile-1
238     mcreate $MOUNT2/$tfile-2
239     # drop first reint reply
240     do_facet $SINGLEMDS lctl set_param fail_loc=0x80000119
241     fail $SINGLEMDS
242     do_facet $SINGLEMDS lctl set_param fail_loc=0
243
244     checkstat $MOUNT1/$tfile-1 && return 1
245     checkstat $MOUNT1/$tfile-2 || return 2
246     rm $MOUNT1/$tfile-2
247
248     return 0
249 }
250 run_test 10 "resending a replayed unlink"
251
252 test_11() {
253         replay_barrier $SINGLEMDS
254         mcreate $DIR1/$tfile-1
255         mcreate $DIR2/$tfile-2
256         mcreate $DIR1/$tfile-3
257         mcreate $DIR2/$tfile-4
258         mcreate $DIR1/$tfile-5
259         # drop all reint replies for a while
260         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x0119
261         # note that with this fail_loc set, facet_failover df will fail
262         facet_failover $SINGLEMDS
263
264         local clients=${CLIENTS:-$HOSTNAME}
265         wait_clients_import_state "$clients" $SINGLEMDS FULL
266
267         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
268
269         rm $DIR1/$tfile-[1-5] || return 1
270
271         return 0
272 }
273 run_test 11 "both clients timeout during replay"
274
275 test_12() {
276     replay_barrier $SINGLEMDS
277
278     multiop_bg_pause $DIR/$tfile mo_c || return 1
279     MULTIPID=$!
280
281 #define OBD_FAIL_LDLM_ENQUEUE_NET                       0x302
282     do_facet $SINGLEMDS lctl set_param fail_loc=0x80000302
283     facet_failover $SINGLEMDS
284     do_facet $SINGLEMDS lctl set_param fail_loc=0
285     clients_up || return 1
286
287     ls $DIR/$tfile
288     kill -USR1 $MULTIPID || return 3
289     wait $MULTIPID || return 4
290     $CHECKSTAT -t file $DIR/$tfile || return 2
291     rm $DIR/$tfile
292
293     return 0
294 }
295 run_test 12 "open resend timeout"
296
297 test_13() {
298     multiop_bg_pause $DIR/$tfile mo_c || return 1
299     MULTIPID=$!
300
301     replay_barrier $SINGLEMDS
302
303     kill -USR1 $MULTIPID || return 3
304     wait $MULTIPID || return 4
305
306     # drop close
307     do_facet $SINGLEMDS lctl set_param fail_loc=0x80000115
308     facet_failover $SINGLEMDS
309     do_facet $SINGLEMDS lctl set_param fail_loc=0
310     clients_up || return 1
311
312     ls $DIR/$tfile
313     $CHECKSTAT -t file $DIR/$tfile || return 2
314     rm $DIR/$tfile
315
316     return 0
317 }
318 run_test 13 "close resend timeout"
319
320 # test 14a removed after 18143 because it shouldn't fail anymore and do the same
321 # as test_15a
322
323 test_14b() {
324         wait_mds_ost_sync
325         wait_delete_completed
326
327         local beforeused=$(df -P $DIR | tail -1 | awk '{ print $3 }')
328
329         mkdir -p $MOUNT1/$tdir
330         $LFS setstripe -i 0 $MOUNT1/$tdir
331         replay_barrier $SINGLEMDS
332         createmany -o $MOUNT1/$tdir/$tfile- 5
333
334         $LFS setstripe -i 0 $MOUNT2/$tfile-2
335         dd if=/dev/zero of=$MOUNT2/$tfile-2 bs=1M count=5
336         createmany -o $MOUNT1/$tdir/$tfile-3- 5
337         umount $MOUNT2
338
339         fail $SINGLEMDS
340         wait_recovery_complete $SINGLEMDS || error "MDS recovery not done"
341
342         # first set of files should have been replayed
343         unlinkmany $MOUNT1/$tdir/$tfile- 5 || error "first unlinks failed"
344         unlinkmany $MOUNT1/$tdir/$tfile-3- 5 || error "second unlinks failed"
345
346         zconf_mount $HOSTNAME $MOUNT2 || error "mount $MOUNT2 failed"
347         [ -f $MOUNT2/$tfile-2 ] && error "$MOUNT2/$tfile-2 exists!"
348
349         wait_mds_ost_sync || error "wait_mds_ost_sync failed"
350         wait_delete_completed || error "wait_delete_complete failed"
351
352         local afterused=$(df -P $DIR | tail -1 | awk '{ print $3 }')
353         log "before $beforeused, after $afterused"
354         # leave some margin for some files/dirs to be modified (OI, llog, etc)
355         [ $afterused -le $((beforeused + $(fs_log_size))) ] ||
356                 error "after $afterused > before $beforeused"
357 }
358 run_test 14b "delete ost orphans if gap occured in objids due to VBR"
359
360 test_15a() { # was test_15
361     replay_barrier $SINGLEMDS
362     createmany -o $MOUNT1/$tfile- 25
363     createmany -o $MOUNT2/$tfile-2- 1
364     umount $MOUNT2
365
366     fail $SINGLEMDS
367
368     unlinkmany $MOUNT1/$tfile- 25 || return 2
369     [ -e $MOUNT1/$tfile-2-0 ] && error "$tfile-2-0 exists"
370
371     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
372     return 0
373 }
374 run_test 15a "timeout waiting for lost client during replay, 1 client completes"
375
376 test_15c() {
377     replay_barrier $SINGLEMDS
378     for ((i = 0; i < 2000; i++)); do
379         echo "data" > "$MOUNT2/${tfile}-$i" || error "create ${tfile}-$i failed"
380     done
381     umount $MOUNT2
382
383     fail $SINGLEMDS
384
385     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
386     return 0
387 }
388 run_test 15c "remove multiple OST orphans"
389
390 test_16() {
391     replay_barrier $SINGLEMDS
392     createmany -o $MOUNT1/$tfile- 25
393     createmany -o $MOUNT2/$tfile-2- 1
394     umount $MOUNT2
395
396     facet_failover $SINGLEMDS
397     sleep $TIMEOUT
398     fail $SINGLEMDS
399
400     unlinkmany $MOUNT1/$tfile- 25 || return 2
401
402     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
403     return 0
404
405 }
406 run_test 16 "fail MDS during recovery (3571)"
407
408 test_17() {
409     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
410
411     createmany -o $MOUNT1/$tfile- 25
412     createmany -o $MOUNT2/$tfile-2- 1
413
414     # Make sure the disconnect is lost
415     replay_barrier ost1
416     umount $MOUNT2
417
418     facet_failover ost1
419     sleep $TIMEOUT
420     fail ost1
421
422     unlinkmany $MOUNT1/$tfile- 25 || return 2
423
424     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
425     return 0
426
427 }
428 run_test 17 "fail OST during recovery (3571)"
429
430 # cleanup with blocked enqueue fails until timer elapses (MDS busy), wait for it
431 export NOW=0
432
433 test_18() { # bug 3822 - evicting client with enqueued lock
434         #set -vx
435         local DLMTRACE=$(do_facet $SINGLEMDS lctl get_param debug)
436         do_facet $SINGLEMDS lctl set_param debug=+dlmtrace
437         mkdir -p $MOUNT1/$tdir || error "mkdir $MOUNT1/$tdir failed"
438         touch $MOUNT1/$tdir/${tfile}0 || error "touch file failed"
439         statmany -s $MOUNT1/$tdir/$tfile 1 500 &
440         OPENPID=$!
441         NOW=$SECONDS
442         #define OBD_FAIL_LDLM_ENQUEUE_BLOCKED    0x30b
443         do_facet $SINGLEMDS lctl set_param fail_loc=0x8000030b  # hold enqueue
444         sleep 1
445         #define OBD_FAIL_LDLM_BL_CALLBACK_NET                   0x305
446         do_facet client lctl set_param ldlm.namespaces.*.early_lock_cancel=0
447         do_facet client lctl set_param fail_loc=0x80000305  # drop cb, evict
448         cancel_lru_locks mdc
449         sleep 0.1 # wait to ensure first client is one that will be evicted
450         openfile -f O_RDONLY $MOUNT2/$tdir/$tfile
451         wait $OPENPID
452         do_facet client lctl set_param ldlm.namespaces.*.early_lock_cancel=1
453         do_facet $SINGLEMDS lctl debug_kernel |
454                 grep "not entering recovery" && error "client not evicted"
455         do_facet client "lctl set_param fail_loc=0"
456         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
457 }
458 run_test 18 "ldlm_handle_enqueue succeeds on evicted export (3822)"
459
460 test_19() { # Bug 10991 - resend of open request does not fail assertion.
461     replay_barrier $SINGLEMDS
462     drop_mdt_ldlm_reply "createmany -o $DIR/$tfile 1" || return 1
463     fail $SINGLEMDS
464     checkstat $DIR2/${tfile}0 || return 2
465     rm $DIR/${tfile}0 || return 3
466
467     return 0
468 }
469 run_test 19 "resend of open request"
470
471 test_20() { #16389
472         local before=$SECONDS
473         replay_barrier $SINGLEMDS
474         touch $DIR1/$tfile.a
475         touch $DIR2/$tfile.b
476         umount $DIR2
477         fail $SINGLEMDS
478         rm $DIR1/$tfile.a
479         zconf_mount $HOSTNAME $DIR2 || error "mount $DIR2 fail"
480         local tier1=$((SECONDS - before))
481
482         before=$SECONDS
483         replay_barrier $SINGLEMDS
484         touch $DIR1/$tfile.a
485         touch $DIR2/$tfile.b
486         umount $DIR2
487         fail $SINGLEMDS
488         rm $DIR1/$tfile.a
489         zconf_mount $HOSTNAME $DIR2 || error "mount $DIR2 fail"
490         local tier2=$((SECONDS - before))
491
492         # timeout is more than 1.5x original timeout
493         ((tier2 < tier1 * 6 / 4)) ||
494                 error "recovery time $tier2 >= 1.5x original time $tier1"
495 }
496 run_test 20 "recovery time is not increasing"
497
498 # commit on sharing tests
499 test_21a() {
500     local param_file=$TMP/$tfile-params
501
502         save_lustre_params $SINGLEMDS "mdt.*.commit_on_sharing" > $param_file
503     do_facet $SINGLEMDS lctl set_param mdt.*.commit_on_sharing=1
504     touch  $MOUNT1/$tfile-1
505     mv  $MOUNT2/$tfile-1 $MOUNT2/$tfile-2
506     mv  $MOUNT1/$tfile-2 $MOUNT1/$tfile-3
507     replay_barrier_nosync $SINGLEMDS
508     umount $MOUNT2
509
510     facet_failover $SINGLEMDS
511
512     # all renames are replayed
513     unlink  $MOUNT1/$tfile-3 || return 2
514
515     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
516
517     do_facet $SINGLEMDS lctl set_param mdt.*.commit_on_sharing=0
518     rm -rf $MOUNT1/$tfile-*
519     restore_lustre_params < $param_file
520     rm -f $param_file
521     return 0
522 }
523 run_test 21a "commit on sharing"
524
525 test_21b_sub () {
526         local mds=$1
527         do_node $CLIENT1 rm -f $MOUNT1/$tfile-*
528
529         do_facet $mds sync
530         do_node $CLIENT1 touch $MOUNT1/$tfile-1
531         do_node $CLIENT2 mv $MOUNT1/$tfile-1 $MOUNT1/$tfile-2
532         do_node $CLIENT1 mv $MOUNT1/$tfile-2 $MOUNT1/$tfile-3
533
534         replay_barrier_nosync $mds
535         shutdown_client $CLIENT2 $MOUNT1
536
537         facet_failover $mds
538
539         # were renames replayed?
540         local rc=0
541         echo UNLINK $MOUNT1/$tfile-3
542         do_node $CLIENT1 unlink  $MOUNT1/$tfile-3 ||
543                 { echo "unlink $tfile-3 fail!" && rc=1; }
544
545         boot_node $CLIENT2
546         zconf_mount_clients $CLIENT2 $MOUNT1 ||
547                 error "mount $CLIENT2 $MOUNT1 fail"
548
549         return $rc
550 }
551
552 test_21b() {
553         [ -z "$CLIENTS" ] && skip "Need two or more clients" && return
554         [ $CLIENTCOUNT -lt 2 ] &&
555                 { skip "Need 2+ clients, have $CLIENTCOUNT" && return; }
556
557         if [ "$FAILURE_MODE" = "HARD" ] && mixed_mdt_devs; then
558                 skip "Several MDTs on one MDS with FAILURE_MODE=$FAILURE_MODE"
559                 return 0
560         fi
561
562         zconf_umount_clients $CLIENTS $MOUNT2
563         zconf_mount_clients $CLIENTS $MOUNT1
564
565         local param_file=$TMP/$tfile-params
566
567         local mdtidx=$($LFS getstripe -m $MOUNT1)
568         local facet=mds$((mdtidx + 1))
569
570         save_lustre_params $facet "mdt.*.commit_on_sharing" > $param_file
571
572         # COS enabled
573         local COS=1
574         do_facet $facet lctl set_param mdt.*.commit_on_sharing=$COS
575
576         test_21b_sub $facet || error "Not all renames are replayed. COS=$COS"
577
578         # there is still a window when transactions may be written to disk
579         # before the mds device is set R/O. To avoid such a rare test failure,
580         # the check is repeated several times.
581         COS=0
582         local n_attempts=1
583         while true; do
584                 # COS disabled (should fail)
585                 do_facet $facet lctl set_param mdt.*.commit_on_sharing=$COS
586
587                 test_21b_sub $facet || break
588                 n_attempts=$((n_attempts + 1))
589                 [ $n_attempts -gt 3 ] &&
590                         error "can't check if COS works: rename replied w/o COS"
591         done
592         zconf_mount_clients $CLIENTS $MOUNT2
593         restore_lustre_params < $param_file
594         rm -f $param_file
595         return 0
596 }
597 run_test 21b "commit on sharing, two clients"
598
599 checkstat_22() {
600         checkstat $MOUNT1/$remote_dir || return 1
601         checkstat $MOUNT1/$remote_dir/dir || return 2
602         checkstat $MOUNT1/$remote_dir/$tfile-1 || return 3
603         checkstat $MOUNT1/$remote_dir/dir/$tfile-1 || return 4
604         return 0
605 }
606
607 create_remote_dir_files_22() {
608         do_node $CLIENT2 mkdir ${MOUNT2}/$remote_dir/dir || return 1
609         do_node $CLIENT1 createmany -o $MOUNT1/$remote_dir/dir/$tfile- 2 ||
610                                                             return 2
611         do_node $CLIENT2 createmany -o $MOUNT2/$remote_dir/$tfile- 2 ||
612                                                             return 3
613         return 0
614 }
615
616 test_22a () {
617         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
618         ([ $FAILURE_MODE == "HARD" ] &&
619                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
620                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
621                 return 0
622
623         local MDTIDX=1
624         local remote_dir=${tdir}/remote_dir
625
626         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
627
628         # OBD_FAIL_MDS_REINT_NET_REP       0x119
629         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
630         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
631         CLIENT_PID=$!
632         sleep 1
633
634         fail mds$((MDTIDX + 1))
635         wait $CLIENT_PID || error "lfs mkdir failed"
636
637         replay_barrier mds$MDTIDX
638         create_remote_dir_files_22 || error "Remote creation failed $?"
639         fail mds$MDTIDX
640
641         checkstat_22 || error "check stat failed $?"
642
643         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
644         return 0
645 }
646 run_test 22a "c1 lfs mkdir -i 1 dir1, M1 drop reply & fail, c2 mkdir dir1/dir"
647
648 test_22b () {
649         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
650         local MDTIDX=1
651         local remote_dir=$tdir/remote_dir
652
653         # OBD_FAIL_MDS_REINT_NET_REP       0x119
654         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
655
656         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
657         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
658         CLIENT_PID=$!
659         sleep 1
660
661         fail mds${MDTIDX},mds$((MDTIDX + 1))
662         wait $CLIENT_PID || error "lfs mkdir failed"
663
664         replay_barrier mds$MDTIDX
665         create_remote_dir_files_22 || error "Remote creation failed $?"
666         fail mds${MDTIDX}
667
668         checkstat_22 || error "check stat failed $?"
669
670         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
671         return 0
672 }
673 run_test 22b "c1 lfs mkdir -i 1 d1, M1 drop reply & fail M0/M1, c2 mkdir d1/dir"
674
675 test_22c () {
676         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
677         ([ $FAILURE_MODE == "HARD" ] &&
678                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
679                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
680                 return 0
681         local MDTIDX=1
682         local remote_dir=${tdir}/remote_dir
683
684         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
685
686         # OBD_FAIL_OUT_UPDATE_NET_REP    0x1701
687         do_facet mds$MDTIDX lctl set_param fail_loc=0x1701
688         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
689         CLIENT_PID=$!
690         sleep 1
691         do_facet mds$MDTIDX lctl set_param fail_loc=0
692
693         fail mds$MDTIDX
694         wait $CLIENT_PID || error "lfs mkdir failed"
695
696         replay_barrier mds$MDTIDX
697         create_remote_dir_files_22 || error "Remote creation failed $?"
698         fail mds$MDTIDX
699
700         checkstat_22 || error "check stat failed $?"
701
702         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
703         return 0
704 }
705 run_test 22c "c1 lfs mkdir -i 1 d1, M1 drop update & fail M1, c2 mkdir d1/dir"
706
707 test_22d () {
708         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
709         local MDTIDX=1
710         local remote_dir=${tdir}/remote_dir
711
712         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
713
714         # OBD_FAIL_OUT_UPDATE_NET_REP    0x1701
715         do_facet mds$MDTIDX lctl set_param fail_loc=0x1701
716         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
717         CLIENT_PID=$!
718         sleep 1
719         do_facet mds$MDTIDX lctl set_param fail_loc=0
720
721         fail mds${MDTIDX},mds$((MDTIDX + 1))
722         wait $CLIENT_PID || error "lfs mkdir failed"
723
724         replay_barrier mds$MDTIDX
725         create_remote_dir_files_22 || error "Remote creation failed $?"
726         fail mds$MDTIDX
727
728         checkstat_22 || error "check stat failed $?"
729
730         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
731         return 0
732 }
733 run_test 22d "c1 lfs mkdir -i 1 d1, M1 drop update & fail M0/M1,c2 mkdir d1/dir"
734
735 checkstat_23() {
736         checkstat $MOUNT1/$remote_dir || return 1
737         checkstat $MOUNT1/$remote_dir/$tfile-1 || return 2
738         return 0
739 }
740
741 create_remote_dir_files_23() {
742         do_node $CLIENT2 mkdir ${MOUNT2}/$remote_dir || return 1
743         do_node $CLIENT2 createmany -o $MOUNT2/$remote_dir/$tfile- 2 || return 2
744         return 0
745 }
746
747 test_23a () {
748         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
749         ([ $FAILURE_MODE == "HARD" ] &&
750                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
751                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
752                 return 0
753         local MDTIDX=1
754         local remote_dir=$tdir/remote_dir
755
756         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
757         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
758                         error "lfs mkdir failed"
759         # OBD_FAIL_MDS_REINT_NET_REP       0x119
760         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
761         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
762         local CLIENT_PID=$!
763         sleep 1
764         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0
765
766         fail mds$((MDTIDX + 1))
767         wait $CLIENT_PID || error "rmdir remote dir failed"
768
769         replay_barrier mds${MDTIDX}
770         create_remote_dir_files_23 || error "Remote creation failed $?"
771         fail mds${MDTIDX}
772
773         checkstat_23 || error "check stat failed $?"
774
775         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
776         return 0
777 }
778 run_test 23a "c1 rmdir d1, M1 drop reply and fail, client2 mkdir d1"
779
780 test_23b () {
781         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
782         local MDTIDX=1
783         local remote_dir=$tdir/remote_dir
784
785         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
786         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
787                         error "lfs mkdir failed"
788
789         # OBD_FAIL_MDS_REINT_NET_REP       0x119
790         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
791         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
792         local CLIENT_PID=$!
793         sleep 1
794         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0
795
796         fail mds${MDTIDX},mds$((MDTIDX + 1))
797         wait $CLIENT_PID || error "rmdir remote dir failed"
798
799         replay_barrier mds${MDTIDX}
800         create_remote_dir_files_23 || error "Remote creation failed $?"
801         fail mds${MDTIDX}
802
803         checkstat_23 || error "check stat failed $?"
804
805         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
806         return 0
807 }
808 run_test 23b "c1 rmdir d1, M1 drop reply and fail M0/M1, c2 mkdir d1"
809
810 test_23c () {
811         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
812
813         ([ $FAILURE_MODE == "HARD" ] &&
814                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
815                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
816                 return 0
817         local MDTIDX=1
818         local remote_dir=$tdir/remote_dir
819
820         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
821         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
822                         error "lfs mkdir failed"
823
824         # OBD_FAIL_OUT_UPDATE_NET_REP    0x1701
825         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
826         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
827         CLIENT_PID=$!
828         sleep 1
829         do_facet mds${MDTIDX} lctl set_param fail_loc=0
830
831         fail mds${MDTIDX}
832         wait $CLIENT_PID || error "rmdir remote dir failed"
833
834         replay_barrier mds${MDTIDX}
835         create_remote_dir_files_23 || error "Remote creation failed $?"
836         fail mds${MDTIDX}
837
838         checkstat_23 || error "check stat failed $?"
839
840         rm -rf $MOUNT1/$tdir || return 6
841         return 0
842 }
843 run_test 23c "c1 rmdir d1, M0 drop update reply and fail M0, c2 mkdir d1"
844
845 test_23d () {
846         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
847         local MDTIDX=1
848         local remote_dir=$tdir/remote_dir
849
850         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
851         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
852                         error "lfs mkdir failed"
853
854         # OBD_FAIL_UPDATE_OBJ_NET    0x1701
855         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
856         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
857         CLIENT_PID=$!
858         sleep 1
859         do_facet mds${MDTIDX} lctl set_param fail_loc=0
860
861         fail mds${MDTIDX},mds$((MDTIDX + 1))
862         wait $CLIENT_PID || error "rmdir remote dir failed"
863
864         replay_barrier mds${MDTIDX}
865         create_remote_dir_files_23 || error "Remote creation failed $?"
866         fail mds${MDTIDX}
867
868         checkstat_23 || error "check stat failed $?"
869
870         rm -rf $MOUNT1/$tdir || return 6
871         return 0
872 }
873 run_test 23d "c1 rmdir d1, M0 drop update reply and fail M0/M1, c2 mkdir d1"
874
875 test_24 () {
876         [[ "$MDS1_VERSION" -gt $(version_code 2.5.2) ]] ||
877                 skip "Need MDS version newer than 2.5.2"
878
879         touch $MOUNT/$tfile
880         stat $MOUNT/$tfile >&/dev/null
881 # OBD_FAIL_MDS_REINT_NET_REP
882         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x119
883         $TRUNCATE $MOUNT/$tfile 100 &
884         PID=$!
885         sleep 1
886         do_facet $SINGLEMDS lctl set_param fail_loc=0
887         # sync to release rep-ack lock quickly
888         do_nodes $(comma_list $(mdts_nodes)) \
889             "lctl set_param -n osd*.*MDT*.force_sync 1"
890         rm $MOUNT2/$tfile
891         wait
892 }
893 run_test 24 "reconstruct on non-existing object"
894
895 # end commit on sharing tests 
896
897 test_25() {
898         cancel_lru_locks osc
899
900         $LFS setstripe -i 0 -c 1 $DIR/$tfile
901
902         # get lock for the 1st client
903         dd if=/dev/zero of=$DIR/$tfile count=1 >/dev/null ||
904                 error "failed to write data"
905
906         # get waiting locks for the 2nd client
907         drop_ldlm_cancel "multiop $DIR2/$tfile Ow512" &
908         sleep 1
909
910         # failover, replay and resend replayed waiting locks
911         if [ "$OST1_VERSION" -ge $(version_code 2.6.90) ]; then
912                 #define OBD_FAIL_LDLM_SRV_CP_AST      0x325
913                 do_facet ost1 lctl set_param fail_loc=0x80000325
914         else
915                 #define OBD_FAIL_OST_LDLM_REPLY_NET     0x213
916                 do_facet ost1 lctl set_param fail_loc=0x80000213
917         fi
918
919         fail ost1
920
921         # multiop does not finish because CP AST is skipped;
922         # it is ok to kill it in the test, because CP AST is already re-sent
923         # and it does not hung forever in real life
924         killall multiop
925         wait
926 }
927 run_test 25 "replay|resend"
928
929 cleanup_26() {
930         trap 0
931         kill -9 $tar_26_pid
932         kill -9 $dbench_26_pid
933         killall -9 dbench
934 }
935
936 test_26() {
937         local clients=${CLIENTS:-$HOSTNAME}
938
939         zconf_mount_clients $clients $MOUNT
940
941         local duration=600
942         [ "$SLOW" = "no" ] && duration=200
943         # set duration to 900 because it takes some time to boot node
944         [ "$FAILURE_MODE" = HARD ] && duration=900
945
946         local start_ts=$SECONDS
947         local rc=0
948
949         trap cleanup_26 EXIT
950         (
951                 local tar_dir=$DIR/$tdir/run_tar
952                 while true; do
953                         test_mkdir -p -c$MDSCOUNT $tar_dir || break
954                         if [ $MDSCOUNT -ge 2 ]; then
955                                 $LFS setdirstripe -D -c$MDSCOUNT $tar_dir ||
956                                         error "set default dirstripe failed"
957                         fi
958                         cd $tar_dir || break
959                         tar cf - /etc | tar xf - || error "tar failed"
960                         cd $DIR/$tdir || break
961                         rm -rf $tar_dir || break
962                 done
963         )&
964         tar_26_pid=$!
965         echo "Started tar $tar_26_pid"
966
967         (
968                 local dbench_dir=$DIR2/$tdir/run_dbench
969                 while true; do
970                         test_mkdir -p -c$MDSCOUNT $dbench_dir || break
971                         if [ $MDSCOUNT -ge 2 ]; then
972                                 $LFS setdirstripe -D -c$MDSCOUNT $dbench_dir ||
973                                         error "set default dirstripe failed"
974                         fi
975                         cd $dbench_dir || break
976                         rundbench 1 -D $dbench_dir -t 100 &>/dev/null || break
977                         cd $DIR/$tdir || break
978                         rm -rf $dbench_dir || break
979                 done
980         )&
981         dbench_26_pid=$!
982         echo "Started dbench $dbench_26_pid"
983
984         local num_failovers=0
985         local fail_index=1
986         while [ $((SECONDS - start_ts)) -lt $duration ]; do
987                 kill -0 $tar_26_pid || error "tar $tar_26_pid missing"
988                 kill -0 $dbench_26_pid || error "dbench $dbench_26_pid missing"
989                 sleep 2
990                 replay_barrier mds$fail_index
991                 sleep 2 # give clients a time to do operations
992                 # Increment the number of failovers
993                 num_failovers=$((num_failovers + 1))
994                 log "$TESTNAME fail mds$fail_index $num_failovers times"
995                 fail mds$fail_index
996                 if [ $fail_index -ge $MDSCOUNT ]; then
997                         fail_index=1
998                 else
999                         fail_index=$((fail_index + 1))
1000                 fi
1001         done
1002         # stop the client loads
1003         kill -0 $tar_26_pid || error "tar $tar_26_pid stopped"
1004         kill -0 $dbench_26_pid || error "dbench $dbench_26_pid stopped"
1005         cleanup_26 || true
1006 }
1007 run_test 26 "dbench and tar with mds failover"
1008
1009 test_28() {
1010         $LFS setstripe -i 0 -c 1 $DIR2/$tfile
1011         dd if=/dev/zero of=$DIR2/$tfile bs=4096 count=1
1012
1013         #define OBD_FAIL_LDLM_SRV_BL_AST         0x324
1014         do_facet ost1 $LCTL set_param fail_loc=0x80000324
1015
1016         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 &
1017         local pid=$!
1018         sleep 2
1019
1020         #define OBD_FAIL_LDLM_GRANT_CHECK        0x32a
1021         do_facet ost1 $LCTL set_param fail_loc=0x32a
1022
1023         fail ost1
1024
1025         sleep 2
1026         cancel_lru_locks OST0000-osc
1027         wait $pid || error "dd failed"
1028 }
1029 run_test 28 "lock replay should be ordered: waiting after granted"
1030
1031 test_29() {
1032         local dir0=$DIR/$tdir/d0
1033         local dir1=$DIR/$tdir/d1
1034
1035         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1036         [ $CLIENTCOUNT -lt 2 ] && skip "needs >= 2 clients" && return 0
1037         [ "$CLIENT1" == "$CLIENT2" ] &&
1038                 skip "clients must be on different nodes" && return 0
1039
1040         mkdir -p $DIR/$tdir
1041         $LFS mkdir -i0 $dir0
1042         $LFS mkdir -i1 $dir1
1043         sync
1044
1045         replay_barrier mds2
1046         # create a remote dir, drop reply
1047         #define OBD_FAIL_PTLRPC_ROUND_XID 0x530
1048         $LCTL set_param fail_loc=0x530 fail_val=36
1049         #define OBD_FAIL_MDS_REINT_MULTI_NET_REP 0x15a
1050         do_facet mds2 $LCTL set_param fail_loc=0x8000015a
1051         echo make remote dir d0 for $dir0
1052         $LFS mkdir -i1 -c1 $dir0/d3 &
1053         sleep 1
1054
1055         echo make local dir d1 for $dir1
1056         do_node $CLIENT2 $LCTL set_param fail_loc=0x530 fail_val=36
1057         do_node $CLIENT2 mkdir $dir1/d4
1058
1059         fail mds2
1060 }
1061 run_test 29 "replay vs update with the same xid"
1062
1063 test_30() {
1064         $LFS setstripe -E 1m -L mdt -E -1 $DIR/$tfile
1065         #first write to have no problems with grants
1066         dd if=/dev/zero of=$DIR/$tfile bs=4k count=10 ||
1067                 error "dd on client failed"
1068         dd if=/dev/zero of=$DIR/$tfile bs=4k count=10 seek=10 ||
1069                 error "dd on client failed"
1070
1071         #define OBD_FAIL_LDLM_REPLAY_PAUSE       0x32e
1072         lctl set_param fail_loc=0x32e fail_val=4
1073         dd of=/dev/null if=$DIR2/$tfile &
1074         local pid=$!
1075         sleep 1
1076
1077         fail $SINGLEMDS
1078
1079         wait $pid || error "dd on client failed"
1080 }
1081 run_test 30 "layout lock replay is not blocked on IO"
1082
1083 complete $SECONDS
1084 SLEEP=$((SECONDS - $NOW))
1085 [ $SLEEP -lt $TIMEOUT ] && sleep $SLEEP
1086 [ "$MOUNTED2" = yes ] && zconf_umount $HOSTNAME $MOUNT2 || true
1087 check_and_cleanup_lustre
1088 exit_status