Whamcloud - gitweb
LU-10143 tests: Add version check for interop
[fs/lustre-release.git] / lustre / tests / replay-single.sh
1 #!/bin/bash
2
3 set -e
4 #set -v
5
6 #
7 # This test needs to be run on the client
8 #
9 SAVE_PWD=$PWD
10 export MULTIOP=${MULTIOP:-multiop}
11 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
12 SETUP=${SETUP:-}
13 CLEANUP=${CLEANUP:-}
14 . $LUSTRE/tests/test-framework.sh
15 init_test_env $@
16 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
17 init_logging
18 CHECK_GRANT=${CHECK_GRANT:-"yes"}
19 GRANT_CHECK_LIST=${GRANT_CHECK_LIST:-""}
20
21 require_dsh_mds || exit 0
22
23 # Skip these tests
24 # bug number for skipped tests:
25 ALWAYS_EXCEPT="$REPLAY_SINGLE_EXCEPT "
26 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
27
28 # time in minutes:                 7.5"
29 [ "$SLOW" = "no" ] && EXCEPT_SLOW="44b"
30
31 if [ $(facet_fstype $SINGLEMDS) = "zfs" ]; then
32 # bug number for skipped test: LU-11388
33         ALWAYS_EXCEPT+="131b"
34 fi
35 if $SHARED_KEY; then
36 # bug number for skipped tests: LU-9795 (all below)
37         ALWAYS_EXCEPT="$ALWAYS_EXCEPT   0b      0c      0d      34      45"
38         ALWAYS_EXCEPT="$ALWAYS_EXCEPT   47      58b     58c     71a     85a"
39         ALWAYS_EXCEPT="$ALWAYS_EXCEPT   85b     86      88      89      90"
40         ALWAYS_EXCEPT="$ALWAYS_EXCEPT   93a     100a    100b    120"
41 fi
42
43 build_test_filter
44
45 check_and_setup_lustre
46
47 mkdir -p $DIR
48
49 assert_DIR
50 rm -rf $DIR/[df][0-9]* $DIR/f.$TESTSUITE.*
51
52 # LU-482 Avert LVM and VM inability to flush caches in pre .33 kernels
53 if [ $LINUX_VERSION_CODE -lt $(version_code 2.6.33) ]; then
54     sync
55     do_facet $SINGLEMDS sync
56 fi
57
58 test_0a() {     # was test_0
59         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
60         replay_barrier $SINGLEMDS
61         fail $SINGLEMDS
62         rmdir $DIR/$tdir
63 }
64 run_test 0a "empty replay"
65
66 test_0b() {
67         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
68
69         # this test attempts to trigger a race in the precreation code,
70         # and must run before any other objects are created on the filesystem
71         fail ost1
72         createmany -o $DIR/$tfile 20 || error "createmany -o $DIR/$tfile failed"
73         unlinkmany $DIR/$tfile 20 || error "unlinkmany $DIR/$tfile failed"
74 }
75 run_test 0b "ensure object created after recover exists. (3284)"
76
77 test_0c() {
78         replay_barrier $SINGLEMDS
79         mcreate $DIR/$tfile
80         umount $MOUNT
81         facet_failover $SINGLEMDS
82         zconf_mount $(hostname) $MOUNT || error "mount fails"
83         client_up || error "post-failover df failed"
84         # file shouldn't exist if replay-barrier works as expected
85         rm $DIR/$tfile && error "File exists and it shouldn't"
86         return 0
87 }
88 run_test 0c "check replay-barrier"
89
90 test_0d() {
91         replay_barrier $SINGLEMDS
92         umount $MOUNT
93         facet_failover $SINGLEMDS
94         zconf_mount $(hostname) $MOUNT || error "mount fails"
95         client_up || error "post-failover df failed"
96 }
97 run_test 0d "expired recovery with no clients"
98
99 test_1() {
100         replay_barrier $SINGLEMDS
101         mcreate $DIR/$tfile
102         fail $SINGLEMDS
103         $CHECKSTAT -t file $DIR/$tfile ||
104                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
105         rm $DIR/$tfile
106 }
107 run_test 1 "simple create"
108
109 test_2a() {
110         replay_barrier $SINGLEMDS
111         touch $DIR/$tfile
112         fail $SINGLEMDS
113         $CHECKSTAT -t file $DIR/$tfile ||
114                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
115         rm $DIR/$tfile
116 }
117 run_test 2a "touch"
118
119 test_2b() {
120         mcreate $DIR/$tfile || error "mcreate $DIR/$tfile failed"
121         replay_barrier $SINGLEMDS
122         touch $DIR/$tfile
123         fail $SINGLEMDS
124         $CHECKSTAT -t file $DIR/$tfile ||
125                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
126         rm $DIR/$tfile
127 }
128 run_test 2b "touch"
129
130 test_2c() {
131         replay_barrier $SINGLEMDS
132         $LFS setstripe -c $OSTCOUNT $DIR/$tfile
133         fail $SINGLEMDS
134         $CHECKSTAT -t file $DIR/$tfile ||
135                 error "$CHECKSTAT $DIR/$tfile check failed"
136 }
137 run_test 2c "setstripe replay"
138
139 test_2d() {
140         [[ $mds1_FSTYPE = "zfs" ]] &&
141                 [[ $MDS1_VERSION -lt $(version_code 2.12.51) ]] &&
142                 skip "requires LU-10143 fix on MDS"
143         replay_barrier $SINGLEMDS
144         $LFS setdirstripe -i 0 -c $MDSCOUNT $DIR/$tdir
145         fail $SINGLEMDS
146         $CHECKSTAT -t dir $DIR/$tdir ||
147                 error "$CHECKSTAT $DIR/$tdir check failed"
148 }
149 run_test 2d "setdirstripe replay"
150
151 test_3a() {
152         local file=$DIR/$tfile
153         replay_barrier $SINGLEMDS
154         mcreate $file
155         openfile -f O_DIRECTORY $file
156         fail $SINGLEMDS
157         $CHECKSTAT -t file $file ||
158                 error "$CHECKSTAT $file attribute check failed"
159         rm $file
160 }
161 run_test 3a "replay failed open(O_DIRECTORY)"
162
163 test_3b() {
164         replay_barrier $SINGLEMDS
165         #define OBD_FAIL_MDS_OPEN_PACK | OBD_FAIL_ONCE
166         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000114"
167         touch $DIR/$tfile
168         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
169         fail $SINGLEMDS
170         $CHECKSTAT -t file $DIR/$tfile &&
171                 error "$CHECKSTAT $DIR/$tfile attribute check should fail"
172         return 0
173 }
174 run_test 3b "replay failed open -ENOMEM"
175
176 test_3c() {
177         replay_barrier $SINGLEMDS
178         #define OBD_FAIL_MDS_ALLOC_OBDO | OBD_FAIL_ONCE
179         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000128"
180         touch $DIR/$tfile
181         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
182         fail $SINGLEMDS
183
184         $CHECKSTAT -t file $DIR/$tfile &&
185                 error "$CHECKSTAT $DIR/$tfile attribute check should fail"
186         return 0
187 }
188 run_test 3c "replay failed open -ENOMEM"
189
190 test_4a() {     # was test_4
191         replay_barrier $SINGLEMDS
192         for i in $(seq 10); do
193                 echo "tag-$i" > $DIR/$tfile-$i
194         done
195         fail $SINGLEMDS
196         for i in $(seq 10); do
197                 grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
198         done
199 }
200 run_test 4a "|x| 10 open(O_CREAT)s"
201
202 test_4b() {
203         for i in $(seq 10); do
204                 echo "tag-$i" > $DIR/$tfile-$i
205         done
206         replay_barrier $SINGLEMDS
207         rm -rf $DIR/$tfile-*
208         fail $SINGLEMDS
209         $CHECKSTAT -t file $DIR/$tfile-* &&
210                 error "$CHECKSTAT $DIR/$tfile-* attribute check should fail" ||
211                 true
212 }
213 run_test 4b "|x| rm 10 files"
214
215 # The idea is to get past the first block of precreated files on both
216 # osts, and then replay.
217 test_5() {
218         replay_barrier $SINGLEMDS
219         for i in $(seq 220); do
220                 echo "tag-$i" > $DIR/$tfile-$i
221         done
222         fail $SINGLEMDS
223         for i in $(seq 220); do
224                 grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
225         done
226         rm -rf $DIR/$tfile-*
227         sleep 3
228         # waiting for commitment of removal
229 }
230 run_test 5 "|x| 220 open(O_CREAT)"
231
232 test_6a() {     # was test_6
233         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
234         replay_barrier $SINGLEMDS
235         mcreate $DIR/$tdir/$tfile
236         fail $SINGLEMDS
237         $CHECKSTAT -t dir $DIR/$tdir ||
238                 error "$CHECKSTAT $DIR/$tdir attribute check failed"
239         $CHECKSTAT -t file $DIR/$tdir/$tfile ||
240                 error "$CHECKSTAT $DIR/$tdir/$tfile attribute check failed"
241         sleep 2
242         # waiting for log process thread
243 }
244 run_test 6a "mkdir + contained create"
245
246 test_6b() {
247         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
248         replay_barrier $SINGLEMDS
249         rm -rf $DIR/$tdir
250         fail $SINGLEMDS
251         $CHECKSTAT -t dir $DIR/$tdir &&
252                 error "$CHECKSTAT $DIR/$tdir attribute check should fail" ||
253                 true
254 }
255 run_test 6b "|X| rmdir"
256
257 test_7() {
258         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
259         replay_barrier $SINGLEMDS
260         mcreate $DIR/$tdir/$tfile
261         fail $SINGLEMDS
262         $CHECKSTAT -t dir $DIR/$tdir ||
263                 error "$CHECKSTAT $DIR/$tdir attribute check failed"
264         $CHECKSTAT -t file $DIR/$tdir/$tfile ||
265                 error "$CHECKSTAT $DIR/$tdir/$tfile attribute check failed"
266         rm -fr $DIR/$tdir
267 }
268 run_test 7 "mkdir |X| contained create"
269
270 test_8() {
271         replay_barrier $SINGLEMDS
272         multiop_bg_pause $DIR/$tfile mo_c ||
273                 error "multiop mknod $DIR/$tfile failed"
274         MULTIPID=$!
275         fail $SINGLEMDS
276         ls $DIR/$tfile
277         $CHECKSTAT -t file $DIR/$tfile ||
278                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
279         kill -USR1 $MULTIPID || error "multiop mknod $MULTIPID not running"
280         wait $MULTIPID || error "multiop mknod $MULTIPID failed"
281         rm $DIR/$tfile
282 }
283 run_test 8 "creat open |X| close"
284
285 test_9() {
286         replay_barrier $SINGLEMDS
287         mcreate $DIR/$tfile
288         local old_inum=$(ls -i $DIR/$tfile | awk '{print $1}')
289         fail $SINGLEMDS
290         local new_inum=$(ls -i $DIR/$tfile | awk '{print $1}')
291
292         echo " old_inum == $old_inum, new_inum == $new_inum"
293         if [ $old_inum -eq $new_inum  ] ;
294         then
295                 echo "old_inum and new_inum match"
296         else
297                 echo " old_inum and new_inum do not match"
298                 error "old index($old_inum) does not match new index($new_inum)"
299         fi
300         rm $DIR/$tfile
301 }
302 run_test 9 "|X| create (same inum/gen)"
303
304 test_10() {
305         mcreate $DIR/$tfile || error "mcreate $DIR/$tfile failed"
306         replay_barrier $SINGLEMDS
307         mv $DIR/$tfile $DIR/$tfile-2
308         rm -f $DIR/$tfile
309         fail $SINGLEMDS
310         $CHECKSTAT $DIR/$tfile &&
311                 error "$CHECKSTAT $DIR/$tfile attribute check should fail"
312         $CHECKSTAT $DIR/$tfile-2 ||
313                 error "$CHECKSTAT $DIR/$tfile-2 attribute check failed"
314         rm $DIR/$tfile-2
315         return 0
316 }
317 run_test 10 "create |X| rename unlink"
318
319 test_11() {
320         mcreate $DIR/$tfile || error "mcreate $DIR/$tfile failed"
321         echo "old" > $DIR/$tfile
322         mv $DIR/$tfile $DIR/$tfile-2
323         replay_barrier $SINGLEMDS
324         echo "new" > $DIR/$tfile
325         grep new $DIR/$tfile
326         grep old $DIR/$tfile-2
327         fail $SINGLEMDS
328         grep new $DIR/$tfile || error "grep $DIR/$tfile failed"
329         grep old $DIR/$tfile-2 || error "grep $DIR/$tfile-2 failed"
330 }
331 run_test 11 "create open write rename |X| create-old-name read"
332
333 test_12() {
334         mcreate $DIR/$tfile || error "mcreate $DIR/$tfile failed"
335         multiop_bg_pause $DIR/$tfile o_tSc ||
336                 error "multiop_bg_pause $DIR/$tfile failed"
337         pid=$!
338         rm -f $DIR/$tfile
339         replay_barrier $SINGLEMDS
340         kill -USR1 $pid || error "multiop $pid not running"
341         wait $pid || error "multiop $pid failed"
342
343         fail $SINGLEMDS
344         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
345         return 0
346 }
347 run_test 12 "open, unlink |X| close"
348
349 # 1777 - replay open after committed chmod that would make
350 #        a regular open a failure
351 test_13() {
352         mcreate $DIR/$tfile || error "mcreate $DIR/$tfile failed"
353         multiop_bg_pause $DIR/$tfile O_wc ||
354                 error "multiop_bg_pause $DIR/$tfile failed"
355         pid=$!
356         chmod 0 $DIR/$tfile
357         $CHECKSTAT -p 0 $DIR/$tfile ||
358                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
359         replay_barrier $SINGLEMDS
360         fail $SINGLEMDS
361         kill -USR1 $pid || error "multiop $pid not running"
362         wait $pid || error "multiop $pid failed"
363
364         $CHECKSTAT -s 1 -p 0 $DIR/$tfile ||
365                 error "second $CHECKSTAT $DIR/$tfile attribute check failed"
366         rm $DIR/$tfile || error "rm $DIR/$tfile failed"
367         return 0
368 }
369 run_test 13 "open chmod 0 |x| write close"
370
371 test_14() {
372         multiop_bg_pause $DIR/$tfile O_tSc ||
373                 error "multiop_bg_pause $DIR/$tfile failed"
374         pid=$!
375         rm -f $DIR/$tfile
376         replay_barrier $SINGLEMDS
377         kill -USR1 $pid || error "multiop $pid not running"
378         wait $pid || error "multiop $pid failed"
379
380         fail $SINGLEMDS
381         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
382         return 0
383 }
384 run_test 14 "open(O_CREAT), unlink |X| close"
385
386 test_15() {
387         multiop_bg_pause $DIR/$tfile O_tSc ||
388                 error "multiop_bg_pause $DIR/$tfile failed"
389         pid=$!
390         rm -f $DIR/$tfile
391         replay_barrier $SINGLEMDS
392         touch $DIR/$tfile-1 || error "touch $DIR/$tfile-1 failed"
393         kill -USR1 $pid || error "multiop $pid not running"
394         wait $pid || error "multiop $pid failed"
395
396         fail $SINGLEMDS
397         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
398         touch $DIR/$tfile-2 || error "touch $DIR/$tfile-2 failed"
399         return 0
400 }
401 run_test 15 "open(O_CREAT), unlink |X|  touch new, close"
402
403 test_16() {
404         replay_barrier $SINGLEMDS
405         mcreate $DIR/$tfile
406         munlink $DIR/$tfile
407         mcreate $DIR/$tfile-2
408         fail $SINGLEMDS
409         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
410         [ -e $DIR/$tfile-2 ] || error "file $DIR/$tfile-2 does not exist"
411         munlink $DIR/$tfile-2 || error "munlink $DIR/$tfile-2 failed"
412 }
413 run_test 16 "|X| open(O_CREAT), unlink, touch new,  unlink new"
414
415 test_17() {
416         replay_barrier $SINGLEMDS
417         multiop_bg_pause $DIR/$tfile O_c ||
418                 error "multiop_bg_pause $DIR/$tfile failed"
419         pid=$!
420         fail $SINGLEMDS
421         kill -USR1 $pid || error "multiop $pid not running"
422         wait $pid || error "multiop $pid failed"
423         $CHECKSTAT -t file $DIR/$tfile ||
424                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
425         rm $DIR/$tfile
426 }
427 run_test 17 "|X| open(O_CREAT), |replay| close"
428
429 test_18() {
430         replay_barrier $SINGLEMDS
431         multiop_bg_pause $DIR/$tfile O_tSc ||
432                 error "multiop_bg_pause $DIR/$tfile failed"
433         pid=$!
434         rm -f $DIR/$tfile
435         touch $DIR/$tfile-2 || error "touch $DIR/$tfile-2 failed"
436         echo "pid: $pid will close"
437         kill -USR1 $pid || error "multiop $pid not running"
438         wait $pid || error "multiop $pid failed"
439
440         fail $SINGLEMDS
441         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
442         [ -e $DIR/$tfile-2 ] || error "file $DIR/$tfile-2 does not exist"
443         # this touch frequently fails
444         touch $DIR/$tfile-3 || error "touch $DIR/$tfile-3 failed"
445         munlink $DIR/$tfile-2 || error "munlink $DIR/$tfile-2 failed"
446         munlink $DIR/$tfile-3 || error "munlink $DIR/$tfile-3 failed"
447         return 0
448 }
449 run_test 18 "open(O_CREAT), unlink, touch new, close, touch, unlink"
450
451 # bug 1855 (a simpler form of test_11 above)
452 test_19() {
453         replay_barrier $SINGLEMDS
454         mcreate $DIR/$tfile
455         echo "old" > $DIR/$tfile
456         mv $DIR/$tfile $DIR/$tfile-2
457         grep old $DIR/$tfile-2
458         fail $SINGLEMDS
459         grep old $DIR/$tfile-2 || error "grep $DIR/$tfile-2 failed"
460 }
461 run_test 19 "mcreate, open, write, rename "
462
463 test_20a() {    # was test_20
464         replay_barrier $SINGLEMDS
465         multiop_bg_pause $DIR/$tfile O_tSc ||
466                 error "multiop_bg_pause $DIR/$tfile failed"
467         pid=$!
468         rm -f $DIR/$tfile
469
470         fail $SINGLEMDS
471         kill -USR1 $pid || error "multiop $pid not running"
472         wait $pid || error "multiop $pid failed"
473         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
474         return 0
475 }
476 run_test 20a "|X| open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
477
478 test_20b() { # bug 10480
479         local wait_timeout=$((TIMEOUT * 4))
480         local extra=$(fs_log_size)
481         local n_attempts=1
482
483         sync_all_data
484         $LFS setstripe -i 0 -c 1 $DIR
485
486         local beforeused=$(df -P $DIR | tail -1 | awk '{ print $3 }')
487
488         dd if=/dev/zero of=$DIR/$tfile bs=4k count=10000 &
489         while [ ! -e $DIR/$tfile ] ; do
490                 usleep 60                       # give dd a chance to start
491         done
492
493         $LFS getstripe $DIR/$tfile || error "$LFS getstripe $DIR/$tfile failed"
494         # make it an orphan
495         rm -f $DIR/$tfile || error "rm -f $DIR/$tfile failed"
496         mds_evict_client
497         client_up || client_up || true          # reconnect
498
499         do_facet $SINGLEMDS "lctl set_param -n osd*.*MDT*.force_sync=1"
500
501         fail $SINGLEMDS                         # start orphan recovery
502         wait_recovery_complete $SINGLEMDS || error "MDS recovery not done"
503         wait_delete_completed $wait_timeout || error "delete did not finish"
504         sync_all_data
505
506         while true; do
507                 local afterused=$(df -P $DIR | tail -1 | awk '{ print $3 }')
508                 log "before $beforeused, after $afterused"
509
510                 (( $beforeused + $extra >= $afterused )) && break
511                 n_attempts=$((n_attempts + 1))
512                 [ $n_attempts -gt 3 ] &&
513                         error "after $afterused > before $beforeused + $extra"
514
515                 wait_zfs_commit $SINGLEMDS 5
516                 sync_all_data
517         done
518 }
519
520 run_test 20b "write, unlink, eviction, replay (test mds_cleanup_orphans)"
521
522 test_20c() { # bug 10480
523         multiop_bg_pause $DIR/$tfile Ow_c ||
524                 error "multiop_bg_pause $DIR/$tfile failed"
525         pid=$!
526
527         ls -la $DIR/$tfile
528
529         mds_evict_client
530         client_up || client_up || true    # reconnect
531
532         kill -USR1 $pid || error "multiop $pid not running"
533         wait $pid || error "multiop $pid failed"
534         [ -s $DIR/$tfile ] || error "File was truncated"
535
536         return 0
537 }
538 run_test 20c "check that client eviction does not affect file content"
539
540 test_21() {
541         replay_barrier $SINGLEMDS
542         multiop_bg_pause $DIR/$tfile O_tSc ||
543                 error "multiop_bg_pause $DIR/$tfile failed"
544         pid=$!
545         rm -f $DIR/$tfile
546         touch $DIR/$tfile-1 || error "touch $DIR/$tfile-1 failed"
547
548         fail $SINGLEMDS
549         kill -USR1 $pid || error "multiop $pid not running"
550         wait $pid || error "multiop $pid failed"
551         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
552         touch $DIR/$tfile-2 || error "touch $DIR/$tfile-2 failed"
553         return 0
554 }
555 run_test 21 "|X| open(O_CREAT), unlink touch new, replay, close (test mds_cleanup_orphans)"
556
557 test_22() {
558         multiop_bg_pause $DIR/$tfile O_tSc ||
559                 error "multiop_bg_pause $DIR/$tfile failed"
560         pid=$!
561
562         replay_barrier $SINGLEMDS
563         rm -f $DIR/$tfile
564
565         fail $SINGLEMDS
566         kill -USR1 $pid || error "multiop $pid not running"
567         wait $pid || error "multiop $pid failed"
568         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
569         return 0
570 }
571 run_test 22 "open(O_CREAT), |X| unlink, replay, close (test mds_cleanup_orphans)"
572
573 test_23() {
574         multiop_bg_pause $DIR/$tfile O_tSc ||
575                 error "multiop_bg_pause $DIR/$tfile failed"
576         pid=$!
577
578         replay_barrier $SINGLEMDS
579         rm -f $DIR/$tfile
580         touch $DIR/$tfile-1 || error "touch $DIR/$tfile-1 failed"
581
582         fail $SINGLEMDS
583         kill -USR1 $pid || error "multiop $pid not running"
584         wait $pid || error "multiop $pid failed"
585         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
586         touch $DIR/$tfile-2 || error "touch $DIR/$tfile-2 failed"
587         return 0
588 }
589 run_test 23 "open(O_CREAT), |X| unlink touch new, replay, close (test mds_cleanup_orphans)"
590
591 test_24() {
592         multiop_bg_pause $DIR/$tfile O_tSc ||
593                 error "multiop_bg_pause $DIR/$tfile failed"
594         pid=$!
595
596         replay_barrier $SINGLEMDS
597         fail $SINGLEMDS
598         rm -f $DIR/$tfile
599         kill -USR1 $pid || error "multiop $pid not running"
600         wait $pid || error "multiop $pid failed"
601         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
602         return 0
603 }
604 run_test 24 "open(O_CREAT), replay, unlink, close (test mds_cleanup_orphans)"
605
606 test_25() {
607         multiop_bg_pause $DIR/$tfile O_tSc ||
608                 error "multiop_bg_pause $DIR/$tfile failed"
609         pid=$!
610         rm -f $DIR/$tfile
611
612         replay_barrier $SINGLEMDS
613         fail $SINGLEMDS
614         kill -USR1 $pid || error "multiop $pid not running"
615         wait $pid || error "multiop $pid failed"
616         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
617         return 0
618 }
619 run_test 25 "open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
620
621 test_26() {
622         replay_barrier $SINGLEMDS
623         multiop_bg_pause $DIR/$tfile-1 O_tSc ||
624                 error "multiop_bg_pause $DIR/$tfile-1 failed"
625         pid1=$!
626         multiop_bg_pause $DIR/$tfile-2 O_tSc ||
627                 error "multiop_bg_pause $DIR/$tfile-2 failed"
628         pid2=$!
629         rm -f $DIR/$tfile-1
630         rm -f $DIR/$tfile-2
631         kill -USR1 $pid2 || error "second multiop $pid2 not running"
632         wait $pid2 || error "second multiop $pid2 failed"
633
634         fail $SINGLEMDS
635         kill -USR1 $pid1 || error "multiop $pid1 not running"
636         wait $pid1 || error "multiop $pid1 failed"
637         [ -e $DIR/$tfile-1 ] && error "file $DIR/$tfile-1 should not exist"
638         [ -e $DIR/$tfile-2 ] && error "file $DIR/$tfile-2 should not exist"
639         return 0
640 }
641 run_test 26 "|X| open(O_CREAT), unlink two, close one, replay, close one (test mds_cleanup_orphans)"
642
643 test_27() {
644         replay_barrier $SINGLEMDS
645         multiop_bg_pause $DIR/$tfile-1 O_tSc ||
646                 error "multiop_bg_pause $DIR/$tfile-1 failed"
647         pid1=$!
648         multiop_bg_pause $DIR/$tfile-2 O_tSc ||
649                 error "multiop_bg_pause $DIR/$tfile-2 failed"
650         pid2=$!
651         rm -f $DIR/$tfile-1
652         rm -f $DIR/$tfile-2
653
654         fail $SINGLEMDS
655         kill -USR1 $pid1 || error "multiop $pid1 not running"
656         wait $pid1 || error "multiop $pid1 failed"
657         kill -USR1 $pid2 || error "second multiop $pid2 not running"
658         wait $pid2 || error "second multiop $pid2 failed"
659         [ -e $DIR/$tfile-1 ] && error "file $DIR/$tfile-1 should not exist"
660         [ -e $DIR/$tfile-2 ] && error "file $DIR/$tfile-2 should not exist"
661         return 0
662 }
663 run_test 27 "|X| open(O_CREAT), unlink two, replay, close two (test mds_cleanup_orphans)"
664
665 test_28() {
666         multiop_bg_pause $DIR/$tfile-1 O_tSc ||
667                 error "multiop_bg_pause $DIR/$tfile-1 failed"
668         pid1=$!
669         multiop_bg_pause $DIR/$tfile-2 O_tSc ||
670                 error "multiop_bg_pause $DIR/$tfile-2 failed"
671         pid2=$!
672         replay_barrier $SINGLEMDS
673         rm -f $DIR/$tfile-1
674         rm -f $DIR/$tfile-2
675         kill -USR1 $pid2 || error "second multiop $pid2 not running"
676         wait $pid2 || error "second multiop $pid2 failed"
677
678         fail $SINGLEMDS
679         kill -USR1 $pid1 || error "multiop $pid1 not running"
680         wait $pid1 || error "multiop $pid1 failed"
681         [ -e $DIR/$tfile-1 ] && error "file $DIR/$tfile-1 should not exist"
682         [ -e $DIR/$tfile-2 ] && error "file $DIR/$tfile-2 should not exist"
683         return 0
684 }
685 run_test 28 "open(O_CREAT), |X| unlink two, close one, replay, close one (test mds_cleanup_orphans)"
686
687 test_29() {
688         multiop_bg_pause $DIR/$tfile-1 O_tSc ||
689                 error "multiop_bg_pause $DIR/$tfile-1 failed"
690         pid1=$!
691         multiop_bg_pause $DIR/$tfile-2 O_tSc ||
692                 error "multiop_bg_pause $DIR/$tfile-2 failed"
693         pid2=$!
694         replay_barrier $SINGLEMDS
695         rm -f $DIR/$tfile-1
696         rm -f $DIR/$tfile-2
697
698         fail $SINGLEMDS
699         kill -USR1 $pid1 || error "multiop $pid1 not running"
700         wait $pid1 || error "multiop $pid1 failed"
701         kill -USR1 $pid2 || error "second multiop $pid2 not running"
702         wait $pid2 || error "second multiop $pid2 failed"
703         [ -e $DIR/$tfile-1 ] && error "file $DIR/$tfile-1 should not exist"
704         [ -e $DIR/$tfile-2 ] && error "file $DIR/$tfile-2 should not exist"
705         return 0
706 }
707 run_test 29 "open(O_CREAT), |X| unlink two, replay, close two (test mds_cleanup_orphans)"
708
709 test_30() {
710         multiop_bg_pause $DIR/$tfile-1 O_tSc ||
711                 error "multiop_bg_pause $DIR/$tfile-1 failed"
712         pid1=$!
713         multiop_bg_pause $DIR/$tfile-2 O_tSc ||
714                 error "multiop_bg_pause $DIR/$tfile-2 failed"
715         pid2=$!
716         rm -f $DIR/$tfile-1
717         rm -f $DIR/$tfile-2
718
719         replay_barrier $SINGLEMDS
720         fail $SINGLEMDS
721         kill -USR1 $pid1 || error "multiop $pid1 not running"
722         wait $pid1 || error "multiop $pid1 failed"
723         kill -USR1 $pid2 || error "second multiop $pid2 not running"
724         wait $pid2 || error "second multiop $pid2 failed"
725         [ -e $DIR/$tfile-1 ] && error "file $DIR/$tfile-1 should not exist"
726         [ -e $DIR/$tfile-2 ] && error "file $DIR/$tfile-2 should not exist"
727         return 0
728 }
729 run_test 30 "open(O_CREAT) two, unlink two, replay, close two (test mds_cleanup_orphans)"
730
731 test_31() {
732         multiop_bg_pause $DIR/$tfile-1 O_tSc ||
733                 error "multiop_bg_pause $DIR/$tfile-1 failed"
734         pid1=$!
735         multiop_bg_pause $DIR/$tfile-2 O_tSc ||
736                 error "multiop_bg_pause $DIR/$tfile-2 failed"
737         pid2=$!
738         rm -f $DIR/$tfile-1
739
740         replay_barrier $SINGLEMDS
741         rm -f $DIR/$tfile-2
742         fail $SINGLEMDS
743         kill -USR1 $pid1 || error "multiop $pid1 not running"
744         wait $pid1 || error "multiop $pid1 failed"
745         kill -USR1 $pid2 || error "second multiop $pid2 not running"
746         wait $pid2 || error "second multiop $pid2 failed"
747         [ -e $DIR/$tfile-1 ] && error "file $DIR/$tfile-1 should not exist"
748         [ -e $DIR/$tfile-2 ] && error "file $DIR/$tfile-2 should not exist"
749         return 0
750 }
751 run_test 31 "open(O_CREAT) two, unlink one, |X| unlink one, close two (test mds_cleanup_orphans)"
752
753 # tests for bug 2104; completion without crashing is success.  The close is
754 # stale, but we always return 0 for close, so the app never sees it.
755 test_32() {
756         multiop_bg_pause $DIR/$tfile O_c ||
757                 error "multiop_bg_pause $DIR/$tfile failed"
758         pid1=$!
759         multiop_bg_pause $DIR/$tfile O_c ||
760                 error "second multiop_bg_pause $DIR/$tfile failed"
761         pid2=$!
762         mds_evict_client
763         client_up || client_up || error "client_up failed"
764         kill -USR1 $pid1 || error "multiop $pid1 not running"
765         kill -USR1 $pid2 || error "second multiop $pid2 not running"
766         wait $pid1 || error "multiop $pid1 failed"
767         wait $pid2 || error "second multiop $pid2 failed"
768         return 0
769 }
770 run_test 32 "close() notices client eviction; close() after client eviction"
771
772 test_33a() {
773         createmany -o $DIR/$tfile-%d 10 ||
774                 error "createmany create $DIR/$tfile failed"
775         replay_barrier_nosync $SINGLEMDS
776         fail_abort $SINGLEMDS
777         # recreate shouldn't fail
778         createmany -o $DIR/$tfile--%d 10 ||
779                 error "createmany recreate $DIR/$tfile failed"
780         rm $DIR/$tfile-* -f
781         return 0
782 }
783 run_test 33a "fid seq shouldn't be reused after abort recovery"
784
785 test_33b() {
786         #define OBD_FAIL_SEQ_ALLOC                          0x1311
787         do_facet $SINGLEMDS "lctl set_param fail_loc=0x1311"
788
789         createmany -o $DIR/$tfile-%d 10
790         replay_barrier_nosync $SINGLEMDS
791         fail_abort $SINGLEMDS
792         # recreate shouldn't fail
793         createmany -o $DIR/$tfile--%d 10 ||
794                 error "createmany recreate $DIR/$tfile failed"
795         rm $DIR/$tfile-* -f
796         return 0
797 }
798 run_test 33b "test fid seq allocation"
799
800 test_34() {
801         multiop_bg_pause $DIR/$tfile O_c ||
802                 error "multiop_bg_pause $DIR/$tfile failed"
803         pid=$!
804         rm -f $DIR/$tfile
805
806         replay_barrier $SINGLEMDS
807         fail_abort $SINGLEMDS
808         kill -USR1 $pid || error "multiop $pid not running"
809         wait $pid || error "multiop $pid failed"
810         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
811         sync
812         return 0
813 }
814 run_test 34 "abort recovery before client does replay (test mds_cleanup_orphans)"
815
816 # bug 2278 - generate one orphan on OST, then destroy it during recovery from llog
817 test_35() {
818         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
819
820         #define OBD_FAIL_MDS_REINT_NET_REP       0x119
821         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000119"
822         rm -f $DIR/$tfile &
823         sleep 1
824         sync
825         sleep 1
826         # give a chance to remove from MDS
827         fail_abort $SINGLEMDS
828         $CHECKSTAT -t file $DIR/$tfile &&
829                 error "$CHECKSTAT $DIR/$tfile attribute check should fail" ||
830                 true
831 }
832 run_test 35 "test recovery from llog for unlink op"
833
834 # b=2432 resent cancel after replay uses wrong cookie,
835 # so don't resend cancels
836 test_36() {
837         replay_barrier $SINGLEMDS
838         touch $DIR/$tfile
839         checkstat $DIR/$tfile
840         facet_failover $SINGLEMDS
841         cancel_lru_locks mdc
842         if dmesg | grep "unknown lock cookie"; then
843                 error "cancel after replay failed"
844         fi
845 }
846 run_test 36 "don't resend cancel"
847
848 # b=2368
849 # directory orphans can't be unlinked from PENDING directory
850 test_37() {
851         rmdir $DIR/$tfile 2>/dev/null
852         multiop_bg_pause $DIR/$tfile dD_c ||
853                 error "multiop_bg_pause $DIR/$tfile failed"
854         pid=$!
855         rmdir $DIR/$tfile
856
857         replay_barrier $SINGLEMDS
858         # clear the dmesg buffer so we only see errors from this recovery
859         do_facet $SINGLEMDS dmesg -c >/dev/null
860         fail_abort $SINGLEMDS
861         kill -USR1 $pid || error "multiop $pid not running"
862         do_facet $SINGLEMDS dmesg | grep "error .* unlinking .* from PENDING" &&
863                 error "error unlinking files"
864         wait $pid || error "multiop $pid failed"
865         sync
866         return 0
867 }
868 run_test 37 "abort recovery before client does replay (test mds_cleanup_orphans for directories)"
869
870 test_38() {
871         createmany -o $DIR/$tfile-%d 800 ||
872                 error "createmany -o $DIR/$tfile failed"
873         unlinkmany $DIR/$tfile-%d 0 400 || error "unlinkmany $DIR/$tfile failed"
874         replay_barrier $SINGLEMDS
875         fail $SINGLEMDS
876         unlinkmany $DIR/$tfile-%d 400 400 ||
877                 error "unlinkmany $DIR/$tfile 400 failed"
878         sleep 2
879         $CHECKSTAT -t file $DIR/$tfile-* &&
880                 error "$CHECKSTAT $DIR/$tfile-* attribute check should fail" ||
881                 true
882 }
883 run_test 38 "test recovery from unlink llog (test llog_gen_rec) "
884
885 test_39() { # bug 4176
886         createmany -o $DIR/$tfile-%d 800 ||
887                 error "createmany -o $DIR/$tfile failed"
888         replay_barrier $SINGLEMDS
889         unlinkmany $DIR/$tfile-%d 0 400
890         fail $SINGLEMDS
891         unlinkmany $DIR/$tfile-%d 400 400 ||
892                 error "unlinkmany $DIR/$tfile 400 failed"
893         sleep 2
894         $CHECKSTAT -t file $DIR/$tfile-* &&
895                 error "$CHECKSTAT $DIR/$tfile-* attribute check should fail" ||
896                 true
897 }
898 run_test 39 "test recovery from unlink llog (test llog_gen_rec) "
899
900 count_ost_writes() {
901     lctl get_param -n osc.*.stats | awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }'
902 }
903
904 #b=2477,2532
905 test_40(){
906         # always need connection to MDS to verify layout during IO. LU-2628.
907         lctl get_param mdc.*.connect_flags | grep -q layout_lock &&
908                 skip "layout_lock needs MDS connection for IO" && return 0
909
910         $LCTL mark multiop $MOUNT/$tfile OS_c
911         multiop $MOUNT/$tfile OS_c  &
912         PID=$!
913         writeme -s $MOUNT/${tfile}-2 &
914         WRITE_PID=$!
915         sleep 1
916         facet_failover $SINGLEMDS
917         #define OBD_FAIL_MDS_CONNECT_NET         0x117
918         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000117"
919         kill -USR1 $PID
920         stat1=$(count_ost_writes)
921         sleep $TIMEOUT
922         stat2=$(count_ost_writes)
923         echo "$stat1, $stat2"
924         if [ $stat1 -lt $stat2 ]; then
925                 echo "writes continuing during recovery"
926                 RC=0
927         else
928                 echo "writes not continuing during recovery, bug 2477"
929                 RC=4
930         fi
931         echo "waiting for writeme $WRITE_PID"
932         kill $WRITE_PID
933         wait $WRITE_PID
934
935         echo "waiting for multiop $PID"
936         wait $PID || error "multiop $PID failed"
937         do_facet client munlink $MOUNT/$tfile  ||
938                 error "munlink $MOUNT/$tfile failed"
939         do_facet client munlink $MOUNT/${tfile}-2  ||
940                 error "munlink $MOUNT/$tfile-2 failed"
941         return $RC
942 }
943 run_test 40 "cause recovery in ptlrpc, ensure IO continues"
944
945 #b=2814
946 # make sure that a read to one osc doesn't try to double-unlock its page just
947 # because another osc is invalid.  trigger_group_io used to mistakenly return
948 # an error if any oscs were invalid even after having successfully put rpcs
949 # on valid oscs.  This was fatal if the caller was ll_readpage who unlocked
950 # the page, guarnateeing that the unlock from the RPC completion would
951 # assert on trying to unlock the unlocked page.
952 test_41() {
953         [ $OSTCOUNT -lt 2 ] && skip_env "needs >= 2 OSTs" && return
954
955         local f=$MOUNT/$tfile
956         # make sure the start of the file is ost1
957         $LFS setstripe -S $((128 * 1024)) -i 0 $f
958         do_facet client dd if=/dev/zero of=$f bs=4k count=1 ||
959                 error "dd on client failed"
960         cancel_lru_locks osc
961         # fail ost2 and read from ost1
962         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS $ost2_svc)
963         local osc2dev=$(do_facet $SINGLEMDS "lctl get_param -n devices" |
964                 grep $mdtosc | awk '{print $1}')
965         [ -z "$osc2dev" ] && echo "OST: $ost2_svc" &&
966                 lctl get_param -n devices &&
967                 error "OST 2 $osc2dev does not exist"
968         do_facet $SINGLEMDS $LCTL --device $osc2dev deactivate ||
969                 error "deactive device on $SINGLEMDS failed"
970         do_facet client dd if=$f of=/dev/null bs=4k count=1 ||
971                 error "second dd on client failed"
972         do_facet $SINGLEMDS $LCTL --device $osc2dev activate ||
973                 error "active device on $SINGLEMDS failed"
974         return 0
975 }
976 run_test 41 "read from a valid osc while other oscs are invalid"
977
978 # test MDS recovery after ost failure
979 test_42() {
980         blocks=$(df -P $MOUNT | tail -n 1 | awk '{ print $2 }')
981         createmany -o $DIR/$tfile-%d 800 ||
982                 error "createmany -o $DIR/$tfile failed"
983         replay_barrier ost1
984         unlinkmany $DIR/$tfile-%d 0 400
985         debugsave
986         lctl set_param debug=-1
987         facet_failover ost1
988
989         # osc is evicted, fs is smaller (but only with failout OSTs (bug 7287)
990         #blocks_after=`df -P $MOUNT | tail -n 1 | awk '{ print $2 }'`
991         #[ $blocks_after -lt $blocks ] || return 1
992         echo "wait for MDS to timeout and recover"
993         sleep $((TIMEOUT * 2))
994         debugrestore
995         unlinkmany $DIR/$tfile-%d 400 400 ||
996                 error "unlinkmany $DIR/$tfile 400 failed"
997         $CHECKSTAT -t file $DIR/$tfile-* &&
998                 error "$CHECKSTAT $DIR/$tfile-* attribute check should fail" ||
999                 true
1000 }
1001 run_test 42 "recovery after ost failure"
1002
1003 # timeout in MDS/OST recovery RPC will LBUG MDS
1004 test_43() { # bug 2530
1005         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1006
1007         replay_barrier $SINGLEMDS
1008
1009         # OBD_FAIL_OST_CREATE_NET 0x204
1010         do_facet ost1 "lctl set_param fail_loc=0x80000204"
1011         fail $SINGLEMDS
1012         sleep 10
1013
1014         return 0
1015 }
1016 run_test 43 "mds osc import failure during recovery; don't LBUG"
1017
1018 test_44a() { # was test_44
1019         local at_max_saved=0
1020
1021         local mdcdev=$($LCTL dl |
1022                 awk "/${FSNAME}-MDT0000-mdc-/ {if (\$2 == \"UP\") {print \$1}}")
1023         [ "$mdcdev" ] || error "${FSNAME}-MDT0000-mdc- not UP"
1024         [ $(echo $mdcdev | wc -w) -eq 1 ] ||
1025                 { $LCTL dl; error "looking for mdcdev=$mdcdev"; }
1026
1027         # adaptive timeouts slow this way down
1028         if at_is_enabled; then
1029                 at_max_saved=$(at_max_get mds)
1030                 at_max_set 40 mds
1031         fi
1032
1033         for i in $(seq 1 10); do
1034                 echo "$i of 10 ($(date +%s))"
1035                 do_facet $SINGLEMDS \
1036                         "lctl get_param -n md[ts].*.mdt.timeouts | grep service"
1037                 #define OBD_FAIL_TGT_CONN_RACE     0x701
1038                 do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000701"
1039                 # lctl below may fail, it is valid case
1040                 $LCTL --device $mdcdev recover
1041                 $LFS df $MOUNT
1042         done
1043         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1044         [ $at_max_saved -ne 0 ] && at_max_set $at_max_saved mds
1045         return 0
1046 }
1047 run_test 44a "race in target handle connect"
1048
1049 test_44b() {
1050         local mdcdev=$($LCTL dl |
1051                 awk "/${FSNAME}-MDT0000-mdc-/ {if (\$2 == \"UP\") {print \$1}}")
1052         [ "$mdcdev" ] || error "${FSNAME}-MDT0000-mdc not up"
1053         [ $(echo $mdcdev | wc -w) -eq 1 ] ||
1054                 { echo mdcdev=$mdcdev; $LCTL dl;
1055                   error "more than one ${FSNAME}-MDT0000-mdc"; }
1056
1057         for i in $(seq 1 10); do
1058                 echo "$i of 10 ($(date +%s))"
1059                 do_facet $SINGLEMDS \
1060                         "lctl get_param -n md[ts].*.mdt.timeouts | grep service"
1061                 #define OBD_FAIL_TGT_DELAY_RECONNECT 0x704
1062                 do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000704"
1063                 # lctl below may fail, it is valid case
1064                 $LCTL --device $mdcdev recover
1065                 df $MOUNT
1066         done
1067         return 0
1068 }
1069 run_test 44b "race in target handle connect"
1070
1071 test_44c() {
1072         replay_barrier $SINGLEMDS
1073         createmany -m $DIR/$tfile-%d 100 || error "failed to create directories"
1074         #define OBD_FAIL_TGT_RCVG_FLAG 0x712
1075         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000712"
1076         fail_abort $SINGLEMDS
1077         unlinkmany $DIR/$tfile-%d 100 && error "unliked after fail abort"
1078         fail $SINGLEMDS
1079         unlinkmany $DIR/$tfile-%d 100 && error "unliked after fail"
1080         return 0
1081 }
1082 run_test 44c "race in target handle connect"
1083
1084 # Handle failed close
1085 test_45() {
1086         local mdcdev=$($LCTL get_param -n devices |
1087                 awk "/ ${FSNAME}-MDT0000-mdc-/ {print \$1}")
1088         [ "$mdcdev" ] || error "${FSNAME}-MDT0000-mdc not up"
1089         [ $(echo $mdcdev | wc -w) -eq 1 ] ||
1090                 { echo mdcdev=$mdcdev; $LCTL dl;
1091                   error "more than one ${FSNAME}-MDT0000-mdc"; }
1092
1093         $LCTL --device $mdcdev recover ||
1094                 error "$LCTL --device $mdcdev recover failed"
1095
1096         multiop_bg_pause $DIR/$tfile O_c ||
1097                 error "multiop_bg_pause $DIR/$tfile failed"
1098         pid=$!
1099
1100         # This will cause the CLOSE to fail before even
1101         # allocating a reply buffer
1102         $LCTL --device $mdcdev deactivate ||
1103                 error "$LCTL --device $mdcdev deactivate failed"
1104
1105         # try the close
1106         kill -USR1 $pid || error "multiop $pid not running"
1107         wait $pid || error "multiop $pid failed"
1108
1109         $LCTL --device $mdcdev activate ||
1110                 error "$LCTL --device $mdcdev activate failed"
1111         sleep 1
1112
1113         $CHECKSTAT -t file $DIR/$tfile ||
1114                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
1115         return 0
1116 }
1117 run_test 45 "Handle failed close"
1118
1119 test_46() {
1120         dmesg -c >/dev/null
1121         drop_reply "touch $DIR/$tfile"
1122         fail $SINGLEMDS
1123         # ironically, the previous test, 45, will cause a real forced close,
1124         # so just look for one for this test
1125         dmesg | grep -i "force closing client file handle for $tfile" &&
1126                 error "found force closing in dmesg"
1127         return 0
1128 }
1129 run_test 46 "Don't leak file handle after open resend (3325)"
1130
1131 test_47() { # bug 2824
1132         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1133
1134         # create some files to make sure precreate has been done on all
1135         # OSTs. (just in case this test is run independently)
1136         createmany -o $DIR/$tfile 20  ||
1137                 error "createmany create $DIR/$tfile failed"
1138
1139         # OBD_FAIL_OST_CREATE_NET 0x204
1140         fail ost1
1141         do_facet ost1 "lctl set_param fail_loc=0x80000204"
1142         client_up || error "client_up failed"
1143
1144         # let the MDS discover the OST failure, attempt to recover, fail
1145         # and recover again.
1146         sleep $((3 * TIMEOUT))
1147
1148         # Without 2824, this createmany would hang
1149         createmany -o $DIR/$tfile 20 ||
1150                 error "createmany recraete $DIR/$tfile failed"
1151         unlinkmany $DIR/$tfile 20 || error "unlinkmany $DIR/$tfile failed"
1152
1153         return 0
1154 }
1155 run_test 47 "MDS->OSC failure during precreate cleanup (2824)"
1156
1157 test_48() {
1158         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1159         [ "$OSTCOUNT" -lt "2" ] && skip_env "needs >= 2 OSTs" && return
1160
1161         replay_barrier $SINGLEMDS
1162         createmany -o $DIR/$tfile 20  ||
1163                 error "createmany -o $DIR/$tfile failed"
1164         # OBD_FAIL_OST_EROFS 0x216
1165         facet_failover $SINGLEMDS
1166         do_facet ost1 "lctl set_param fail_loc=0x80000216"
1167         client_up || error "client_up failed"
1168
1169         # let the MDS discover the OST failure, attempt to recover, fail
1170         # and recover again.
1171         sleep $((3 * TIMEOUT))
1172
1173         createmany -o $DIR/$tfile 20 20 ||
1174                 error "createmany recraete $DIR/$tfile failed"
1175         unlinkmany $DIR/$tfile 40 || error "unlinkmany $DIR/$tfile failed"
1176         return 0
1177 }
1178 run_test 48 "MDS->OSC failure during precreate cleanup (2824)"
1179
1180 test_50() {
1181         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS $ost1_svc)
1182         local oscdev=$(do_facet $SINGLEMDS "lctl get_param -n devices" |
1183                 grep $mdtosc | awk '{print $1}')
1184         [ "$oscdev" ] || error "could not find OSC device on MDS"
1185         do_facet $SINGLEMDS $LCTL --device $oscdev recover ||
1186                 error "OSC device $oscdev recovery failed"
1187         do_facet $SINGLEMDS $LCTL --device $oscdev recover ||
1188                 error "second OSC device $oscdev recovery failed"
1189         # give the mds_lov_sync threads a chance to run
1190         sleep 5
1191 }
1192 run_test 50 "Double OSC recovery, don't LASSERT (3812)"
1193
1194 # b3764 timed out lock replay
1195 test_52() {
1196         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.6.90) ] &&
1197                 skip "MDS prior to 2.6.90 handle LDLM_REPLY_NET incorrectly" &&
1198                 return 0
1199
1200         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
1201         cancel_lru_locks mdc
1202
1203         multiop_bg_pause $DIR/$tfile s_s || error "multiop $DIR/$tfile failed"
1204         mpid=$!
1205
1206         #define OBD_FAIL_MDS_LDLM_REPLY_NET     0x157
1207         lctl set_param -n ldlm.cancel_unused_locks_before_replay "0"
1208         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000157"
1209
1210         fail $SINGLEMDS || error "fail $SINGLEMDS failed"
1211         kill -USR1 $mpid
1212         wait $mpid || error "multiop_bg_pause pid failed"
1213
1214         do_facet $SINGLEMDS "lctl set_param fail_loc=0x0"
1215         lctl set_param fail_loc=0x0
1216         lctl set_param -n ldlm.cancel_unused_locks_before_replay "1"
1217         rm -f $DIR/$tfile
1218 }
1219 run_test 52 "time out lock replay (3764)"
1220
1221 # bug 3462 - simultaneous MDC requests
1222 test_53a() {
1223         [[ $(lctl get_param mdc.*.import |
1224              grep "connect_flags:.*multi_mod_rpc") ]] ||
1225                 { skip "Need MDC with 'multi_mod_rpcs' feature"; return 0; }
1226
1227         cancel_lru_locks mdc    # cleanup locks from former test cases
1228         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1229         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1230         multiop $DIR/${tdir}-1/f O_c &
1231         close_pid=$!
1232         # give multiop a change to open
1233         sleep 1
1234
1235         #define OBD_FAIL_MDS_CLOSE_NET 0x115
1236         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
1237         kill -USR1 $close_pid
1238         cancel_lru_locks mdc    # force the close
1239         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1240
1241         mcreate $DIR/${tdir}-2/f || error "mcreate $DIR/${tdir}-2/f failed"
1242
1243         # close should still be here
1244         [ -d /proc/$close_pid ] || error "close_pid doesn't exist"
1245
1246         replay_barrier_nodf $SINGLEMDS
1247         fail $SINGLEMDS
1248         wait $close_pid || error "close_pid $close_pid failed"
1249
1250         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1251                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1252         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1253                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1254         rm -rf $DIR/${tdir}-*
1255 }
1256 run_test 53a "|X| close request while two MDC requests in flight"
1257
1258 test_53b() {
1259         cancel_lru_locks mdc    # cleanup locks from former test cases
1260
1261         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1262         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1263         multiop_bg_pause $DIR/${tdir}-1/f O_c ||
1264                 error "multiop_bg_pause $DIR/${tdir}-1/f failed"
1265         close_pid=$!
1266
1267         #define OBD_FAIL_MDS_REINT_NET 0x107
1268         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
1269         mcreate $DIR/${tdir}-2/f &
1270         open_pid=$!
1271         sleep 1
1272
1273         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1274         kill -USR1 $close_pid
1275         cancel_lru_locks mdc    # force the close
1276         wait $close_pid || error "close_pid $close_pid failed"
1277         # open should still be here
1278         [ -d /proc/$open_pid ] || error "open_pid doesn't exist"
1279
1280         replay_barrier_nodf $SINGLEMDS
1281         fail $SINGLEMDS
1282         wait $open_pid || error "open_pid failed"
1283
1284         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1285                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1286         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1287                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1288         rm -rf $DIR/${tdir}-*
1289 }
1290 run_test 53b "|X| open request while two MDC requests in flight"
1291
1292 test_53c() {
1293         cancel_lru_locks mdc    # cleanup locks from former test cases
1294
1295         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1296         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1297         multiop $DIR/${tdir}-1/f O_c &
1298         close_pid=$!
1299
1300         #define OBD_FAIL_MDS_REINT_NET 0x107
1301         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
1302         mcreate $DIR/${tdir}-2/f &
1303         open_pid=$!
1304         sleep 1
1305
1306         #define OBD_FAIL_MDS_CLOSE_NET 0x115
1307         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
1308         kill -USR1 $close_pid
1309         cancel_lru_locks mdc    # force the close
1310
1311         #bz20647: make sure all pids exist before failover
1312         [ -d /proc/$close_pid ] || error "close_pid doesn't exist"
1313         [ -d /proc/$open_pid ] || error "open_pid doesn't exists"
1314         replay_barrier_nodf $SINGLEMDS
1315         fail_nodf $SINGLEMDS
1316         wait $open_pid || error "open_pid failed"
1317         sleep 2
1318         # close should be gone
1319         [ -d /proc/$close_pid ] && error "close_pid should not exist"
1320         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1321
1322         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1323                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1324         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1325                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1326         rm -rf $DIR/${tdir}-*
1327 }
1328 run_test 53c "|X| open request and close request while two MDC requests in flight"
1329
1330 test_53d() {
1331         [[ $(lctl get_param mdc.*.import |
1332              grep "connect_flags:.*multi_mod_rpc") ]] ||
1333                 { skip "Need MDC with 'multi_mod_rpcs' feature"; return 0; }
1334
1335         cancel_lru_locks mdc    # cleanup locks from former test cases
1336
1337         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1338         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1339         multiop $DIR/${tdir}-1/f O_c &
1340         close_pid=$!
1341         # give multiop a chance to open
1342         sleep 1
1343
1344         #define OBD_FAIL_MDS_CLOSE_NET_REP 0x13b
1345         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000013b"
1346         kill -USR1 $close_pid
1347         cancel_lru_locks mdc    # force the close
1348         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1349         mcreate $DIR/${tdir}-2/f || error "mcreate $DIR/${tdir}-2/f failed"
1350
1351         # close should still be here
1352         [ -d /proc/$close_pid ] || error "close_pid doesn't exist"
1353         fail $SINGLEMDS
1354         wait $close_pid || error "close_pid failed"
1355
1356         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1357                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1358         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1359                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1360         rm -rf $DIR/${tdir}-*
1361 }
1362 run_test 53d "close reply while two MDC requests in flight"
1363
1364 test_53e() {
1365         cancel_lru_locks mdc    # cleanup locks from former test cases
1366
1367         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1368         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1369         multiop $DIR/${tdir}-1/f O_c &
1370         close_pid=$!
1371
1372         #define OBD_FAIL_MDS_REINT_NET_REP 0x119
1373         do_facet $SINGLEMDS "lctl set_param fail_loc=0x119"
1374         mcreate $DIR/${tdir}-2/f &
1375         open_pid=$!
1376         sleep 1
1377
1378         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1379         kill -USR1 $close_pid
1380         cancel_lru_locks mdc    # force the close
1381         wait $close_pid || error "close_pid failed"
1382         # open should still be here
1383         [ -d /proc/$open_pid ] || error "open_pid doesn't exists"
1384
1385         replay_barrier_nodf $SINGLEMDS
1386         fail $SINGLEMDS
1387         wait $open_pid || error "open_pid failed"
1388
1389         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1390                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1391         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1392                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1393         rm -rf $DIR/${tdir}-*
1394 }
1395 run_test 53e "|X| open reply while two MDC requests in flight"
1396
1397 test_53f() {
1398         cancel_lru_locks mdc    # cleanup locks from former test cases
1399
1400         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1401         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1402         multiop $DIR/${tdir}-1/f O_c &
1403         close_pid=$!
1404
1405         #define OBD_FAIL_MDS_REINT_NET_REP 0x119
1406         do_facet $SINGLEMDS "lctl set_param fail_loc=0x119"
1407         mcreate $DIR/${tdir}-2/f &
1408         open_pid=$!
1409         sleep 1
1410
1411         #define OBD_FAIL_MDS_CLOSE_NET_REP 0x13b
1412         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000013b"
1413         kill -USR1 $close_pid
1414         cancel_lru_locks mdc    # force the close
1415
1416         #bz20647: make sure all pids are exists before failover
1417         [ -d /proc/$close_pid ] || error "close_pid doesn't exist"
1418         [ -d /proc/$open_pid ] || error "open_pid doesn't exists"
1419         replay_barrier_nodf $SINGLEMDS
1420         fail_nodf $SINGLEMDS
1421         wait $open_pid || error "open_pid failed"
1422         sleep 2
1423         # close should be gone
1424         [ -d /proc/$close_pid ] && error "close_pid should not exist"
1425         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1426
1427         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1428                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1429         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1430                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1431         rm -rf $DIR/${tdir}-*
1432 }
1433 run_test 53f "|X| open reply and close reply while two MDC requests in flight"
1434
1435 test_53g() {
1436         cancel_lru_locks mdc    # cleanup locks from former test cases
1437
1438         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1439         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1440         multiop $DIR/${tdir}-1/f O_c &
1441         close_pid=$!
1442
1443         #define OBD_FAIL_MDS_REINT_NET_REP 0x119
1444         do_facet $SINGLEMDS "lctl set_param fail_loc=0x119"
1445         mcreate $DIR/${tdir}-2/f &
1446         open_pid=$!
1447         sleep 1
1448
1449         #define OBD_FAIL_MDS_CLOSE_NET 0x115
1450         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
1451         kill -USR1 $close_pid
1452         cancel_lru_locks mdc    # force the close
1453         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1454
1455         #bz20647: make sure all pids are exists before failover
1456         [ -d /proc/$close_pid ] || error "close_pid doesn't exist"
1457         [ -d /proc/$open_pid ] || error "open_pid doesn't exists"
1458         replay_barrier_nodf $SINGLEMDS
1459         fail_nodf $SINGLEMDS
1460         wait $open_pid || error "open_pid failed"
1461         sleep 2
1462         # close should be gone
1463         [ -d /proc/$close_pid ] && error "close_pid should not exist"
1464
1465         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1466                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1467         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1468                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1469         rm -rf $DIR/${tdir}-*
1470 }
1471 run_test 53g "|X| drop open reply and close request while close and open are both in flight"
1472
1473 test_53h() {
1474         cancel_lru_locks mdc    # cleanup locks from former test cases
1475
1476         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1477         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1478         multiop $DIR/${tdir}-1/f O_c &
1479         close_pid=$!
1480
1481         #define OBD_FAIL_MDS_REINT_NET 0x107
1482         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
1483         mcreate $DIR/${tdir}-2/f &
1484         open_pid=$!
1485         sleep 1
1486
1487         #define OBD_FAIL_MDS_CLOSE_NET_REP 0x13b
1488         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000013b"
1489         kill -USR1 $close_pid
1490         cancel_lru_locks mdc    # force the close
1491         sleep 1
1492
1493         #bz20647: make sure all pids are exists before failover
1494         [ -d /proc/$close_pid ] || error "close_pid doesn't exist"
1495         [ -d /proc/$open_pid ] || error "open_pid doesn't exists"
1496         replay_barrier_nodf $SINGLEMDS
1497         fail_nodf $SINGLEMDS
1498         wait $open_pid || error "open_pid failed"
1499         sleep 2
1500         # close should be gone
1501         [ -d /proc/$close_pid ] && error "close_pid should not exist"
1502         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1503
1504         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1505                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1506         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1507                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1508         rm -rf $DIR/${tdir}-*
1509 }
1510 run_test 53h "open request and close reply while two MDC requests in flight"
1511
1512 #b3761 ASSERTION(hash != 0) failed
1513 test_55() {
1514 # OBD_FAIL_MDS_OPEN_CREATE | OBD_FAIL_ONCE
1515     do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000012b"
1516     touch $DIR/$tfile &
1517     # give touch a chance to run
1518     sleep 5
1519     do_facet $SINGLEMDS "lctl set_param fail_loc=0x0"
1520     rm $DIR/$tfile
1521     return 0
1522 }
1523 run_test 55 "let MDS_CHECK_RESENT return the original return code instead of 0"
1524
1525 #b3440 ASSERTION(rec->ur_fid2->id) failed
1526 test_56() {
1527     ln -s foo $DIR/$tfile
1528     replay_barrier $SINGLEMDS
1529     #drop_reply "cat $DIR/$tfile"
1530     fail $SINGLEMDS
1531     sleep 10
1532 }
1533 run_test 56 "don't replay a symlink open request (3440)"
1534
1535 #recovery one mds-ost setattr from llog
1536 test_57() {
1537         #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1538         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000012c"
1539         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
1540         replay_barrier $SINGLEMDS
1541         fail $SINGLEMDS
1542         wait_recovery_complete $SINGLEMDS || error "MDS recovery is not done"
1543         wait_mds_ost_sync || error "wait_mds_ost_sync failed"
1544         $CHECKSTAT -t file $DIR/$tfile ||
1545                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
1546         do_facet $SINGLEMDS "lctl set_param fail_loc=0x0"
1547         rm $DIR/$tfile
1548 }
1549 run_test 57 "test recovery from llog for setattr op"
1550
1551 cleanup_58() {
1552         zconf_umount $(hostname) $MOUNT2
1553         trap - EXIT
1554 }
1555
1556 #recovery many mds-ost setattr from llog
1557 test_58a() {
1558         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1559         #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1560         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000012c"
1561         createmany -o $DIR/$tdir/$tfile-%d 2500
1562         replay_barrier $SINGLEMDS
1563         fail $SINGLEMDS
1564         sleep 2
1565         $CHECKSTAT -t file $DIR/$tdir/$tfile-* >/dev/null ||
1566                 error "$CHECKSTAT $DIR/$tfile-* attribute check failed"
1567         do_facet $SINGLEMDS "lctl set_param fail_loc=0x0"
1568         unlinkmany $DIR/$tdir/$tfile-%d 2500 ||
1569                 error "unlinkmany $DIR/$tfile failed"
1570         rmdir $DIR/$tdir
1571 }
1572 run_test 58a "test recovery from llog for setattr op (test llog_gen_rec)"
1573
1574 test_58b() {
1575         local orig
1576         local new
1577
1578         trap cleanup_58 EXIT
1579
1580         large_xattr_enabled &&
1581                 orig="$(generate_string $(max_xattr_size))" || orig="bar"
1582         # Original extended attribute can be long. Print a small version of
1583         # attribute if an error occurs
1584         local sm_msg=$(printf "%.9s" $orig)
1585
1586         mount_client $MOUNT2 || error "mount_client on $MOUNT2 failed"
1587         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1588         touch $DIR/$tdir/$tfile || error "touch $DIR/$tdir/$tfile failed"
1589         replay_barrier $SINGLEMDS
1590         setfattr -n trusted.foo -v $orig $DIR/$tdir/$tfile
1591         fail $SINGLEMDS
1592         new=$(get_xattr_value trusted.foo $MOUNT2/$tdir/$tfile)
1593         [[ "$new" = "$orig" ]] ||
1594                 error "xattr set ($sm_msg...) differs from xattr get ($new)"
1595         rm -f $DIR/$tdir/$tfile
1596         rmdir $DIR/$tdir
1597         cleanup_58
1598         wait_clients_import_state ${CLIENTS:-$HOSTNAME} "mgs" FULL
1599 }
1600 run_test 58b "test replay of setxattr op"
1601
1602 test_58c() { # bug 16570
1603         local orig
1604         local orig1
1605         local new
1606
1607         trap cleanup_58 EXIT
1608
1609         if large_xattr_enabled; then
1610                 local xattr_size=$(max_xattr_size)
1611                 orig="$(generate_string $((xattr_size / 2)))"
1612                 orig1="$(generate_string $xattr_size)"
1613         else
1614                 orig="bar"
1615                 orig1="bar1"
1616         fi
1617
1618         # PING_INTERVAL max(obd_timeout / 4, 1U)
1619         sleep $((TIMEOUT / 4))
1620
1621         # Original extended attribute can be long. Print a small version of
1622         # attribute if an error occurs
1623         local sm_msg=$(printf "%.9s" $orig)
1624         local sm_msg1=$(printf "%.9s" $orig1)
1625
1626         mount_client $MOUNT2 || error "mount_client on $MOUNT2 failed"
1627         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1628         touch $DIR/$tdir/$tfile || error "touch $DIR/$tdir/$tfile failed"
1629         drop_request "setfattr -n trusted.foo -v $orig $DIR/$tdir/$tfile" ||
1630                 error "drop_request for setfattr failed"
1631         new=$(get_xattr_value trusted.foo $MOUNT2/$tdir/$tfile)
1632         [[ "$new" = "$orig" ]] ||
1633                 error "xattr set ($sm_msg...) differs from xattr get ($new)"
1634         drop_reint_reply "setfattr -n trusted.foo1 \
1635                           -v $orig1 $DIR/$tdir/$tfile" ||
1636                 error "drop_reint_reply for setfattr failed"
1637         new=$(get_xattr_value trusted.foo1 $MOUNT2/$tdir/$tfile)
1638         [[ "$new" = "$orig1" ]] ||
1639                 error "second xattr set ($sm_msg1...) differs xattr get ($new)"
1640         rm -f $DIR/$tdir/$tfile
1641         rmdir $DIR/$tdir
1642         cleanup_58
1643 }
1644 run_test 58c "resend/reconstruct setxattr op"
1645
1646 # log_commit_thread vs filter_destroy race used to lead to import use after free
1647 # bug 11658
1648 test_59() {
1649         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1650
1651         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1652         createmany -o $DIR/$tdir/$tfile-%d 200 ||
1653                 error "createmany create files failed"
1654         sync
1655         unlinkmany $DIR/$tdir/$tfile-%d 200 ||
1656                 error "unlinkmany $DIR/$tdir/$tfile failed"
1657         #define OBD_FAIL_PTLRPC_DELAY_RECOV       0x507
1658         do_facet ost1 "lctl set_param fail_loc=0x507"
1659         fail ost1
1660         fail $SINGLEMDS
1661         do_facet ost1 "lctl set_param fail_loc=0x0"
1662         sleep 20
1663         rmdir $DIR/$tdir
1664 }
1665 run_test 59 "test log_commit_thread vs filter_destroy race"
1666
1667 # race between add unlink llog vs cat log init in post_recovery (only for b1_6)
1668 # bug 12086: should no oops and No ctxt error for this test
1669 test_60() {
1670         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1671         createmany -o $DIR/$tdir/$tfile-%d 200 ||
1672                 error "createmany create files failed"
1673         replay_barrier $SINGLEMDS
1674         unlinkmany $DIR/$tdir/$tfile-%d 0 100
1675         fail $SINGLEMDS
1676         unlinkmany $DIR/$tdir/$tfile-%d 100 100
1677         local no_ctxt=$(dmesg | grep "No ctxt")
1678         [ -z "$no_ctxt" ] || error "ctxt is not initialized in recovery"
1679 }
1680 run_test 60 "test llog post recovery init vs llog unlink"
1681
1682 #test race  llog recovery thread vs llog cleanup
1683 test_61a() {    # was test_61
1684         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1685
1686         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1687         createmany -o $DIR/$tdir/$tfile-%d 800 ||
1688                 error "createmany create files failed"
1689         replay_barrier ost1
1690         unlinkmany $DIR/$tdir/$tfile-%d 800
1691         #   OBD_FAIL_OST_LLOG_RECOVERY_TIMEOUT 0x221
1692         set_nodes_failloc "$(osts_nodes)" 0x80000221
1693         facet_failover ost1
1694         sleep 10
1695         fail ost1
1696         sleep 30
1697         set_nodes_failloc "$(osts_nodes)" 0x0
1698
1699         $CHECKSTAT -t file $DIR/$tdir/$tfile-* &&
1700                 error "$CHECKSTAT $DIR/$tdir/$tfile attribute check should fail"
1701         rmdir $DIR/$tdir
1702 }
1703 run_test 61a "test race llog recovery vs llog cleanup"
1704
1705 #test race  mds llog sync vs llog cleanup
1706 test_61b() {
1707         #   OBD_FAIL_MDS_LLOG_SYNC_TIMEOUT 0x13a
1708         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000013a"
1709         facet_failover $SINGLEMDS
1710         sleep 10
1711         fail $SINGLEMDS
1712         do_facet client dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 ||
1713                 error "dd failed"
1714 }
1715 run_test 61b "test race mds llog sync vs llog cleanup"
1716
1717 #test race  cancel cookie cb vs llog cleanup
1718 test_61c() {
1719         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1720
1721         #   OBD_FAIL_OST_CANCEL_COOKIE_TIMEOUT 0x222
1722         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
1723         set_nodes_failloc "$(osts_nodes)" 0x80000222
1724         rm $DIR/$tfile
1725         sleep 10
1726         fail ost1
1727         set_nodes_failloc "$(osts_nodes)" 0x0
1728 }
1729 run_test 61c "test race mds llog sync vs llog cleanup"
1730
1731 test_61d() { # bug 16002 # bug 17466 # bug 22137
1732 #   OBD_FAIL_OBD_LLOG_SETUP        0x605
1733     stop mgs
1734     do_facet mgs "lctl set_param fail_loc=0x80000605"
1735     start mgs $(mgsdevname) $MGS_MOUNT_OPTS &&
1736         error "mgs start should have failed"
1737     do_facet mgs "lctl set_param fail_loc=0"
1738     start mgs $(mgsdevname) $MGS_MOUNT_OPTS || error "cannot restart mgs"
1739 }
1740 run_test 61d "error in llog_setup should cleanup the llog context correctly"
1741
1742 test_62() { # Bug 15756 - don't mis-drop resent replay
1743         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1744         replay_barrier $SINGLEMDS
1745         createmany -o $DIR/$tdir/$tfile- 25 ||
1746                 error "createmany create files failed"
1747         #define OBD_FAIL_TGT_REPLAY_DROP         0x707
1748         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000707"
1749         fail $SINGLEMDS
1750         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1751         unlinkmany $DIR/$tdir/$tfile- 25 ||
1752                 error "unlinkmany $DIR/$tdir/$tfile failed"
1753         return 0
1754 }
1755 run_test 62 "don't mis-drop resent replay"
1756
1757 #Adaptive Timeouts (bug 3055)
1758 AT_MAX_SET=0
1759
1760 at_cleanup () {
1761     local var
1762     local facet
1763     local at_new
1764
1765     echo "Cleaning up AT ..."
1766     if [ -n "$ATOLDBASE" ]; then
1767         local at_history=$($LCTL get_param -n at_history)
1768         do_facet $SINGLEMDS "lctl set_param at_history=$at_history" || true
1769         do_facet ost1 "lctl set_param at_history=$at_history" || true
1770     fi
1771
1772         if [ $AT_MAX_SET -ne 0 ]; then
1773                 for facet in mds client ost; do
1774                         var=AT_MAX_SAVE_${facet}
1775                         echo restore AT on $facet to saved value ${!var}
1776                         at_max_set ${!var} $facet
1777                         at_new=$(at_max_get $facet)
1778                         echo Restored AT value on $facet $at_new
1779                         [ $at_new -eq ${!var} ] ||
1780                         error "AT value not restored SAVED ${!var} NEW $at_new"
1781                 done
1782         fi
1783 }
1784
1785 at_start()
1786 {
1787     local at_max_new=600
1788
1789     # Save at_max original values
1790     local facet
1791     if [ $AT_MAX_SET -eq 0 ]; then
1792         # Suppose that all osts have the same at_max
1793         for facet in mds client ost; do
1794             eval AT_MAX_SAVE_${facet}=$(at_max_get $facet)
1795         done
1796     fi
1797     local at_max
1798     for facet in mds client ost; do
1799         at_max=$(at_max_get $facet)
1800         if [ $at_max -ne $at_max_new ]; then
1801             echo "AT value on $facet is $at_max, set it by force temporarily to $at_max_new"
1802             at_max_set $at_max_new $facet
1803             AT_MAX_SET=1
1804         fi
1805     done
1806
1807     if [ -z "$ATOLDBASE" ]; then
1808         ATOLDBASE=$(do_facet $SINGLEMDS "lctl get_param -n at_history")
1809         # speed up the timebase so we can check decreasing AT
1810         do_facet $SINGLEMDS "lctl set_param at_history=8" || true
1811         do_facet ost1 "lctl set_param at_history=8" || true
1812
1813         # sleep for a while to cool down, should be > 8s and also allow
1814         # at least one ping to be sent. simply use TIMEOUT to be safe.
1815         sleep $TIMEOUT
1816     fi
1817 }
1818
1819 test_65a() #bug 3055
1820 {
1821     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1822
1823     at_start || return 0
1824     $LCTL dk > /dev/null
1825     debugsave
1826     $LCTL set_param debug="other"
1827     # Slow down a request to the current service time, this is critical
1828     # because previous tests may have caused this value to increase.
1829     REQ_DELAY=`lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts |
1830                awk '/portal 12/ {print $5}'`
1831     REQ_DELAY=$((${REQ_DELAY} + ${REQ_DELAY} / 4 + 5))
1832
1833     do_facet $SINGLEMDS lctl set_param fail_val=$((${REQ_DELAY} * 1000))
1834 #define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
1835     do_facet $SINGLEMDS $LCTL set_param fail_loc=0x8000050a
1836     createmany -o $DIR/$tfile 10 > /dev/null
1837     unlinkmany $DIR/$tfile 10 > /dev/null
1838     # check for log message
1839     $LCTL dk | grep "Early reply #" || error "No early reply"
1840     debugrestore
1841     # client should show REQ_DELAY estimates
1842     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep portal
1843     sleep 9
1844     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep portal
1845 }
1846 run_test 65a "AT: verify early replies"
1847
1848 test_65b() #bug 3055
1849 {
1850         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1851
1852         at_start || return 0
1853         # turn on D_ADAPTTO
1854         debugsave
1855         $LCTL set_param debug="other trace"
1856         $LCTL dk > /dev/null
1857         # Slow down a request to the current service time, this is critical
1858         # because previous tests may have caused this value to increase.
1859         $LFS setstripe --stripe-index=0 --stripe-count=1 $DIR/$tfile ||
1860                 error "$LFS setstripe failed for $DIR/$tfile"
1861
1862         multiop $DIR/$tfile Ow1yc
1863         REQ_DELAY=`lctl get_param -n osc.${FSNAME}-OST0000-osc-*.timeouts |
1864                    awk '/portal 6/ {print $5}'`
1865         REQ_DELAY=$((${REQ_DELAY} + ${REQ_DELAY} / 4 + 5))
1866
1867         do_facet ost1 lctl set_param fail_val=${REQ_DELAY}
1868         #define OBD_FAIL_OST_BRW_PAUSE_PACK      0x224
1869         do_facet ost1 $LCTL set_param fail_loc=0x224
1870
1871         rm -f $DIR/$tfile
1872         $LFS setstripe --stripe-index=0 --stripe-count=1 $DIR/$tfile ||
1873                 error "$LFS setstripe failed"
1874         # force some real bulk transfer
1875         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
1876
1877         do_facet ost1 $LCTL set_param fail_loc=0
1878         # check for log message
1879         $LCTL dk | grep "Early reply #" || error "No early reply"
1880         debugrestore
1881         # client should show REQ_DELAY estimates
1882         lctl get_param -n osc.${FSNAME}-OST0000-osc-*.timeouts | grep portal
1883 }
1884 run_test 65b "AT: verify early replies on packed reply / bulk"
1885
1886 test_66a() #bug 3055
1887 {
1888     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1889
1890     at_start || return 0
1891     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1892     # adjust 5s at a time so no early reply is sent (within deadline)
1893     do_facet $SINGLEMDS "$LCTL set_param fail_val=5000"
1894 #define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
1895     do_facet $SINGLEMDS "$LCTL set_param fail_loc=0x8000050a"
1896     createmany -o $DIR/$tfile 20 > /dev/null
1897     unlinkmany $DIR/$tfile 20 > /dev/null
1898     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1899     do_facet $SINGLEMDS "$LCTL set_param fail_val=10000"
1900     do_facet $SINGLEMDS "$LCTL set_param fail_loc=0x8000050a"
1901     createmany -o $DIR/$tfile 20 > /dev/null
1902     unlinkmany $DIR/$tfile 20 > /dev/null
1903     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1904     do_facet $SINGLEMDS "$LCTL set_param fail_loc=0"
1905     sleep 9
1906     createmany -o $DIR/$tfile 20 > /dev/null
1907     unlinkmany $DIR/$tfile 20 > /dev/null
1908     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1909     CUR=$(lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | awk '/portal 12/ {print $5}')
1910     WORST=$(lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | awk '/portal 12/ {print $7}')
1911     echo "Current MDT timeout $CUR, worst $WORST"
1912     [ $CUR -lt $WORST ] || error "Current $CUR should be less than worst $WORST"
1913 }
1914 run_test 66a "AT: verify MDT service time adjusts with no early replies"
1915
1916 test_66b() #bug 3055
1917 {
1918         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1919
1920         at_start || return 0
1921         ORIG=$(lctl get_param -n mdc.${FSNAME}-MDT0000*.timeouts |
1922                 awk '/network/ {print $4}')
1923         $LCTL set_param fail_val=$(($ORIG + 5))
1924         #define OBD_FAIL_PTLRPC_PAUSE_REP      0x50c
1925         $LCTL set_param fail_loc=0x50c
1926         touch $DIR/$tfile > /dev/null 2>&1
1927         $LCTL set_param fail_loc=0
1928         CUR=$(lctl get_param -n mdc.${FSNAME}-MDT0000*.timeouts |
1929                 awk '/network/ {print $4}')
1930         WORST=$(lctl get_param -n mdc.${FSNAME}-MDT0000*.timeouts |
1931                 awk '/network/ {print $6}')
1932         echo "network timeout orig $ORIG, cur $CUR, worst $WORST"
1933         [ $WORST -gt $ORIG ] ||
1934                 error "Worst $WORST should be worse than orig $ORIG"
1935 }
1936 run_test 66b "AT: verify net latency adjusts"
1937
1938 test_67a() #bug 3055
1939 {
1940     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1941
1942     at_start || return 0
1943     CONN1=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1944     # sleeping threads may drive values above this
1945     do_facet ost1 "$LCTL set_param fail_val=400"
1946 #define OBD_FAIL_PTLRPC_PAUSE_REQ    0x50a
1947     do_facet ost1 "$LCTL set_param fail_loc=0x50a"
1948     createmany -o $DIR/$tfile 20 > /dev/null
1949     unlinkmany $DIR/$tfile 20 > /dev/null
1950     do_facet ost1 "$LCTL set_param fail_loc=0"
1951     CONN2=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1952     ATTEMPTS=$(($CONN2 - $CONN1))
1953     echo "$ATTEMPTS osc reconnect attempts on gradual slow"
1954         [ $ATTEMPTS -gt 0 ] &&
1955                 error_ignore bz13721 "AT should have prevented reconnect"
1956         return 0
1957 }
1958 run_test 67a "AT: verify slow request processing doesn't induce reconnects"
1959
1960 test_67b() #bug 3055
1961 {
1962     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1963
1964     at_start || return 0
1965     CONN1=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1966
1967     # exhaust precreations on ost1
1968     local OST=$(ostname_from_index 0)
1969     local mdtosc=$(get_mdtosc_proc_path mds $OST)
1970     local last_id=$(do_facet $SINGLEMDS lctl get_param -n \
1971         osc.$mdtosc.prealloc_last_id)
1972     local next_id=$(do_facet $SINGLEMDS lctl get_param -n \
1973         osc.$mdtosc.prealloc_next_id)
1974
1975         mkdir -p $DIR/$tdir/${OST} || error "mkdir $DIR/$tdir/${OST} failed"
1976         $LFS setstripe -i 0 -c 1 $DIR/$tdir/${OST} ||
1977                 error "$LFS setstripe failed"
1978         echo "Creating to objid $last_id on ost $OST..."
1979 #define OBD_FAIL_OST_PAUSE_CREATE        0x223
1980     do_facet ost1 "$LCTL set_param fail_val=20000"
1981     do_facet ost1 "$LCTL set_param fail_loc=0x80000223"
1982     createmany -o $DIR/$tdir/${OST}/f $next_id $((last_id - next_id + 2))
1983
1984     client_reconnect
1985     do_facet ost1 "lctl get_param -n ost.OSS.ost_create.timeouts"
1986     log "phase 2"
1987     CONN2=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1988     ATTEMPTS=$(($CONN2 - $CONN1))
1989     echo "$ATTEMPTS osc reconnect attempts on instant slow"
1990     # do it again; should not timeout
1991     do_facet ost1 "$LCTL set_param fail_loc=0x80000223"
1992     cp /etc/profile $DIR/$tfile || error "cp failed"
1993     do_facet ost1 "$LCTL set_param fail_loc=0"
1994     client_reconnect
1995     do_facet ost1 "lctl get_param -n ost.OSS.ost_create.timeouts"
1996     CONN3=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1997     ATTEMPTS=$(($CONN3 - $CONN2))
1998     echo "$ATTEMPTS osc reconnect attempts on 2nd slow"
1999     [ $ATTEMPTS -gt 0 ] && error "AT should have prevented reconnect"
2000     return 0
2001 }
2002 run_test 67b "AT: verify instant slowdown doesn't induce reconnects"
2003
2004 test_68 () #bug 13813
2005 {
2006     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
2007
2008     at_start || return 0
2009     local ldlm_enqueue_min=$(find /sys -name ldlm_enqueue_min)
2010     [ -z "$ldlm_enqueue_min" ] && skip "missing /sys/.../ldlm_enqueue_min" && return 0
2011     local ldlm_enqueue_min_r=$(do_facet ost1 "find /sys -name ldlm_enqueue_min")
2012     [ -z "$ldlm_enqueue_min_r" ] && skip "missing /sys/.../ldlm_enqueue_min in the ost1" && return 0
2013     local ENQ_MIN=$(cat $ldlm_enqueue_min)
2014     local ENQ_MIN_R=$(do_facet ost1 "cat $ldlm_enqueue_min_r")
2015         echo $TIMEOUT >> $ldlm_enqueue_min
2016         do_facet ost1 "echo $TIMEOUT >> $ldlm_enqueue_min_r"
2017
2018         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2019         $LFS setstripe --stripe-index=0 -c 1 $DIR/$tdir ||
2020                 error "$LFS setstripe failed for $DIR/$tdir"
2021         #define OBD_FAIL_LDLM_PAUSE_CANCEL       0x312
2022         $LCTL set_param fail_val=$(($TIMEOUT - 1))
2023         $LCTL set_param fail_loc=0x80000312
2024         cp /etc/profile $DIR/$tdir/${tfile}_1 || error "1st cp failed $?"
2025         $LCTL set_param fail_val=$((TIMEOUT * 5 / 4))
2026         $LCTL set_param fail_loc=0x80000312
2027         cp /etc/profile $DIR/$tdir/${tfile}_2 || error "2nd cp failed $?"
2028         $LCTL set_param fail_loc=0
2029
2030         echo $ENQ_MIN >> $ldlm_enqueue_min
2031         do_facet ost1 "echo $ENQ_MIN_R >> $ldlm_enqueue_min_r"
2032         rm -rf $DIR/$tdir
2033         return 0
2034 }
2035 run_test 68 "AT: verify slowing locks"
2036
2037 at_cleanup
2038 # end of AT tests includes above lines
2039
2040 # start multi-client tests
2041 test_70a () {
2042         [ -z "$CLIENTS" ] &&
2043                 { skip "Need two or more clients." && return; }
2044         [ $CLIENTCOUNT -lt 2 ] &&
2045                 { skip "Need two or more clients, have $CLIENTCOUNT" && return; }
2046
2047         echo "mount clients $CLIENTS ..."
2048         zconf_mount_clients $CLIENTS $MOUNT
2049
2050         local clients=${CLIENTS//,/ }
2051         echo "Write/read files on $DIR ; clients $CLIENTS ... "
2052         for CLIENT in $clients; do
2053                 do_node $CLIENT dd bs=1M count=10 if=/dev/zero \
2054                         of=$DIR/${tfile}_${CLIENT} 2>/dev/null ||
2055                                 error "dd failed on $CLIENT"
2056         done
2057
2058         local prev_client=$(echo $clients | sed 's/^.* \(.\+\)$/\1/')
2059         for C in ${CLIENTS//,/ }; do
2060                 do_node $prev_client dd if=$DIR/${tfile}_${C} \
2061                         of=/dev/null 2>/dev/null ||
2062                         error "dd if=$DIR/${tfile}_${C} failed on $prev_client"
2063                 prev_client=$C
2064         done
2065
2066         ls $DIR
2067 }
2068 run_test 70a "check multi client t-f"
2069
2070 check_for_process () {
2071         local clients=$1
2072         shift
2073         local prog=$@
2074
2075         killall_process $clients "$prog" -0
2076 }
2077
2078 test_70b () {
2079         local clients=${CLIENTS:-$HOSTNAME}
2080
2081         zconf_mount_clients $clients $MOUNT
2082
2083         local duration=300
2084         [ "$SLOW" = "no" ] && duration=120
2085         # set duration to 900 because it takes some time to boot node
2086         [ "$FAILURE_MODE" = HARD ] && duration=900
2087
2088         local elapsed
2089         local start_ts=$(date +%s)
2090         local cmd="rundbench 1 -t $duration"
2091         local pid=""
2092         if [ $MDSCOUNT -ge 2 ]; then
2093                 test_mkdir -p -c$MDSCOUNT $DIR/$tdir
2094                 $LFS setdirstripe -D -c$MDSCOUNT $DIR/$tdir
2095         fi
2096         do_nodesv $clients "set -x; MISSING_DBENCH_OK=$MISSING_DBENCH_OK \
2097                 PATH=\$PATH:$LUSTRE/utils:$LUSTRE/tests/:$DBENCH_LIB \
2098                 DBENCH_LIB=$DBENCH_LIB TESTSUITE=$TESTSUITE TESTNAME=$TESTNAME \
2099                 MOUNT=$MOUNT DIR=$DIR/$tdir/\\\$(hostname) LCTL=$LCTL $cmd" &
2100         pid=$!
2101
2102         #LU-1897 wait for all dbench copies to start
2103         while ! check_for_process $clients dbench; do
2104                 elapsed=$(($(date +%s) - start_ts))
2105                 if [ $elapsed -gt $duration ]; then
2106                         killall_process $clients dbench
2107                         error "dbench failed to start on $clients!"
2108                 fi
2109                 sleep 1
2110         done
2111
2112         log "Started rundbench load pid=$pid ..."
2113
2114         elapsed=$(($(date +%s) - start_ts))
2115         local num_failovers=0
2116         local fail_index=1
2117         while [ $elapsed -lt $duration ]; do
2118                 if ! check_for_process $clients dbench; then
2119                         error_noexit "dbench stopped on some of $clients!"
2120                         killall_process $clients dbench
2121                         break
2122                 fi
2123                 sleep 1
2124                 replay_barrier mds$fail_index
2125                 sleep 1 # give clients a time to do operations
2126                 # Increment the number of failovers
2127                 num_failovers=$((num_failovers+1))
2128                 log "$TESTNAME fail mds$fail_index $num_failovers times"
2129                 fail mds$fail_index
2130                 elapsed=$(($(date +%s) - start_ts))
2131                 if [ $fail_index -ge $MDSCOUNT ]; then
2132                         fail_index=1
2133                 else
2134                         fail_index=$((fail_index+1))
2135                 fi
2136         done
2137
2138         wait $pid || error "rundbench load on $clients failed!"
2139 }
2140 run_test 70b "dbench ${MDSCOUNT}mdts recovery; $CLIENTCOUNT clients"
2141 # end multi-client tests
2142
2143 random_fail_mdt() {
2144         local max_index=$1
2145         local duration=$2
2146         local monitor_pid=$3
2147         local elapsed
2148         local start_ts=$(date +%s)
2149         local num_failovers=0
2150         local fail_index
2151
2152         elapsed=$(($(date +%s) - start_ts))
2153         while [ $elapsed -lt $duration ]; do
2154                 fail_index=$((RANDOM%max_index+1))
2155                 kill -0 $monitor_pid ||
2156                         error "$monitor_pid stopped"
2157                 sleep 120
2158                 replay_barrier mds$fail_index
2159                 sleep 10
2160                 # Increment the number of failovers
2161                 num_failovers=$((num_failovers+1))
2162                 log "$TESTNAME fail mds$fail_index $num_failovers times"
2163                 fail mds$fail_index
2164                 elapsed=$(($(date +%s) - start_ts))
2165         done
2166 }
2167
2168 cleanup_70c() {
2169         trap 0
2170         rm -f $DIR/replay-single.70c.lck
2171         rm -rf /$DIR/$tdir
2172 }
2173
2174 test_70c () {
2175         local clients=${CLIENTS:-$HOSTNAME}
2176         local rc=0
2177
2178         zconf_mount_clients $clients $MOUNT
2179
2180         local duration=300
2181         [ "$SLOW" = "no" ] && duration=180
2182         # set duration to 900 because it takes some time to boot node
2183         [ "$FAILURE_MODE" = HARD ] && duration=600
2184
2185         local elapsed
2186         local start_ts=$(date +%s)
2187
2188         trap cleanup_70c EXIT
2189         (
2190                 while [ ! -e $DIR/replay-single.70c.lck ]; do
2191                         test_mkdir -p -c$MDSCOUNT $DIR/$tdir || break
2192                         if [ $MDSCOUNT -ge 2 ]; then
2193                                 $LFS setdirstripe -D -c$MDSCOUNT $DIR/$tdir ||
2194                                 error "set default dirstripe failed"
2195                         fi
2196                         cd $DIR/$tdir || break
2197                         tar cf - /etc | tar xf - || error "tar failed in loop"
2198                 done
2199         )&
2200         tar_70c_pid=$!
2201         echo "Started tar $tar_70c_pid"
2202
2203         random_fail_mdt $MDSCOUNT $duration $tar_70c_pid
2204         kill -0 $tar_70c_pid || error "tar $tar_70c_pid stopped"
2205
2206         touch $DIR/replay-single.70c.lck
2207         wait $tar_70c_pid || error "$?: tar failed"
2208
2209         cleanup_70c
2210         true
2211 }
2212 run_test 70c "tar ${MDSCOUNT}mdts recovery"
2213
2214 cleanup_70d() {
2215         trap 0
2216         kill -9 $mkdir_70d_pid
2217 }
2218
2219 test_70d () {
2220         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2221         local clients=${CLIENTS:-$HOSTNAME}
2222         local rc=0
2223
2224         zconf_mount_clients $clients $MOUNT
2225
2226         local duration=300
2227         [ "$SLOW" = "no" ] && duration=180
2228         # set duration to 900 because it takes some time to boot node
2229         [ "$FAILURE_MODE" = HARD ] && duration=900
2230
2231         mkdir -p $DIR/$tdir
2232
2233         local elapsed
2234         local start_ts=$(date +%s)
2235
2236         trap cleanup_70d EXIT
2237         (
2238                 while true; do
2239                         $LFS mkdir -i0 -c2 $DIR/$tdir/test || {
2240                                 echo "mkdir fails"
2241                                 break
2242                         }
2243                         $LFS mkdir -i1 -c2 $DIR/$tdir/test1 || {
2244                                 echo "mkdir fails"
2245                                 break
2246                         }
2247
2248                         touch $DIR/$tdir/test/a || {
2249                                 echo "touch fails"
2250                                 break;
2251                         }
2252                         mkdir $DIR/$tdir/test/b || {
2253                                 echo "mkdir fails"
2254                                 break;
2255                         }
2256                         rm -rf $DIR/$tdir/test || {
2257                                 echo "rmdir fails"
2258                                 ls -lR $DIR/$tdir
2259                                 break
2260                         }
2261
2262                         touch $DIR/$tdir/test1/a || {
2263                                 echo "touch fails"
2264                                 break;
2265                         }
2266                         mkdir $DIR/$tdir/test1/b || {
2267                                 echo "mkdir fails"
2268                                 break;
2269                         }
2270
2271                         rm -rf $DIR/$tdir/test1 || {
2272                                 echo "rmdir fails"
2273                                 ls -lR $DIR/$tdir/test1
2274                                 break
2275                         }
2276                 done
2277         )&
2278         mkdir_70d_pid=$!
2279         echo "Started  $mkdir_70d_pid"
2280
2281         random_fail_mdt $MDSCOUNT $duration $mkdir_70d_pid
2282         kill -0 $mkdir_70d_pid || error "mkdir/rmdir $mkdir_70d_pid stopped"
2283
2284         cleanup_70d
2285         true
2286 }
2287 run_test 70d "mkdir/rmdir striped dir ${MDSCOUNT}mdts recovery"
2288
2289 test_70e () {
2290         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2291         local clients=${CLIENTS:-$HOSTNAME}
2292         local rc=0
2293
2294         lctl set_param debug=+ha
2295         zconf_mount_clients $clients $MOUNT
2296
2297         local duration=300
2298         [ "$SLOW" = "no" ] && duration=180
2299         # set duration to 900 because it takes some time to boot node
2300         [ "$FAILURE_MODE" = HARD ] && duration=900
2301
2302         mkdir -p $DIR/$tdir
2303         $LFS mkdir -i0 $DIR/$tdir/test_0
2304         $LFS mkdir -i0 $DIR/$tdir/test_1
2305         touch $DIR/$tdir/test_0/a
2306         touch $DIR/$tdir/test_1/b
2307         (
2308         while true; do
2309                 mrename $DIR/$tdir/test_0/a $DIR/$tdir/test_1/b > /dev/null || {
2310                         echo "a->b fails"
2311                         break;
2312                 }
2313
2314                 checkstat $DIR/$tdir/test_0/a && {
2315                         echo "a still exists"
2316                         break
2317                 }
2318
2319                 checkstat $DIR/$tdir/test_1/b || {
2320                         echo "b still  exists"
2321                         break
2322                 }
2323
2324                 touch $DIR/$tdir/test_0/a || {
2325                         echo "touch a fails"
2326                         break
2327                 }
2328
2329                 mrename $DIR/$tdir/test_1/b $DIR/$tdir/test_0/a > /dev/null || {
2330                         echo "a->a fails"
2331                         break;
2332                 }
2333         done
2334         )&
2335         rename_70e_pid=$!
2336         stack_trap "kill -9 $rename_70e_pid" EXIT
2337         echo "Started PID=$rename_70e_pid"
2338
2339         random_fail_mdt 2 $duration $rename_70e_pid
2340         kill -0 $rename_70e_pid || error "rename $rename_70e_pid stopped"
2341 }
2342 run_test 70e "rename cross-MDT with random fails"
2343
2344 test_70f_write_and_read(){
2345         local srcfile=$1
2346         local stopflag=$2
2347         local client
2348
2349         echo "Write/read files in: '$DIR/$tdir', clients: '$CLIENTS' ..."
2350         for client in ${CLIENTS//,/ }; do
2351                 [ -f $stopflag ] || return
2352
2353                 local tgtfile=$DIR/$tdir/$tfile.$client
2354                 do_node $client dd $DD_OPTS bs=1M count=10 if=$srcfile \
2355                         of=$tgtfile 2>/dev/null ||
2356                         error "dd $DD_OPTS bs=1M count=10 if=$srcfile " \
2357                               "of=$tgtfile failed on $client, rc=$?"
2358         done
2359
2360         local prev_client=$(echo ${CLIENTS//,/ } | awk '{ print $NF }')
2361         local index=0
2362
2363         for client in ${CLIENTS//,/ }; do
2364                 [ -f $stopflag ] || return
2365
2366                 # flush client cache in case test is running on only one client
2367                 # do_node $client cancel_lru_locks osc
2368                 do_node $client $LCTL set_param ldlm.namespaces.*.lru_size=clear
2369
2370                 tgtfile=$DIR/$tdir/$tfile.$client
2371                 local md5=$(do_node $prev_client "md5sum $tgtfile")
2372                 [ ${checksum[$index]// */} = ${md5// */} ] ||
2373                         error "$tgtfile: checksum doesn't match on $prev_client"
2374                 index=$((index + 1))
2375                 prev_client=$client
2376         done
2377 }
2378
2379 test_70f_loop(){
2380         local srcfile=$1
2381         local stopflag=$2
2382         DD_OPTS=
2383
2384         mkdir -p $DIR/$tdir || error "cannot create $DIR/$tdir directory"
2385         $LFS setstripe -c -1 $DIR/$tdir ||
2386                 error "cannot $LFS setstripe $DIR/$tdir"
2387
2388         touch $stopflag
2389         while [ -f $stopflag ]; do
2390                 test_70f_write_and_read $srcfile $stopflag
2391                 # use direct IO and buffer cache in turns if loop
2392                 [ -n "$DD_OPTS" ] && DD_OPTS="" || DD_OPTS="oflag=direct"
2393         done
2394 }
2395
2396 test_70f_cleanup() {
2397         trap 0
2398         rm -f $TMP/$tfile.stop
2399         do_nodes $CLIENTS rm -f $TMP/$tfile
2400         rm -f $DIR/$tdir/$tfile.*
2401 }
2402
2403 test_70f() {
2404 #       [ x$ost1failover_HOST = x$ost_HOST ] &&
2405 #               { skip "Failover host not defined" && return; }
2406 #       [ -z "$CLIENTS" ] &&
2407 #               { skip "CLIENTS are not specified." && return; }
2408 #       [ $CLIENTCOUNT -lt 2 ] &&
2409 #               { skip "Need 2 or more clients, have $CLIENTCOUNT" && return; }
2410
2411         [[ $(lustre_version_code ost1) -lt $(version_code 2.9.53) ]] &&
2412                 skip "Need server version at least 2.9.53" && return
2413
2414         echo "mount clients $CLIENTS ..."
2415         zconf_mount_clients $CLIENTS $MOUNT
2416
2417         local srcfile=$TMP/$tfile
2418         local client
2419         local index=0
2420
2421         trap test_70f_cleanup EXIT
2422         # create a different source file local to each client node so we can
2423         # detect if the file wasn't written out properly after failover
2424         do_nodes $CLIENTS dd bs=1M count=10 if=/dev/urandom of=$srcfile \
2425                 2>/dev/null || error "can't create $srcfile on $CLIENTS"
2426         for client in ${CLIENTS//,/ }; do
2427                 checksum[$index]=$(do_node $client "md5sum $srcfile")
2428                 index=$((index + 1))
2429         done
2430
2431         local duration=120
2432         [ "$SLOW" = "no" ] && duration=60
2433         # set duration to 900 because it takes some time to boot node
2434         [ "$FAILURE_MODE" = HARD ] && duration=900
2435
2436         local stopflag=$TMP/$tfile.stop
2437         test_70f_loop $srcfile $stopflag &
2438         local pid=$!
2439
2440         local elapsed=0
2441         local num_failovers=0
2442         local start_ts=$SECONDS
2443         while [ $elapsed -lt $duration ]; do
2444                 sleep 3
2445                 replay_barrier ost1
2446                 sleep 1
2447                 num_failovers=$((num_failovers + 1))
2448                 log "$TESTNAME failing OST $num_failovers times"
2449                 fail ost1
2450                 sleep 2
2451                 elapsed=$((SECONDS - start_ts))
2452         done
2453
2454         rm -f $stopflag
2455         wait $pid
2456         test_70f_cleanup
2457 }
2458 run_test 70f "OSS O_DIRECT recovery with $CLIENTCOUNT clients"
2459
2460 cleanup_71a() {
2461         trap 0
2462         kill -9 $mkdir_71a_pid
2463 }
2464
2465 random_double_fail_mdt() {
2466         local max_index=$1
2467         local duration=$2
2468         local monitor_pid=$3
2469         local elapsed
2470         local start_ts=$(date +%s)
2471         local num_failovers=0
2472         local fail_index
2473         local second_index
2474
2475         elapsed=$(($(date +%s) - start_ts))
2476         while [ $elapsed -lt $duration ]; do
2477                 fail_index=$((RANDOM%max_index + 1))
2478                 if [ $fail_index -eq $max_index ]; then
2479                         second_index=1
2480                 else
2481                         second_index=$((fail_index + 1))
2482                 fi
2483                 kill -0 $monitor_pid ||
2484                         error "$monitor_pid stopped"
2485                 sleep 120
2486                 replay_barrier mds$fail_index
2487                 replay_barrier mds$second_index
2488                 sleep 10
2489                 # Increment the number of failovers
2490                 num_failovers=$((num_failovers+1))
2491                 log "fail mds$fail_index mds$second_index $num_failovers times"
2492                 fail mds${fail_index},mds${second_index}
2493                 elapsed=$(($(date +%s) - start_ts))
2494         done
2495 }
2496
2497 test_71a () {
2498         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2499         local clients=${CLIENTS:-$HOSTNAME}
2500         local rc=0
2501
2502         zconf_mount_clients $clients $MOUNT
2503
2504         local duration=300
2505         [ "$SLOW" = "no" ] && duration=180
2506         # set duration to 900 because it takes some time to boot node
2507         [ "$FAILURE_MODE" = HARD ] && duration=900
2508
2509         mkdir -p $DIR/$tdir
2510
2511         local elapsed
2512         local start_ts=$(date +%s)
2513
2514         trap cleanup_71a EXIT
2515         (
2516                 while true; do
2517                         $LFS mkdir -i0 -c2 $DIR/$tdir/test
2518                         rmdir $DIR/$tdir/test
2519                 done
2520         )&
2521         mkdir_71a_pid=$!
2522         echo "Started  $mkdir_71a_pid"
2523
2524         random_double_fail_mdt 2 $duration $mkdir_71a_pid
2525         kill -0 $mkdir_71a_pid || error "mkdir/rmdir $mkdir_71a_pid stopped"
2526
2527         cleanup_71a
2528         true
2529 }
2530 run_test 71a "mkdir/rmdir striped dir with 2 mdts recovery"
2531
2532 test_73a() {
2533         multiop_bg_pause $DIR/$tfile O_tSc ||
2534                 error "multiop_bg_pause $DIR/$tfile failed"
2535         pid=$!
2536         rm -f $DIR/$tfile
2537
2538         replay_barrier $SINGLEMDS
2539         #define OBD_FAIL_LDLM_ENQUEUE_NET                       0x302
2540         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000302"
2541         fail $SINGLEMDS
2542         kill -USR1 $pid
2543         wait $pid || error "multiop pid failed"
2544         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
2545         return 0
2546 }
2547 run_test 73a "open(O_CREAT), unlink, replay, reconnect before open replay, close"
2548
2549 test_73b() {
2550         multiop_bg_pause $DIR/$tfile O_tSc ||
2551                 error "multiop_bg_pause $DIR/$tfile failed"
2552         pid=$!
2553         rm -f $DIR/$tfile
2554
2555         replay_barrier $SINGLEMDS
2556         #define OBD_FAIL_MDS_LDLM_REPLY_NET       0x157
2557         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000157"
2558         fail $SINGLEMDS
2559         kill -USR1 $pid
2560         wait $pid || error "multiop pid failed"
2561         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
2562         return 0
2563 }
2564 run_test 73b "open(O_CREAT), unlink, replay, reconnect at open_replay reply, close"
2565
2566 # bug 18554
2567 test_74() {
2568         local clients=${CLIENTS:-$HOSTNAME}
2569
2570         zconf_umount_clients $clients $MOUNT
2571         stop ost1
2572         facet_failover $SINGLEMDS
2573         zconf_mount_clients $clients $MOUNT
2574         mount_facet ost1
2575         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
2576         rm $DIR/$tfile || error "rm $DIR/$tfile failed"
2577         clients_up || error "client evicted: $?"
2578         return 0
2579 }
2580 run_test 74 "Ensure applications don't fail waiting for OST recovery"
2581
2582 remote_dir_check_80() {
2583         local mdtidx=1
2584         local diridx
2585         local fileidx
2586
2587         diridx=$($LFS getstripe -m $remote_dir) ||
2588                 error "$LFS getstripe -m $remote_dir failed"
2589         [ $diridx -eq $mdtidx ] || error "$diridx != $mdtidx"
2590
2591         createmany -o $remote_dir/f-%d 20 || error "creation failed"
2592         fileidx=$($LFS getstripe -m $remote_dir/f-1) ||
2593                 error "$LFS getstripe -m $remote_dir/f-1 failed"
2594         [ $fileidx -eq $mdtidx ] || error "$fileidx != $mdtidx"
2595
2596         return 0
2597 }
2598
2599 test_80a() {
2600         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2601         ([ $FAILURE_MODE == "HARD" ] &&
2602                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2603                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2604                 return 0
2605
2606         local MDTIDX=1
2607         local remote_dir=$DIR/$tdir/remote_dir
2608
2609         mkdir -p $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2610         #define OBD_FAIL_OUT_UPDATE_NET_REP     0x1701
2611         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2612         $LFS mkdir -i $MDTIDX $remote_dir &
2613         local CLIENT_PID=$!
2614
2615         replay_barrier mds1
2616         fail mds${MDTIDX}
2617
2618         wait $CLIENT_PID || error "remote creation failed"
2619
2620         remote_dir_check_80 || error "remote dir check failed"
2621         rm -rf $DIR/$tdir || error "rmdir failed"
2622
2623         return 0
2624 }
2625 run_test 80a "DNE: create remote dir, drop update rep from MDT0, fail MDT0"
2626
2627 test_80b() {
2628         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2629         ([ $FAILURE_MODE == "HARD" ] &&
2630                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2631                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2632                 return 0
2633
2634         local MDTIDX=1
2635         local remote_dir=$DIR/$tdir/remote_dir
2636
2637         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2638         #define OBD_FAIL_OUT_UPDATE_NET_REP     0x1701
2639         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2640         $LFS mkdir -i $MDTIDX $remote_dir &
2641         local CLIENT_PID=$!
2642
2643         replay_barrier mds1
2644         replay_barrier mds2
2645         fail mds$((MDTIDX + 1))
2646
2647         wait $CLIENT_PID || error "remote creation failed"
2648
2649         remote_dir_check_80 || error "remote dir check failed"
2650         rm -rf $DIR/$tdir || error "rmdir failed"
2651
2652         return 0
2653 }
2654 run_test 80b "DNE: create remote dir, drop update rep from MDT0, fail MDT1"
2655
2656 test_80c() {
2657         [[ $mds1_FSTYPE = "zfs" ]] &&
2658                 [[ $MDS1_VERSION -lt $(version_code 2.12.51) ]] &&
2659                 skip "requires LU-10143 fix on MDS"
2660         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2661         ([ $FAILURE_MODE == "HARD" ] &&
2662                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2663                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2664                 return 0
2665
2666         local MDTIDX=1
2667         local remote_dir=$DIR/$tdir/remote_dir
2668
2669         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2670         #define OBD_FAIL_OUT_UPDATE_NET_REP     0x1701
2671         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2672         $LFS mkdir -i $MDTIDX $remote_dir &
2673         local CLIENT_PID=$!
2674
2675         replay_barrier mds1
2676         replay_barrier mds2
2677         fail mds${MDTIDX}
2678         fail mds$((MDTIDX + 1))
2679
2680         wait $CLIENT_PID || error "remote creation failed"
2681
2682         remote_dir_check_80 || error "remote dir check failed"
2683         rm -rf $DIR/$tdir || error "rmdir failed"
2684
2685         return 0
2686 }
2687 run_test 80c "DNE: create remote dir, drop update rep from MDT1, fail MDT[0,1]"
2688
2689 test_80d() {
2690         [[ $mds1_FSTYPE = "zfs" ]] &&
2691                 [[ $MDS1_VERSION -lt $(version_code 2.12.51) ]] &&
2692                 skip "requires LU-10143 fix on MDS"
2693         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2694         local MDTIDX=1
2695         local remote_dir=$DIR/$tdir/remote_dir
2696
2697         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2698         #define OBD_FAIL_OUT_UPDATE_NET_REP     0x1701
2699         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2700         $LFS mkdir -i $MDTIDX $remote_dir &
2701         local CLIENT_PID=$!
2702
2703         # sleep 3 seconds to make sure MDTs are failed after
2704         # lfs mkdir -i has finished on all of MDTs.
2705         sleep 3
2706
2707         replay_barrier mds1
2708         replay_barrier mds2
2709         fail mds${MDTIDX},mds$((MDTIDX + 1))
2710
2711         wait $CLIENT_PID || error "remote creation failed"
2712
2713         remote_dir_check_80 || error "remote dir check failed"
2714         rm -rf $DIR/$tdir || error "rmdir failed"
2715
2716         return 0
2717 }
2718 run_test 80d "DNE: create remote dir, drop update rep from MDT1, fail 2 MDTs"
2719
2720 test_80e() {
2721         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2722         ([ $FAILURE_MODE == "HARD" ] &&
2723                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2724                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2725                 return 0
2726
2727         local MDTIDX=1
2728         local remote_dir=$DIR/$tdir/remote_dir
2729
2730         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2731         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2732         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2733         $LFS mkdir -i $MDTIDX $remote_dir &
2734         local CLIENT_PID=$!
2735
2736         # sleep 3 seconds to make sure MDTs are failed after
2737         # lfs mkdir -i has finished on all of MDTs.
2738         sleep 3
2739
2740         replay_barrier mds1
2741         fail mds${MDTIDX}
2742
2743         wait $CLIENT_PID || error "remote creation failed"
2744
2745         remote_dir_check_80 || error "remote dir check failed"
2746         rm -rf $DIR/$tdir || error "rmdir failed"
2747
2748         return 0
2749 }
2750 run_test 80e "DNE: create remote dir, drop MDT1 rep, fail MDT0"
2751
2752 test_80f() {
2753         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2754         ([ $FAILURE_MODE == "HARD" ] &&
2755                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2756                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2757                 return 0
2758         local MDTIDX=1
2759         local remote_dir=$DIR/$tdir/remote_dir
2760
2761         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2762         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2763         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2764         $LFS mkdir -i $MDTIDX $remote_dir &
2765         local CLIENT_PID=$!
2766
2767         replay_barrier mds2
2768         fail mds$((MDTIDX + 1))
2769
2770         wait $CLIENT_PID || error "remote creation failed"
2771
2772         remote_dir_check_80 || error "remote dir check failed"
2773         rm -rf $DIR/$tdir || error "rmdir failed"
2774
2775         return 0
2776 }
2777 run_test 80f "DNE: create remote dir, drop MDT1 rep, fail MDT1"
2778
2779 test_80g() {
2780         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2781         ([ $FAILURE_MODE == "HARD" ] &&
2782                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2783                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2784                 return 0
2785
2786         local MDTIDX=1
2787         local remote_dir=$DIR/$tdir/remote_dir
2788
2789         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2790         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2791         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2792         $LFS mkdir -i $MDTIDX $remote_dir &
2793         local CLIENT_PID=$!
2794
2795         # sleep 3 seconds to make sure MDTs are failed after
2796         # lfs mkdir -i has finished on all of MDTs.
2797         sleep 3
2798
2799         replay_barrier mds1
2800         replay_barrier mds2
2801         fail mds${MDTIDX}
2802         fail mds$((MDTIDX + 1))
2803
2804         wait $CLIENT_PID || error "remote creation failed"
2805
2806         remote_dir_check_80 || error "remote dir check failed"
2807         rm -rf $DIR/$tdir || error "rmdir failed"
2808
2809         return 0
2810 }
2811 run_test 80g "DNE: create remote dir, drop MDT1 rep, fail MDT0, then MDT1"
2812
2813 test_80h() {
2814         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2815         local MDTIDX=1
2816         local remote_dir=$DIR/$tdir/remote_dir
2817
2818         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2819         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2820         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2821         $LFS mkdir -i $MDTIDX $remote_dir &
2822         local CLIENT_PID=$!
2823
2824         # sleep 3 seconds to make sure MDTs are failed after
2825         # lfs mkdir -i has finished on all of MDTs.
2826         sleep 3
2827
2828         replay_barrier mds1
2829         replay_barrier mds2
2830         fail mds${MDTIDX},mds$((MDTIDX + 1))
2831
2832         wait $CLIENT_PID || error "remote dir creation failed"
2833
2834         remote_dir_check_80 || error "remote dir check failed"
2835         rm -rf $DIR/$tdir || error "rmdir failed"
2836
2837         return 0
2838 }
2839 run_test 80h "DNE: create remote dir, drop MDT1 rep, fail 2 MDTs"
2840
2841 test_81a() {
2842         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2843         ([ $FAILURE_MODE == "HARD" ] &&
2844                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2845                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2846                 return 0
2847
2848         local MDTIDX=1
2849         local remote_dir=$DIR/$tdir/remote_dir
2850
2851         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2852         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2853
2854         touch $remote_dir || error "touch $remote_dir failed"
2855         # OBD_FAIL_OUT_UPDATE_NET_REP       0x1701
2856         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2857         rmdir $remote_dir &
2858         local CLIENT_PID=$!
2859
2860         replay_barrier mds2
2861         fail mds$((MDTIDX + 1))
2862
2863         wait $CLIENT_PID || error "rm remote dir failed"
2864
2865         stat $remote_dir &>/dev/null && error "$remote_dir still exist!"
2866
2867         rm -rf $DIR/$tdir || error "rmdir failed"
2868
2869         return 0
2870 }
2871 run_test 81a "DNE: unlink remote dir, drop MDT0 update rep,  fail MDT1"
2872
2873 test_81b() {
2874         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2875         ([ $FAILURE_MODE == "HARD" ] &&
2876                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2877                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2878                 return 0
2879         local MDTIDX=1
2880         local remote_dir=$DIR/$tdir/remote_dir
2881
2882         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2883         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2884
2885         # OBD_FAIL_OUT_UPDATE_NET_REP       0x1701
2886         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2887         rmdir $remote_dir &
2888         local CLIENT_PID=$!
2889
2890         replay_barrier mds1
2891         fail mds${MDTIDX}
2892
2893         wait $CLIENT_PID || error "rm remote dir failed"
2894
2895         stat $remote_dir &>/dev/null && error "$remote_dir still exist!"
2896
2897         rm -rf $DIR/$tdir || error "rmdir failed"
2898
2899         return 0
2900 }
2901 run_test 81b "DNE: unlink remote dir, drop MDT0 update reply,  fail MDT0"
2902
2903 test_81c() {
2904         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2905         ([ $FAILURE_MODE == "HARD" ] &&
2906                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2907                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2908                 return 0
2909
2910         local MDTIDX=1
2911         local remote_dir=$DIR/$tdir/remote_dir
2912
2913         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2914         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2915
2916         # OBD_FAIL_OUT_UPDATE_NET_REP       0x1701
2917         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2918         rmdir $remote_dir &
2919         local CLIENT_PID=$!
2920
2921         replay_barrier mds1
2922         replay_barrier mds2
2923         fail mds${MDTIDX}
2924         fail mds$((MDTIDX + 1))
2925
2926         wait $CLIENT_PID || error "rm remote dir failed"
2927
2928         stat $remote_dir &>/dev/null && error "$remote_dir still exist!"
2929
2930         rm -rf $DIR/$tdir || error "rmdir failed"
2931
2932         return 0
2933 }
2934 run_test 81c "DNE: unlink remote dir, drop MDT0 update reply, fail MDT0,MDT1"
2935
2936 test_81d() {
2937         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2938         local MDTIDX=1
2939         local remote_dir=$DIR/$tdir/remote_dir
2940
2941         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2942         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2943
2944         # OBD_FAIL_OUT_UPDATE_NET_REP       0x1701
2945         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2946         rmdir $remote_dir &
2947         local CLIENT_PID=$!
2948
2949         replay_barrier mds1
2950         replay_barrier mds2
2951         fail mds${MDTIDX},mds$((MDTIDX + 1))
2952
2953         wait $CLIENT_PID || error "rm remote dir failed"
2954
2955         stat $remote_dir &>/dev/null && error "$remote_dir still exist!"
2956
2957         rm -rf $DIR/$tdir || error "rmdir failed"
2958
2959         return 0
2960 }
2961 run_test 81d "DNE: unlink remote dir, drop MDT0 update reply,  fail 2 MDTs"
2962
2963 test_81e() {
2964         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2965         ([ $FAILURE_MODE == "HARD" ] &&
2966                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2967                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2968                 return 0
2969
2970         local MDTIDX=1
2971         local remote_dir=$DIR/$tdir/remote_dir
2972
2973         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2974         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2975
2976         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2977         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2978         rmdir $remote_dir &
2979         local CLIENT_PID=$!
2980         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0
2981
2982         replay_barrier mds1
2983         fail mds${MDTIDX}
2984
2985         wait $CLIENT_PID || error "rm remote dir failed"
2986
2987         stat $remote_dir &>/dev/null && error "$remote_dir still exist!"
2988
2989         rm -rf $DIR/$tdir || error "rmdir failed"
2990
2991         return 0
2992 }
2993 run_test 81e "DNE: unlink remote dir, drop MDT1 req reply, fail MDT0"
2994
2995 test_81f() {
2996         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2997         ([ $FAILURE_MODE == "HARD" ] &&
2998                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2999                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3000                 return 0
3001
3002         local MDTIDX=1
3003         local remote_dir=$DIR/$tdir/remote_dir
3004
3005         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
3006         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
3007
3008         # OBD_FAIL_MDS_REINT_NET_REP       0x119
3009         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
3010         rmdir $remote_dir &
3011         local CLIENT_PID=$!
3012
3013         replay_barrier mds2
3014         fail mds$((MDTIDX + 1))
3015
3016         wait $CLIENT_PID || error "rm remote dir failed"
3017
3018         stat $remote_dir &>/dev/null && error "$remote_dir still exist!"
3019
3020         rm -rf $DIR/$tdir || error "rmdir failed"
3021
3022         return 0
3023 }
3024 run_test 81f "DNE: unlink remote dir, drop MDT1 req reply, fail MDT1"
3025
3026 test_81g() {
3027         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3028         ([ $FAILURE_MODE == "HARD" ] &&
3029                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3030                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3031                 return 0
3032
3033         local MDTIDX=1
3034         local remote_dir=$DIR/$tdir/remote_dir
3035
3036         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
3037         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
3038
3039         # OBD_FAIL_MDS_REINT_NET_REP       0x119
3040         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
3041         rmdir $remote_dir &
3042         local CLIENT_PID=$!
3043
3044         replay_barrier mds1
3045         replay_barrier mds2
3046         fail mds${MDTIDX}
3047         fail mds$((MDTIDX + 1))
3048
3049         wait $CLIENT_PID || error "rm remote dir failed"
3050
3051         stat $remote_dir &>/dev/null && error "$remote_dir still exist!"
3052
3053         rm -rf $DIR/$tdir || error "rmdir failed"
3054
3055         return 0
3056 }
3057 run_test 81g "DNE: unlink remote dir, drop req reply, fail M0, then M1"
3058
3059 test_81h() {
3060         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3061         local MDTIDX=1
3062         local remote_dir=$DIR/$tdir/remote_dir
3063
3064         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
3065         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
3066
3067         # OBD_FAIL_MDS_REINT_NET_REP       0x119
3068         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
3069         rmdir $remote_dir &
3070         local CLIENT_PID=$!
3071
3072         replay_barrier mds1
3073         replay_barrier mds2
3074         fail mds${MDTIDX},mds$((MDTIDX + 1))
3075
3076         wait $CLIENT_PID || error "rm remote dir failed"
3077
3078         stat $remote_dir &>/dev/null && error "$remote_dir still exist!"
3079
3080         rm -rf $DIR/$tdir || error "rmdir failed"
3081
3082         return 0
3083 }
3084 run_test 81h "DNE: unlink remote dir, drop request reply, fail 2 MDTs"
3085
3086 test_84a() {
3087 #define OBD_FAIL_MDS_OPEN_WAIT_CREATE  0x144
3088     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000144"
3089     createmany -o $DIR/$tfile- 1 &
3090     PID=$!
3091     mds_evict_client
3092     wait $PID
3093     client_up || client_up || true    # reconnect
3094 }
3095 run_test 84a "stale open during export disconnect"
3096
3097 test_85a() { #bug 16774
3098         lctl set_param -n ldlm.cancel_unused_locks_before_replay "1"
3099
3100         for i in $(seq 100); do
3101                 echo "tag-$i" > $DIR/$tfile-$i
3102                 grep -q "tag-$i" $DIR/$tfile-$i || error "f2-$i"
3103         done
3104
3105         lov_id=$(lctl dl | grep "clilov")
3106         addr=$(echo $lov_id | awk '{print $4}' | awk -F '-' '{print $NF}')
3107         count=$(lctl get_param -n \
3108                 ldlm.namespaces.*MDT0000*$addr.lock_unused_count)
3109         echo "before recovery: unused locks count = $count"
3110
3111         fail $SINGLEMDS
3112
3113         count2=$(lctl get_param -n \
3114                  ldlm.namespaces.*MDT0000*$addr.lock_unused_count)
3115         echo "after recovery: unused locks count = $count2"
3116
3117         if [ $count2 -ge $count ]; then
3118                 error "unused locks are not canceled"
3119         fi
3120 }
3121 run_test 85a "check the cancellation of unused locks during recovery(IBITS)"
3122
3123 test_85b() { #bug 16774
3124         rm -rf $DIR/$tdir
3125         mkdir $DIR/$tdir
3126
3127         lctl set_param -n ldlm.cancel_unused_locks_before_replay "1"
3128
3129         if ! combined_mgs_mds ; then
3130                 mount_mgs_client
3131         fi
3132
3133         $LFS setstripe -c 1 -i 0 $DIR/$tdir
3134
3135         for i in $(seq 100); do
3136                 dd if=/dev/urandom of=$DIR/$tdir/$tfile-$i bs=4096 \
3137                         count=32 >/dev/null 2>&1
3138         done
3139
3140         cancel_lru_locks osc
3141
3142         for i in $(seq 100); do
3143                 dd if=$DIR/$tdir/$tfile-$i of=/dev/null bs=4096 \
3144                         count=32 >/dev/null 2>&1
3145         done
3146
3147         lov_id=$(lctl dl | grep "clilov")
3148         addr=$(echo $lov_id | awk '{print $4}' | awk -F '-' '{print $NF}')
3149         count=$(lctl get_param -n \
3150                           ldlm.namespaces.*OST0000*$addr.lock_unused_count)
3151         echo "before recovery: unused locks count = $count"
3152         [ $count -ne 0 ] || error "unused locks ($count) should be zero"
3153
3154         fail ost1
3155
3156         count2=$(lctl get_param \
3157                  -n ldlm.namespaces.*OST0000*$addr.lock_unused_count)
3158         echo "after recovery: unused locks count = $count2"
3159
3160         if ! combined_mgs_mds ; then
3161                 umount_mgs_client
3162         fi
3163
3164         if [ $count2 -ge $count ]; then
3165                 error "unused locks are not canceled"
3166         fi
3167
3168         rm -rf $DIR/$tdir
3169 }
3170 run_test 85b "check the cancellation of unused locks during recovery(EXTENT)"
3171
3172 test_86() {
3173         local clients=${CLIENTS:-$HOSTNAME}
3174
3175         zconf_umount_clients $clients $MOUNT
3176         do_facet $SINGLEMDS lctl set_param mdt.${FSNAME}-MDT*.exports.clear=0
3177         remount_facet $SINGLEMDS
3178         zconf_mount_clients $clients $MOUNT
3179 }
3180 run_test 86 "umount server after clear nid_stats should not hit LBUG"
3181
3182 test_87a() {
3183         do_facet ost1 "lctl set_param -n obdfilter.${ost1_svc}.sync_journal 0"
3184
3185         replay_barrier ost1
3186         $LFS setstripe -i 0 -c 1 $DIR/$tfile
3187         dd if=/dev/urandom of=$DIR/$tfile bs=1024k count=8 ||
3188                 error "dd to $DIR/$tfile failed"
3189         cksum=$(md5sum $DIR/$tfile | awk '{print $1}')
3190         cancel_lru_locks osc
3191         fail ost1
3192         dd if=$DIR/$tfile of=/dev/null bs=1024k count=8 || error "Cannot read"
3193         cksum2=$(md5sum $DIR/$tfile | awk '{print $1}')
3194         if [ $cksum != $cksum2 ] ; then
3195                 error "New checksum $cksum2 does not match original $cksum"
3196         fi
3197 }
3198 run_test 87a "write replay"
3199
3200 test_87b() {
3201         do_facet ost1 "lctl set_param -n obdfilter.${ost1_svc}.sync_journal 0"
3202
3203         replay_barrier ost1
3204         $LFS setstripe -i 0 -c 1 $DIR/$tfile
3205         dd if=/dev/urandom of=$DIR/$tfile bs=1024k count=8 ||
3206                 error "dd to $DIR/$tfile failed"
3207         sleep 1 # Give it a chance to flush dirty data
3208         echo TESTTEST | dd of=$DIR/$tfile bs=1 count=8 seek=64
3209         cksum=$(md5sum $DIR/$tfile | awk '{print $1}')
3210         cancel_lru_locks osc
3211         fail ost1
3212         dd if=$DIR/$tfile of=/dev/null bs=1024k count=8 || error "Cannot read"
3213         cksum2=$(md5sum $DIR/$tfile | awk '{print $1}')
3214         if [ $cksum != $cksum2 ] ; then
3215                 error "New checksum $cksum2 does not match original $cksum"
3216         fi
3217 }
3218 run_test 87b "write replay with changed data (checksum resend)"
3219
3220 test_88() { #bug 17485
3221         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
3222         mkdir -p $TMP/$tdir || error "mkdir $TMP/$tdir failed"
3223
3224         $LFS setstripe -i 0 -c 1 $DIR/$tdir || error "$LFS setstripe failed"
3225
3226         replay_barrier ost1
3227         replay_barrier $SINGLEMDS
3228
3229     # exhaust precreations on ost1
3230     local OST=$(ostname_from_index 0)
3231     local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS $OST)
3232     local last_id=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_last_id)
3233     local next_id=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_next_id)
3234         echo "before test: last_id = $last_id, next_id = $next_id"
3235
3236         echo "Creating to objid $last_id on ost $OST..."
3237         createmany -o $DIR/$tdir/f-%d $next_id $((last_id - next_id + 2)) ||
3238                 error "createmany create files to last_id failed"
3239
3240         #create some files to use some uncommitted objids
3241         last_id=$(($last_id + 1))
3242         createmany -o $DIR/$tdir/f-%d $last_id 8 ||
3243                 error "createmany create files with uncommitted objids failed"
3244
3245     last_id2=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_last_id)
3246     next_id2=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_next_id)
3247     echo "before recovery: last_id = $last_id2, next_id = $next_id2" 
3248
3249     # if test uses shutdown_facet && reboot_facet instead of facet_failover ()
3250     # it has to take care about the affected facets, bug20407
3251     local affected_mds1=$(affected_facets mds1)
3252     local affected_ost1=$(affected_facets ost1)
3253
3254     shutdown_facet $SINGLEMDS
3255     shutdown_facet ost1
3256
3257     reboot_facet $SINGLEMDS
3258     change_active $affected_mds1
3259     wait_for_facet $affected_mds1
3260     mount_facets $affected_mds1 || error "Restart of mds failed"
3261
3262     reboot_facet ost1
3263     change_active $affected_ost1
3264     wait_for_facet $affected_ost1
3265     mount_facets $affected_ost1 || error "Restart of ost1 failed"
3266
3267     clients_up
3268
3269     last_id2=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_last_id)
3270     next_id2=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_next_id)
3271         echo "after recovery: last_id = $last_id2, next_id = $next_id2"
3272
3273         # create new files, which should use new objids, and ensure the orphan
3274         # cleanup phase for ost1 is completed at the same time
3275         for i in $(seq 8); do
3276                 file_id=$(($last_id + 10 + $i))
3277                 dd if=/dev/urandom of=$DIR/$tdir/f-$file_id bs=4096 count=128
3278         done
3279
3280         # if the objids were not recreated, then "ls" will fail with -ENOENT
3281         ls -l $DIR/$tdir/* || error "can't get the status of precreated files"
3282
3283         local file_id
3284         # write into previously created files
3285         for i in $(seq 8); do
3286                 file_id=$(($last_id + $i))
3287                 dd if=/dev/urandom of=$DIR/$tdir/f-$file_id bs=4096 count=128
3288                 cp -f $DIR/$tdir/f-$file_id $TMP/$tdir/
3289         done
3290
3291         # compare the content
3292         for i in $(seq 8); do
3293                 file_id=$(($last_id + $i))
3294                 cmp $TMP/$tdir/f-$file_id $DIR/$tdir/f-$file_id ||
3295                         error "the content of file is modified!"
3296         done
3297
3298         rm -fr $TMP/$tdir
3299 }
3300 run_test 88 "MDS should not assign same objid to different files "
3301
3302 function calc_osc_kbytes_used() {
3303         local kbtotal=$(calc_osc_kbytes kbytestotal)
3304         local kbfree=$(calc_osc_kbytes kbytesfree)
3305         echo $((kbtotal-kbfree))
3306 }
3307
3308 test_89() {
3309         cancel_lru_locks osc
3310         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
3311         rm -f $DIR/$tdir/$tfile
3312         wait_mds_ost_sync || error "initial MDS-OST sync timed out"
3313         wait_delete_completed || error "initial wait delete timed out"
3314         local blocks1=$(calc_osc_kbytes_used)
3315         local write_size=$(fs_log_size)
3316
3317         $LFS setstripe -i 0 -c 1 $DIR/$tdir/$tfile
3318         [ $write_size -lt 1024 ] && write_size=1024
3319         dd if=/dev/zero bs=${write_size}k count=10 of=$DIR/$tdir/$tfile
3320         sync
3321         stop ost1
3322         facet_failover $SINGLEMDS
3323         rm $DIR/$tdir/$tfile
3324         umount $MOUNT