Whamcloud - gitweb
b=12494,i=eeb:
[fs/lustre-release.git] / lustre / tests / replay-single.sh
1 #!/bin/bash
2
3 set -e
4 #set -v
5
6 #
7 # This test needs to be run on the client
8 #
9 SAVE_PWD=$PWD
10 LUSTRE=${LUSTRE:-`dirname $0`/..}
11 SETUP=${SETUP:-}
12 CLEANUP=${CLEANUP:-}
13 . $LUSTRE/tests/test-framework.sh
14 init_test_env $@
15 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
16 CHECK_GRANT=${CHECK_GRANT:-"yes"}
17 GRANT_CHECK_LIST=${GRANT_CHECK_LIST:-""}
18
19
20 # Skip these tests
21 # bug number: 2766 4176
22 ALWAYS_EXCEPT="0b  39   $REPLAY_SINGLE_EXCEPT"
23
24 build_test_filter
25
26 cleanup_and_setup_lustre
27
28 mkdir -p $DIR
29
30 test_0() {
31     sleep 10
32     mkdir $DIR/$tfile
33     replay_barrier $SINGLEMDS
34     fail $SINGLEMDS
35     rmdir $DIR/$tfile
36 }
37 run_test 0 "empty replay"
38
39 test_0b() {
40     # this test attempts to trigger a race in the precreation code, 
41     # and must run before any other objects are created on the filesystem
42     fail ost1
43     createmany -o $DIR/$tfile 20 || return 1
44     unlinkmany $DIR/$tfile 20 || return 2
45 }
46 run_test 0b "ensure object created after recover exists. (3284)"
47
48 seq_set_width()
49 {
50     local mds=$1
51     local width=$2
52     local file=`ls /proc/fs/lustre/seq/cli-srv-$mds-mdc-*/width` 
53     echo $width > $file
54 }
55
56 seq_get_width()
57 {
58     local mds=$1
59     local file=`ls /proc/fs/lustre/seq/cli-srv-$mds-mdc-*/width` 
60     cat $file
61 }
62
63 # This test should pass for single-mds and multi-mds configs.
64 # But for different configurations it tests different things.
65 #
66 # single-mds
67 # ----------
68 # (1) fld_create replay should happen;
69 #
70 # (2) fld_create replay should not return -EEXISTS, if it does
71 # this means sequence manager recovery code is buggy and allocated 
72 # same sequence two times after recovery.
73 #
74 # multi-mds
75 # ---------
76 # (1) fld_create replay may not happen, because its home MDS is 
77 # MDS2 which is not involved to revovery;
78 #
79 # (2) as fld_create does not happen on MDS1, it does not make any 
80 # problem.
81 test_0c() {
82     local label=`mdsdevlabel 1`
83     [ -z "$label" ] && echo "No label for mds1" && return 1
84
85     replay_barrier $SINGLEMDS
86     local sw=`seq_get_width $label`
87     
88     # make seq manager switch to next sequence each 
89     # time as new fid is needed.
90     seq_set_width $label 1
91     
92     # make sure that fld has created at least one new 
93     # entry on server
94     touch $DIR/$tfile || return 2
95     seq_set_width $label $sw
96     
97     # fail $SINGLEMDS and start recovery, replay RPCs, etc.
98     fail $SINGLEMDS
99     
100     # wait for recovery finish
101     sleep 10
102     df $MOUNT
103     
104     # flush fld cache and dentry cache to make it lookup 
105     # created entry instead of revalidating existent one
106     umount $MOUNT
107     zconf_mount `hostname` $MOUNT
108     
109     # issue lookup which should call fld lookup which 
110     # should fail if client did not replay fld create 
111     # correctly and server has no fld entry
112     touch $DIR/$tfile || return 3
113     rm $DIR/$tfile || return 4
114 }
115 run_test 0c "fld create"
116
117 test_1() {
118     replay_barrier $SINGLEMDS
119     mcreate $DIR/$tfile
120     fail $SINGLEMDS
121     $CHECKSTAT -t file $DIR/$tfile || return 1
122     rm $DIR/$tfile
123 }
124 run_test 1 "simple create"
125
126 test_2a() {
127     replay_barrier $SINGLEMDS
128     touch $DIR/$tfile
129     fail $SINGLEMDS
130     $CHECKSTAT -t file $DIR/$tfile || return 1
131     rm $DIR/$tfile
132 }
133 run_test 2a "touch"
134
135 test_2b() {
136     mcreate $DIR/$tfile
137     replay_barrier $SINGLEMDS
138     touch $DIR/$tfile
139     fail $SINGLEMDS
140     $CHECKSTAT -t file $DIR/$tfile || return 1
141     rm $DIR/$tfile
142 }
143 run_test 2b "touch"
144
145 test_3a() {
146     replay_barrier $SINGLEMDS
147     mcreate $DIR/$tfile
148     o_directory $DIR/$tfile
149     fail $SINGLEMDS
150     $CHECKSTAT -t file $DIR/$tfile || return 2
151     rm $DIR/$tfile
152 }
153 run_test 3a "replay failed open(O_DIRECTORY)"
154
155 test_3b() {
156     replay_barrier $SINGLEMDS
157 #define OBD_FAIL_MDS_OPEN_PACK | OBD_FAIL_ONCE
158     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000114"
159     touch $DIR/$tfile
160     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
161     fail $SINGLEMDS
162     $CHECKSTAT -t file $DIR/$tfile && return 2
163     return 0
164 }
165 run_test 3b "replay failed open -ENOMEM"
166
167 test_3c() {
168     replay_barrier $SINGLEMDS
169 #define OBD_FAIL_MDS_ALLOC_OBDO | OBD_FAIL_ONCE
170     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000128"
171     touch $DIR/$tfile
172     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
173     fail $SINGLEMDS
174
175     $CHECKSTAT -t file $DIR/$tfile && return 2
176     return 0
177 }
178 run_test 3c "replay failed open -ENOMEM"
179
180 test_4() {
181     replay_barrier $SINGLEMDS
182     for i in `seq 10`; do
183         echo "tag-$i" > $DIR/$tfile-$i
184     done 
185     fail $SINGLEMDS
186     for i in `seq 10`; do
187       grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
188     done 
189 }
190 run_test 4 "|x| 10 open(O_CREAT)s"
191
192 test_4b() {
193     replay_barrier $SINGLEMDS
194     rm -rf $DIR/$tfile-*
195     fail $SINGLEMDS
196     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
197 }
198 run_test 4b "|x| rm 10 files"
199
200 # The idea is to get past the first block of precreated files on both 
201 # osts, and then replay.
202 test_5() {
203     replay_barrier $SINGLEMDS
204     for i in `seq 220`; do
205         echo "tag-$i" > $DIR/$tfile-$i
206     done 
207     fail $SINGLEMDS
208     for i in `seq 220`; do
209       grep -q "tag-$i" $DIR/$tfile-$i || error "f1c-$i"
210     done 
211     rm -rf $DIR/$tfile-*
212     sleep 3
213     # waiting for commitment of removal
214 }
215 run_test 5 "|x| 220 open(O_CREAT)"
216
217
218 test_6() {
219     replay_barrier $SINGLEMDS
220     mkdir $DIR/$tdir
221     mcreate $DIR/$tdir/$tfile
222     fail $SINGLEMDS
223     $CHECKSTAT -t dir $DIR/$tdir || return 1
224     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
225     sleep 2
226     # waiting for log process thread
227 }
228 run_test 6 "mkdir + contained create"
229
230 test_6b() {
231     replay_barrier $SINGLEMDS
232     rm -rf $DIR/$tdir
233     fail $SINGLEMDS
234     $CHECKSTAT -t dir $DIR/$tdir && return 1 || true 
235 }
236 run_test 6b "|X| rmdir"
237
238 test_7() {
239     mkdir $DIR/$tdir
240     replay_barrier $SINGLEMDS
241     mcreate $DIR/$tdir/$tfile
242     fail $SINGLEMDS
243     $CHECKSTAT -t dir $DIR/$tdir || return 1
244     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
245     rm -fr $DIR/$tdir
246 }
247 run_test 7 "mkdir |X| contained create"
248
249 test_8() {
250     # make sure no side-effect from previous test.
251     rm -f $DIR/$tfile
252     replay_barrier $SINGLEMDS
253     multiop $DIR/$tfile mo_c &
254     MULTIPID=$!
255     sleep 1
256     fail $SINGLEMDS
257     ls $DIR/$tfile
258     $CHECKSTAT -t file $DIR/$tfile || return 1
259     kill -USR1 $MULTIPID || return 2
260     wait $MULTIPID || return 3
261     rm $DIR/$tfile
262 }
263 run_test 8 "creat open |X| close"
264
265 test_9() {
266     replay_barrier $SINGLEMDS
267     mcreate $DIR/$tfile
268     local old_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
269     fail $SINGLEMDS
270     local new_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
271
272     echo " old_inum == $old_inum, new_inum == $new_inum"
273     if [ $old_inum -eq $new_inum  ] ;
274     then
275         echo " old_inum and new_inum match"
276     else
277         echo "!!!! old_inum and new_inum NOT match"
278         return 1
279     fi
280     rm $DIR/$tfile
281 }
282 run_test 9  "|X| create (same inum/gen)"
283
284 test_10() {
285     mcreate $DIR/$tfile
286     replay_barrier $SINGLEMDS
287     mv $DIR/$tfile $DIR/$tfile-2
288     rm -f $DIR/$tfile
289     fail $SINGLEMDS
290     $CHECKSTAT $DIR/$tfile && return 1
291     $CHECKSTAT $DIR/$tfile-2 ||return 2
292     rm $DIR/$tfile-2
293     return 0
294 }
295 run_test 10 "create |X| rename unlink"
296
297 test_11() {
298     mcreate $DIR/$tfile
299     echo "old" > $DIR/$tfile
300     mv $DIR/$tfile $DIR/$tfile-2
301     replay_barrier $SINGLEMDS
302     echo "new" > $DIR/$tfile
303     grep new $DIR/$tfile 
304     grep old $DIR/$tfile-2
305     fail $SINGLEMDS
306     grep new $DIR/$tfile || return 1
307     grep old $DIR/$tfile-2 || return 2
308 }
309 run_test 11 "create open write rename |X| create-old-name read"
310
311 test_12() {
312     mcreate $DIR/$tfile 
313     multiop $DIR/$tfile o_tSc &
314     pid=$!
315     # give multiop a chance to open
316     sleep 1
317     rm -f $DIR/$tfile
318     replay_barrier $SINGLEMDS
319     kill -USR1 $pid
320     wait $pid || return 1
321
322     fail $SINGLEMDS
323     [ -e $DIR/$tfile ] && return 2
324     return 0
325 }
326 run_test 12 "open, unlink |X| close"
327
328
329 # 1777 - replay open after committed chmod that would make
330 #        a regular open a failure    
331 test_13() {
332     mcreate $DIR/$tfile 
333     multiop $DIR/$tfile O_wc &
334     pid=$!
335     # give multiop a chance to open
336     sleep 1 
337     chmod 0 $DIR/$tfile
338     $CHECKSTAT -p 0 $DIR/$tfile
339     replay_barrier $SINGLEMDS
340     fail $SINGLEMDS
341     kill -USR1 $pid
342     wait $pid || return 1
343
344     $CHECKSTAT -s 1 -p 0 $DIR/$tfile || return 2
345     return 0
346 }
347 run_test 13 "open chmod 0 |x| write close"
348
349 test_14() {
350     multiop $DIR/$tfile O_tSc &
351     pid=$!
352     # give multiop a chance to open
353     sleep 1 
354     rm -f $DIR/$tfile
355     replay_barrier $SINGLEMDS
356     kill -USR1 $pid || return 1
357     wait $pid || return 2
358
359     fail $SINGLEMDS
360     [ -e $DIR/$tfile ] && return 3
361     return 0
362 }
363 run_test 14 "open(O_CREAT), unlink |X| close"
364
365 test_15() {
366     multiop $DIR/$tfile O_tSc &
367     pid=$!
368     # give multiop a chance to open
369     sleep 1 
370     rm -f $DIR/$tfile
371     replay_barrier $SINGLEMDS
372     touch $DIR/g11 || return 1
373     kill -USR1 $pid
374     wait $pid || return 2
375
376     fail $SINGLEMDS
377     [ -e $DIR/$tfile ] && return 3
378     touch $DIR/h11 || return 4
379     return 0
380 }
381 run_test 15 "open(O_CREAT), unlink |X|  touch new, close"
382
383
384 test_16() {
385     replay_barrier $SINGLEMDS
386     mcreate $DIR/$tfile
387     munlink $DIR/$tfile
388     mcreate $DIR/$tfile-2
389     fail $SINGLEMDS
390     [ -e $DIR/$tfile ] && return 1
391     [ -e $DIR/$tfile-2 ] || return 2
392     munlink $DIR/$tfile-2 || return 3
393 }
394 run_test 16 "|X| open(O_CREAT), unlink, touch new,  unlink new"
395
396 test_17() {
397     replay_barrier $SINGLEMDS
398     multiop $DIR/$tfile O_c &
399     pid=$!
400     # give multiop a chance to open
401     sleep 1 
402     fail $SINGLEMDS
403     kill -USR1 $pid || return 1
404     wait $pid || return 2
405     $CHECKSTAT -t file $DIR/$tfile || return 3
406     rm $DIR/$tfile
407 }
408 run_test 17 "|X| open(O_CREAT), |replay| close"
409
410 test_18() {
411     replay_barrier $SINGLEMDS
412     multiop $DIR/$tfile O_tSc &
413     pid=$!
414     # give multiop a chance to open
415     sleep 1 
416     rm -f $DIR/$tfile
417     touch $DIR/$tfile-2 || return 1
418     echo "pid: $pid will close"
419     kill -USR1 $pid
420     wait $pid || return 2
421
422     fail $SINGLEMDS
423     [ -e $DIR/$tfile ] && return 3
424     [ -e $DIR/$tfile-2 ] || return 4
425     # this touch frequently fails
426     touch $DIR/$tfile-3 || return 5
427     munlink $DIR/$tfile-2 || return 6
428     munlink $DIR/$tfile-3 || return 7
429     return 0
430 }
431 run_test 18 "|X| open(O_CREAT), unlink, touch new, close, touch, unlink"
432
433 # bug 1855 (a simpler form of test_11 above)
434 test_19() {
435     replay_barrier $SINGLEMDS
436     mcreate $DIR/$tfile
437     echo "old" > $DIR/$tfile
438     mv $DIR/$tfile $DIR/$tfile-2
439     grep old $DIR/$tfile-2
440     fail $SINGLEMDS
441     grep old $DIR/$tfile-2 || return 2
442 }
443 run_test 19 "|X| mcreate, open, write, rename "
444
445 test_20() {
446     replay_barrier $SINGLEMDS
447     multiop $DIR/$tfile O_tSc &
448     pid=$!
449     # give multiop a chance to open
450     sleep 1 
451     rm -f $DIR/$tfile
452
453     fail $SINGLEMDS
454     kill -USR1 $pid
455     wait $pid || return 1
456     [ -e $DIR/$tfile ] && return 2
457     return 0
458 }
459 run_test 20 "|X| open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
460
461 test_20b() { # bug 10480
462     BEFOREUSED=`df -P $DIR | tail -1 | awk '{ print $3 }'`
463
464     dd if=/dev/zero of=$DIR/$tfile bs=4k count=10000 &
465     pid=$!
466     while [ ! -e $DIR/$tfile ] ; do
467         usleep 60                           # give dd a chance to start
468     done
469
470     lfs getstripe $DIR/$tfile || return 1
471     rm -f $DIR/$tfile || return 2       # make it an orphan
472     mds_evict_client
473     df -P $DIR || df -P $DIR || true    # reconnect
474
475     fail $SINGLEMDS                            # start orphan recovery
476     df -P $DIR || df -P $DIR || true    # reconnect
477     wait_mds_recovery_done || error "MDS recovery not done"
478
479     AFTERUSED=`df -P $DIR | tail -1 | awk '{ print $3 }'`
480     log "before $BEFOREUSED, after $AFTERUSED"
481     [ $AFTERUSED -gt $((BEFOREUSED + 20)) ] && \
482         error "after $AFTERUSED > before $BEFOREUSED" && return 5
483     return 0
484 }
485 run_test 20b "write, unlink, eviction, replay, (test mds_cleanup_orphans)"
486
487 test_20c() { # bug 10480
488     multiop $DIR/$tfile Ow_c &
489     pid=$!
490     # give multiop a chance to open
491     sleep 1
492
493     ls -la $DIR/$tfile
494
495     mds_evict_client
496
497     df -P $DIR || df -P $DIR || true    # reconnect
498
499     kill -USR1 $pid
500     test -s $DIR/$tfile || error "File was truncated"
501
502     return 0
503 }
504 run_test 20c "check that client eviction does not affect file content"
505
506 test_21() {
507     replay_barrier $SINGLEMDS
508     multiop $DIR/$tfile O_tSc &
509     pid=$!
510     # give multiop a chance to open
511     sleep 1 
512     rm -f $DIR/$tfile
513     touch $DIR/g11 || return 1
514
515     fail $SINGLEMDS
516     kill -USR1 $pid
517     wait $pid || return 2
518     [ -e $DIR/$tfile ] && return 3
519     touch $DIR/h11 || return 4
520     return 0
521 }
522 run_test 21 "|X| open(O_CREAT), unlink touch new, replay, close (test mds_cleanup_orphans)"
523
524 test_22() {
525     multiop $DIR/$tfile O_tSc &
526     pid=$!
527     # give multiop a chance to open
528     sleep 1 
529
530     replay_barrier $SINGLEMDS
531     rm -f $DIR/$tfile
532
533     fail $SINGLEMDS
534     kill -USR1 $pid
535     wait $pid || return 1
536     [ -e $DIR/$tfile ] && return 2
537     return 0
538 }
539 run_test 22 "open(O_CREAT), |X| unlink, replay, close (test mds_cleanup_orphans)"
540
541 test_23() {
542     multiop $DIR/$tfile O_tSc &
543     pid=$!
544     # give multiop a chance to open
545     sleep 1 
546
547     replay_barrier $SINGLEMDS
548     rm -f $DIR/$tfile
549     touch $DIR/g11 || return 1
550
551     fail $SINGLEMDS
552     kill -USR1 $pid
553     wait $pid || return 2
554     [ -e $DIR/$tfile ] && return 3
555     touch $DIR/h11 || return 4
556     return 0
557 }
558 run_test 23 "open(O_CREAT), |X| unlink touch new, replay, close (test mds_cleanup_orphans)"
559
560 test_24() {
561     multiop $DIR/$tfile O_tSc &
562     pid=$!
563     # give multiop a chance to open
564     sleep 1 
565
566     replay_barrier $SINGLEMDS
567     fail $SINGLEMDS
568     rm -f $DIR/$tfile
569     kill -USR1 $pid
570     wait $pid || return 1
571     [ -e $DIR/$tfile ] && return 2
572     return 0
573 }
574 run_test 24 "open(O_CREAT), replay, unlink, close (test mds_cleanup_orphans)"
575
576 test_25() {
577     multiop $DIR/$tfile O_tSc &
578     pid=$!
579     # give multiop a chance to open
580     sleep 1 
581     rm -f $DIR/$tfile
582
583     replay_barrier $SINGLEMDS
584     fail $SINGLEMDS
585     kill -USR1 $pid
586     wait $pid || return 1
587     [ -e $DIR/$tfile ] && return 2
588     return 0
589 }
590 run_test 25 "open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
591
592 test_26() {
593     replay_barrier $SINGLEMDS
594     multiop $DIR/$tfile-1 O_tSc &
595     pid1=$!
596     multiop $DIR/$tfile-2 O_tSc &
597     pid2=$!
598     # give multiop a chance to open
599     sleep 1 
600     rm -f $DIR/$tfile-1
601     rm -f $DIR/$tfile-2
602     kill -USR1 $pid2
603     wait $pid2 || return 1
604
605     fail $SINGLEMDS
606     kill -USR1 $pid1
607     wait $pid1 || return 2
608     [ -e $DIR/$tfile-1 ] && return 3
609     [ -e $DIR/$tfile-2 ] && return 4
610     return 0
611 }
612 run_test 26 "|X| open(O_CREAT), unlink two, close one, replay, close one (test mds_cleanup_orphans)"
613
614 test_27() {
615     replay_barrier $SINGLEMDS
616     multiop $DIR/$tfile-1 O_tSc &
617     pid1=$!
618     multiop $DIR/$tfile-2 O_tSc &
619     pid2=$!
620     # give multiop a chance to open
621     sleep 1 
622     rm -f $DIR/$tfile-1
623     rm -f $DIR/$tfile-2
624
625     fail $SINGLEMDS
626     kill -USR1 $pid1
627     wait $pid1 || return 1
628     kill -USR1 $pid2
629     wait $pid2 || return 2
630     [ -e $DIR/$tfile-1 ] && return 3
631     [ -e $DIR/$tfile-2 ] && return 4
632     return 0
633 }
634 run_test 27 "|X| open(O_CREAT), unlink two, replay, close two (test mds_cleanup_orphans)"
635
636 test_28() {
637     multiop $DIR/$tfile-1 O_tSc &
638     pid1=$!
639     multiop $DIR/$tfile-2 O_tSc &
640     pid2=$!
641     # give multiop a chance to open
642     sleep 1 
643     replay_barrier $SINGLEMDS
644     rm -f $DIR/$tfile-1
645     rm -f $DIR/$tfile-2
646     kill -USR1 $pid2
647     wait $pid2 || return 1
648
649     fail $SINGLEMDS
650     kill -USR1 $pid1
651     wait $pid1 || return 2
652     [ -e $DIR/$tfile-1 ] && return 3
653     [ -e $DIR/$tfile-2 ] && return 4
654     return 0
655 }
656 run_test 28 "open(O_CREAT), |X| unlink two, close one, replay, close one (test mds_cleanup_orphans)"
657
658 test_29() {
659     multiop $DIR/$tfile-1 O_tSc &
660     pid1=$!
661     multiop $DIR/$tfile-2 O_tSc &
662     pid2=$!
663     # give multiop a chance to open
664     sleep 1 
665     replay_barrier $SINGLEMDS
666     rm -f $DIR/$tfile-1
667     rm -f $DIR/$tfile-2
668
669     fail $SINGLEMDS
670     kill -USR1 $pid1
671     wait $pid1 || return 1
672     kill -USR1 $pid2
673     wait $pid2 || return 2
674     [ -e $DIR/$tfile-1 ] && return 3
675     [ -e $DIR/$tfile-2 ] && return 4
676     return 0
677 }
678 run_test 29 "open(O_CREAT), |X| unlink two, replay, close two (test mds_cleanup_orphans)"
679
680 test_30() {
681     multiop $DIR/$tfile-1 O_tSc &
682     pid1=$!
683     multiop $DIR/$tfile-2 O_tSc &
684     pid2=$!
685     # give multiop a chance to open
686     sleep 1 
687     rm -f $DIR/$tfile-1
688     rm -f $DIR/$tfile-2
689
690     replay_barrier $SINGLEMDS
691     fail $SINGLEMDS
692     kill -USR1 $pid1
693     wait $pid1 || return 1
694     kill -USR1 $pid2
695     wait $pid2 || return 2
696     [ -e $DIR/$tfile-1 ] && return 3
697     [ -e $DIR/$tfile-2 ] && return 4
698     return 0
699 }
700 run_test 30 "open(O_CREAT) two, unlink two, replay, close two (test mds_cleanup_orphans)"
701
702 test_31() {
703     multiop $DIR/$tfile-1 O_tSc &
704     pid1=$!
705     multiop $DIR/$tfile-2 O_tSc &
706     pid2=$!
707     # give multiop a chance to open
708     sleep 1 
709     rm -f $DIR/$tfile-1
710
711     replay_barrier $SINGLEMDS
712     rm -f $DIR/$tfile-2
713     fail $SINGLEMDS
714     kill -USR1 $pid1
715     wait $pid1 || return 1
716     kill -USR1 $pid2
717     wait $pid2 || return 2
718     [ -e $DIR/$tfile-1 ] && return 3
719     [ -e $DIR/$tfile-2 ] && return 4
720     return 0
721 }
722 run_test 31 "open(O_CREAT) two, unlink one, |X| unlink one, close two (test mds_cleanup_orphans)"
723
724 # tests for bug 2104; completion without crashing is success.  The close is
725 # stale, but we always return 0 for close, so the app never sees it.
726 test_32() {
727     multiop $DIR/$tfile O_c &
728     pid1=$!
729     multiop $DIR/$tfile O_c &
730     pid2=$!
731     # give multiop a chance to open
732     sleep 1
733     mds_evict_client
734     df $MOUNT || sleep 1 && df $MOUNT || return 1
735     kill -USR1 $pid1
736     kill -USR1 $pid2
737     sleep 1
738     return 0
739 }
740 run_test 32 "close() notices client eviction; close() after client eviction"
741
742 # Abort recovery before client complete
743 test_33() {
744     replay_barrier $SINGLEMDS
745     createmany -o $DIR/$tfile-%d 100
746     fail_abort $SINGLEMDS
747     # this file should be gone, because the replay was aborted
748     $CHECKSTAT -t file $DIR/$tfile-* && return 3 
749     unlinkmany $DIR/$tfile-%d 0 100
750     return 0
751 }
752 run_test 33 "abort recovery before client does replay"
753
754 # Stale FID sequence 
755 test_33a() {
756     replay_barrier $SINGLEMDS
757     createmany -o $DIR/$tfile-%d 10
758     fail_abort $SINGLEMDS
759     unlinkmany $DIR/$tfile-%d 0 10
760     # recreate shouldn't fail
761     createmany -o $DIR/$tfile-%d 10 || return 3
762     unlinkmany $DIR/$tfile-%d 0 10
763     return 0
764 }
765 run_test 33a "fid shouldn't be reused after abort recovery"
766
767 test_34() {
768     multiop $DIR/$tfile O_c &
769     pid=$!
770     # give multiop a chance to open
771     sleep 1 
772     rm -f $DIR/$tfile
773
774     replay_barrier $SINGLEMDS
775     fail_abort $SINGLEMDS
776     kill -USR1 $pid
777     [ -e $DIR/$tfile ] && return 1
778     sync
779     return 0
780 }
781 run_test 34 "abort recovery before client does replay (test mds_cleanup_orphans)"
782
783 # bug 2278 - generate one orphan on OST, then destroy it during recovery from llog 
784 test_35() {
785     touch $DIR/$tfile
786
787 #define OBD_FAIL_MDS_REINT_NET_REP       0x119
788     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000119"
789     rm -f $DIR/$tfile &
790     sleep 1
791     sync
792     sleep 1
793     # give a chance to remove from MDS
794     fail_abort $SINGLEMDS
795     $CHECKSTAT -t file $DIR/$tfile && return 1 || true
796 }
797 run_test 35 "test recovery from llog for unlink op"
798
799 # b=2432 resent cancel after replay uses wrong cookie,
800 # so don't resend cancels
801 test_36() {
802     replay_barrier $SINGLEMDS
803     touch $DIR/$tfile
804     checkstat $DIR/$tfile
805     facet_failover $SINGLEMDS
806     cancel_lru_locks mdc
807     if dmesg | grep "unknown lock cookie"; then 
808         echo "cancel after replay failed"
809         return 1
810     fi
811 }
812 run_test 36 "don't resend cancel"
813
814 # b=2368
815 # directory orphans can't be unlinked from PENDING directory
816 test_37() {
817     rmdir $DIR/$tfile 2>/dev/null
818     multiop $DIR/$tfile dD_c &
819     pid=$!
820     # give multiop a chance to open
821     sleep 1 
822     rmdir $DIR/$tfile
823
824     replay_barrier $SINGLEMDS
825     # clear the dmesg buffer so we only see errors from this recovery
826     dmesg -c >/dev/null
827     fail_abort $SINGLEMDS
828     kill -USR1 $pid
829     dmesg | grep  "mds_unlink_orphan.*error .* unlinking orphan" && return 1
830     sync
831     return 0
832 }
833 run_test 37 "abort recovery before client does replay (test mds_cleanup_orphans for directories)"
834
835 test_38() {
836     createmany -o $DIR/$tfile-%d 800
837     unlinkmany $DIR/$tfile-%d 0 400
838     replay_barrier $SINGLEMDS
839     fail $SINGLEMDS
840     unlinkmany $DIR/$tfile-%d 400 400
841     sleep 2
842     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
843 }
844 run_test 38 "test recovery from unlink llog (test llog_gen_rec) "
845
846 test_39() { # bug 4176
847     createmany -o $DIR/$tfile-%d 800
848     replay_barrier $SINGLEMDS
849     unlinkmany $DIR/$tfile-%d 0 400
850     fail $SINGLEMDS
851     unlinkmany $DIR/$tfile-%d 400 400
852     sleep 2
853     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
854 }
855 run_test 39 "test recovery from unlink llog (test llog_gen_rec) "
856
857 count_ost_writes() {
858     awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }' $LPROC/osc/*/stats
859 }
860
861 #b=2477,2532
862 test_40(){
863     $LCTL mark multiop $MOUNT/$tfile OS_c 
864     multiop $MOUNT/$tfile OS_c  &
865     PID=$!
866     writeme -s $MOUNT/${tfile}-2 &
867     WRITE_PID=$!
868     sleep 1
869     facet_failover $SINGLEMDS
870 #define OBD_FAIL_MDS_CONNECT_NET         0x117
871     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000117"
872     kill -USR1 $PID
873     stat1=`count_ost_writes`
874     sleep $TIMEOUT
875     stat2=`count_ost_writes`
876     echo "$stat1, $stat2"
877     if [ $stat1 -lt $stat2 ]; then 
878        echo "writes continuing during recovery"
879        RC=0
880     else
881        echo "writes not continuing during recovery, bug 2477"
882        RC=4
883     fi
884     echo "waiting for writeme $WRITE_PID"
885     kill $WRITE_PID
886     wait $WRITE_PID 
887
888     echo "waiting for multiop $PID"
889     wait $PID || return 2
890     do_facet client munlink $MOUNT/$tfile  || return 3
891     do_facet client munlink $MOUNT/${tfile}-2  || return 3
892     return $RC
893 }
894 run_test 40 "cause recovery in ptlrpc, ensure IO continues"
895
896
897 #b=2814
898 # make sure that a read to one osc doesn't try to double-unlock its page just
899 # because another osc is invalid.  trigger_group_io used to mistakenly return
900 # an error if any oscs were invalid even after having successfully put rpcs
901 # on valid oscs.  This was fatal if the caller was ll_readpage who unlocked
902 # the page, guarnateeing that the unlock from the RPC completion would
903 # assert on trying to unlock the unlocked page.
904 test_41() {
905     [ $OSTCOUNT -lt 2 ] && \
906         skip "skipping test 41: we don't have a second OST to test with" && \
907         return
908
909     local f=$MOUNT/$tfile
910     # make sure the start of the file is ost1
911     lfs setstripe $f $((128 * 1024)) 0 0 
912     do_facet client dd if=/dev/zero of=$f bs=4k count=1 || return 3
913     cancel_lru_locks osc
914     # fail ost2 and read from ost1
915     local osc2dev=`do_facet mds "grep ${ost2_svc}-osc-MDT0000 $LPROC/devices" | awk '{print $1}'`
916     [ -z "$osc2dev" ] && echo "OST: $ost2_svc" && cat $LPROC/devices && return 4
917     do_facet mds $LCTL --device $osc2dev deactivate || return 1
918     do_facet client dd if=$f of=/dev/null bs=4k count=1 || return 3
919     do_facet mds $LCTL --device $osc2dev activate || return 2
920     return 0
921 }
922 run_test 41 "read from a valid osc while other oscs are invalid"
923
924 # test MDS recovery after ost failure
925 test_42() {
926     blocks=`df -P $MOUNT | tail -n 1 | awk '{ print $2 }'`
927     createmany -o $DIR/$tfile-%d 800
928     replay_barrier ost1
929     unlinkmany $DIR/$tfile-%d 0 400
930     debugsave
931     sysctl -w lnet.debug=-1
932     facet_failover ost1
933     
934     # osc is evicted, fs is smaller (but only with failout OSTs (bug 7287)
935     #blocks_after=`df -P $MOUNT | tail -n 1 | awk '{ print $2 }'`
936     #[ $blocks_after -lt $blocks ] || return 1
937     echo wait for MDS to timeout and recover
938     sleep $((TIMEOUT * 2))
939     debugrestore
940     unlinkmany $DIR/$tfile-%d 400 400
941     $CHECKSTAT -t file $DIR/$tfile-* && return 2 || true
942 }
943 run_test 42 "recovery after ost failure"
944
945 # timeout in MDS/OST recovery RPC will LBUG MDS
946 test_43() { # bug 2530
947     replay_barrier $SINGLEMDS
948
949     # OBD_FAIL_OST_CREATE_NET 0x204
950     do_facet ost1 "sysctl -w lustre.fail_loc=0x80000204"
951     fail $SINGLEMDS
952     sleep 10
953     do_facet ost1 "sysctl -w lustre.fail_loc=0"
954
955     return 0
956 }
957 run_test 43 "mds osc import failure during recovery; don't LBUG"
958
959 test_44() {
960     mdcdev=`awk '/MDT0000-mdc-/ {print $1}' $LPROC/devices`
961     [ "$mdcdev" ] || exit 2
962     for i in `seq 1 10`; do
963         #define OBD_FAIL_TGT_CONN_RACE     0x701
964         do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000701"
965         $LCTL --device $mdcdev recover
966         df $MOUNT
967     done
968     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
969     return 0
970 }
971 run_test 44 "race in target handle connect"
972
973 test_44b() {
974     mdcdev=`awk '/MDT0000-mdc-/ {print $1}' $LPROC/devices`
975     [ "$mdcdev" ] || exit 2
976     for i in `seq 1 10`; do
977         #define OBD_FAIL_TGT_DELAY_RECONNECT 0x704
978         do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000704"
979         $LCTL --device $mdcdev recover
980         df $MOUNT
981     done
982     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
983     return 0
984 }
985 run_test 44b "race in target handle connect"
986
987 # Handle failed close
988 test_45() {
989     mdcdev=`awk '/MDT0000-mdc-/ {print $1}' $LPROC/devices`
990     [ "$mdcdev" ] || exit 2
991     $LCTL --device $mdcdev recover
992
993     multiop $DIR/$tfile O_c &
994     pid=$!
995     sleep 1
996
997     # This will cause the CLOSE to fail before even 
998     # allocating a reply buffer
999     $LCTL --device $mdcdev deactivate || return 4
1000
1001     # try the close
1002     kill -USR1 $pid
1003     wait $pid || return 1
1004
1005     $LCTL --device $mdcdev activate || return 5
1006     sleep 1
1007
1008     $CHECKSTAT -t file $DIR/$tfile || return 2
1009     return 0
1010 }
1011 run_test 45 "Handle failed close"
1012
1013 test_46() {
1014     dmesg -c >/dev/null
1015     drop_reply "touch $DIR/$tfile"
1016     fail $SINGLEMDS
1017     # ironically, the previous test, 45, will cause a real forced close,
1018     # so just look for one for this test
1019     dmesg | grep -i "force closing client file handle for $tfile" && return 1
1020     return 0
1021 }
1022 run_test 46 "Don't leak file handle after open resend (3325)"
1023
1024 test_47() { # bug 2824
1025     # create some files to make sure precreate has been done on all 
1026     # OSTs. (just in case this test is run independently)
1027     createmany -o $DIR/$tfile 20  || return 1
1028
1029     # OBD_FAIL_OST_CREATE_NET 0x204
1030     fail ost1
1031     do_facet ost1 "sysctl -w lustre.fail_loc=0x80000204"
1032     df $MOUNT || return 2
1033
1034     # let the MDS discover the OST failure, attempt to recover, fail
1035     # and recover again.  
1036     sleep $((3 * TIMEOUT))
1037
1038     # Without 2824, this createmany would hang 
1039     createmany -o $DIR/$tfile 20 || return 3
1040     unlinkmany $DIR/$tfile 20 || return 4
1041
1042     do_facet ost1 "sysctl -w lustre.fail_loc=0"
1043     return 0
1044 }
1045 run_test 47 "MDS->OSC failure during precreate cleanup (2824)"
1046
1047 test_48() {
1048     replay_barrier $SINGLEMDS
1049     createmany -o $DIR/$tfile 20  || return 1
1050     # OBD_FAIL_OST_EROFS 0x216
1051     fail $SINGLEMDS
1052     do_facet ost1 "sysctl -w lustre.fail_loc=0x80000216"
1053     df $MOUNT || return 2
1054
1055     createmany -o $DIR/$tfile 20 20 || return 2
1056     unlinkmany $DIR/$tfile 40 || return 3
1057
1058     do_facet ost1 "sysctl -w lustre.fail_loc=0"
1059     return 0
1060 }
1061 run_test 48 "MDS->OSC failure during precreate cleanup (2824)"
1062
1063 test_50() {
1064     local oscdev=`grep ${ost1_svc}-osc-MDT0000 $LPROC/devices | awk '{print $1}'`
1065     [ "$oscdev" ] || return 1
1066     $LCTL --device $oscdev recover &&  $LCTL --device $oscdev recover
1067     # give the mds_lov_sync threads a chance to run
1068     sleep 5
1069 }
1070 run_test 50 "Double OSC recovery, don't LASSERT (3812)"
1071
1072 # b3764 timed out lock replay
1073 test_52() {
1074     touch $DIR/$tfile
1075     cancel_lru_locks mdc
1076
1077     multiop $DIR/$tfile s || return 1
1078     replay_barrier $SINGLEMDS
1079 #define OBD_FAIL_LDLM_REPLY              0x30c
1080     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x8000030c"
1081     fail $SINGLEMDS || return 2
1082     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x0"
1083
1084     $CHECKSTAT -t file $DIR/$tfile-* && return 3 || true
1085 }
1086 run_test 52 "time out lock replay (3764)"
1087
1088 #b_cray 53 "|X| open request and close reply while two MDC requests in flight"
1089 #b_cray 54 "|X| open request and close reply while two MDC requests in flight"
1090
1091 #b3761 ASSERTION(hash != 0) failed
1092 test_55() {
1093 # OBD_FAIL_MDS_OPEN_CREATE | OBD_FAIL_ONCE
1094     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x8000012b"
1095     touch $DIR/$tfile &
1096     # give touch a chance to run
1097     sleep 5
1098     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x0"
1099     rm $DIR/$tfile
1100     return 0
1101 }
1102 run_test 55 "let MDS_CHECK_RESENT return the original return code instead of 0"
1103
1104 #b3440 ASSERTION(rec->ur_fid2->id) failed
1105 test_56() {
1106     ln -s foo $DIR/$tfile
1107     replay_barrier $SINGLEMDS
1108     #drop_reply "cat $DIR/$tfile"
1109     fail $SINGLEMDS
1110     sleep 10
1111 }
1112 run_test 56 "don't replay a symlink open request (3440)"
1113
1114 #recovery one mds-ost setattr from llog
1115 test_57() {
1116 #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1117     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x8000012c"
1118     touch $DIR/$tfile
1119     replay_barrier $SINGLEMDS
1120     fail $SINGLEMDS
1121     sleep 1
1122     $CHECKSTAT -t file $DIR/$tfile || return 1
1123     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x0"
1124     rm $DIR/$tfile
1125 }
1126 run_test 57 "test recovery from llog for setattr op"
1127
1128 #recovery many mds-ost setattr from llog
1129 test_58() {
1130 #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1131     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x8000012c"
1132     mkdir $DIR/$tdir
1133     createmany -o $DIR/$tdir/$tfile-%d 2500
1134     replay_barrier $SINGLEMDS
1135     fail $SINGLEMDS
1136     sleep 2
1137     $CHECKSTAT -t file $DIR/$tdir/$tfile-* || return 1
1138     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x0"
1139     unlinkmany $DIR/$tdir/$tfile-%d 2500
1140     rmdir $DIR/$tdir
1141 }
1142 run_test 58 "test recovery from llog for setattr op (test llog_gen_rec)"
1143
1144 # log_commit_thread vs filter_destroy race used to lead to import use after free
1145 # bug 11658
1146 test_59() {
1147     mkdir $DIR/$tdir
1148     createmany -o $DIR/$tdir/$tfile-%d 200
1149     sync
1150     unlinkmany $DIR/$tdir/$tfile-%d 200
1151 #define OBD_FAIL_PTLRPC_DELAY_RECOV       0x507
1152     do_facet ost1 "sysctl -w lustre.fail_loc=0x507"
1153     fail ost1
1154     fail $SINGLEMDS
1155     do_facet ost1 "sysctl -w lustre.fail_loc=0x0"
1156     sleep 20
1157     rmdir $DIR/$tdir
1158 }
1159 run_test 59 "test log_commit_thread vs filter_destroy race"
1160
1161 # race between add unlink llog vs cat log init in post_recovery (only for b1_6)
1162 # bug 12086: should no oops and No ctxt error for this test
1163 test_60() {
1164     mkdir $DIR/$tdir
1165     createmany -o $DIR/$tdir/$tfile-%d 200
1166     replay_barrier $SINGLEMDS
1167     unlinkmany $DIR/$tdir/$tfile-%d 0 100
1168     fail $SINGLEMDS
1169     unlinkmany $DIR/$tdir/$tfile-%d 100 100
1170     local no_ctxt=`dmesg | grep "No ctxt"`
1171     [ -z "$no_ctxt" ] || error "ctxt is not initialized in recovery" 
1172 }
1173 run_test 60 "test llog post recovery init vs llog unlink"
1174
1175 equals_msg `basename $0`: test complete, cleaning up
1176 check_and_cleanup_lustre
1177 [ -f "$TESTSUITELOG" ] && cat $TESTSUITELOG || true