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