Whamcloud - gitweb
ed7fae3c3166a2df86dc8838d13bdb41b6b385f6
[fs/lustre-release.git] / lustre / tests / recovery-small.sh
1 #!/bin/bash
2
3 set -e
4
5 #         bug  5493  LU2034
6 ALWAYS_EXCEPT="52    60      $RECOVERY_SMALL_EXCEPT"
7
8 export MULTIOP=${MULTIOP:-multiop}
9 PTLDEBUG=${PTLDEBUG:--1}
10 LUSTRE=${LUSTRE:-`dirname $0`/..}
11 . $LUSTRE/tests/test-framework.sh
12 init_test_env $@
13 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
14 init_logging
15
16 require_dsh_mds || exit 0
17
18 # also long tests: 19, 21a, 21e, 21f, 23, 27
19 #                                   1  2.5  2.5    4    4          (min)"
20 [ "$SLOW" = "no" ] && EXCEPT_SLOW="17  26a  26b    50   51     57"
21
22 [ $(facet_fstype $SINGLEMDS) = "zfs" ] &&
23 # bug number for skipped test:        LU-2194 LU-2547
24         ALWAYS_EXCEPT="$ALWAYS_EXCEPT 19b     24a 24b"
25
26 build_test_filter
27
28 # Allow us to override the setup if we already have a mounted system by
29 # setting SETUP=" " and CLEANUP=" "
30 SETUP=${SETUP:-""}
31 CLEANUP=${CLEANUP:-""}
32
33 check_and_setup_lustre
34
35 assert_DIR
36 rm -rf $DIR/d[0-9]* $DIR/f.${TESTSUITE}*
37
38 test_1() {
39         local f1="$DIR/$tfile"
40         local f2="$DIR/$tfile.2"
41
42         drop_request "mcreate $f1" ||
43                 error_noexit "create '$f1': drop req"
44
45         drop_reint_reply "mcreate $f2" ||
46                 error_noexit "create '$f2': drop rep"
47
48         drop_request "tchmod 111 $f2" ||
49                 error_noexit "chmod '$f2': drop req"
50
51         drop_reint_reply "tchmod 666 $f2" ||
52                 error_noexit "chmod '$f2': drop rep"
53
54         drop_request "statone $f2" ||
55                 error_noexit "stat '$f2': drop req"
56
57         drop_reply  "statone $f2" ||
58                 error_noexit "stat '$f2': drop rep"
59 }
60 run_test 1 "create, chmod, stat: drop req, drop rep"
61
62 test_4() {
63         local t=$DIR/$tfile
64         do_facet_create_file client $t 10K ||
65                 error_noexit "Create file $t"
66
67         drop_request "cat $t > /dev/null" ||
68                 error_noexit "Open request for $t file"
69
70         drop_reply "cat $t > /dev/null" ||
71                 error_noexit "Open replay for $t file"
72 }
73 run_test 4 "open: drop req, drop rep"
74
75 test_5() {
76         local T=$DIR/$tfile
77         local R="$T-renamed"
78         local RR="$T-renamed-again"
79         do_facet_create_file client $T 10K ||
80                 error_noexit "Create file $T"
81
82         drop_request "mv $T $R" ||
83                 error_noexit "Rename $T"
84
85         drop_reint_reply "mv $R $RR" ||
86                 error_noexit "Failed rename replay on $R"
87
88         do_facet client "checkstat -v $RR" ||
89                 error_noexit "checkstat error on $RR"
90
91         do_facet client "rm $RR" ||
92                 error_noexit "Can't remove file $RR"
93 }
94 run_test 5 "rename: drop req, drop rep"
95
96 test_6() {
97         local T=$DIR/$tfile
98         local LINK1=$DIR/$tfile.link1
99         local LINK2=$DIR/$tfile.link2
100
101         do_facet_create_file client $T 10K ||
102                 error_noexit "Create file $T"
103
104         drop_request "mlink $T $LINK1" ||
105                 error_noexit "mlink request for $T"
106
107         drop_reint_reply "mlink $T $LINK2" ||
108                 error_noexit "mlink reply for $T"
109
110         drop_request "munlink $LINK1" ||
111                 error_noexit "munlink request for $T"
112
113         drop_reint_reply "munlink $LINK2" ||
114                 error_noexit "munlink reply for $T"
115
116         do_facet client "rm $T" ||
117                 error_noexit "Can't remove file $T"
118 }
119 run_test 6 "link, unlink: drop req, drop rep"
120
121 #bug 1423
122 test_8() {
123     drop_reint_reply "touch $DIR/$tfile"    || return 1
124 }
125 run_test 8 "touch: drop rep (bug 1423)"
126
127 #bug 1420
128 test_9() {
129         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
130
131         local t1=${tfile}.1
132         local t2=${tfile}.2
133         do_facet_random_file client $TMP/$tfile 1K ||
134                 error_noexit "Create random file $TMP/$tfile"
135         # make this big, else test 9 doesn't wait for bulk -- bz 5595
136         do_facet_create_file client $TMP/$t1 4M ||
137                 error_noexit "Create file $TMP/$t1"
138         do_facet client "cp $TMP/$t1 $DIR/$t1" ||
139                 error_noexit "Can't copy to $DIR/$t1 file"
140         pause_bulk "cp $TMP/$tfile $DIR/$tfile" ||
141                 error_noexit "Can't pause_bulk copy"
142         do_facet client "cp $TMP/$t1 $DIR/$t2" ||
143                 error_noexit "Can't copy file"
144         do_facet client "sync"
145         do_facet client "rm $DIR/$tfile $DIR/$t2 $DIR/$t1" ||
146                 error_noexit "Can't remove files"
147         do_facet client "rm $TMP/$t1 $TMP/$tfile"
148 }
149 run_test 9 "pause bulk on OST (bug 1420)"
150
151 #bug 1521
152 test_10() {
153         do_facet client mcreate $DIR/$tfile ||
154                 { error "mcreate failed: $?"; return 1; }
155         drop_bl_callback "chmod 0777 $DIR/$tfile"  || echo "evicted as expected"
156         # wait for the mds to evict the client
157         #echo "sleep $(($TIMEOUT*2))"
158         #sleep $(($TIMEOUT*2))
159         do_facet client touch $DIR/$tfile || echo "touch failed, evicted"
160         do_facet client checkstat -v -p 0777 $DIR/$tfile ||
161                 { error "client checkstat failed: $?"; return 3; }
162         do_facet client "munlink $DIR/$tfile"
163         # allow recovery to complete
164         client_up || client_up || sleep $TIMEOUT
165 }
166 run_test 10 "finish request on server after client eviction (bug 1521)"
167
168 #bug 2460
169 # wake up a thread waiting for completion after eviction
170 test_11(){
171         do_facet client $MULTIOP $DIR/$tfile Ow  ||
172                 { error "multiop write failed: $?"; return 1; }
173         do_facet client $MULTIOP $DIR/$tfile or  ||
174                 { error "multiop read failed: $?"; return 2; }
175
176         cancel_lru_locks osc
177
178         do_facet client $MULTIOP $DIR/$tfile or  ||
179                 { error "multiop read failed: $?"; return 3; }
180         drop_bl_callback $MULTIOP $DIR/$tfile Ow || echo "evicted as expected"
181
182         do_facet client munlink $DIR/$tfile ||
183                 { error "munlink failed: $?"; return 4; }
184         # allow recovery to complete
185         client_up || client_up || sleep $TIMEOUT
186 }
187 run_test 11 "wake up a thread waiting for completion after eviction (b=2460)"
188
189 #b=2494
190 test_12(){
191         $LCTL mark $MULTIOP $DIR/$tfile OS_c
192         do_facet $SINGLEMDS "lctl set_param fail_loc=0x115"
193         clear_failloc $SINGLEMDS $((TIMEOUT * 2)) &
194         multiop_bg_pause $DIR/$tfile OS_c ||
195                 { error "multiop failed: $?"; return 1; }
196         PID=$!
197 #define OBD_FAIL_MDS_CLOSE_NET           0x115
198         kill -USR1 $PID
199         echo "waiting for multiop $PID"
200         wait $PID || { error "wait for multiop faile: $?"; return 2; }
201         do_facet client munlink $DIR/$tfile ||
202                 { error "client munlink failed: $?"; return 3; }
203         # allow recovery to complete
204         client_up || client_up || sleep $TIMEOUT
205 }
206 run_test 12 "recover from timed out resend in ptlrpcd (b=2494)"
207
208 # Bug 113, check that readdir lost recv timeout works.
209 test_13() {
210         mkdir -p $DIR/$tdir || { error "mkdir failed: $?"; return 1; }
211         touch $DIR/$tdir/newentry || { error "touch failed: $?"; return 2; }
212 # OBD_FAIL_MDS_READPAGE_NET|OBD_FAIL_ONCE
213         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000104"
214         ls $DIR/$tdir || { error "ls failed: $?"; return 3; }
215         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
216         rm -rf $DIR/$tdir || { error "remove test dir failed: $?"; return 4; }
217 }
218 run_test 13 "mdc_readpage restart test (bug 1138)"
219
220 # Bug 113, check that readdir lost send timeout works.
221 test_14() {
222     mkdir -p $DIR/$tdir
223     touch $DIR/$tdir/newentry
224 # OBD_FAIL_MDS_SENDPAGE|OBD_FAIL_ONCE
225     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000106"
226     ls $DIR/$tdir || return 1
227     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
228 }
229 run_test 14 "mdc_readpage resend test (bug 1138)"
230
231 test_15() {
232     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000128"
233     touch $DIR/$tfile && return 1
234     return 0
235 }
236 run_test 15 "failed open (-ENOMEM)"
237
238 READ_AHEAD=`lctl get_param -n llite.*.max_read_ahead_mb | head -n 1`
239 stop_read_ahead() {
240    lctl set_param -n llite.*.max_read_ahead_mb 0
241 }
242
243 start_read_ahead() {
244    lctl set_param -n llite.*.max_read_ahead_mb $READ_AHEAD
245 }
246
247 test_16() {
248         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
249
250         do_facet_random_file client $TMP/$tfile 100K ||
251                 { error_noexit "Create random file $TMP/$T" ; return 0; }
252         do_facet client "cp $TMP/$tfile $DIR/$tfile" ||
253                 { error_noexit "Copy to $DIR/$tfile file" ; return 0; }
254         sync
255         stop_read_ahead
256
257 #define OBD_FAIL_PTLRPC_BULK_PUT_NET 0x504 | OBD_FAIL_ONCE
258         do_facet ost1 "lctl set_param fail_loc=0x80000504"
259         cancel_lru_locks osc
260         # OST bulk will time out here, client resends
261         do_facet client "cmp $TMP/$tfile $DIR/$tfile" || return 1
262         do_facet ost1 lctl set_param fail_loc=0
263         # give recovery a chance to finish (shouldn't take long)
264         sleep $TIMEOUT
265         do_facet client "cmp $TMP/$tfile $DIR/$tfile" || return 2
266         start_read_ahead
267         rm -f $TMP/$tfile
268 }
269 run_test 16 "timeout bulk put, don't evict client (2732)"
270
271 test_17() {
272     local at_max_saved=0
273
274     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
275
276         local SAMPLE_FILE=$TMP/$tfile
277         do_facet_random_file client $SAMPLE_FILE 20K ||
278                 { error_noexit "Create random file $SAMPLE_FILE" ; return 0; }
279
280     # With adaptive timeouts, bulk_get won't expire until adaptive_timeout_max
281     if at_is_enabled; then
282         at_max_saved=$(at_max_get ost1)
283         at_max_set $TIMEOUT ost1
284     fi
285
286     # OBD_FAIL_PTLRPC_BULK_GET_NET 0x0503 | OBD_FAIL_ONCE
287     # OST bulk will time out here, client retries
288     do_facet ost1 lctl set_param fail_loc=0x80000503
289     # need to ensure we send an RPC
290     do_facet client cp $SAMPLE_FILE $DIR/$tfile
291     sync
292
293     # with AT, client will wait adaptive_max*factor+net_latency before
294     # expiring the req, hopefully timeout*2 is enough
295     sleep $(($TIMEOUT*2))
296
297     do_facet ost1 lctl set_param fail_loc=0
298     do_facet client "df $DIR"
299     # expect cmp to succeed, client resent bulk
300     do_facet client "cmp $SAMPLE_FILE $DIR/$tfile" || return 3
301     do_facet client "rm $DIR/$tfile" || return 4
302     [ $at_max_saved -ne 0 ] && at_max_set $at_max_saved ost1
303     return 0
304 }
305 run_test 17 "timeout bulk get, don't evict client (2732)"
306
307 test_18a() {
308     [ -z ${ost2_svc} ] && skip_env "needs 2 osts" && return 0
309
310         do_facet_create_file client $TMP/$tfile 20K ||
311                 { error_noexit "Create file $TMP/$tfile" ; return 0; }
312
313     do_facet client mkdir -p $DIR/$tdir
314     f=$DIR/$tdir/$tfile
315
316     cancel_lru_locks osc
317     pgcache_empty || return 1
318
319     # 1 stripe on ost2
320     $LFS setstripe -i 1 -c 1 $f
321     stripe_index=$($LFS getstripe -i $f)
322     if [ $stripe_index -ne 1 ]; then
323         $LFS getstripe $f
324         error "$f: stripe_index $stripe_index != 1" && return
325     fi
326
327     do_facet client cp $TMP/$tfile $f
328     sync
329     local osc2dev=`lctl get_param -n devices | grep ${ost2_svc}-osc- | egrep -v 'MDT' | awk '{print $1}'`
330     $LCTL --device $osc2dev deactivate || return 3
331     # my understanding is that there should be nothing in the page
332     # cache after the client reconnects?     
333     rc=0
334     pgcache_empty || rc=2
335     $LCTL --device $osc2dev activate
336     rm -f $f $TMP/$tfile
337     return $rc
338 }
339 run_test 18a "manual ost invalidate clears page cache immediately"
340
341 test_18b() {
342     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
343
344         do_facet_create_file client $TMP/$tfile 20K ||
345                 { error_noexit "Create file $TMP/$tfile" ; return 0; }
346
347     do_facet client mkdir -p $DIR/$tdir
348     f=$DIR/$tdir/$tfile
349
350     cancel_lru_locks osc
351     pgcache_empty || return 1
352
353     $LFS setstripe -i 0 -c 1 $f
354     stripe_index=$($LFS getstripe -i $f)
355     if [ $stripe_index -ne 0 ]; then
356         $LFS getstripe $f
357         error "$f: stripe_index $stripe_index != 0" && return
358     fi
359
360     do_facet client cp $TMP/$tfile $f
361     sync
362     ost_evict_client
363     # allow recovery to complete
364     sleep $((TIMEOUT + 2))
365     # my understanding is that there should be nothing in the page
366     # cache after the client reconnects?     
367     rc=0
368     pgcache_empty || rc=2
369     rm -f $f $TMP/$tfile
370     return $rc
371 }
372 run_test 18b "eviction and reconnect clears page cache (2766)"
373
374 test_18c() {
375     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
376
377         do_facet_create_file client $TMP/$tfile 20K ||
378                 { error_noexit "Create file $TMP/$tfile" ; return 0; }
379
380     do_facet client mkdir -p $DIR/$tdir
381     f=$DIR/$tdir/$tfile
382
383     cancel_lru_locks osc
384     pgcache_empty || return 1
385
386     $LFS setstripe -i 0 -c 1 $f
387     stripe_index=$($LFS getstripe -i $f)
388     if [ $stripe_index -ne 0 ]; then
389         $LFS getstripe $f
390         error "$f: stripe_index $stripe_index != 0" && return
391     fi
392
393     do_facet client cp $TMP/$tfile $f
394     sync
395     ost_evict_client
396
397     # OBD_FAIL_OST_CONNECT_NET2
398     # lost reply to connect request
399     do_facet ost1 lctl set_param fail_loc=0x80000225
400     # force reconnect
401     sleep 1
402     df $MOUNT > /dev/null 2>&1
403     sleep 2
404     # my understanding is that there should be nothing in the page
405     # cache after the client reconnects?     
406     rc=0
407     pgcache_empty || rc=2
408     rm -f $f $TMP/$tfile
409     return $rc
410 }
411 run_test 18c "Dropped connect reply after eviction handing (14755)"
412
413 test_19a() {
414         local BEFORE=`date +%s`
415         local EVICT
416
417         mount_client $DIR2 || error "failed to mount $DIR2"
418
419         # cancel cached locks from OST to avoid eviction from it
420         cancel_lru_locks osc
421
422         do_facet client "stat $DIR > /dev/null"  ||
423                 error "failed to stat $DIR: $?"
424         drop_ldlm_cancel "chmod 0777 $DIR2" ||
425                 error "failed to chmod $DIR2"
426
427         umount_client $DIR2
428
429         # let the client reconnect
430         client_reconnect
431         EVICT=$(do_facet client $LCTL get_param mdc.$FSNAME-MDT*.state | \
432             awk -F"[ [,]" '/EVICTED]$/ { if (mx<$4) {mx=$4;} } END { print mx }')
433
434         [ ! -z "$EVICT" ] && [[ $EVICT -gt $BEFORE ]] ||
435                 (do_facet client $LCTL get_param mdc.$FSNAME-MDT*.state;
436                     error "no eviction: $EVICT before:$BEFORE")
437 }
438 run_test 19a "test expired_lock_main on mds (2867)"
439
440 test_19b() {
441         local BEFORE=`date +%s`
442         local EVICT
443
444         mount_client $DIR2 || error "failed to mount $DIR2: $?"
445
446         # cancel cached locks from MDT to avoid eviction from it
447         cancel_lru_locks mdc
448
449         do_facet client $MULTIOP $DIR/$tfile Ow ||
450                 error "failed to run multiop: $?"
451         drop_ldlm_cancel $MULTIOP $DIR2/$tfile Ow ||
452                 error "failed to ldlm_cancel: $?"
453
454         umount_client $DIR2 || error "failed to unmount $DIR2: $?"
455         do_facet client munlink $DIR/$tfile ||
456                 error "failed to unlink $DIR/$tfile: $?"
457
458         # let the client reconnect
459         client_reconnect
460         EVICT=$(do_facet client $LCTL get_param osc.$FSNAME-OST*.state | \
461             awk -F"[ [,]" '/EVICTED]$/ { if (mx<$4) {mx=$4;} } END { print mx }')
462
463         [ ! -z "$EVICT" ] && [[ $EVICT -gt $BEFORE ]] ||
464                 (do_facet client $LCTL get_param osc.$FSNAME-OST*.state;
465                     error "no eviction: $EVICT before:$BEFORE")
466 }
467 run_test 19b "test expired_lock_main on ost (2867)"
468
469 test_19c() {
470         local BEFORE=`date +%s`
471
472         mount_client $DIR2
473         $LCTL set_param ldlm.namespaces.*.early_lock_cancel=0
474
475         mkdir -p $DIR1/$tfile
476         stat $DIR1/$tfile
477
478 #define OBD_FAIL_PTLRPC_CANCEL_RESEND 0x516
479         do_facet mds $LCTL set_param fail_loc=0x80000516
480
481         touch $DIR2/$tfile/file1 &
482         PID1=$!
483         # let touch to get blocked on the server
484         sleep 2
485
486         wait $PID1
487         $LCTL set_param ldlm.namespaces.*.early_lock_cancel=1
488         umount_client $DIR2
489
490         # let the client reconnect
491         sleep 5
492         EVICT=$(do_facet client $LCTL get_param mdc.$FSNAME-MDT*.state |
493            awk -F"[ [,]" '/EVICTED]$/ { if (mx<$4) {mx=$4;} } END { print mx }')
494
495         [ -z "$EVICT" ] || [[ $EVICT -le $BEFORE ]] || error "eviction happened"
496 }
497 run_test 19c "check reconnect and lock resend do not trigger expired_lock_main"
498
499 test_20a() {    # bug 2983 - ldlm_handle_enqueue cleanup
500         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
501
502         mkdir -p $DIR/$tdir
503         $LFS setstripe -i 0 -c 1 $DIR/$tdir/${tfile}
504         multiop_bg_pause $DIR/$tdir/${tfile} O_wc || return 1
505         MULTI_PID=$!
506         cancel_lru_locks osc
507 #define OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR 0x308
508         do_facet ost1 lctl set_param fail_loc=0x80000308
509         kill -USR1 $MULTI_PID
510         wait $MULTI_PID
511         rc=$?
512         [ $rc -eq 0 ] && error "multiop didn't fail enqueue: rc $rc" || true
513 }
514 run_test 20a "ldlm_handle_enqueue error (should return error)" 
515
516 test_20b() {    # bug 2986 - ldlm_handle_enqueue error during open
517         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
518
519         mkdir -p $DIR/$tdir
520         $LFS setstripe -i 0 -c 1 $DIR/$tdir/${tfile}
521         cancel_lru_locks osc
522 #define OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR 0x308
523         do_facet ost1 lctl set_param fail_loc=0x80000308
524         dd if=/etc/hosts of=$DIR/$tdir/$tfile && \
525                 error "didn't fail open enqueue" || true
526 }
527 run_test 20b "ldlm_handle_enqueue error (should return error)"
528
529 test_21a() {
530        mkdir -p $DIR/$tdir-1
531        mkdir -p $DIR/$tdir-2
532        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
533        close_pid=$!
534
535        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000129"
536        $MULTIOP $DIR/$tdir-2/f Oc &
537        open_pid=$!
538        sleep 1
539        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
540
541        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
542        kill -USR1 $close_pid
543        cancel_lru_locks mdc
544        wait $close_pid || return 1
545        wait $open_pid || return 2
546        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
547
548        $CHECKSTAT -t file $DIR/$tdir-1/f || return 3
549        $CHECKSTAT -t file $DIR/$tdir-2/f || return 4
550
551        rm -rf $DIR/$tdir-*
552 }
553 run_test 21a "drop close request while close and open are both in flight"
554
555 test_21b() {
556        mkdir -p $DIR/$tdir-1
557        mkdir -p $DIR/$tdir-2
558        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
559        close_pid=$!
560
561        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
562        mcreate $DIR/$tdir-2/f &
563        open_pid=$!
564        sleep 1
565        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
566
567        kill -USR1 $close_pid
568        cancel_lru_locks mdc
569        wait $close_pid || return 1
570        wait $open_pid || return 3
571
572        $CHECKSTAT -t file $DIR/$tdir-1/f || return 4
573        $CHECKSTAT -t file $DIR/$tdir-2/f || return 5
574        rm -rf $DIR/$tdir-*
575 }
576 run_test 21b "drop open request while close and open are both in flight"
577
578 test_21c() {
579        mkdir -p $DIR/$tdir-1
580        mkdir -p $DIR/$tdir-2
581        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
582        close_pid=$!
583
584        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
585        mcreate $DIR/$tdir-2/f &
586        open_pid=$!
587        sleep 3
588        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
589
590        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
591        kill -USR1 $close_pid
592        cancel_lru_locks mdc
593        wait $close_pid || return 1
594        wait $open_pid || return 2
595
596        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
597
598        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
599        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
600        rm -rf $DIR/$tdir-*
601 }
602 run_test 21c "drop both request while close and open are both in flight"
603
604 test_21d() {
605        mkdir -p $DIR/$tdir-1
606        mkdir -p $DIR/$tdir-2
607        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
608        pid=$!
609
610        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000129"
611        $MULTIOP $DIR/$tdir-2/f Oc &
612        sleep 1
613        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
614
615        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000122"
616        kill -USR1 $pid
617        cancel_lru_locks mdc
618        wait $pid || return 1
619        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
620
621        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
622        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
623
624        rm -rf $DIR/$tdir-*
625 }
626 run_test 21d "drop close reply while close and open are both in flight"
627
628 test_21e() {
629        mkdir -p $DIR/$tdir-1
630        mkdir -p $DIR/$tdir-2
631        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
632        pid=$!
633
634        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000119"
635        touch $DIR/$tdir-2/f &
636        sleep 1
637        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
638
639        kill -USR1 $pid
640        cancel_lru_locks mdc
641        wait $pid || return 1
642
643        sleep $TIMEOUT
644        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
645        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
646        rm -rf $DIR/$tdir-*
647 }
648 run_test 21e "drop open reply while close and open are both in flight"
649
650 test_21f() {
651        mkdir -p $DIR/$tdir-1
652        mkdir -p $DIR/$tdir-2
653        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
654        pid=$!
655
656        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000119"
657        touch $DIR/$tdir-2/f &
658        sleep 1
659        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
660
661        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000122"
662        kill -USR1 $pid
663        cancel_lru_locks mdc
664        wait $pid || return 1
665        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
666
667        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
668        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
669        rm -rf $DIR/$tdir-*
670 }
671 run_test 21f "drop both reply while close and open are both in flight"
672
673 test_21g() {
674        mkdir -p $DIR/$tdir-1
675        mkdir -p $DIR/$tdir-2
676        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
677        pid=$!
678
679        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000119"
680        touch $DIR/$tdir-2/f &
681        sleep 1
682        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
683
684        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
685        kill -USR1 $pid
686        cancel_lru_locks mdc
687        wait $pid || return 1
688        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
689
690        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
691        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
692        rm -rf $DIR/$tdir-*
693 }
694 run_test 21g "drop open reply and close request while close and open are both in flight"
695
696 test_21h() {
697        mkdir -p $DIR/$tdir-1
698        mkdir -p $DIR/$tdir-2
699        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
700        pid=$!
701
702        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
703        touch $DIR/$tdir-2/f &
704        touch_pid=$!
705        sleep 1
706        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
707
708        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000122"
709        cancel_lru_locks mdc
710        kill -USR1 $pid
711        wait $pid || return 1
712        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
713
714        wait $touch_pid || return 2
715
716        $CHECKSTAT -t file $DIR/$tdir-1/f || return 3
717        $CHECKSTAT -t file $DIR/$tdir-2/f || return 4
718        rm -rf $DIR/$tdir-*
719 }
720 run_test 21h "drop open request and close reply while close and open are both in flight"
721
722 # bug 3462 - multiple MDC requests
723 test_22() {
724     f1=$DIR/${tfile}-1
725     f2=$DIR/${tfile}-2
726     
727     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
728     $MULTIOP $f2 Oc &
729     close_pid=$!
730
731     sleep 1
732     $MULTIOP $f1 msu || return 1
733
734     cancel_lru_locks mdc
735     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
736
737     wait $close_pid || return 2
738     rm -rf $f2 || return 4
739 }
740 run_test 22 "drop close request and do mknod"
741
742 test_23() { #b=4561
743     multiop_bg_pause $DIR/$tfile O_c || return 1
744     pid=$!
745     # give a chance for open
746     sleep 5
747
748     # try the close
749     drop_request "kill -USR1 $pid"
750
751     fail $SINGLEMDS
752     wait $pid || return 1
753     return 0
754 }
755 run_test 23 "client hang when close a file after mds crash"
756
757 test_24a() { # bug 11710 details correct fsync() behavior
758         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
759
760         mkdir -p $DIR/$tdir
761         $LFS setstripe -i 0 -c 1 $DIR/$tdir
762         cancel_lru_locks osc
763         multiop_bg_pause $DIR/$tdir/$tfile Owy_wyc || return 1
764         MULTI_PID=$!
765         ost_evict_client
766         kill -USR1 $MULTI_PID
767         wait $MULTI_PID
768         rc=$?
769         lctl set_param fail_loc=0x0
770         client_reconnect
771         [ $rc -eq 0 ] &&
772                 error_ignore bz5494 "multiop didn't fail fsync: rc $rc" || true
773 }
774 run_test 24a "fsync error (should return error)"
775
776 wait_client_evicted () {
777         local facet=$1
778         local exports=$2
779         local varsvc=${facet}_svc
780
781         wait_update $(facet_active_host $facet) \
782                 "lctl get_param -n *.${!varsvc}.num_exports | cut -d' ' -f2" \
783                 $((exports - 1)) $3
784 }
785
786 test_24b() {
787         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
788
789         dmesg -c > /dev/null
790         mkdir -p $DIR/$tdir
791         lfs setstripe $DIR/$tdir -s 0 -i 0 -c 1
792         cancel_lru_locks osc
793         multiop_bg_pause $DIR/$tdir/$tfile-1 Ow8192_yc ||
794                 error "mulitop Ow8192_yc failed"
795
796         MULTI_PID1=$!
797         multiop_bg_pause $DIR/$tdir/$tfile-2 Ow8192_c ||
798                 error "mulitop Ow8192_c failed"
799
800         MULTI_PID2=$!
801         ost_evict_client
802
803         kill -USR1 $MULTI_PID1
804         wait $MULTI_PID1
805         rc1=$?
806         kill -USR1 $MULTI_PID2
807         wait $MULTI_PID2
808         rc2=$?
809         lctl set_param fail_loc=0x0
810         client_reconnect
811         [ $rc1 -eq 0 -o $rc2 -eq 0 ] &&
812         error_ignore bz5494 "multiop didn't fail fsync: $rc1 or close: $rc2" ||
813                 true
814
815         dmesg | grep "dirty page discard:" ||
816                 error "no discarded dirty page found!"
817 }
818 run_test 24b "test dirty page discard due to client eviction"
819
820 test_26a() {      # was test_26 bug 5921 - evict dead exports by pinger
821 # this test can only run from a client on a separate node.
822         remote_ost || { skip "local OST" && return 0; }
823         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
824         remote_mds || { skip "local MDS" && return 0; }
825
826         if [ $(facet_host mgs) = $(facet_host ost1) ]; then
827                 skip "msg and ost1 are at the same node"
828                 return 0
829         fi
830
831         check_timeout || return 1
832
833         local OST_NEXP=$(do_facet ost1 lctl get_param -n obdfilter.${ost1_svc}.num_exports | cut -d' ' -f2)
834
835         echo starting with $OST_NEXP OST exports
836 # OBD_FAIL_PTLRPC_DROP_RPC 0x505
837         do_facet client lctl set_param fail_loc=0x505
838         # evictor takes PING_EVICT_TIMEOUT + 3 * PING_INTERVAL to evict.
839         # But if there's a race to start the evictor from various obds,
840         # the loser might have to wait for the next ping.
841
842         local rc=0
843         wait_client_evicted ost1 $OST_NEXP $((TIMEOUT * 2 + TIMEOUT * 3 / 4))
844         rc=$?
845         do_facet client lctl set_param fail_loc=0x0
846         [ $rc -eq 0 ] || error "client not evicted from OST"
847 }
848 run_test 26a "evict dead exports"
849
850 test_26b() {      # bug 10140 - evict dead exports by pinger
851         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
852
853         if [ $(facet_host mgs) = $(facet_host ost1) ]; then
854                 skip "msg and ost1 are at the same node"
855                 return 0
856         fi
857
858         check_timeout || return 1
859         clients_up
860         zconf_mount `hostname` $MOUNT2 ||
861                 { error "Failed to mount $MOUNT2"; return 2; }
862         sleep 1 # wait connections being established
863
864         local MDS_NEXP=$(do_facet $SINGLEMDS lctl get_param -n mdt.${mds1_svc}.num_exports | cut -d' ' -f2)
865         local OST_NEXP=$(do_facet ost1 lctl get_param -n obdfilter.${ost1_svc}.num_exports | cut -d' ' -f2)
866
867         echo starting with $OST_NEXP OST and $MDS_NEXP MDS exports
868
869         zconf_umount `hostname` $MOUNT2 -f
870
871         # PING_INTERVAL max(obd_timeout / 4, 1U)
872         # PING_EVICT_TIMEOUT (PING_INTERVAL * 6)
873
874         # evictor takes PING_EVICT_TIMEOUT + 3 * PING_INTERVAL to evict.  
875         # But if there's a race to start the evictor from various obds, 
876         # the loser might have to wait for the next ping.
877         # = 9 * PING_INTERVAL + PING_INTERVAL
878         # = 10 PING_INTERVAL = 10 obd_timeout / 4 = 2.5 obd_timeout
879         # let's wait $((TIMEOUT * 3)) # bug 19887
880         local rc=0
881         wait_client_evicted ost1 $OST_NEXP $((TIMEOUT * 3)) || \
882                 error "Client was not evicted by ost" rc=1
883         wait_client_evicted $SINGLEMDS $MDS_NEXP $((TIMEOUT * 3)) || \
884                 error "Client was not evicted by mds"
885 }
886 run_test 26b "evict dead exports"
887
888 test_27() {
889         mkdir -p $DIR/$tdir
890         writemany -q -a $DIR/$tdir/$tfile 0 5 &
891         CLIENT_PID=$!
892         sleep 1
893         local save_FAILURE_MODE=$FAILURE_MODE
894         FAILURE_MODE="SOFT"
895         facet_failover $SINGLEMDS
896 #define OBD_FAIL_OSC_SHUTDOWN            0x407
897         do_facet $SINGLEMDS lctl set_param fail_loc=0x80000407
898         # need to wait for reconnect
899         echo waiting for fail_loc
900         wait_update_facet $SINGLEMDS "lctl get_param -n fail_loc" "-2147482617"
901         facet_failover $SINGLEMDS
902         #no crashes allowed!
903         kill -USR1 $CLIENT_PID
904         wait $CLIENT_PID 
905         true
906         FAILURE_MODE=$save_FAILURE_MODE
907 }
908 run_test 27 "fail LOV while using OSC's"
909
910 test_28() {      # bug 6086 - error adding new clients
911         do_facet client mcreate $DIR/$tfile       || return 1
912         drop_bl_callback "chmod 0777 $DIR/$tfile" ||echo "evicted as expected"
913         #define OBD_FAIL_MDS_CLIENT_ADD 0x12f
914         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000012f"
915         # fail once (evicted), reconnect fail (fail_loc), ok
916         client_up || (sleep 10; client_up) || (sleep 10; client_up) || error "reconnect failed"
917         rm -f $DIR/$tfile
918         fail $SINGLEMDS         # verify MDS last_rcvd can be loaded
919 }
920 run_test 28 "handle error adding new clients (bug 6086)"
921
922 test_29a() { # bug 22273 - error adding new clients
923         #define OBD_FAIL_TGT_CLIENT_ADD 0x711
924         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000711"
925         # fail abort so client will be new again
926         fail_abort $SINGLEMDS
927         client_up || error "reconnect failed"
928         wait_osc_import_state $SINGLEMDS ost FULL
929         return 0
930 }
931 run_test 29a "error adding new clients doesn't cause LBUG (bug 22273)"
932
933 test_29b() { # bug 22273 - error adding new clients
934         #define OBD_FAIL_TGT_CLIENT_ADD 0x711
935         do_facet ost1 "lctl set_param fail_loc=0x80000711"
936         # fail abort so client will be new again
937         fail_abort ost1
938         client_up || error "reconnect failed"
939         return 0
940 }
941 run_test 29b "error adding new clients doesn't cause LBUG (bug 22273)"
942
943 test_50() {
944         mkdir -p $DIR/$tdir
945         # put a load of file creates/writes/deletes
946         writemany -q $DIR/$tdir/$tfile 0 5 &
947         CLIENT_PID=$!
948         echo writemany pid $CLIENT_PID
949         sleep 10
950         FAILURE_MODE="SOFT"
951         fail $SINGLEMDS
952         # wait for client to reconnect to MDS
953         sleep 60
954         fail $SINGLEMDS
955         sleep 60
956         fail $SINGLEMDS
957         # client process should see no problems even though MDS went down
958         sleep $TIMEOUT
959         kill -USR1 $CLIENT_PID
960         wait $CLIENT_PID 
961         rc=$?
962         echo writemany returned $rc
963         #these may fail because of eviction due to slow AST response.
964         [ $rc -eq 0 ] ||
965                 error_ignore bz13652 "writemany returned rc $rc" || true
966 }
967 run_test 50 "failover MDS under load"
968
969 test_51() {
970         #define OBD_FAIL_MDS_SYNC_CAPA_SL                    0x1310
971         do_facet ost1 lctl set_param fail_loc=0x00001310
972
973         mkdir -p $DIR/$tdir
974         # put a load of file creates/writes/deletes
975         writemany -q $DIR/$tdir/$tfile 0 5 &
976         CLIENT_PID=$!
977         sleep 1
978         FAILURE_MODE="SOFT"
979         facet_failover $SINGLEMDS
980         # failover at various points during recovery
981         SEQ="1 5 10 $(seq $TIMEOUT 5 $(($TIMEOUT+10)))"
982         echo will failover at $SEQ
983         for i in $SEQ
984         do
985                 #echo failover in $i sec
986                 log "test_$testnum: failover in $i sec"
987                 sleep $i
988                 facet_failover $SINGLEMDS
989         done
990         # client process should see no problems even though MDS went down
991         # and recovery was interrupted
992         sleep $TIMEOUT
993         kill -USR1 $CLIENT_PID
994         wait $CLIENT_PID
995         rc=$?
996         echo writemany returned $rc
997         [ $rc -eq 0 ] ||
998                 error_ignore bz13652 "writemany returned rc $rc" || true
999 }
1000 run_test 51 "failover MDS during recovery"
1001
1002 test_52_guts() {
1003         do_facet client "mkdir -p $DIR/$tdir"
1004         do_facet client "writemany -q -a $DIR/$tdir/$tfile 300 5" &
1005         CLIENT_PID=$!
1006         echo writemany pid $CLIENT_PID
1007         sleep 10
1008         FAILURE_MODE="SOFT"
1009         fail ost1
1010         rc=0
1011         wait $CLIENT_PID || rc=$?
1012         # active client process should see an EIO for down OST
1013         [ $rc -eq 5 ] && { echo "writemany correctly failed $rc" && return 0; }
1014         # but timing or failover setup may allow success
1015         [ $rc -eq 0 ] && { echo "writemany succeeded" && return 0; }
1016         echo "writemany returned $rc"
1017         return $rc
1018 }
1019
1020 test_52() {
1021         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1022
1023         mkdir -p $DIR/$tdir
1024         test_52_guts
1025         rc=$?
1026         [ $rc -ne 0 ] && { return $rc; }
1027         # wait for client to reconnect to OST
1028         sleep 30
1029         test_52_guts
1030         rc=$?
1031         [ $rc -ne 0 ] && { return $rc; }
1032         sleep 30
1033         test_52_guts
1034         rc=$?
1035         client_reconnect
1036         #return $rc
1037 }
1038 run_test 52 "failover OST under load"
1039
1040 # test of open reconstruct
1041 test_53() {
1042         touch $DIR/$tfile
1043         drop_ldlm_reply "openfile -f O_RDWR:O_CREAT -m 0755 $DIR/$tfile" ||\
1044                 return 2
1045 }
1046 run_test 53 "touch: drop rep"
1047
1048 test_54() {
1049         zconf_mount `hostname` $MOUNT2
1050         touch $DIR/$tfile
1051         touch $DIR2/$tfile.1
1052         sleep 10
1053         cat $DIR2/$tfile.missing # save transno = 0, rc != 0 into last_rcvd
1054         fail $SINGLEMDS
1055         umount $MOUNT2
1056         ERROR=`dmesg | egrep "(test 54|went back in time)" | tail -n1 | grep "went back in time"`
1057         [ x"$ERROR" == x ] || error "back in time occured"
1058 }
1059 run_test 54 "back in time"
1060
1061 # bug 11330 - liblustre application death during I/O locks up OST
1062 test_55() {
1063         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1064
1065         mkdir -p $DIR/$tdir
1066
1067         # Minimum pass speed is 2MBps
1068         local ddtimeout=64
1069         # LU-2887/LU-3089 - set min pass speed to 500KBps
1070         [ "$(facet_fstype ost1)" = "zfs" ] && ddtimeout=256
1071
1072         # first dd should be finished quickly
1073         $LFS setstripe -c 1 -i 0 $DIR/$tdir/$tfile-1
1074         dd if=/dev/zero of=$DIR/$tdir/$tfile-1 bs=32M count=4 &
1075         DDPID=$!
1076         count=0
1077         echo  "step1: testing ......"
1078         while kill -0 $DDPID 2> /dev/null; do
1079                 let count++
1080                 if [ $count -gt $ddtimeout ]; then
1081                         error "dd should be finished!"
1082                 fi
1083                 sleep 1
1084         done
1085         echo "(dd_pid=$DDPID, time=$count)successful"
1086
1087         $LFS setstripe -c 1 -i 0 $DIR/$tdir/$tfile-2
1088         #define OBD_FAIL_OST_DROP_REQ            0x21d
1089         do_facet ost1 lctl set_param fail_loc=0x0000021d
1090         # second dd will be never finished
1091         dd if=/dev/zero of=$DIR/$tdir/$tfile-2 bs=32M count=4 &
1092         DDPID=$!
1093         count=0
1094         echo  "step2: testing ......"
1095         while [ $count -le $ddtimeout ]; do
1096                 if ! kill -0 $DDPID 2> /dev/null; then
1097                         ls -l $DIR/$tdir
1098                         error "dd shouldn't be finished! (time=$count)"
1099                 fi
1100                 let count++
1101                 sleep 1
1102         done
1103         echo "(dd_pid=$DDPID, time=$count)successful"
1104
1105         #Recover fail_loc and dd will finish soon
1106         do_facet ost1 lctl set_param fail_loc=0
1107         count=0
1108         echo  "step3: testing ......"
1109         while kill -0 $DDPID 2> /dev/null; do
1110                 let count++
1111                 if [ $count -gt $((ddtimeout + 440)) ]; then
1112                         error "dd should be finished!"
1113                 fi
1114                 sleep 1
1115         done
1116         echo "(dd_pid=$DDPID, time=$count)successful"
1117
1118         rm -rf $DIR/$tdir
1119 }
1120 run_test 55 "ost_brw_read/write drops timed-out read/write request"
1121
1122 test_56() { # b=11277
1123 #define OBD_FAIL_MDS_RESEND      0x136
1124         touch $DIR/$tfile
1125         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000136"
1126         stat $DIR/$tfile
1127         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1128         rm -f $DIR/$tfile
1129 }
1130 run_test 56 "do not allow reconnect to busy exports"
1131
1132 test_57_helper() {
1133         # no oscs means no client or mdt 
1134         while lctl get_param osc.*.* > /dev/null 2>&1; do
1135                 : # loop until proc file is removed
1136         done
1137 }
1138
1139 test_57() { # bug 10866
1140         test_57_helper &
1141         pid=$!
1142         sleep 1
1143 #define OBD_FAIL_LPROC_REMOVE            0xB00
1144         lctl set_param fail_loc=0x80000B00
1145         zconf_umount `hostname` $DIR
1146         lctl set_param fail_loc=0x80000B00
1147         fail_abort $SINGLEMDS
1148         kill -9 $pid
1149         lctl set_param fail_loc=0
1150         mount_client $DIR
1151         do_facet client "df $DIR"
1152 }
1153 run_test 57 "read procfs entries causes kernel crash"
1154
1155 test_58() { # bug 11546
1156 #define OBD_FAIL_MDC_ENQUEUE_PAUSE        0x801
1157         touch $DIR/$tfile
1158         ls -la $DIR/$tfile
1159         lctl set_param fail_loc=0x80000801
1160         cp $DIR/$tfile /dev/null &
1161         pid=$!
1162         sleep 1
1163         lctl set_param fail_loc=0
1164         drop_bl_callback rm -f $DIR/$tfile
1165         wait $pid
1166         # the first 'df' could tigger the eviction caused by
1167         # 'drop_bl_callback', and it's normal case.
1168         # but the next 'df' should return successfully.
1169         do_facet client "df $DIR" || do_facet client "df $DIR"
1170 }
1171 run_test 58 "Eviction in the middle of open RPC reply processing"
1172
1173 test_59() { # bug 10589
1174         zconf_mount `hostname` $MOUNT2 || error "Failed to mount $MOUNT2"
1175         echo $DIR2 | grep -q $MOUNT2 || error "DIR2 is not set properly: $DIR2"
1176 #define OBD_FAIL_LDLM_CANCEL_EVICT_RACE  0x311
1177         lctl set_param fail_loc=0x311
1178         writes=$(LANG=C dd if=/dev/zero of=$DIR2/$tfile count=1 2>&1)
1179         [ $? = 0 ] || error "dd write failed"
1180         writes=$(echo $writes | awk  -F '+' '/out/ {print $1}')
1181         lctl set_param fail_loc=0
1182         sync
1183         zconf_umount `hostname` $MOUNT2 -f
1184         reads=$(LANG=C dd if=$DIR/$tfile of=/dev/null 2>&1)
1185         [ $? = 0 ] || error "dd read failed"
1186         reads=$(echo $reads | awk -F '+' '/in/ {print $1}')
1187         [ "$reads" -eq "$writes" ] || error "read" $reads "blocks, must be" $writes
1188 }
1189 run_test 59 "Read cancel race on client eviction"
1190
1191 err17935 () {
1192         # we assume that all md changes are in the MDT0 changelog
1193         if [ $MDSCOUNT -gt 1 ]; then
1194                 error_ignore bz17935 $*
1195         else
1196                 error $*
1197         fi
1198 }
1199
1200 test_60() {
1201         MDT0=$($LCTL get_param -n mdc.*.mds_server_uuid |
1202                 awk '{ gsub(/_UUID/,""); print $1 }' | head -n1)
1203
1204         NUM_FILES=15000
1205         mkdir -p $DIR/$tdir
1206
1207         # Register (and start) changelog
1208         USER=$(do_facet $SINGLEMDS lctl --device $MDT0 changelog_register -n)
1209         echo "Registered as $MDT0 changelog user $USER"
1210
1211         # Generate a large number of changelog entries
1212         createmany -o $DIR/$tdir/$tfile $NUM_FILES
1213         sync
1214         sleep 5
1215
1216         # Unlink files in the background
1217         unlinkmany $DIR/$tdir/$tfile $NUM_FILES &
1218         CLIENT_PID=$!
1219         sleep 1
1220
1221         # Failover the MDS while unlinks are happening
1222         facet_failover $SINGLEMDS
1223
1224         # Wait for unlinkmany to finish
1225         wait $CLIENT_PID
1226
1227         # Check if all the create/unlink events were recorded
1228         # in the changelog
1229         $LFS changelog $MDT0 >> $DIR/$tdir/changelog
1230         local cl_count=$(grep UNLNK $DIR/$tdir/changelog | wc -l)
1231         echo "$cl_count unlinks in $MDT0 changelog"
1232
1233         do_facet $SINGLEMDS lctl --device $MDT0 changelog_deregister $USER
1234         USERS=$(( $(do_facet $SINGLEMDS lctl get_param -n \
1235             mdd.$MDT0.changelog_users | wc -l) - 2 ))
1236         if [ $USERS -eq 0 ]; then
1237             [ $cl_count -eq $NUM_FILES ] || \
1238                 err17935 "Recorded ${cl_count} unlinks out of $NUM_FILES"
1239             # Also make sure we can clear large changelogs
1240             cl_count=$($LFS changelog $FSNAME | wc -l)
1241             [ $cl_count -le 2 ] || \
1242                 error "Changelog not empty: $cl_count entries"
1243         else
1244             # If there are other users, there may be other unlinks in the log
1245             [ $cl_count -ge $NUM_FILES ] || \
1246                 err17935 "Recorded ${cl_count} unlinks out of $NUM_FILES"
1247             echo "$USERS other changelog users; can't verify clear"
1248         fi
1249 }
1250 run_test 60 "Add Changelog entries during MDS failover"
1251
1252 test_61()
1253 {
1254         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS $FSNAME-OST0000)
1255         mdtosc=${mdtosc/-MDT*/-MDT\*}
1256         local cflags="osc.$mdtosc.connect_flags"
1257         do_facet $SINGLEMDS "lctl get_param -n $cflags" |grep -q skip_orphan
1258         [ $? -ne 0 ] && skip "don't have skip orphan feature" && return
1259
1260         mkdir -p $DIR/$tdir || error "mkdir dir $DIR/$tdir failed"
1261         # Set the default stripe of $DIR/$tdir to put the files to ost1
1262         $LFS setstripe -c 1 -i 0 $DIR/$tdir
1263
1264         replay_barrier $SINGLEMDS
1265         createmany -o $DIR/$tdir/$tfile-%d 10 
1266         local oid=`do_facet ost1 "lctl get_param -n obdfilter.${ost1_svc}.last_id"`
1267
1268         fail_abort $SINGLEMDS
1269         
1270         touch $DIR/$tdir/$tfile
1271         local id=`$LFS getstripe $DIR/$tdir/$tfile | awk '$1 == 0 { print $2 }'`
1272         [ $id -le $oid ] && error "the orphan objid was reused, failed"
1273
1274         # Cleanup
1275         rm -rf $DIR/$tdir
1276 }
1277 run_test 61 "Verify to not reuse orphan objects - bug 17025"
1278
1279 # test_62 as seen it b2_1 please do not reuse test_62
1280 #test_62()
1281 #{
1282 #       zconf_umount `hostname` $DIR
1283 #       #define OBD_FAIL_PTLRPC_DELAY_IMP_FULL   0x516
1284 #       lctl set_param fail_loc=0x516
1285 #       mount_client $DIR
1286 #}
1287 #run_test 62 "Verify connection flags race - bug LU-1716"
1288
1289 check_cli_ir_state()
1290 {
1291         local NODE=${1:-$HOSTNAME}
1292         local st
1293         st=$(do_node $NODE "lctl get_param mgc.*.ir_state |
1294                             awk '/imperative_recovery:/ { print \\\$2}'")
1295         [ $st != ON -o $st != OFF -o $st != ENABLED -o $st != DISABLED ] ||
1296                 error "Error state $st, must be ENABLED or DISABLED"
1297         echo -n $st
1298 }
1299
1300 check_target_ir_state()
1301 {
1302         local target=${1}
1303         local name=${target}_svc
1304         local recovery_proc=obdfilter.${!name}.recovery_status
1305         local st
1306
1307         st=$(do_facet $target "lctl get_param -n $recovery_proc |
1308                                awk '/IR:/{ print \\\$2}'")
1309         [ $st != ON -o $st != OFF -o $st != ENABLED -o $st != DISABLED ] ||
1310                 error "Error state $st, must be ENABLED or DISABLED"
1311         echo -n $st
1312 }
1313
1314 set_ir_status()
1315 {
1316         do_facet mgs lctl set_param -n mgs.MGS.live.$FSNAME="state=$1"
1317 }
1318
1319 get_ir_status()
1320 {
1321         local state=$(do_facet mgs "lctl get_param -n mgs.MGS.live.$FSNAME |
1322                                     awk '/state:/{ print \\\$2 }'")
1323         echo -n ${state/,/}
1324 }
1325
1326 nidtbl_version_mgs()
1327 {
1328         local ver=$(do_facet mgs "lctl get_param -n mgs.MGS.live.$FSNAME |
1329                                   awk '/nidtbl_version:/{ print \\\$2 }'")
1330         echo -n $ver
1331 }
1332
1333 # nidtbl_version_client <mds1|client> [node]
1334 nidtbl_version_client()
1335 {
1336         local cli=$1
1337         local node=${2:-$HOSTNAME}
1338
1339         if [ X$cli = Xclient ]; then
1340                 cli=$FSNAME-client
1341         else
1342                 local obdtype=${cli/%[0-9]*/}
1343                 [ $obdtype != mds ] && error "wrong parameters $cli"
1344
1345                 node=$(facet_active_host $cli)
1346                 local t=${cli}_svc
1347                 cli=${!t}
1348         fi
1349
1350         local vers=$(do_node $node "lctl get_param -n mgc.*.ir_state" |
1351                      awk "/$cli/{print \$6}" |sort -u)
1352
1353         # in case there are multiple mounts on the client node
1354         local arr=($vers)
1355         [ ${#arr[@]} -ne 1 ] && error "versions on client node mismatch"
1356         echo -n $vers
1357 }
1358
1359 nidtbl_versions_match()
1360 {
1361         [ $(nidtbl_version_mgs) -eq $(nidtbl_version_client ${1:-client}) ]
1362 }
1363
1364 target_instance_match()
1365 {
1366         local srv=$1
1367         local obdtype
1368         local cliname
1369
1370         obdtype=${srv/%[0-9]*/}
1371         case $obdtype in
1372         mds)
1373                 obdname="mdt"
1374                 cliname="mdc"
1375                 ;;
1376         ost)
1377                 obdname="obdfilter"
1378                 cliname="osc"
1379                 ;;
1380         *)
1381                 error "invalid target type" $srv
1382                 return 1
1383                 ;;
1384         esac
1385
1386         local target=${srv}_svc
1387         local si=$(do_facet $srv lctl get_param -n $obdname.${!target}.instance)
1388         local ci=$(lctl get_param -n $cliname.${!target}-${cliname}-*.import |
1389                 awk '/instance/{ print $2 }' | head -n1)
1390
1391         return $([ $si -eq $ci ])
1392 }
1393
1394 test_100()
1395 {
1396         do_facet mgs $LCTL list_param mgs.*.ir_timeout ||
1397                 { skip "MGS without IR support"; return 0; }
1398
1399         # MDT was just restarted in the previous test, make sure everything
1400         # is all set.
1401         local cnt=30
1402         while [ $cnt -gt 0 ]; do
1403                 nidtbl_versions_match && break
1404                 sleep 1
1405                 cnt=$((cnt - 1))
1406         done
1407
1408         # disable IR
1409         set_ir_status disabled
1410
1411         local prev_ver=$(nidtbl_version_client client)
1412
1413         local saved_FAILURE_MODE=$FAILURE_MODE
1414         [ $(facet_host mgs) = $(facet_host ost1) ] && FAILURE_MODE="SOFT"
1415         fail ost1
1416
1417         # valid check
1418         [ $(nidtbl_version_client client) -eq $prev_ver ] ||
1419                 error "version must not change due to IR disabled"
1420         target_instance_match ost1 || error "instance mismatch"
1421
1422         # restore env
1423         set_ir_status full
1424         FAILURE_MODE=$saved_FAILURE_MODE
1425 }
1426 run_test 100 "IR: Make sure normal recovery still works w/o IR"
1427
1428 test_101()
1429 {
1430         do_facet mgs $LCTL list_param mgs.*.ir_timeout ||
1431                 { skip "MGS without IR support"; return 0; }
1432
1433         set_ir_status full
1434
1435         local OST1_IMP=$(get_osc_import_name client ost1)
1436
1437         # disable pinger recovery
1438         lctl set_param -n osc.$OST1_IMP.pinger_recov=0
1439
1440         fail ost1
1441
1442         target_instance_match ost1 || error "instance mismatch"
1443         nidtbl_versions_match || error "version must match"
1444
1445         lctl set_param -n osc.$OST1_IMP.pinger_recov=1
1446 }
1447 run_test 101 "IR: Make sure IR works w/o normal recovery"
1448
1449 test_102()
1450 {
1451         do_facet mgs $LCTL list_param mgs.*.ir_timeout ||
1452                 { skip "MGS without IR support"; return 0; }
1453
1454         local clients=${CLIENTS:-$HOSTNAME}
1455         local old_version
1456         local new_version
1457         local mgsdev=mgs
1458
1459         set_ir_status full
1460
1461         # let's have a new nidtbl version
1462         fail ost1
1463
1464         # sleep for a while so that clients can see the failure of ost
1465         # it must be MGC_TIMEOUT_MIN_SECONDS + MGC_TIMEOUT_RAND_CENTISEC.
1466         # int mgc_request.c:
1467         # define MGC_TIMEOUT_MIN_SECONDS   5
1468         # define MGC_TIMEOUT_RAND_CENTISEC 0x1ff /* ~500 *
1469         local count=30  # 20 seconds at most
1470         while [ $count -gt 0 ]; do
1471                 nidtbl_versions_match && break
1472                 sleep 1
1473                 count=$((count-1))
1474         done
1475
1476         nidtbl_versions_match || error "nidtbl mismatch"
1477
1478         # get the version #
1479         old_version=$(nidtbl_version_client client)
1480
1481         zconf_umount_clients $clients $MOUNT || error "Cannot umount client"
1482
1483         # restart mgs
1484         combined_mgs_mds && mgsdev=mds1
1485         remount_facet $mgsdev
1486         fail ost1
1487
1488         zconf_mount_clients $clients $MOUNT || error "Cannot mount client"
1489
1490         # check new version
1491         new_version=$(nidtbl_version_client client)
1492         [ $new_version -lt $old_version ] &&
1493                 error "nidtbl version wrong after mgs restarts"
1494         return 0
1495 }
1496 run_test 102 "IR: New client gets updated nidtbl after MGS restart"
1497
1498 test_103()
1499 {
1500         do_facet mgs $LCTL list_param mgs.*.ir_timeout ||
1501                 { skip "MGS without IR support"; return 0; }
1502
1503         combined_mgs_mds && skip "mgs and mds on the same target" && return 0
1504
1505         # workaround solution to generate config log on the mds
1506         remount_facet mds1
1507
1508         stop mgs
1509         stop mds1
1510
1511         # We need this test because mds is like a client in IR context.
1512         start mds1 $(mdsdevname 1) $MDS_MOUNT_OPTS ||
1513                 error "MDS should start w/o mgs"
1514
1515         # start mgs and remount mds w/ ir
1516         start mgs $(mgsdevname) $MGS_MOUNT_OPTS
1517         clients_up
1518
1519         # remount client so that fsdb will be created on the MGS
1520         umount_client $MOUNT || error "umount failed"
1521         mount_client $MOUNT || error "mount failed"
1522
1523         # sleep 30 seconds so the MDS has a chance to detect MGS restarting
1524         local count=30
1525         while [ $count -gt 0 ]; do
1526                 [ $(nidtbl_version_client mds1) -ne 0 ] && break
1527                 sleep 1
1528                 count=$((count-1))
1529         done
1530
1531         # after a while, mds should be able to reconnect to mgs and fetch
1532         # up-to-date nidtbl version
1533         nidtbl_versions_match mds1 || error "mds nidtbl mismatch"
1534
1535         # reset everything
1536         set_ir_status full
1537 }
1538 run_test 103 "IR: MDS can start w/o MGS and get updated nidtbl later"
1539
1540 test_104()
1541 {
1542         do_facet mgs $LCTL list_param mgs.*.ir_timeout ||
1543                 { skip "MGS without IR support"; return 0; }
1544
1545         set_ir_status full
1546
1547         stop ost1
1548         start ost1 $(ostdevname 1) "$OST_MOUNT_OPTS -onoir" ||
1549                 error "OST1 cannot start"
1550         clients_up
1551
1552         local ir_state=$(check_target_ir_state ost1)
1553         [ $ir_state = "DISABLED" -o $ir_state = "OFF" ] ||
1554                 error "ir status on ost1 should be DISABLED"
1555 }
1556 run_test 104 "IR: ost can disable IR voluntarily"
1557
1558 test_105()
1559 {
1560         [ -z "$RCLIENTS" ] && skip "Needs multiple clients" && return 0
1561         do_facet mgs $LCTL list_param mgs.*.ir_timeout ||
1562                 { skip "MGS without IR support"; return 0; }
1563
1564         set_ir_status full
1565
1566         # get one of the clients from client list
1567         local rcli=$(echo $RCLIENTS |cut -d' ' -f 1)
1568
1569         local old_MOUNTOPT=$MOUNTOPT
1570         MOUNTOPT=${MOUNTOPT},noir
1571         zconf_umount $rcli $MOUNT || error "umount failed"
1572         zconf_mount $rcli $MOUNT || error "mount failed"
1573
1574         # make sure lustre mount at $rcli disabling IR
1575         local ir_state=$(check_cli_ir_state $rcli)
1576         [ $ir_state = "DISABLED" -o $ir_state = "OFF" ] ||
1577                 error "IR state must be DISABLED at $rcli"
1578
1579         # Since the client just mounted, its last_rcvd entry is not on disk.
1580         # Send an RPC so exp_need_sync forces last_rcvd to commit this export
1581         # so the client can reconnect during OST recovery (LU-924, LU-1582)
1582         $SETSTRIPE -i 0 $DIR/$tfile
1583         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 conv=sync
1584
1585         # make sure MGS's state is Partial
1586         [ $(get_ir_status) = "partial" ] || error "MGS IR state must be partial"
1587
1588         fail ost1
1589         # make sure IR on ost1 is DISABLED
1590         local ir_state=$(check_target_ir_state ost1)
1591         [ $ir_state = "DISABLED" -o $ir_state = "OFF" ] ||
1592                 error "IR status on ost1 should be DISABLED"
1593
1594         # restore it
1595         MOUNTOPT=$old_MOUNTOPT
1596         zconf_umount $rcli $MOUNT || error "umount failed"
1597         zconf_mount $rcli $MOUNT || error "mount failed"
1598
1599         # make sure MGS's state is full
1600         [ $(get_ir_status) = "full" ] || error "MGS IR status must be full"
1601
1602         fail ost1
1603         # make sure IR on ost1 is ENABLED
1604         local ir_state=$(check_target_ir_state ost1)
1605         [ $ir_state = "ENABLED" -o $ir_state = "ON" ] ||
1606                 error "IR status on ost1 should be ENABLED"
1607
1608         return 0
1609 }
1610 run_test 105 "IR: NON IR clients support"
1611
1612 cleanup_106() {
1613         trap 0
1614         umount_client $DIR2
1615         debugrestore
1616 }
1617
1618 test_106() { # LU-1789
1619         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.3.50) ]] ||
1620                 { skip "Need MDS version at least 2.3.50"; return 0; }
1621
1622 #define OBD_FAIL_MDC_LIGHTWEIGHT         0x805
1623         $LCTL set_param fail_loc=0x805
1624
1625         debugsave
1626         trap cleanup_106 EXIT
1627
1628         # enable lightweight flag on mdc connection
1629         mount_client $DIR2
1630
1631         local MDS_NEXP=$(do_facet $SINGLEMDS \
1632                          lctl get_param -n mdt.${mds1_svc}.num_exports |
1633                          cut -d' ' -f2)
1634         $LCTL set_param fail_loc=0
1635
1636         touch $DIR2/$tfile || error "failed to create empty file"
1637         replay_barrier $SINGLEMDS
1638
1639         $LCTL set_param debug=console
1640         $LCTL clear
1641         facet_failover $SINGLEMDS
1642
1643         # lightweight connection must be evicted
1644         touch -c $DIR2/$tfile || true
1645         $LCTL dk $TMP/lustre-log-$TESTNAME.log
1646         evicted=`awk '/This client was evicted by .*MDT0000/ {
1647                                       print;
1648                       }' $TMP/lustre-log-$TESTNAME.log`
1649         [ -z "$evicted" ] && error "lightweight client not evicted by mds"
1650
1651         # and all operations performed by lightweight client should be
1652         # synchronous, so the file created before mds restart should be there
1653         $CHECKSTAT -t file $DIR/$tfile || error "file not present"
1654         rm -f $DIR/$tfile
1655
1656         cleanup_106
1657 }
1658 run_test 106 "lightweight connection support"
1659
1660 test_107 () {
1661         local CLIENT_PID
1662         local close_pid
1663
1664         mkdir -p $DIR/$tdir
1665         # OBD_FAIL_MDS_REINT_NET_REP   0x119
1666         do_facet $SINGLEMDS lctl set_param fail_loc=0x119
1667         multiop $DIR/$tdir D_c &
1668         close_pid=$!
1669         mkdir $DIR/$tdir/dir_106 &
1670         CLIENT_PID=$!
1671         do_facet $SINGLEMDS lctl set_param fail_loc=0
1672         fail $SINGLEMDS
1673
1674         wait $CLIENT_PID || rc=$?
1675         checkstat -t dir $DIR/$tdir/dir_106 || return 1
1676
1677         kill -USR1 $close_pid
1678         wait $close_pid || return 2
1679
1680         return $rc
1681 }
1682 run_test 107 "drop reint reply, then restart MDT"
1683
1684 test_110a () {
1685         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1686         local remote_dir=$DIR/$tdir/remote_dir
1687         local MDTIDX=1
1688
1689         mkdir -p $DIR/$tdir
1690         drop_request "$LFS mkdir -i $MDTIDX -c2 $remote_dir" ||
1691                                         error "lfs mkdir failed"
1692         local diridx=$($GETSTRIPE -M $remote_dir)
1693         [ $diridx -eq $MDTIDX ] || error "$diridx != $MDTIDX"
1694
1695         rm -rf $DIR/$tdir || error "rmdir failed"
1696 }
1697 run_test 110a "create remote directory: drop client req"
1698
1699 test_110b () {
1700         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1701         local remote_dir=$DIR/$tdir/remote_dir
1702         local MDTIDX=1
1703
1704         mkdir -p $DIR/$tdir
1705         drop_reint_reply "$LFS mkdir -i $MDTIDX -c2 $remote_dir" ||
1706                                         error "lfs mkdir failed"
1707
1708         diridx=$($GETSTRIPE -M $remote_dir)
1709         [ $diridx -eq $MDTIDX ] || error "$diridx != $MDTIDX"
1710
1711         rm -rf $DIR/$tdir || error "rmdir failed"
1712 }
1713 run_test 110b "create remote directory: drop Master rep"
1714
1715 test_110c () {
1716         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1717         local remote_dir=$DIR/$tdir/remote_dir
1718         local MDTIDX=1
1719
1720         mkdir -p $DIR/$tdir
1721         drop_update_reply $MDTIDX "$LFS mkdir -i $MDTIDX -c2 $remote_dir" ||
1722                                                 error "lfs mkdir failed"
1723
1724         diridx=$($GETSTRIPE -M $remote_dir)
1725         [ $diridx -eq $MDTIDX ] || error "$diridx != $MDTIDX"
1726
1727         rm -rf $DIR/$tdir || error "rmdir failed"
1728 }
1729 run_test 110c "create remote directory: drop update rep on slave MDT"
1730
1731 test_110d () {
1732         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1733         local remote_dir=$DIR/$tdir/remote_dir
1734         local MDTIDX=1
1735
1736         mkdir -p $DIR/$tdir
1737         $LFS mkdir -i $MDTIDX -c2 $remote_dir || error "lfs mkdir failed"
1738
1739         drop_request "rm -rf $remote_dir" || error "rm remote dir failed"
1740
1741         rm -rf $DIR/$tdir || error "rmdir failed"
1742
1743         return 0
1744 }
1745 run_test 110d "remove remote directory: drop client req"
1746
1747 test_110e () {
1748         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1749         local remote_dir=$DIR/$tdir/remote_dir
1750         local MDTIDX=1
1751
1752         mkdir -p $DIR/$tdir
1753         $LFS mkdir -i $MDTIDX -c2 $remote_dir  || error "lfs mkdir failed"
1754         drop_reint_reply "rm -rf $remote_dir" || error "rm remote dir failed"
1755
1756         rm -rf $DIR/$tdir || error "rmdir failed"
1757
1758         return 0
1759 }
1760 run_test 110e "remove remote directory: drop master rep"
1761
1762 test_110f () {
1763         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1764         local remote_dir=$DIR/$tdir/remote_dir
1765         local MDTIDX=1
1766
1767         mkdir -p $DIR/$tdir
1768         $LFS mkdir -i $MDTIDX -c2 $remote_dir || error "lfs mkdir failed"
1769         drop_update_reply $MDTIDX "rm -rf $remote_dir" ||
1770                                         error "rm remote dir failed"
1771
1772         rm -rf $DIR/$tdir || error "rmdir failed"
1773 }
1774 run_test 110f "remove remote directory: drop slave rep"
1775
1776 test_110g () {
1777         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1778         local remote_dir=$DIR/$tdir/remote_dir
1779         local MDTIDX=1
1780
1781         mkdir -p $remote_dir
1782
1783         createmany -o $remote_dir/f 100
1784
1785         #define OBD_FAIL_MIGRATE_NET_REP        0x1702
1786         do_facet mds$MDTIDX lctl set_param fail_loc=0x1702
1787         $LFS mv -M $MDTIDX $remote_dir || error "migrate failed"
1788         do_facet mds$MDTIDX lctl set_param fail_loc=0x0
1789
1790         for file in $(find $remote_dir); do
1791                 mdt_index=$($LFS getstripe -M $file)
1792                 [ $mdt_index == $MDTIDX ] ||
1793                         error "$file is not on MDT${MDTIDX}"
1794         done
1795
1796         rm -rf $DIR/$tdir || error "rmdir failed"
1797 }
1798 run_test 110g "drop reply during migration"
1799
1800 # LU-2844 mdt prepare fail should not cause umount oops
1801 test_111 ()
1802 {
1803         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.3.62) ]] ||
1804                 { skip "Need MDS version at least 2.3.62"; return 0; }
1805
1806         local mdsdev=$(mdsdevname ${SINGLEMDS//mds/})
1807 #define OBD_FAIL_MDS_CHANGELOG_INIT 0x151
1808         do_facet $SINGLEMDS lctl set_param fail_loc=0x151
1809         stop $SINGLEMDS || error "stop MDS failed"
1810         start $SINGLEMDS $mdsdev && error "start MDS should fail"
1811         do_facet $SINGLEMDS lctl set_param fail_loc=0
1812         start $SINGLEMDS $mdsdev || error "start MDS failed"
1813 }
1814 run_test 111 "mdd setup fail should not cause umount oops"
1815
1816 # LU-793
1817 test_112a() {
1818         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1819
1820         do_facet_random_file client $TMP/$tfile 100K ||
1821                 error_noexit "Create random file $TMP/$tfile"
1822
1823         pause_bulk "cp $TMP/$tfile $DIR/$tfile" $TIMEOUT ||
1824                 error_noexit "Can't pause_bulk copy"
1825
1826         df $DIR
1827         # expect cmp to succeed, client resent bulk
1828         cmp $TMP/$tfile $DIR/$tfile ||
1829                 error_noexit "Wrong data has been written"
1830         rm $DIR/$tfile ||
1831                 error_noexit "Can't remove file"
1832         rm $TMP/$tfile
1833 }
1834 run_test 112a "bulk resend while orignal request is in progress"
1835
1836 # parameters: fail_loc CMD RC
1837 test_120_reply() {
1838         local PID
1839         local PID2
1840         local rc=5
1841         local fail
1842
1843         #define OBD_FAIL_LDLM_CP_CB_WAIT2       0x320
1844         #define OBD_FAIL_LDLM_CP_CB_WAIT3       0x321
1845         #define OBD_FAIL_LDLM_CP_CB_WAIT4       0x322
1846         #define OBD_FAIL_LDLM_CP_CB_WAIT5       0x323
1847
1848         echo
1849         echo -n "** FLOCK REPLY vs. EVICTION race, lock $2"
1850         [ "$1" = "CLEANUP" ] &&
1851                 fail=0x80000320 && echo ", $1 cp first"
1852         [ "$1" = "REPLY" ] &&
1853                 fail=0x80000321 && echo ", $1 cp first"
1854         [ "$1" = "DEADLOCK CLEANUP" ] &&
1855                 fail=0x80000322 && echo " DEADLOCK, CLEANUP cp first"
1856         [ "$1" = "DEADLOCK REPLY" ] &&
1857                 fail=0x80000323 && echo " DEADLOCK, REPLY cp first"
1858
1859         if [ x"$2" = x"get" ]; then
1860                 #for TEST lock, take a conflict in advance
1861                 # sleep longer than evictor to not confuse fail_loc: 2+2+4
1862                 echo "** Taking conflict **"
1863                 flocks_test 5 set read sleep 10 $DIR/$tfile &
1864                 PID2=$!
1865
1866                 sleep 2
1867         fi
1868
1869         $LCTL set_param fail_loc=$fail
1870
1871         flocks_test 5 $2 write $DIR/$tfile &
1872         PID=$!
1873
1874         sleep 2
1875         echo "** Evicting and re-connecting client **"
1876         mds_evict_client
1877
1878         client_reconnect
1879
1880         if [ x"$2" = x"get" ]; then
1881                 wait $PID2
1882         fi
1883
1884         wait $PID
1885         rc=$?
1886
1887         # check if the return value is allowed
1888         [ $rc -eq $3 ] && rc=0
1889
1890         $LCTL set_param fail_loc=0
1891         return $rc
1892 }
1893
1894 # a lock is taken, unlock vs. cleanup_resource() race for destroying
1895 # the ORIGINAL lock.
1896 test_120_destroy()
1897 {
1898         local PID
1899
1900         flocks_test 5 set write sleep 4 $DIR/$tfile &
1901         PID=$!
1902         sleep 2
1903
1904         # let unlock to sleep in CP CB
1905         $LCTL set_param fail_loc=$1
1906         sleep 4
1907
1908         # let cleanup to cleep in CP CB
1909         mds_evict_client
1910
1911         client_reconnect
1912
1913         wait $PID
1914         rc=$?
1915
1916         $LCTL set_param fail_loc=0
1917         return $rc
1918 }
1919
1920 test_120() {
1921         flock_is_enabled || { skip "mount w/o flock enabled" && return; }
1922         touch $DIR/$tfile
1923
1924         test_120_reply "CLEANUP" set 5 || error "SET race failed"
1925         test_120_reply "CLEANUP" get 5 || error "GET race failed"
1926         test_120_reply "CLEANUP" unlock 5 || error "UNLOCK race failed"
1927
1928         test_120_reply "REPLY" set 5 || error "SET race failed"
1929         test_120_reply "REPLY" get 5 || error "GET race failed"
1930         test_120_reply "REPLY" unlock 5 || error "UNLOCK race failed"
1931
1932         # DEADLOCK tests
1933         test_120_reply "DEADLOCK CLEANUP" set 5 || error "DEADLOCK race failed"
1934         test_120_reply "DEADLOCK REPLY" set 35 || error "DEADLOCK race failed"
1935
1936         test_120_destroy 0x320 || error "unlock-cleanup race failed"
1937 }
1938 run_test 120 "flock race: completion vs. evict"
1939
1940 complete $SECONDS
1941 check_and_cleanup_lustre
1942 exit_status