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