Whamcloud - gitweb
Branch HEAD
[fs/lustre-release.git] / lustre / tests / recovery-small.sh
1 #!/bin/bash
2
3 set -e
4
5 #         bug  5494 7288 5493
6 ALWAYS_EXCEPT="24   27   52 $RECOVERY_SMALL_EXCEPT"
7
8 PTLDEBUG=${PTLDEBUG:--1}
9 LUSTRE=${LUSTRE:-`dirname $0`/..}
10 . $LUSTRE/tests/test-framework.sh
11 init_test_env $@
12 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
13
14 if [ "$FAILURE_MODE" = "HARD" ] && mixed_ost_devs; then
15     CONFIG_EXCEPTIONS="52"
16     echo -n "Several ost services on one ost node are used with FAILURE_MODE=$FAILURE_MODE. "
17     echo "Except the tests: $CONFIG_EXCEPTIONS"
18     ALWAYS_EXCEPT="$ALWAYS_EXCEPT $CONFIG_EXCEPTIONS"
19 fi
20
21 remote_mds_nodsh && skip "remote MDS with nodsh" && exit 0
22
23 # also long tests: 19, 21a, 21e, 21f, 23, 27
24 #                                   1  2.5  2.5    4    4          (min)"
25 [ "$SLOW" = "no" ] && EXCEPT_SLOW="17  26a  26b    50   51     57"
26
27 build_test_filter
28
29 # Allow us to override the setup if we already have a mounted system by
30 # setting SETUP=" " and CLEANUP=" "
31 SETUP=${SETUP:-""}
32 CLEANUP=${CLEANUP:-""}
33
34 check_and_setup_lustre
35
36 assert_DIR
37 rm -rf $DIR/[df][0-9]*
38
39 test_1() {
40     drop_request "mcreate $DIR/f1"  || return 1
41     drop_reint_reply "mcreate $DIR/f2"    || return 2
42 }
43 run_test 1 "mcreate: drop req, drop rep"
44
45 test_2() {
46     drop_request "tchmod 111 $DIR/f2"  || return 1
47     drop_reint_reply "tchmod 666 $DIR/f2"    || return 2
48 }
49 run_test 2 "chmod: drop req, drop rep"
50
51 test_3() {
52     drop_request "statone $DIR/f2" || return 1
53     drop_reply "statone $DIR/f2"   || return 2
54 }
55 run_test 3 "stat: drop req, drop rep"
56
57 SAMPLE_NAME=f0.recovery-small.junk
58 SAMPLE_FILE=$TMP/$SAMPLE_NAME
59 # make this big, else test 9 doesn't wait for bulk -- bz 5595
60 dd if=/dev/urandom of=$SAMPLE_FILE bs=1M count=4
61
62 test_4() {
63     do_facet client "cp $SAMPLE_FILE $DIR/$SAMPLE_NAME" || return 1
64     drop_request "cat $DIR/$SAMPLE_NAME > /dev/null"   || return 2
65     drop_reply "cat $DIR/$SAMPLE_NAME > /dev/null"     || return 3
66 }
67 run_test 4 "open: drop req, drop rep"
68
69 RENAMED_AGAIN=$DIR/f0.renamed-again
70
71 test_5() {
72     drop_request "mv $DIR/$SAMPLE_NAME $DIR/$tfile-renamed" || return 1
73     drop_reint_reply "mv $DIR/$tfile-renamed $RENAMED_AGAIN" || return 2
74     do_facet client "checkstat -v $RENAMED_AGAIN"  || return 3
75 }
76 run_test 5 "rename: drop req, drop rep"
77
78 [ ! -e $RENAMED_AGAIN ] && cp $SAMPLE_FILE $RENAMED_AGAIN
79 LINK1=$DIR/f0.link1
80 LINK2=$DIR/f0.link2
81
82 test_6() {
83     drop_request "mlink $RENAMED_AGAIN $LINK1" || return 1
84     drop_reint_reply "mlink $RENAMED_AGAIN $LINK2"   || return 2
85 }
86 run_test 6 "link: drop req, drop rep"
87
88 [ ! -e $LINK1 ] && mlink $RENAMED_AGAIN $LINK1
89 [ ! -e $LINK2 ] && mlink $RENAMED_AGAIN $LINK2
90 test_7() {
91     drop_request "munlink $LINK1"   || return 1
92     drop_reint_reply "munlink $LINK2"     || return 2
93 }
94 run_test 7 "unlink: drop req, drop rep"
95
96 #bug 1423
97 test_8() {
98     drop_reint_reply "touch $DIR/$tfile"    || return 1
99 }
100 run_test 8 "touch: drop rep (bug 1423)"
101
102 #bug 1420
103 test_9() {
104     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
105
106     pause_bulk "cp /etc/profile $DIR/$tfile"       || return 1
107     do_facet client "cp $SAMPLE_FILE $DIR/${tfile}.2"  || return 2
108     do_facet client "sync"
109     do_facet client "rm $DIR/$tfile $DIR/${tfile}.2" || return 3
110 }
111 run_test 9 "pause bulk on OST (bug 1420)"
112
113 #bug 1521
114 test_10() {
115     do_facet client mcreate $DIR/$tfile        || return 1
116     drop_bl_callback "chmod 0777 $DIR/$tfile"  || echo "evicted as expected"
117     # wait for the mds to evict the client
118     #echo "sleep $(($TIMEOUT*2))"
119     #sleep $(($TIMEOUT*2))
120     do_facet client touch $DIR/$tfile || echo "touch failed, evicted"
121     do_facet client checkstat -v -p 0777 $DIR/$tfile  || return 3
122     do_facet client "munlink $DIR/$tfile"
123 }
124 run_test 10 "finish request on server after client eviction (bug 1521)"
125
126 #bug 2460
127 # wake up a thread waiting for completion after eviction
128 test_11(){
129     do_facet client multiop $DIR/$tfile Ow  || return 1
130     do_facet client multiop $DIR/$tfile or  || return 2
131
132     cancel_lru_locks osc
133
134     do_facet client multiop $DIR/$tfile or  || return 3
135     drop_bl_callback multiop $DIR/$tfile Ow || echo "evicted as expected"
136
137     do_facet client munlink $DIR/$tfile  || return 4
138 }
139 run_test 11 "wake up a thread waiting for completion after eviction (b=2460)"
140
141 #b=2494
142 test_12(){
143     $LCTL mark multiop $DIR/$tfile OS_c 
144     do_facet $SINGLEMDS "lctl set_param fail_loc=0x115"
145     clear_failloc $SINGLEMDS $((TIMEOUT * 2)) &
146     multiop_bg_pause $DIR/$tfile OS_c || return 1
147     PID=$!
148 #define OBD_FAIL_MDS_CLOSE_NET           0x115
149     kill -USR1 $PID
150     echo "waiting for multiop $PID"
151     wait $PID || return 2
152     do_facet client munlink $DIR/$tfile  || return 3
153 }
154 run_test 12 "recover from timed out resend in ptlrpcd (b=2494)"
155
156 # Bug 113, check that readdir lost recv timeout works.
157 test_13() {
158     mkdir -p $DIR/$tdir || return 1
159     touch $DIR/$tdir/newentry || return
160 # OBD_FAIL_MDS_READPAGE_NET|OBD_FAIL_ONCE
161     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000104"
162     ls $DIR/$tdir || return 3
163     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
164     rm -rf $DIR/$tdir || return 4
165 }
166 run_test 13 "mdc_readpage restart test (bug 1138)"
167
168 # Bug 113, check that readdir lost send timeout works.
169 test_14() {
170     mkdir -p $DIR/$tdir
171     touch $DIR/$tdir/newentry
172 # OBD_FAIL_MDS_SENDPAGE|OBD_FAIL_ONCE
173     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000106"
174     ls $DIR/$tdir || return 1
175     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
176 }
177 run_test 14 "mdc_readpage resend test (bug 1138)"
178
179 test_15() {
180     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000128"
181     touch $DIR/$tfile && return 1
182     return 0
183 }
184 run_test 15 "failed open (-ENOMEM)"
185
186 READ_AHEAD=`lctl get_param -n llite.*.max_read_ahead_mb | head -n 1`
187 stop_read_ahead() {
188    lctl set_param -n llite.*.max_read_ahead_mb 0
189 }
190
191 start_read_ahead() {
192    lctl set_param -n llite.*.max_read_ahead_mb $READ_AHEAD
193 }
194
195 test_16() {
196     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
197
198     do_facet client cp $SAMPLE_FILE $DIR
199     sync
200     stop_read_ahead
201
202 #define OBD_FAIL_PTLRPC_BULK_PUT_NET 0x504 | OBD_FAIL_ONCE
203     do_facet ost1 "lctl set_param fail_loc=0x80000504"
204     cancel_lru_locks osc
205     # OST bulk will time out here, client resends
206     do_facet client "cmp $SAMPLE_FILE $DIR/${SAMPLE_FILE##*/}" || return 1
207     do_facet ost1 lctl set_param fail_loc=0
208     # give recovery a chance to finish (shouldn't take long)
209     sleep $TIMEOUT
210     do_facet client "cmp $SAMPLE_FILE $DIR/${SAMPLE_FILE##*/}" || return 2
211     start_read_ahead
212 }
213 run_test 16 "timeout bulk put, don't evict client (2732)"
214
215 test_17() {
216     local at_max_saved=0
217
218     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
219
220     # With adaptive timeouts, bulk_get won't expire until adaptive_timeout_max
221     if at_is_valid && at_is_enabled; then
222         at_max_saved=$(at_max_get ost1)
223         at_max_set $TIMEOUT ost1
224     fi
225
226     # OBD_FAIL_PTLRPC_BULK_GET_NET 0x0503 | OBD_FAIL_ONCE
227     # OST bulk will time out here, client retries
228     do_facet ost1 lctl set_param fail_loc=0x80000503
229     # need to ensure we send an RPC
230     do_facet client cp /etc/termcap $DIR/$tfile
231     sync
232
233     # with AT, client will wait adaptive_max*factor+net_latency before
234     # expiring the req, hopefully timeout*2 is enough
235     sleep $(($TIMEOUT*2))
236
237     do_facet ost1 lctl set_param fail_loc=0
238     do_facet client "df $DIR"
239     # expect cmp to succeed, client resent bulk
240     do_facet client "cmp /etc/termcap $DIR/$tfile" || return 3
241     do_facet client "rm $DIR/$tfile" || return 4
242     [ $at_max_saved -ne 0 ] && $(at_max_set $at_max_saved ost1)
243     return 0
244 }
245 run_test 17 "timeout bulk get, don't evict client (2732)"
246
247 test_18a() {
248     [ -z ${ost2_svc} ] && skip "needs 2 osts" && return 0
249
250     do_facet client mkdir -p $DIR/$tdir
251     f=$DIR/$tdir/$tfile
252
253     cancel_lru_locks osc
254     pgcache_empty || return 1
255
256     # 1 stripe on ost2
257     lfs setstripe $f -s $((128 * 1024)) -i 1 -c 1
258
259     do_facet client cp $SAMPLE_FILE $f
260     sync
261     local osc2dev=`lctl get_param -n devices | grep ${ost2_svc}-osc- | egrep -v 'MDT' | awk '{print $1}'`
262     $LCTL --device $osc2dev deactivate || return 3
263     # my understanding is that there should be nothing in the page
264     # cache after the client reconnects?     
265     rc=0
266     pgcache_empty || rc=2
267     $LCTL --device $osc2dev activate
268     rm -f $f
269     return $rc
270 }
271 run_test 18a "manual ost invalidate clears page cache immediately"
272
273 test_18b() {
274     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
275
276     do_facet client mkdir -p $DIR/$tdir
277     f=$DIR/$tdir/$tfile
278     f2=$DIR/$tdir/${tfile}-2
279
280     cancel_lru_locks osc
281     pgcache_empty || return 1
282
283     # shouldn't have to set stripe size of count==1
284     lfs setstripe $f -s $((128 * 1024)) -i 0 -c 1
285     lfs setstripe $f2 -s $((128 * 1024)) -i 0 -c 1
286
287     do_facet client cp $SAMPLE_FILE $f
288     sync
289     ost_evict_client
290     # allow recovery to complete
291     sleep $((TIMEOUT + 2))
292     # my understanding is that there should be nothing in the page
293     # cache after the client reconnects?     
294     rc=0
295     pgcache_empty || rc=2
296     rm -f $f $f2
297     return $rc
298 }
299 run_test 18b "eviction and reconnect clears page cache (2766)"
300
301 test_18c() {
302     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
303
304     do_facet client mkdir -p $DIR/$tdir
305     f=$DIR/$tdir/$tfile
306     f2=$DIR/$tdir/${tfile}-2
307
308     cancel_lru_locks osc
309     pgcache_empty || return 1
310
311     # shouldn't have to set stripe size of count==1
312     lfs setstripe $f -s $((128 * 1024)) -i 0 -c 1
313     lfs setstripe $f2 -s $((128 * 1024)) -i 0 -c 1
314
315     do_facet client cp $SAMPLE_FILE $f
316     sync
317     ost_evict_client
318
319     # OBD_FAIL_OST_CONNECT_NET2
320     # lost reply to connect request
321     do_facet ost1 lctl set_param fail_loc=0x80000225
322     # force reconnect
323     df $MOUNT > /dev/null 2>&1
324     sleep 2
325     # my understanding is that there should be nothing in the page
326     # cache after the client reconnects?     
327     rc=0
328     pgcache_empty || rc=2
329     rm -f $f $f2
330     return $rc
331 }
332 run_test 18c "Dropped connect reply after eviction handing (14755)"
333
334 test_19a() {
335     f=$DIR/$tfile
336     do_facet client mcreate $f        || return 1
337     drop_ldlm_cancel "chmod 0777 $f"  || echo "evicted as expected"
338
339     do_facet client checkstat -v -p 0777 $f  || echo evicted
340     # let the client reconnect
341     sleep 5
342     do_facet client "munlink $f"
343 }
344 run_test 19a "test expired_lock_main on mds (2867)"
345
346 test_19b() {
347     f=$DIR/$tfile
348     do_facet client multiop $f Ow  || return 1
349     do_facet client multiop $f or  || return 2
350
351     cancel_lru_locks osc
352
353     do_facet client multiop $f or  || return 3
354     drop_ldlm_cancel multiop $f Ow  || echo "client evicted, as expected"
355
356     do_facet client munlink $f  || return 4
357 }
358 run_test 19b "test expired_lock_main on ost (2867)"
359
360 test_20a() {    # bug 2983 - ldlm_handle_enqueue cleanup
361         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
362
363         mkdir -p $DIR/$tdir
364         lfs setstripe $DIR/$tdir/${tfile} -i 0 -c 1
365         multiop_bg_pause $DIR/$tdir/${tfile} O_wc || return 1
366         MULTI_PID=$!
367         cancel_lru_locks osc
368 #define OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR 0x308
369         do_facet ost1 lctl set_param fail_loc=0x80000308
370         kill -USR1 $MULTI_PID
371         wait $MULTI_PID
372         rc=$?
373         [ $rc -eq 0 ] && error "multiop didn't fail enqueue: rc $rc" || true
374 }
375 run_test 20a "ldlm_handle_enqueue error (should return error)" 
376
377 test_20b() {    # bug 2986 - ldlm_handle_enqueue error during open
378         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
379
380         mkdir -p $DIR/$tdir
381         lfs setstripe $DIR/$tdir/${tfile} -i 0 -c 1
382         cancel_lru_locks osc
383 #define OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR 0x308
384         do_facet ost1 lctl set_param fail_loc=0x80000308
385         dd if=/etc/hosts of=$DIR/$tdir/$tfile && \
386                 error "didn't fail open enqueue" || true
387 }
388 run_test 20b "ldlm_handle_enqueue error (should return error)"
389
390 test_21a() {
391        mkdir -p $DIR/$tdir-1
392        mkdir -p $DIR/$tdir-2
393        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
394        close_pid=$!
395
396        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000129"
397        multiop $DIR/$tdir-2/f Oc &
398        open_pid=$!
399        sleep 1
400        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
401
402        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
403        kill -USR1 $close_pid
404        cancel_lru_locks mdc
405        wait $close_pid || return 1
406        wait $open_pid || return 2
407        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
408
409        $CHECKSTAT -t file $DIR/$tdir-1/f || return 3
410        $CHECKSTAT -t file $DIR/$tdir-2/f || return 4
411
412        rm -rf $DIR/$tdir-*
413 }
414 run_test 21a "drop close request while close and open are both in flight"
415
416 test_21b() {
417        mkdir -p $DIR/$tdir-1
418        mkdir -p $DIR/$tdir-2
419        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
420        close_pid=$!
421
422        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
423        mcreate $DIR/$tdir-2/f &
424        open_pid=$!
425        sleep 1
426        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
427
428        kill -USR1 $close_pid
429        cancel_lru_locks mdc
430        wait $close_pid || return 1
431        wait $open_pid || return 3
432
433        $CHECKSTAT -t file $DIR/$tdir-1/f || return 4
434        $CHECKSTAT -t file $DIR/$tdir-2/f || return 5
435        rm -rf $DIR/$tdir-*
436 }
437 run_test 21b "drop open request while close and open are both in flight"
438
439 test_21c() {
440        mkdir -p $DIR/$tdir-1
441        mkdir -p $DIR/$tdir-2
442        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
443        close_pid=$!
444
445        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
446        mcreate $DIR/$tdir-2/f &
447        open_pid=$!
448        sleep 3
449        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
450
451        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
452        kill -USR1 $close_pid
453        cancel_lru_locks mdc
454        wait $close_pid || return 1
455        wait $open_pid || return 2
456
457        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
458
459        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
460        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
461        rm -rf $DIR/$tdir-*
462 }
463 run_test 21c "drop both request while close and open are both in flight"
464
465 test_21d() {
466        mkdir -p $DIR/$tdir-1
467        mkdir -p $DIR/$tdir-2
468        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
469        pid=$!
470
471        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000129"
472        multiop $DIR/$tdir-2/f Oc &
473        sleep 1
474        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
475
476        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000122"
477        kill -USR1 $pid
478        cancel_lru_locks mdc
479        wait $pid || return 1
480        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
481
482        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
483        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
484
485        rm -rf $DIR/$tdir-*
486 }
487 run_test 21d "drop close reply while close and open are both in flight"
488
489 test_21e() {
490        mkdir -p $DIR/$tdir-1
491        mkdir -p $DIR/$tdir-2
492        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
493        pid=$!
494
495        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000119"
496        touch $DIR/$tdir-2/f &
497        sleep 1
498        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
499
500        kill -USR1 $pid
501        cancel_lru_locks mdc
502        wait $pid || return 1
503
504        sleep $TIMEOUT
505        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
506        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
507        rm -rf $DIR/$tdir-*
508 }
509 run_test 21e "drop open reply while close and open are both in flight"
510
511 test_21f() {
512        mkdir -p $DIR/$tdir-1
513        mkdir -p $DIR/$tdir-2
514        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
515        pid=$!
516
517        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000119"
518        touch $DIR/$tdir-2/f &
519        sleep 1
520        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
521
522        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000122"
523        kill -USR1 $pid
524        cancel_lru_locks mdc
525        wait $pid || return 1
526        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
527
528        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
529        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
530        rm -rf $DIR/$tdir-*
531 }
532 run_test 21f "drop both reply while close and open are both in flight"
533
534 test_21g() {
535        mkdir -p $DIR/$tdir-1
536        mkdir -p $DIR/$tdir-2
537        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
538        pid=$!
539
540        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000119"
541        touch $DIR/$tdir-2/f &
542        sleep 1
543        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
544
545        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
546        kill -USR1 $pid
547        cancel_lru_locks mdc
548        wait $pid || return 1
549        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
550
551        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
552        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
553        rm -rf $DIR/$tdir-*
554 }
555 run_test 21g "drop open reply and close request while close and open are both in flight"
556
557 test_21h() {
558        mkdir -p $DIR/$tdir-1
559        mkdir -p $DIR/$tdir-2
560        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
561        pid=$!
562
563        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
564        touch $DIR/$tdir-2/f &
565        touch_pid=$!
566        sleep 1
567        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
568
569        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000122"
570        cancel_lru_locks mdc
571        kill -USR1 $pid
572        wait $pid || return 1
573        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
574
575        wait $touch_pid || return 2
576
577        $CHECKSTAT -t file $DIR/$tdir-1/f || return 3
578        $CHECKSTAT -t file $DIR/$tdir-2/f || return 4
579        rm -rf $DIR/$tdir-*
580 }
581 run_test 21h "drop open request and close reply while close and open are both in flight"
582
583 # bug 3462 - multiple MDC requests
584 test_22() {
585     f1=$DIR/${tfile}-1
586     f2=$DIR/${tfile}-2
587     
588     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
589     multiop $f2 Oc &
590     close_pid=$!
591
592     sleep 1
593     multiop $f1 msu || return 1
594
595     cancel_lru_locks mdc
596     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
597
598     wait $close_pid || return 2
599     rm -rf $f2 || return 4
600 }
601 run_test 22 "drop close request and do mknod"
602
603 test_23() { #b=4561
604     multiop_bg_pause $DIR/$tfile O_c || return 1
605     pid=$!
606     # give a chance for open
607     sleep 5
608
609     # try the close
610     drop_request "kill -USR1 $pid"
611
612     fail $SINGLEMDS
613     wait $pid || return 1
614     return 0
615 }
616 run_test 23 "client hang when close a file after mds crash"
617
618 test_24() { # bug 11710 details correct fsync() behavior
619         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
620
621         mkdir -p $DIR/$tdir
622         lfs setstripe $DIR/$tdir -s 0 -i 0 -c 1
623         cancel_lru_locks osc
624         multiop_bg_pause $DIR/$tdir/$tfile Owy_wyc || return 1
625         MULTI_PID=$!
626         ost_evict_client
627         kill -USR1 $MULTI_PID
628         wait $MULTI_PID
629         rc=$?
630         lctl set_param fail_loc=0x0
631         client_reconnect
632         [ $rc -eq 0 ] && error_ignore 5494 "multiop didn't fail fsync: rc $rc" || true
633 }
634 run_test 24 "fsync error (should return error)"
635
636 test_26a() {      # was test_26 bug 5921 - evict dead exports by pinger
637 # this test can only run from a client on a separate node.
638         remote_ost || { skip "local OST" && return 0; }
639         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
640         remote_mds || { skip "local MDS" && return 0; }
641         OST_FILE=obdfilter.${ost1_svc}.num_exports
642         OST_EXP="`do_facet ost1 lctl get_param -n $OST_FILE`"
643         OST_NEXP1=`echo $OST_EXP | cut -d' ' -f2`
644         echo starting with $OST_NEXP1 OST exports
645 # OBD_FAIL_PTLRPC_DROP_RPC 0x505
646         do_facet client lctl set_param fail_loc=0x505
647         # evictor takes PING_EVICT_TIMEOUT + 3 * PING_INTERVAL to evict.
648         # But if there's a race to start the evictor from various obds,
649         # the loser might have to wait for the next ping.
650         echo Waiting for $(($TIMEOUT * 8)) secs
651         sleep $(($TIMEOUT * 8))
652         OST_EXP="`do_facet ost1 lctl get_param -n $OST_FILE`"
653         OST_NEXP2=`echo $OST_EXP | cut -d' ' -f2`
654         echo ending with $OST_NEXP2 OST exports
655         do_facet client lctl set_param fail_loc=0x0
656         [ $OST_NEXP1 -le $OST_NEXP2 ] && error "client not evicted"
657         return 0
658 }
659 run_test 26a "evict dead exports"
660
661 test_26b() {      # bug 10140 - evict dead exports by pinger
662         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
663
664         client_df
665         zconf_mount `hostname` $MOUNT2 || error "Failed to mount $MOUNT2"
666         sleep 1 # wait connections being established
667         MDS_FILE=mdt.${mds1_svc}.num_exports
668         MDS_NEXP1="`do_facet $SINGLEMDS lctl get_param -n $MDS_FILE | cut -d' ' -f2`"
669         OST_FILE=obdfilter.${ost1_svc}.num_exports
670         OST_NEXP1="`do_facet ost1 lctl get_param -n $OST_FILE | cut -d' ' -f2`"
671         echo starting with $OST_NEXP1 OST and $MDS_NEXP1 MDS exports
672         zconf_umount `hostname` $MOUNT2 -f
673         # evictor takes PING_EVICT_TIMEOUT + 3 * PING_INTERVAL to evict.  
674         # But if there's a race to start the evictor from various obds, 
675         # the loser might have to wait for the next ping.
676         echo Waiting for $(($TIMEOUT * 3)) secs
677         sleep $(($TIMEOUT * 3))
678         OST_NEXP2="`do_facet ost1 lctl get_param -n $OST_FILE | cut -d' ' -f2`"
679         MDS_NEXP2="`do_facet $SINGLEMDS lctl get_param -n $MDS_FILE | cut -d' ' -f2`"
680         echo ending with $OST_NEXP2 OST and $MDS_NEXP2 MDS exports
681         [ $OST_NEXP1 -le $OST_NEXP2 ] && error "client not evicted from OST"
682         [ $MDS_NEXP1 -le $MDS_NEXP2 ] && error "client not evicted from MDS"
683         return 0
684 }
685 run_test 26b "evict dead exports"
686
687 test_27() {
688         mkdir -p $DIR/$tdir
689         writemany -q -a $DIR/$tdir/$tfile 0 5 &
690         CLIENT_PID=$!
691         sleep 1
692         local save_FAILURE_MODE=$FAILURE_MODE
693         FAILURE_MODE="SOFT"
694         facet_failover $SINGLEMDS
695 #define OBD_FAIL_OSC_SHUTDOWN            0x407
696         do_facet $SINGLEMDS lctl set_param fail_loc=0x80000407
697         # need to wait for reconnect
698         echo -n waiting for fail_loc
699         while [ $(do_facet $SINGLEMDS lctl get_param -n fail_loc) -eq -2147482617 ]; do
700             sleep 1
701             echo -n .
702         done
703         do_facet $SINGLEMDS lctl get_param -n fail_loc
704         facet_failover $SINGLEMDS
705         #no crashes allowed!
706         kill -USR1 $CLIENT_PID
707         wait $CLIENT_PID 
708         true
709         FAILURE_MODE=$save_FAILURE_MODE
710 }
711 run_test 27 "fail LOV while using OSC's"
712
713 test_28() {      # bug 6086 - error adding new clients
714         do_facet client mcreate $DIR/$tfile       || return 1
715         drop_bl_callback "chmod 0777 $DIR/$tfile" ||echo "evicted as expected"
716         #define OBD_FAIL_MDS_CLIENT_ADD 0x12f
717         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000012f"
718         # fail once (evicted), reconnect fail (fail_loc), ok
719         df || (sleep 10; df) || (sleep 10; df) || error "reconnect failed"
720         rm -f $DIR/$tfile
721         fail $SINGLEMDS         # verify MDS last_rcvd can be loaded
722 }
723 run_test 28 "handle error adding new clients (bug 6086)"
724
725 test_50() {
726         mkdir -p $DIR/$tdir
727         # put a load of file creates/writes/deletes
728         writemany -q $DIR/$tdir/$tfile 0 5 &
729         CLIENT_PID=$!
730         echo writemany pid $CLIENT_PID
731         sleep 10
732         FAILURE_MODE="SOFT"
733         fail $SINGLEMDS
734         # wait for client to reconnect to MDS
735         sleep 60
736         fail $SINGLEMDS
737         sleep 60
738         fail $SINGLEMDS
739         # client process should see no problems even though MDS went down
740         sleep $TIMEOUT
741         kill -USR1 $CLIENT_PID
742         wait $CLIENT_PID 
743         rc=$?
744         echo writemany returned $rc
745         #these may fail because of eviction due to slow AST response.
746         [ $rc -eq 0 ] || error_ignore 13652 "writemany returned rc $rc" || true
747 }
748 run_test 50 "failover MDS under load"
749
750 test_51() {
751         mkdir -p $DIR/$tdir
752         # put a load of file creates/writes/deletes
753         writemany -q $DIR/$tdir/$tfile 0 5 &
754         CLIENT_PID=$!
755         sleep 1
756         FAILURE_MODE="SOFT"
757         facet_failover $SINGLEMDS
758         # failover at various points during recovery
759         SEQ="1 5 10 $(seq $TIMEOUT 5 $(($TIMEOUT+10)))"
760         echo will failover at $SEQ
761         for i in $SEQ
762           do
763           echo failover in $i sec
764           sleep $i
765           facet_failover $SINGLEMDS
766         done
767         # client process should see no problems even though MDS went down
768         # and recovery was interrupted
769         sleep $TIMEOUT
770         kill -USR1 $CLIENT_PID
771         wait $CLIENT_PID 
772         rc=$?
773         echo writemany returned $rc
774         [ $rc -eq 0 ] || error_ignore 13652 "writemany returned rc $rc" || true
775 }
776 run_test 51 "failover MDS during recovery"
777
778 test_52_guts() {
779         do_facet client "mkdir -p $DIR/$tdir"
780         do_facet client "writemany -q -a $DIR/$tdir/$tfile 300 5" &
781         CLIENT_PID=$!
782         echo writemany pid $CLIENT_PID
783         sleep 10
784         FAILURE_MODE="SOFT"
785         fail ost1
786         rc=0
787         wait $CLIENT_PID || rc=$?
788         # active client process should see an EIO for down OST
789         [ $rc -eq 5 ] && { echo "writemany correctly failed $rc" && return 0; }
790         # but timing or failover setup may allow success
791         [ $rc -eq 0 ] && { echo "writemany succeeded" && return 0; }
792         echo "writemany returned $rc"
793         return $rc
794 }
795
796 test_52() {
797         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
798
799         mkdir -p $DIR/$tdir
800         test_52_guts
801         rc=$?
802         [ $rc -ne 0 ] && { return $rc; }
803         # wait for client to reconnect to OST
804         sleep 30
805         test_52_guts
806         rc=$?
807         [ $rc -ne 0 ] && { return $rc; }
808         sleep 30
809         test_52_guts
810         rc=$?
811         client_reconnect
812         #return $rc
813 }
814 run_test 52 "failover OST under load"
815
816 # test of open reconstruct
817 test_53() {
818         touch $DIR/$tfile
819         drop_ldlm_reply "openfile -f O_RDWR:O_CREAT -m 0755 $DIR/$tfile" ||\
820                 return 2
821 }
822 run_test 53 "touch: drop rep"
823
824 test_54() {
825         zconf_mount `hostname` $MOUNT2
826         touch $DIR/$tfile
827         touch $DIR2/$tfile.1
828         sleep 10
829         cat $DIR2/$tfile.missing # save transno = 0, rc != 0 into last_rcvd
830         fail $SINGLEMDS
831         umount $MOUNT2
832         ERROR=`dmesg | egrep "(test 54|went back in time)" | tail -n1 | grep "went back in time"`
833         [ x"$ERROR" == x ] || error "back in time occured"
834 }
835 run_test 54 "back in time"
836
837 # bug 11330 - liblustre application death during I/O locks up OST
838 test_55() {
839         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
840
841         mkdir -p $DIR/$tdir
842
843         # first dd should be finished quickly
844         lfs setstripe $DIR/$tdir/$tfile-1 -c 1 -i 0
845         dd if=/dev/zero of=$DIR/$tdir/$tfile-1 bs=32M count=4  &
846         DDPID=$!
847         count=0
848         echo  "step1: testing ......"
849         while [ true ]; do
850             if [ -z `ps x | awk '$1 == '$DDPID' { print $5 }'` ]; then break; fi
851             count=$[count+1]
852             if [ $count -gt 64 ]; then
853                 error "dd should be finished!"
854             fi
855             sleep 1
856         done    
857         echo "(dd_pid=$DDPID, time=$count)successful"
858
859         lfs setstripe $DIR/$tdir/$tfile-2 -c 1 -i 0
860         #define OBD_FAIL_OST_DROP_REQ            0x21d
861         do_facet ost1 lctl set_param fail_loc=0x0000021d
862         # second dd will be never finished
863         dd if=/dev/zero of=$DIR/$tdir/$tfile-2 bs=32M count=4  &        
864         DDPID=$!
865         count=0
866         echo  "step2: testing ......"
867         while [ $count -le 64 ]; do
868             dd_name="`ps x | awk '$1 == '$DDPID' { print $5 }'`"            
869             if [ -z  $dd_name ]; then 
870                 ls -l $DIR/$tdir
871                 echo  "debug: (dd_name=$dd_name, dd_pid=$DDPID, time=$count)"
872                 error "dd shouldn't be finished!"
873             fi
874             count=$[count+1]
875             sleep 1
876         done    
877         echo "(dd_pid=$DDPID, time=$count)successful"
878
879         #Recover fail_loc and dd will finish soon
880         do_facet ost1 lctl set_param fail_loc=0
881         count=0
882         echo  "step3: testing ......"
883         while [ true ]; do
884             if [ -z `ps x | awk '$1 == '$DDPID' { print $5 }'` ]; then break; fi
885             count=$[count+1]
886             if [ $count -gt 500 ]; then
887                 error "dd should be finished!"
888             fi
889             sleep 1
890         done    
891         echo "(dd_pid=$DDPID, time=$count)successful"
892
893         rm -rf $DIR/$tdir
894 }
895 run_test 55 "ost_brw_read/write drops timed-out read/write request"
896
897 test_56() { # b=11277
898 #define OBD_FAIL_MDS_RESEND      0x136
899         touch $DIR/$tfile
900         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000136"
901         stat $DIR/$tfile
902         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
903         rm -f $DIR/$tfile
904 }
905 run_test 56 "do not allow reconnect to busy exports"
906
907 test_57_helper() {
908         # no oscs means no client or mdt 
909         while lctl get_param osc.*.* > /dev/null 2>&1; do
910                 : # loop until proc file is removed
911         done
912 }
913
914 test_57() { # bug 10866
915         test_57_helper &
916         pid=$!
917         sleep 1
918 #define OBD_FAIL_LPROC_REMOVE            0xB00
919         lctl set_param fail_loc=0x80000B00
920         zconf_umount `hostname` $DIR
921         lctl set_param fail_loc=0x80000B00
922         fail_abort $SINGLEMDS
923         kill -9 $pid
924         lctl set_param fail_loc=0
925         mount_client $DIR
926         do_facet client "df $DIR"
927 }
928 run_test 57 "read procfs entries causes kernel crash"
929
930 test_58() { # bug 11546
931 #define OBD_FAIL_MDC_ENQUEUE_PAUSE        0x801
932         touch $DIR/$tfile
933         ls -la $DIR/$tfile
934         lctl set_param fail_loc=0x80000801
935         cp $DIR/$tfile /dev/null &
936         pid=$!
937         sleep 1
938         lctl set_param fail_loc=0
939         drop_bl_callback rm -f $DIR/$tfile
940         wait $pid
941         do_facet client "df $DIR"
942 }
943 run_test 58 "Eviction in the middle of open RPC reply processing"
944
945 test_59() { # bug 10589
946         zconf_mount `hostname` $MOUNT2 || error "Failed to mount $MOUNT2"
947         echo $DIR2 | grep -q $MOUNT2 || error "DIR2 is not set properly: $DIR2"
948 #define OBD_FAIL_LDLM_CANCEL_EVICT_RACE  0x311
949         lctl set_param fail_loc=0x311
950         writes=$(LANG=C dd if=/dev/zero of=$DIR2/$tfile count=1 2>&1)
951         [ $? = 0 ] || error "dd write failed"
952         writes=$(echo $writes | awk  -F '+' '/out/ {print $1}')
953         lctl set_param fail_loc=0
954         sync
955         zconf_umount `hostname` $MOUNT2 -f
956         reads=$(LANG=C dd if=$DIR/$tfile of=/dev/null 2>&1)
957         [ $? = 0 ] || error "dd read failed"
958         reads=$(echo $reads | awk -F '+' '/in/ {print $1}')
959         [ "$reads" -eq "$writes" ] || error "read" $reads "blocks, must be" $writes
960 }
961 run_test 59 "Read cancel race on client eviction"
962
963 equals_msg `basename $0`: test complete, cleaning up
964 check_and_cleanup_lustre
965 [ -f "$TESTSUITELOG" ] && cat $TESTSUITELOG && grep -q FAIL $TESTSUITELOG && exit 1 || true