Whamcloud - gitweb
LU-14547 test: skip sanityn 109 for local setup
[fs/lustre-release.git] / lustre / tests / sanityn.sh
1 #!/bin/bash
2
3 set -e
4
5 ONLY=${ONLY:-"$*"}
6
7 SIZE=${SIZE:-40960}
8 OPENFILE=${OPENFILE:-openfile}
9 OPENUNLINK=${OPENUNLINK:-openunlink}
10 export TMP=${TMP:-/tmp}
11 MOUNT_2=${MOUNT_2:-"yes"}
12 CHECK_GRANT=${CHECK_GRANT:-"yes"}
13 GRANT_CHECK_LIST=${GRANT_CHECK_LIST:-""}
14
15 LUSTRE=${LUSTRE:-$(dirname $0)/..}
16 . $LUSTRE/tests/test-framework.sh
17 init_test_env $@
18 init_logging
19
20 ALWAYS_EXCEPT="$SANITYN_EXCEPT "
21 # bug number for skipped test:  LU-7105
22 ALWAYS_EXCEPT+="                28 "
23 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
24
25 # skip tests for PPC until they are fixed
26 if [[ $(uname -m) = ppc64 ]]; then
27         # bug number:    LU-11597 LU-11787
28         ALWAYS_EXCEPT+=" 16a      71a"
29 fi
30
31 if [ $mds1_FSTYPE = "zfs" ]; then
32         # LU-2829 / LU-2887 - make allowances for ZFS slowness
33         TEST33_NFILES=${TEST33_NFILES:-1000}
34 fi
35
36 #                                  23   (min)"
37 [ "$SLOW" = "no" ] && EXCEPT_SLOW="33a"
38
39 build_test_filter
40
41 FAIL_ON_ERROR=false
42
43 SETUP=${SETUP:-:}
44 TRACE=${TRACE:-""}
45
46 check_and_setup_lustre
47
48 OSC=${OSC:-"osc"}
49
50 assert_DIR
51 rm -rf $DIR1/[df][0-9]* $DIR1/lnk $DIR/[df].${TESTSUITE}*
52
53 SAMPLE_FILE=$TMP/$(basename $0 .sh).junk
54 dd if=/dev/urandom of=$SAMPLE_FILE bs=1M count=1
55
56 # $RUNAS_ID may get set incorrectly somewhere else
57 [ $UID -eq 0 -a $RUNAS_ID -eq 0 ] && error "\$RUNAS_ID set to 0, but \$UID is also 0!"
58
59 check_runas_id $RUNAS_ID $RUNAS_GID $RUNAS
60
61 test_1() {
62         touch $DIR1/$tfile
63         [ -f $DIR2/$tfile ] || error "Check create"
64         chmod 777 $DIR2/$tfile
65         $CHECKSTAT -t file -p 0777 $DIR1/$tfile ||
66                 error "Check attribute update for 0777"
67
68         chmod a-x $DIR2/$tfile
69         $CHECKSTAT -t file -p 0666 $DIR1/$tfile ||
70                 error "Check attribute update for 0666"
71
72         rm $DIR2/$tfile
73         $CHECKSTAT -a $DIR1/$tfile ||
74                 error "Check unlink - removes file on other mountpoint"
75 }
76 run_test 1 "Check attribute updates on 2 mount points"
77
78 test_2a() {
79         touch $DIR1/f2a
80         ls -l $DIR2/f2a
81         chmod 777 $DIR2/f2a
82         $CHECKSTAT -t file -p 0777 $DIR1/f2a ||
83                 error "Either not file type or perms not 0777"
84 }
85 run_test 2a "check cached attribute updates on 2 mtpt's ========"
86
87 test_2b() {
88         touch $DIR1/f2b
89         ls -l $DIR2/f2b
90         chmod 777 $DIR1/f2b
91         $CHECKSTAT -t file -p 0777 $DIR2/f2b ||
92                 error "Either not file type or perms not 0777"
93 }
94 run_test 2b "check cached attribute updates on 2 mtpt's ========"
95
96 # NEED TO SAVE ROOT DIR MODE
97 test_2c() {
98         chmod 777 $DIR1
99         $CHECKSTAT -t dir -p 0777 $DIR2 ||
100                 error "Either not dir type or perms not 0777"
101 }
102 run_test 2c "check cached attribute updates on 2 mtpt's root ==="
103
104 test_2d() {
105         chmod 755 $DIR1
106         $CHECKSTAT -t dir -p 0755 $DIR2 ||
107                 error "Either not file type or perms not 0775"
108 }
109 run_test 2d "check cached attribute updates on 2 mtpt's root ==="
110
111 test_2e() {
112         chmod 755 $DIR1
113         ls -l $DIR1
114         ls -l $DIR2
115         chmod 777 $DIR1
116                 $RUNAS dd if=/dev/zero of=$DIR2/$tfile count=1 ||
117                         error "dd failed"
118 }
119 run_test 2e "check chmod on root is propagated to others"
120
121 test_2f() {
122         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
123         local MDTIDX=1
124         local remote_dir=$tdir/remote_dir
125
126         mkdir -p $DIR1/$tdir
127         $LFS mkdir -i $MDTIDX $DIR1/$remote_dir ||
128                    error "Create remote directory failed"
129
130         touch $DIR1/$remote_dir/$tfile ||
131                 error "Create file under remote directory failed"
132         chmod 777 $DIR1/$remote_dir/$tfile ||
133                 error "Chmod file under remote directory failed"
134
135         $CHECKSTAT -t file -p 0777 $DIR2/$remote_dir/$tfile ||
136                 error "Check attr of file under remote directory failed"
137
138         chown $RUNAS_ID:$RUNAS_GID $DIR1/$remote_dir/$tfile ||
139                 error "Chown file under remote directory failed"
140
141         $CHECKSTAT -u \#$RUNAS_ID -g \#$RUNAS_GID $DIR2/$remote_dir/$tfile ||
142                 error "Check owner of file under remote directory failed"
143
144         cd $DIR2/$remote_dir || error "enter remote dir"
145         rm -rf $DIR1/$remote_dir/$tfile ||
146                 error "Unlink remote directory failed"
147
148         $CHECKSTAT -t file $DIR2/$remote_dir/$tfile &&
149                 error "unlink file still exists!"
150
151         cd $DIR2/$tdir || error "exit remote dir"
152         rm -rf $DIR1/$tdir || error "unlink directory failed"
153 }
154 run_test 2f "check attr/owner updates on DNE with 2 mtpt's"
155
156 test_2g() {
157         dd if=/dev/zero of=$DIR1/$tfile oflag=sync bs=1M count=2
158
159         local block1=$(stat $DIR1/$tfile | awk '/Blocks/ {print $4} ')
160         cancel_lru_locks osc
161         local block2=$(stat $DIR2/$tfile | awk '/Blocks/ {print $4} ')
162         echo "$DIR1/$tfile has $block1 blocks"
163         echo "$DIR2/$tfile has $block2 blocks"
164         [ $block1 -eq $block2 ] || error "$block1 not equal to $block2"
165 }
166 run_test 2g "check blocks update on sync write"
167
168 test_3() {
169         local target="this/is/good"
170         ln -s $target $DIR1/$tfile || error "ln -s $target $DIR1/$tfile failed"
171         [ "$(ls -l $DIR2/$tfile | sed -e 's/.* -> //')" = "$target" ] ||
172                 error "link $DIR2/$tfile not as expected"
173 }
174 run_test 3 "symlink on one mtpt, readlink on another ==========="
175
176 test_4() {
177         multifstat $DIR1/f4 $DIR2/f4
178 }
179 run_test 4 "fstat validation on multiple mount points =========="
180
181 test_5() {
182         mcreate $DIR1/f5
183         $TRUNCATE $DIR2/f5 100
184         $CHECKSTAT -t file -s 100 $DIR1/f5 ||
185                 error "Either not file type or size not equal to 100 bytes"
186         rm $DIR1/f5
187 }
188 run_test 5 "create a file on one mount, truncate it on the other"
189
190 test_6() {
191         openunlink $DIR1/$tfile $DIR2/$tfile || \
192                 error "openunlink $DIR1/$tfile $DIR2/$tfile"
193 }
194 run_test 6 "remove of open file on other node =================="
195
196 test_7() {
197         local dir=d7
198         opendirunlink $DIR1/$dir $DIR2/$dir || \
199                 error "opendirunlink $DIR1/$dir $DIR2/$dir"
200 }
201 run_test 7 "remove of open directory on other node ============="
202
203 test_8() {
204         opendevunlink $DIR1/$tfile $DIR2/$tfile || \
205                 error "opendevunlink $DIR1/$tfile $DIR2/$tfile"
206 }
207 run_test 8 "remove of open special file on other node =========="
208
209 test_9a() {
210         MTPT=1
211         local dir
212         > $DIR2/f9
213         for C in a b c d e f g h i j k l; do
214                 dir=`eval echo \\$DIR$MTPT`
215                 echo -n $C >> $dir/f9
216                 [ "$MTPT" -eq 1 ] && MTPT=2 || MTPT=1
217         done
218         [ "`cat $DIR1/f9`" = "abcdefghijkl" ] || \
219                 error "`od -a $DIR1/f9` != abcdefghijkl"
220 }
221 run_test 9a "append of file with sub-page size on multiple mounts"
222
223 #LU-10681 - tiny writes & appending to sparse striped file
224 test_9b() {
225         [[ $OSTCOUNT -ge 2 ]] || { skip "needs >= 2 OSTs"; return; }
226
227         $LFS setstripe -c 2 -S 1M $DIR/$tfile
228         echo "foo" >> $DIR/$tfile
229         dd if=/dev/zero of=$DIR2/$tfile bs=1M count=1 seek=1 conv=notrunc ||
230                 error "sparse dd $DIR2/$tfile failed"
231         echo "foo" >> $DIR/$tfile
232
233         data=$(dd if=$DIR2/$tfile bs=1 count=3 skip=$((2 * 1048576)) conv=notrunc)
234         echo "Data read (expecting 'foo')": $data
235         [ "$data" = "foo" ] || error "append to sparse striped file failed"
236 }
237 run_test 9b "append to striped sparse file"
238
239 test_10a() {
240         MTPT=1
241         local dir
242         OFFSET=0
243         > $DIR2/f10
244         for C in a b c d e f g h i j k l; do
245                 dir=`eval echo \\$DIR$MTPT`
246                 echo -n $C | dd of=$dir/f10 bs=1 seek=$OFFSET count=1
247                 [ "$MTPT" -eq 1 ] && MTPT=2 || MTPT=1
248                 OFFSET=`expr $OFFSET + 1`
249         done
250         [ "`cat $DIR1/f10`" = "abcdefghijkl" ] || \
251                 error "`od -a $DIR1/f10` != abcdefghijkl"
252 }
253 run_test 10a "write of file with sub-page size on multiple mounts "
254
255 test_10b() {
256         # create a seed file
257         yes "R" | head -c 4000 >$TMP/f10b-seed
258         dd if=$TMP/f10b-seed of=$DIR1/f10b bs=3k count=1 || error "dd $DIR1"
259
260         $TRUNCATE $DIR1/f10b 4096 || error "truncate 4096"
261
262         dd if=$DIR2/f10b of=$TMP/f10b-lustre bs=4k count=1 || error "dd $DIR2"
263
264         # create a test file locally to compare
265         dd if=$TMP/f10b-seed of=$TMP/f10b bs=3k count=1 || error "dd random"
266         $TRUNCATE $TMP/f10b 4096 || error "truncate 4096"
267         cmp $TMP/f10b $TMP/f10b-lustre || error "file miscompare"
268         rm $TMP/f10b $TMP/f10b-lustre $TMP/f10b-seed
269 }
270 run_test 10b "write of file with sub-page size on multiple mounts "
271
272 test_11() {
273         test_mkdir $DIR1/d11
274         multiop_bg_pause $DIR1/d11/f O_c || return 1
275         MULTIPID=$!
276         cp -p /bin/ls $DIR1/d11/f
277         $DIR2/d11/f
278         RC=$?
279         kill -USR1 $MULTIPID
280         wait $MULTIPID || error "wait for PID $MULTIPID failed"
281         [ $RC -eq 0 ] && error || true
282 }
283 run_test 11 "execution of file opened for write should return error ===="
284
285 test_12() {
286         DIR=$DIR DIR2=$DIR2 sh lockorder.sh
287 }
288 run_test 12 "test lock ordering (link, stat, unlink)"
289
290 test_13() {     # bug 2451 - directory coherency
291         test_mkdir $DIR1/d13
292         cd $DIR1/d13 || error "cd to $DIR1/d13 failed"
293         ls
294         ( touch $DIR1/d13/f13 ) # needs to be a separate shell
295         ls
296         rm -f $DIR2/d13/f13 || error "Cannot remove $DIR2/d13/f13"
297         ls 2>&1 | grep f13 && error "f13 shouldn't return an error (1)" || true
298         # need to run it twice
299         ( touch $DIR1/d13/f13 ) # needs to be a separate shell
300         ls
301         rm -f $DIR2/d13/f13 || error "Cannot remove $DIR2/d13/f13"
302         ls 2>&1 | grep f13 && error "f13 shouldn't return an error (2)" || true
303 }
304 run_test 13 "test directory page revocation"
305
306 test_14aa() {
307         test_mkdir $DIR1/$tdir
308         cp -p /bin/ls $DIR1/$tdir/$tfile
309         multiop_bg_pause $DIR1/$tdir/$tfile Ow_c || return 1
310         MULTIPID=$!
311
312         $DIR2/$tdir/$tfile && error || true
313         kill $MULTIPID
314 }
315 run_test 14aa "execution of file open for write returns -ETXTBSY"
316
317 test_14ab() {
318         test_mkdir $DIR1/$tdir
319         cp -p $(which sleep) $DIR1/$tdir/sleep || error "cp failed"
320         $DIR1/$tdir/sleep 60 &
321         SLEEP_PID=$!
322         $MULTIOP $DIR2/$tdir/sleep Oc && error "expected error, got success"
323         kill $SLEEP_PID
324 }
325 run_test 14ab "open(RDWR) of executing file returns -ETXTBSY"
326
327 test_14b() { # bug 3192, 7040
328         test_mkdir $DIR1/$tdir
329         cp -p $(which sleep) $DIR1/$tdir/sleep || error "cp failed"
330         $DIR1/$tdir/sleep 60 &
331         SLEEP_PID=$!
332         $TRUNCATE $DIR2/$tdir/sleep 60 && kill -9 $SLEEP_PID && \
333                 error "expected truncate error, got success"
334         kill $SLEEP_PID
335         cmp $(which sleep) $DIR1/$tdir/sleep || error "binary changed"
336 }
337 run_test 14b "truncate of executing file returns -ETXTBSY ======"
338
339 test_14c() { # bug 3430, 7040
340         test_mkdir $DIR1/$tdir
341         cp -p $(which sleep) $DIR1/$tdir/sleep || error "cp failed"
342         $DIR1/$tdir/sleep 60 &
343         SLEEP_PID=$!
344         cp /etc/hosts $DIR2/$tdir/sleep && error "expected error, got success"
345         kill $SLEEP_PID
346         cmp $(which sleep) $DIR1/$tdir/sleep || error "binary changed"
347 }
348 run_test 14c "open(O_TRUNC) of executing file return -ETXTBSY =="
349
350 test_14d() { # bug 10921
351         test_mkdir $DIR1/$tdir
352         cp -p $(which sleep) $DIR1/$tdir/sleep || error "cp failed"
353         $DIR1/$tdir/sleep 60 &
354         SLEEP_PID=$!
355         log chmod
356         chmod 600 $DIR1/$tdir/sleep || error "chmod failed"
357         kill $SLEEP_PID
358         cmp $(which sleep) $DIR1/$tdir/sleep || error "binary changed"
359 }
360 run_test 14d "chmod of executing file is still possible ========"
361
362 test_15() {     # bug 974 - ENOSPC
363         echo "PATH=$PATH"
364         sh oos2.sh $MOUNT1 $MOUNT2
365         wait_delete_completed
366         grant_error=$(dmesg | grep "< tot_grant")
367         [ -z "$grant_error" ] || error "$grant_error"
368 }
369 run_test 15 "test out-of-space with multiple writers ==========="
370
371 COUNT=${COUNT:-2500}
372 # The FSXNUM reduction for ZFS is needed until ORI-487 is fixed.
373 # We don't want to skip it entirely, but ZFS is VERY slow and cannot
374 # pass a 2500 operation dual-mount run within the time limit.
375 if [ "$ost1_FSTYPE" = "zfs" ]; then
376         FSXNUM=$((COUNT / 5))
377         FSXP=1
378 elif [ "$SLOW" = "yes" ]; then
379         FSXNUM=$((COUNT * 5))
380         FSXP=500
381 else
382         FSXNUM=$COUNT
383         FSXP=100
384 fi
385
386 test_16a() {
387         local file1=$DIR1/$tfile
388         local file2=$DIR2/$tfile
389         local stripe_size=$(do_facet $SINGLEMDS \
390                 "$LCTL get_param -n lod.$(facet_svc $SINGLEMDS)*.stripesize")
391
392         check_set_fallocate
393
394         # to allocate grant because it may run out due to test_15.
395         $LFS setstripe -c -1 $file1
396         dd if=/dev/zero of=$file1 bs=$stripe_size count=$OSTCOUNT oflag=sync
397         dd if=/dev/zero of=$file2 bs=$stripe_size count=$OSTCOUNT oflag=sync
398         rm -f $file1
399
400         $LFS setstripe -c -1 $file1 # b=10919
401         $FSX -c 50 -p $FSXP -N $FSXNUM -l $((SIZE * 256)) -S 0 $file1 $file2 ||
402                 error "fsx failed"
403         rm -f $file1
404
405         # O_DIRECT reads and writes must be aligned to the device block size.
406         $FSX -c 50 -p $FSXP -N $FSXNUM -l $((SIZE * 256)) -S 0 -Z -r 4096 \
407                 -w 4096 $file1 $file2 || error "fsx with O_DIRECT failed."
408 }
409 run_test 16a "$FSXNUM iterations of dual-mount fsx"
410
411 # Consistency check for tiny writes, LU-9409
412 test_16b() {
413         local file1=$DIR1/$tfile
414         local file2=$DIR2/$tfile
415         local stripe_size=($($LFS getstripe -S $DIR))
416
417         check_set_fallocate
418
419         # to allocate grant because it may run out due to test_15.
420         lfs setstripe -c -1 $file1
421         dd if=/dev/zero of=$file1 bs=$stripe_size count=$OSTCOUNT oflag=sync ||
422                 error "dd failed writing to file=$file1"
423         dd if=/dev/zero of=$file2 bs=$stripe_size count=$OSTCOUNT oflag=sync ||
424                 error "dd failed writing to file=$file2"
425         rm -f $file1
426
427         lfs setstripe -c -1 $file1 # b=10919
428         # -o is set to 8192 because writes < 1 page and between 1 and 2 pages
429         # create a mix of tiny writes & normal writes
430         $FSX -c 50 -p $FSXP -N $FSXNUM -l $((SIZE * 256)) -o 8192 -S 0 \
431                 $file1 $file2 || error "fsx with tiny write failed."
432 }
433 run_test 16b "$FSXNUM iterations of dual-mount fsx at small size"
434
435 test_16c() {
436         local file1=$DIR1/$tfile
437         local file2=$DIR2/$tfile
438         local stripe_size=$(do_facet $SINGLEMDS \
439                 "$LCTL get_param -n lod.$(facet_svc $SINGLEMDS)*.stripesize")
440
441         [ "$ost1_FSTYPE" != ldiskfs ] && skip "dio on ldiskfs only"
442
443         check_set_fallocate
444
445         # to allocate grant because it may run out due to test_15.
446         $LFS setstripe -c -1 $file1
447         dd if=/dev/zero of=$file1 bs=$stripe_size count=$OSTCOUNT oflag=sync
448         dd if=/dev/zero of=$file2 bs=$stripe_size count=$OSTCOUNT oflag=sync
449         rm -f $file1
450         wait_delete_completed
451
452         local list=$(comma_list $(osts_nodes))
453         if ! get_osd_param $list '' read_cache_enable >/dev/null; then
454                 skip "not cache-capable obdfilter"
455         fi
456
457         set_osd_param $list '' read_cache_enable 0
458         set_osd_param $list '' writethrough_cache_enable 0
459
460         $LFS setstripe -c -1 $file1 # b=10919
461         $FSX -c 50 -p $FSXP -N $FSXNUM -l $((SIZE * 256)) -S 0 $file1 $file2 ||
462                 error "fsx failed"
463         rm -f $file1
464
465         set_osd_param $list '' read_cache_enable 1
466         set_osd_param $list '' writethrough_cache_enable 1
467
468         return 0
469 }
470 run_test 16c "verify data consistency on ldiskfs with cache disabled (b=17397)"
471
472 test_16d() {
473         local file1=$DIR1/$tfile
474         local file2=$DIR2/$tfile
475         local file3=$DIR1/file
476         local tmpfile=$(mktemp)
477         local stripe_size=$(do_facet $SINGLEMDS \
478                 "$LCTL get_param -n lod.$(facet_svc $SINGLEMDS)*.stripesize")
479
480         # to allocate grant because it may run out due to test_15.
481         $LFS setstripe -c -1 $file1
482         stack_trap "rm -f $file1 $file2 $file3 $tmpfile"
483         dd if=/dev/zero of=$file1 bs=$stripe_size count=$OSTCOUNT oflag=sync
484         dd if=/dev/zero of=$file2 bs=$stripe_size count=$OSTCOUNT oflag=sync
485         rm -f $file1
486
487         $LFS setstripe -c -1 $file1 # b=10919
488         $LCTL set_param ldlm.namespaces.*.lru_size=clear
489         
490         # direct write on one client and direct read from another
491         dd if=/dev/urandom of=$file1 bs=1M count=100 oflag=direct
492         dd if=$file2 of=$tmpfile iflag=direct bs=1M
493         diff $file1 $tmpfile || error "file different(1)"
494         rm -f $file1
495
496         # buffer write on one client, but direct read from another
497         dd if=$tmpfile of=$file1 bs=1M count=100
498         dd if=$file2 of=$file3 bs=1M iflag=direct count=100
499         diff $file3 $tmpfile || error "file different(2)"
500
501         rm -f $file3 $file2 $file1
502         # direct write on one client
503         dd if=$tmpfile of=$file1 bs=1M count=100 oflag=direct
504         # buffer read from another client
505         dd if=$file2 of=$file3 bs=1M count=100
506         diff $file3 $tmpfile || error "file different(3)"
507 }
508 run_test 16d "Verify DIO and buffer IO with two clients"
509
510 test_16e() { # LU-13227
511         # issue:        LU-14314
512
513         (( "$MDS1_VERSION" >= $(version_code 2.13.53) )) ||
514                 skip "Need MDS version at least 2.13.53"
515
516         local file1=$DIR1/$tfile
517         local file2=$DIR2/$tfile
518
519         # client1 write 10M data
520         dd if=/dev/zero of=$file1 bs=1M count=10
521         # drop locks
522         cancel_lru_locks osc > /dev/null
523         # use lockahead to generate one PW lock to keep LVB loaded.
524         $LFS ladvise -a lockahead --start 0 --length 1M \
525                 --mode WRITE $file1
526         # direct write to extend file size on client2
527         dd if=/dev/zero of=$file2 bs=1M seek=20 count=1 \
528                 oflag=direct conv=notrunc
529         local filesize=$(stat -c %s $file2)
530         [ "$filesize" -eq 22020096 ] ||
531                 error "expected filesize 22020096 got $filesize"
532         rm -f $file1
533 }
534 run_test 16e "Verify size consistency for O_DIRECT write"
535
536 test_17() { # bug 3513, 3667
537         remote_ost_nodsh && skip "remote OST with nodsh" && return
538
539         lfs setstripe $DIR1/$tfile -i 0 -c 1
540         cp $SAMPLE_FILE $DIR1/$tfile
541         cancel_lru_locks osc > /dev/null
542         #define OBD_FAIL_ONCE|OBD_FAIL_LDLM_CREATE_RESOURCE    0x30a
543         do_facet ost1 lctl set_param fail_loc=0x8000030a
544         ls -ls $DIR1/$tfile | awk '{ print $1,$6 }' > $DIR1/$tfile-1 & \
545         ls -ls $DIR2/$tfile | awk '{ print $1,$6 }' > $DIR2/$tfile-2
546         wait
547         diff -u $DIR1/$tfile-1 $DIR2/$tfile-2 || error "files are different"
548 }
549 run_test 17 "resource creation/LVB creation race ==============="
550
551 test_18() {
552         # turn e.g. ALWAYS_EXCEPT="18c" into "-e 3"
553         local idx
554         local excepts=
555         for idx in {a..z}; do
556                 local ptr=EXCEPT_ALWAYS_18$idx
557                 [ x${!ptr} = xtrue ] || continue
558
559                 excepts="$excepts -e $(($(printf %d \'$idx)-96))"
560         done
561
562         excepts="$excepts -e 7 -e 8 -e 9"
563         $LUSTRE/tests/mmap_sanity -d $MOUNT1 -m $MOUNT2 $excepts ||
564                 error "mmap_sanity test failed"
565         sync; sleep 1; sync
566 }
567 run_test 18 "mmap sanity check ================================="
568
569 test_19() { # bug3811
570         local node=$(facet_active_host ost1)
571
572         [ "x$DOM" = "xyes" ] && node=$(facet_active_host $SINGLEMDS)
573
574         # check whether obdfilter is cache capable at all
575         get_osd_param $node '' read_cache_enable >/dev/null ||
576                 skip "not cache-capable obdfilter"
577
578         local MAX=$(get_osd_param $node '' readcache_max_filesize | head -n 1)
579         set_osd_param $node '' readcache_max_filesize 4096
580         dd if=/dev/urandom of=$TMP/$tfile bs=512k count=32
581         local SUM=$(cksum $TMP/$tfile | cut -d" " -f 1,2)
582         cp $TMP/$tfile $DIR1/$tfile
583         for i in `seq 1 20`; do
584                 [ $((i % 5)) -eq 0 ] && log "$testname loop $i"
585                 cancel_lru_locks $OSC > /dev/null
586                 cksum $DIR1/$tfile | cut -d" " -f 1,2 > $TMP/sum1 & \
587                 cksum $DIR2/$tfile | cut -d" " -f 1,2 > $TMP/sum2
588                 wait
589                 [ "$(cat $TMP/sum1)" = "$SUM" ] || \
590                         error "$DIR1/$tfile $(cat $TMP/sum1) != $SUM"
591                 [ "$(cat $TMP/sum2)" = "$SUM" ] || \
592                         error "$DIR2/$tfile $(cat $TMP/sum2) != $SUM"
593         done
594         set_osd_param $node '' readcache_max_filesize $MAX
595         rm $DIR1/$tfile
596 }
597 run_test 19 "test concurrent uncached read races ==============="
598
599 test_20() {
600         test_mkdir $DIR1/$tdir
601         cancel_lru_locks
602         CNT=$($LCTL get_param -n llite.*.dump_page_cache | wc -l)
603         $MULTIOP $DIR1/$tdir/$tfile Ow8190c
604         $MULTIOP $DIR2/$tdir/$tfile Oz8194w8190c
605         $MULTIOP $DIR1/$tdir/$tfile Oz0r8190c
606         cancel_lru_locks
607         CNT2=$($LCTL get_param -n llite.*.dump_page_cache | wc -l)
608         [[ $CNT2 == $CNT ]] ||
609                 error $((CNT2 - CNT))" page left in cache after lock cancel"
610 }
611 run_test 20 "test extra readahead page left in cache ===="
612
613 cleanup_21() {
614         trap 0
615         umount $DIR1/$tdir
616 }
617
618 test_21() { # Bug 5907
619         test_mkdir $DIR1/$tdir
620         mount /etc $DIR1/$tdir --bind || error "mount failed" # Poor man's mount.
621         trap cleanup_21 EXIT
622         rmdir -v $DIR1/$tdir && error "Removed mounted directory"
623         rmdir -v $DIR2/$tdir && echo "Removed mounted directory from another mountpoint, needs to be fixed"
624         test -d $DIR1/$tdir || error "Mounted directory disappeared"
625         cleanup_21
626         test -d $DIR2/$tdir || test -d $DIR1/$tdir && error "Removed dir still visible after umount"
627         true
628 }
629 run_test 21 " Try to remove mountpoint on another dir ===="
630
631 test_23() { # Bug 5972
632         local at_diff=$(do_facet $SINGLEMDS \
633                 $LCTL get_param -n mdd.*MDT0000*.atime_diff | head -n1)
634         echo "atime should be updated while another read" > $DIR1/$tfile
635
636         # clear the lock(mode: LCK_PW) gotten from creating operation
637         cancel_lru_locks $OSC
638         time1=$(date +%s)
639         echo "now is $time1"
640         sleep $((at_diff + 1))
641
642         echo "starting reads"
643         multiop_bg_pause $DIR1/$tfile or20_c || return 1
644         # with SOM and opencache enabled, we need to close a file and cancel
645         # open lock to get atime propogated to MDS
646         kill -USR1 $! || return 2
647         cancel_lru_locks mdc
648
649         time2=$(stat -c "%X" $DIR/$tfile)
650         echo "new atime is $time2"
651
652         [ $time2 -gt $time1 ] || error "atime was not updated"
653         rm -f $DIR1/$tfile || error "rm -f $DIR1/$tfile failed"
654         true
655 }
656 run_test 23 " others should see updated atime while another read===="
657
658 test_24a() {
659         touch $DIR1/$tfile
660         lfs df || error "lfs df failed"
661         lfs df -ih || error "lfs df -ih failed"
662         lfs df -h $DIR1 || error "lfs df -h $DIR1 failed"
663         lfs df -i $DIR2 || error "lfs df -i $DIR2 failed"
664         lfs df $DIR1/$tfile || error "lfs df $DIR1/$tfile failed"
665         lfs df -ih $DIR2/$tfile || error "lfs df -ih $DIR2/$tfile failed"
666
667         OSC=`lctl dl | awk '/-osc-|OSC.*MNT/ {print $4}' | head -n 1`
668 #       OSC=`lctl dl | awk '/-osc-/ {print $4}' | head -n 1`
669         lctl --device %osc deactivate
670         lfs df -i || error "lfs df -i with deactivated OSC failed"
671         lctl --device %osc activate
672         lfs df || error "lfs df with reactivated OSC failed"
673 }
674 run_test 24a "lfs df [-ih] [path] test ========================="
675
676 test_24b() {
677         touch $DIR1/$tfile
678         fsnum=$(lfs_df | grep -c "summary")
679         [ $fsnum -eq 2 ] || error "lfs df shows $fsnum != 2 filesystems."
680 }
681 run_test 24b "lfs df should show both filesystems ==============="
682
683 test_25a() {
684         local acl=$(lctl get_param -n mdc.*MDT0000-mdc-*.connect_flags |
685                                                                 grep -c acl)
686         [ "$acl" -lt 1 ] && skip "must have acl, skipping" && return
687
688         mkdir -p $DIR1/$tdir
689         touch $DIR1/$tdir/f1 || error "touch $DIR1/$tdir/f1"
690         chmod 0755 $DIR1/$tdir/f1 || error "chmod 0755 $DIR1/$tdir/f1"
691
692         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 || error "checkstat $DIR2/$tdir/f1 #1"
693         setfacl -m u:$RUNAS_ID:--- -m g:$RUNAS_GID:--- $DIR1/$tdir ||
694                 error "setfacl $DIR2/$tdir #1"
695         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 && error "checkstat $DIR2/$tdir/f1 #2"
696         setfacl -m u:$RUNAS_ID:r-x -m g:$RUNAS_GID:r-x $DIR1/$tdir ||
697                 error "setfacl $DIR2/$tdir #2"
698         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 || error "checkstat $DIR2/$tdir/f1 #3"
699         setfacl -m u:$RUNAS_ID:--- -m g:$RUNAS_GID:--- $DIR1/$tdir ||
700                 error "setfacl $DIR2/$tdir #3"
701         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 && error "checkstat $DIR2/$tdir/f1 #4"
702         setfacl -x u:$RUNAS_ID: -x g:$RUNAS_GID: $DIR1/$tdir ||
703                 error "setfacl $DIR2/$tdir #4"
704         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 || error "checkstat $DIR2/$tdir/f1 #5"
705
706         rm -rf $DIR1/$tdir
707 }
708 run_test 25a "change ACL on one mountpoint be seen on another ==="
709
710 test_25b() {
711         local acl=$(lctl get_param -n mdc.*MDT0000-mdc-*.connect_flags |
712                                                         grep -c acl)
713         [ "$acl" -lt 1 ] && skip "must have acl, skipping" && return
714
715         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
716
717         rm -rf $DIR1/$tdir
718         $LFS mkdir -i 1 $DIR1/$tdir
719         touch $DIR1/$tdir/f1 || error "touch $DIR1/$tdir/f1"
720         chmod 0755 $DIR1/$tdir/f1 || error "chmod 0755 $DIR1/$tdir/f1"
721
722         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 || error "checkstat $DIR2/$tdir/f1 #1"
723         setfacl -m u:$RUNAS_ID:--- -m g:$RUNAS_GID:--- $DIR1/$tdir ||
724                 error "setfacl $DIR2/$tdir #1"
725         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 && error "checkstat $DIR2/$tdir/f1 #2"
726         setfacl -m u:$RUNAS_ID:r-x -m g:$RUNAS_GID:r-x $DIR1/$tdir ||
727                 error "setfacl $DIR2/$tdir #2"
728         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 || error "checkstat $DIR2/$tdir/f1 #3"
729         setfacl -m u:$RUNAS_ID:--- -m g:$RUNAS_GID:--- $DIR1/$tdir ||
730                 error "setfacl $DIR2/$tdir #3"
731         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 && error "checkstat $DIR2/$tdir/f1 #4"
732         setfacl -x u:$RUNAS_ID: -x g:$RUNAS_GID: $DIR1/$tdir ||
733                 error "setfacl $DIR2/$tdir #4"
734         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 || error "checkstat $DIR2/$tdir/f1 #5"
735
736         rm -rf $DIR1/$tdir
737 }
738 run_test 25b "change ACL under remote dir on one mountpoint be seen on another"
739
740 test_26a() {
741         utime $DIR1/f26a -s $DIR2/f26a || error "utime failed for $DIR1/f26a"
742 }
743 run_test 26a "allow mtime to get older"
744
745 test_26b() {
746         touch $DIR1/$tfile
747         sleep 1
748         echo "aaa" >> $DIR1/$tfile
749         sleep 1
750         chmod a+x $DIR2/$tfile
751         mt1=`stat -c %Y $DIR1/$tfile`
752         mt2=`stat -c %Y $DIR2/$tfile`
753
754         if [ x"$mt1" != x"$mt2" ]; then
755                 error "not equal mtime, client1: "$mt1", client2: "$mt2"."
756         fi
757 }
758 run_test 26b "sync mtime between ost and mds"
759
760 test_27() {
761         cancel_lru_locks $OSC
762         lctl clear
763         dd if=/dev/zero of=$DIR2/$tfile bs=$((4096+4))k conv=notrunc count=4 seek=3 &
764         DD2_PID=$!
765         sleep 0.5
766         log "dd 1 started"
767
768         dd if=/dev/zero of=$DIR1/$tfile bs=$((16384-1024))k conv=notrunc count=1 seek=4 &
769         DD1_PID=$!
770         log "dd 2 started"
771
772         sleep 1
773         dd if=/dev/zero of=$DIR1/$tfile bs=8k conv=notrunc count=1 seek=0
774         log "dd 3 finished"
775         lctl set_param -n ldlm.dump_namespaces ""
776         wait $DD1_PID $DD2_PID
777         [ $? -ne 0 ] && lctl dk $TMP/debug || true
778 }
779 run_test 27 "align non-overlapping extent locks from request ==="
780
781 test_28() { # bug 9977
782         ECHO_UUID="ECHO_osc1_UUID"
783         tOST=$($LCTL dl | awk '/-osc-|OSC.*MNT/ { print $4 }' | head -n1)
784
785         $LFS setstripe $DIR1/$tfile -S 1048576 -i 0 -c 2
786         tOBJID=`$LFS getstripe $DIR1/$tfile | awk '$1 == 1 {print $2}'`
787         dd if=/dev/zero of=$DIR1/$tfile bs=1024k count=2
788
789         $LCTL <<-EOF
790                 newdev
791                 attach echo_client ECHO_osc1 $ECHO_UUID
792                 setup $tOST
793         EOF
794
795         tECHOID=`$LCTL dl | grep $ECHO_UUID | awk '{ print $1 }'`
796         $LCTL --device $tECHOID destroy "${tOBJID}:0"
797
798         $LCTL <<-EOF
799                 cfg_device ECHO_osc1
800                 cleanup
801                 detach
802         EOF
803
804         # reading of 1st stripe should pass
805         dd if=$DIR2/$tfile of=/dev/null bs=1024k count=1 || error "dd failed"
806         # reading of 2nd stripe should fail (this stripe was destroyed)
807         dd if=$DIR2/$tfile of=/dev/null bs=1024k count=1 skip=1 && error
808
809         # now, recreating test file
810         dd if=/dev/zero of=$DIR1/$tfile bs=1024k count=2 || error "dd failed"
811         # reading of 1st stripe should pass
812         dd if=$DIR2/$tfile of=/dev/null bs=1024k count=1 || error "dd failed"
813         # reading of 2nd stripe should pass
814         dd if=$DIR2/$tfile of=/dev/null bs=1024k count=1 skip=1 ||
815                 error "dd failed"
816 }
817 run_test 28 "read/write/truncate file with lost stripes"
818
819 test_30() { #b=11110, LU-2523
820         test_mkdir $DIR1/$tdir
821         cp -f /bin/bash $DIR1/$tdir/bash
822         /bin/sh -c 'sleep 1; rm -f $DIR2/$tdir/bash; cp /bin/bash $DIR2/$tdir' &
823         $DIR1/$tdir/bash -c 'sleep 2;
824                 openfile -f O_RDONLY /proc/$$/exe >& /dev/null; echo $?'
825         wait
826         true
827 }
828 run_test 30 "recreate file race"
829
830 test_31a() {
831         test_mkdir $DIR1/$tdir
832         local writes=$(LANG=C dd if=/dev/zero of=$DIR/$tdir/$tfile \
833                        count=1 2>&1 | awk 'BEGIN { FS="+" } /out/ {print $1}')
834         #define OBD_FAIL_LDLM_CANCEL_BL_CB_RACE   0x314
835         lctl set_param fail_loc=0x314
836         local reads=$(LANG=C dd if=$DIR2/$tdir/$tfile of=/dev/null 2>&1 |
837                       awk 'BEGIN { FS="+" } /in/ {print $1}')
838         [ $reads -eq $writes ] || error "read" $reads "blocks, must be" $writes
839 }
840 run_test 31a "voluntary cancel / blocking ast race=============="
841
842 test_31b() {
843         remote_ost || { skip "local OST" && return 0; }
844         remote_ost_nodsh && skip "remote OST w/o dsh" && return 0
845
846         # make sure there is no local locks due to destroy
847         wait_mds_ost_sync || error "wait_mds_ost_sync()"
848         wait_delete_completed || error "wait_delete_completed()"
849
850         test_mkdir $DIR1/$tdir
851         lfs setstripe $DIR/$tdir/$tfile -i 0 -c 1
852         cp /etc/hosts $DIR/$tdir/$tfile
853         #define OBD_FAIL_LDLM_CANCEL_BL_CB_RACE   0x314
854         lctl set_param fail_loc=0x314
855         #define OBD_FAIL_LDLM_OST_FAIL_RACE      0x316
856         do_facet ost1 lctl set_param fail_loc=0x316
857         # Don't crash kernel
858         cat $DIR2/$tdir/$tfile > /dev/null 2>&1
859         lctl set_param fail_loc=0
860         do_facet ost1 lctl set_param fail_loc=0
861         # cleanup: reconnect the client back
862         df $DIR2
863 }
864 run_test 31b "voluntary OST cancel / blocking ast race=============="
865
866 # enable/disable lockless truncate feature, depending on the arg 0/1
867 enable_lockless_truncate() {
868         lctl set_param -n $OSC.*.lockless_truncate $1
869 }
870
871 test_32a() { # bug 11270
872         local save="$TMP/$TESTSUITE-$TESTNAME.parameters"
873         local stripe_size=$(do_facet $SINGLEMDS \
874                 "$LCTL get_param -n lod.$(facet_svc $SINGLEMDS)*.stripesize")
875
876         save_lustre_params client "$OSC.*.lockless_truncate" > $save
877         # restore lockless_truncate default values on exit
878         stack_trap "restore_lustre_params < $save; rm -f $save" EXIT
879         cancel_lru_locks $OSC
880         enable_lockless_truncate 1
881         rm -f $DIR1/$tfile
882         lfs setstripe -c -1 $DIR1/$tfile
883         dd if=/dev/zero of=$DIR1/$tfile count=$OSTCOUNT bs=$stripe_size > \
884                 /dev/null 2>&1
885         clear_stats $OSC.*.${OSC}_stats
886
887         log "checking cached lockless truncate"
888         $TRUNCATE $DIR1/$tfile 8000000
889         $CHECKSTAT -s 8000000 $DIR2/$tfile ||
890                 error "cached truncate - wrong file size"
891         [ $(calc_stats $OSC.*.${OSC}_stats lockless_truncate) -ne 0 ] ||
892                 error "cached truncate isn't lockless"
893
894         log "checking not cached lockless truncate"
895         $TRUNCATE $DIR2/$tfile 5000000
896         $CHECKSTAT -s 5000000 $DIR1/$tfile ||
897                 error "not cached truncate - wrong file size"
898         [ $(calc_stats $OSC.*.${OSC}_stats lockless_truncate) -ne 0 ] ||
899                 error "not cached truncate isn't lockless"
900
901         log "disabled lockless truncate"
902         enable_lockless_truncate 0
903         clear_stats $OSC.*.${OSC}_stats
904         $TRUNCATE $DIR2/$tfile 3000000
905         $CHECKSTAT -s 3000000 $DIR1/$tfile ||
906                 error "lockless truncate disabled - wrong file size"
907         [ $(calc_stats $OSC.*.${OSC}_stats lockless_truncate) -eq 0 ] ||
908                 error "lockless truncate disabling failed"
909         rm -f $DIR1/$tfile
910 }
911 run_test 32a "lockless truncate"
912
913 test_32b() { # bug 11270
914         remote_ost_nodsh && skip "remote OST with nodsh" && return
915
916         local node
917         local facets=$(get_facets OST)
918         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
919
920         save_lustre_params client "osc.*.contention_seconds" > $p
921         save_lustre_params $facets \
922                 "ldlm.namespaces.filter-*.max_nolock_bytes" >> $p
923         save_lustre_params $facets \
924                 "ldlm.namespaces.filter-*.contended_locks" >> $p
925         save_lustre_params $facets \
926                 "ldlm.namespaces.filter-*.contention_seconds" >> $p
927         clear_stats $OSC.*.${OSC}_stats
928
929         # agressive lockless i/o settings
930         do_nodes $(comma_list $(osts_nodes)) \
931                 "lctl set_param -n ldlm.namespaces.*.max_nolock_bytes=2000000 \
932                         ldlm.namespaces.filter-*.contended_locks=0 \
933                         ldlm.namespaces.filter-*.contention_seconds=60"
934         lctl set_param -n $OSC.*.contention_seconds=60
935         for i in {1..5}; do
936                 dd if=/dev/zero of=$DIR1/$tfile bs=4k count=1 conv=notrunc > \
937                         /dev/null 2>&1
938                 dd if=/dev/zero of=$DIR2/$tfile bs=4k count=1 conv=notrunc > \
939                         /dev/null 2>&1
940         done
941         [ $(calc_stats $OSC.*.${OSC}_stats lockless_write_bytes) -ne 0 ] ||
942                 error "lockless i/o was not triggered"
943         # disable lockless i/o (it is disabled by default)
944         do_nodes $(comma_list $(osts_nodes)) \
945                 "lctl set_param -n ldlm.namespaces.filter-*.max_nolock_bytes=0 \
946                         ldlm.namespaces.filter-*.contended_locks=32 \
947                         ldlm.namespaces.filter-*.contention_seconds=0"
948         # set contention_seconds to 0 at client too, otherwise Lustre still
949         # remembers lock contention
950         lctl set_param -n $OSC.*.contention_seconds=0
951         clear_stats $OSC.*.${OSC}_stats
952         for i in {1..1}; do
953                 dd if=/dev/zero of=$DIR1/$tfile bs=4k count=1 conv=notrunc > \
954                         /dev/null 2>&1
955                 dd if=/dev/zero of=$DIR2/$tfile bs=4k count=1 conv=notrunc > \
956                         /dev/null 2>&1
957         done
958         [ $(calc_stats $OSC.*.${OSC}_stats lockless_write_bytes) -eq 0 ] ||
959                 error "lockless i/o works when disabled"
960         rm -f $DIR1/$tfile
961         restore_lustre_params <$p
962         rm -f $p
963 }
964 run_test 32b "lockless i/o"
965
966 print_jbd_stat () {
967     local dev
968     local mdts=$(get_facets MDS)
969     local varcvs
970     local mds
971
972     local stat=0
973     for mds in ${mdts//,/ }; do
974         varsvc=${mds}_svc
975         dev=$(basename $(do_facet $mds "lctl get_param -n osd*.${!varsvc}.mntdev|\
976                 xargs readlink -f" ))
977         val=$(do_facet $mds "cat /proc/fs/jbd*/${dev}{,:*,-*}/info 2>/dev/null |
978                 head -n1")
979         val=${val%% *};
980         stat=$(( stat + val))
981     done
982     echo $stat
983 }
984
985 # commit on sharing tests
986 test_33a() {
987         remote_mds_nodsh && skip "remote MDS with nodsh" && return
988
989         [ -z "$CLIENTS" ] && skip "Need two or more clients, have $CLIENTS"
990         [ $CLIENTCOUNT -lt 2 ] &&
991                 skip "Need two or more clients, have $CLIENTCOUNT"
992
993         local nfiles=${TEST33_NFILES:-10000}
994         local param_file=$TMP/$tfile-params
995         local COS
996         local jbdold="N/A"
997         local jbdnew="N/A"
998         local jbd
999
1000         save_lustre_params $(get_facets MDS) \
1001                 "mdt.*.commit_on_sharing" > $param_file
1002
1003         for COS in 0 1; do
1004                 do_facet $SINGLEMDS lctl set_param mdt.*.commit_on_sharing=$COS
1005                 avgjbd=0
1006                 avgtime=0
1007                 for i in 1 2 3; do
1008                         do_nodes $CLIENT1,$CLIENT2 "mkdir -p $DIR1/$tdir-\\\$(hostname)-$i"
1009
1010                 [ "$mds1_FSTYPE" = ldiskfs ] && jbdold=$(print_jbd_stat)
1011                 echo "=== START createmany old: $jbdold transaction"
1012                 local elapsed=$(do_and_time "do_nodes $CLIENT1,$CLIENT2 createmany -o $DIR1/$tdir-\\\$(hostname)-$i/f- -r$DIR2/$tdir-\\\$(hostname)-$i/f- $nfiles > /dev/null 2>&1")
1013                 [ "$mds1_FSTYPE" = ldiskfs ] && jbdnew=$(print_jbd_stat)
1014                 [ "$mds1_FSTYPE" = ldiskfs ] && jbd=$(( jbdnew - jbdold ))
1015                 echo "=== END   createmany new: $jbdnew transaction :  $jbd transactions  nfiles $nfiles time $elapsed COS=$COS"
1016                 [ "$mds1_FSTYPE" = ldiskfs ] && avgjbd=$(( avgjbd + jbd ))
1017                 avgtime=$(( avgtime + elapsed ))
1018                 done
1019         eval cos${COS}_jbd=$((avgjbd / 3))
1020         eval cos${COS}_time=$((avgtime / 3))
1021         done
1022
1023         echo "COS=0 transactions (avg): $cos0_jbd  time (avg): $cos0_time"
1024         echo "COS=1 transactions (avg): $cos1_jbd  time (avg): $cos1_time"
1025         [ "$cos0_jbd" != 0 ] &&
1026                 echo "COS=1 vs COS=0 jbd:  $((((cos1_jbd/cos0_jbd - 1)) * 100 )) %"
1027         [ "$cos0_time" != 0 ] &&
1028                 echo "COS=1 vs COS=0 time: $((((cos1_time/cos0_time - 1)) * 100 )) %"
1029
1030         restore_lustre_params < $param_file
1031         rm -f $param_file
1032         return 0
1033 }
1034 run_test 33a "commit on sharing, cross crete/delete, 2 clients, benchmark"
1035
1036 # commit on sharing tests
1037 test_33b() {
1038         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1039
1040         [ -n "$CLIENTS" ] || { skip "Need two or more clients" && return 0; }
1041         [ $CLIENTCOUNT -ge 2 ] ||
1042                 { skip "Need two or more clients, have $CLIENTCOUNT" &&
1043                                                                 return 0; }
1044         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
1045
1046         local nfiles=${TEST33_NFILES:-10000}
1047         local param_file=$TMP/$tfile-params
1048
1049         save_lustre_params $(get_facets MDS) \
1050                 "mdt.*.commit_on_sharing" > $param_file
1051
1052         local COS
1053         local jbdold
1054         local jbdnew
1055         local jbd
1056         local MDTIDX=1
1057
1058         for COS in 0 1; do
1059                 do_facet $SINGLEMDS lctl set_param mdt.*.commit_on_sharing=$COS
1060                 avgjbd=0
1061                 avgtime=0
1062                 for i in 1 2 3; do
1063                         do_node $CLIENT1 "$LFS mkdir -i $MDTIDX \
1064                                           $DIR1/$tdir-\\\$(hostname)-$i"
1065
1066                         jbdold=$(print_jbd_stat)
1067                         echo "=== START createmany old: $jbdold transaction"
1068                         local elapsed=$(do_and_time "do_nodes $CLIENT1,$CLIENT2\
1069                                 createmany -o $DIR1/$tdir-\\\$(hostname)-$i/f- \
1070                                 -r$DIR2/$tdir-\\\$(hostname)-$i/f- $nfiles > \
1071                                                                 /dev/null 2>&1")
1072                         jbdnew=$(print_jbd_stat)
1073                         jbd=$(( jbdnew - jbdold ))
1074                         echo "=== END   createmany new: $jbdnew transaction : \
1075                         $jbd transactions nfiles $nfiles time $elapsed COS=$COS"
1076                         avgjbd=$(( avgjbd + jbd ))
1077                         avgtime=$(( avgtime + elapsed ))
1078                 done
1079                 eval cos${COS}_jbd=$((avgjbd / 3))
1080                 eval cos${COS}_time=$((avgtime / 3))
1081         done
1082
1083         echo "COS=0 transactions (avg): $cos0_jbd  time (avg): $cos0_time"
1084         echo "COS=1 transactions (avg): $cos1_jbd  time (avg): $cos1_time"
1085         [ "$cos0_jbd" != 0 ] &&
1086             echo "COS=1 vs COS=0 jbd: $(((cos1_jbd/cos0_jbd - 1) * 100)) %"
1087         [ "$cos0_time" != 0 ] &&
1088             echo "COS=1 vs COS=0 time: $(((cos1_time/cos0_time - 1) * 100)) %"
1089
1090         restore_lustre_params < $param_file
1091         rm -f $param_file
1092         return 0
1093 }
1094 run_test 33b "COS: cross create/delete, 2 clients, benchmark under remote dir"
1095
1096 test_33c() {
1097         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
1098         [ "$MDS1_VERSION" -lt $(version_code 2.7.63) ] &&
1099                 skip "DNE CoS not supported"
1100
1101         # LU-13522
1102         stop mds1
1103         start mds1 $(mdsdevname 1) $MDS_MOUNT_OPTS || error "start mds1 failed"
1104
1105         local sync_count
1106
1107         mkdir $DIR/$tdir
1108         sync_all_data
1109         do_facet mds1 "lctl set_param -n mdt.*.sync_count=0"
1110         # do twice in case transaction is committed before unlock, see LU-8200
1111         for i in 1 2; do
1112                 # remote dir is created on MDT1, which enqueued lock of $tdir on
1113                 # MDT0
1114                 $LFS mkdir -i 1 $DIR/$tdir/remote.$i
1115                 mkdir $DIR/$tdir/local.$i
1116         done
1117         sync_count=$(do_facet mds1 "lctl get_param -n mdt.*MDT0000.sync_count")
1118         echo "sync_count $sync_count"
1119         [ $sync_count -eq 0 ] && error "Sync-Lock-Cancel not triggered"
1120
1121         sync_all_data
1122         do_facet mds1 "lctl set_param -n mdt.*.sync_count=0"
1123         $LFS mkdir -i 1 $DIR/$tdir/remote.3
1124         # during sleep remote mkdir should have been committed and canceled
1125         # remote lock spontaneously, which shouldn't trigger sync
1126         sleep 6
1127         mkdir $DIR/$tdir/local.3
1128         sync_count=$(do_facet mds1 "lctl get_param -n mdt.*MDT0000.sync_count")
1129         echo "sync_count $sync_count"
1130         [ $sync_count -eq 0 ] || error "Sync-Lock-Cancel triggered"
1131 }
1132 run_test 33c "Cancel cross-MDT lock should trigger Sync-Lock-Cancel"
1133
1134 # arg1 is operations done before CoS, arg2 is the operation that triggers CoS
1135 op_trigger_cos() {
1136         local commit_nr
1137         local total=0
1138         local nodes=$(comma_list $(mdts_nodes))
1139
1140         sync_all_data
1141
1142         # trigger CoS twice in case transaction commit before unlock
1143         for i in 1 2; do
1144                 sh -c "$1"
1145                 do_nodes $nodes "lctl set_param -n mdt.*.async_commit_count=0"
1146                 sh -c "$2"
1147                 commit_nr=$(do_nodes $nodes \
1148                         "lctl get_param -n mdt.*.async_commit_count" | calc_sum)
1149                 total=$((total + commit_nr));
1150                 rm -rf $DIR/$tdir
1151                 sync_all_data
1152         done
1153
1154         echo "CoS count $total"
1155         [ $total -gt 0 ] || error "$2 didn't trigger CoS"
1156 }
1157
1158 test_33d() {
1159         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
1160         [ "$MDS1_VERSION" -lt $(version_code 2.7.63) ] &&
1161                 skip "DNE CoS not supported"
1162
1163         # remote directory create
1164         op_trigger_cos "mkdir $DIR/$tdir" "$LFS mkdir -i 1 $DIR/$tdir/subdir"
1165         # remote directory unlink
1166         op_trigger_cos "$LFS mkdir -i 1 $DIR/$tdir" "rmdir $DIR/$tdir"
1167         # striped directory create
1168         op_trigger_cos "mkdir $DIR/$tdir" "$LFS mkdir -c 2 $DIR/$tdir/subdir"
1169         # striped directory setattr
1170         op_trigger_cos "$LFS mkdir -c 2 $DIR/$tdir; touch $DIR/$tdir" \
1171                 "chmod 713 $DIR/$tdir"
1172         # striped directory unlink
1173         op_trigger_cos "$LFS mkdir -c 2 $DIR/$tdir; touch $DIR/$tdir" \
1174                 "rmdir $DIR/$tdir"
1175         # cross-MDT link
1176         op_trigger_cos "$LFS mkdir -c 2 $DIR/$tdir; \
1177                         $LFS mkdir -i 0 $DIR/$tdir/d1; \
1178                         $LFS mkdir -i 1 $DIR/$tdir/d2; \
1179                         touch $DIR/$tdir/d1/tgt" \
1180                 "ln $DIR/$tdir/d1/tgt $DIR/$tdir/d2/src"
1181         # cross-MDT rename
1182         op_trigger_cos "$LFS mkdir -c 2 $DIR/$tdir; \
1183                         $LFS mkdir -i 0 $DIR/$tdir/d1; \
1184                         $LFS mkdir -i 1 $DIR/$tdir/d2; \
1185                         touch $DIR/$tdir/d1/src" \
1186                 "mv $DIR/$tdir/d1/src $DIR/$tdir/d2/tgt"
1187         # migrate
1188         op_trigger_cos "$LFS mkdir -i 0 $DIR/$tdir" \
1189                 "$LFS migrate -m 1 $DIR/$tdir"
1190
1191         return 0
1192 }
1193 run_test 33d "DNE distributed operation should trigger COS"
1194
1195 test_33e() {
1196         [ -n "$CLIENTS" ] || skip "Need two or more clients"
1197         [ $CLIENTCOUNT -ge 2 ] ||
1198                 skip "Need two or more clients, have $CLIENTCOUNT"
1199         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
1200         [ "$MDS1_VERSION" -lt $(version_code 2.7.63) ] &&
1201                 skip "DNE CoS not supported"
1202
1203         local client2=${CLIENT2:-$(hostname)}
1204
1205         sync
1206
1207         local nodes=$(comma_list $(mdts_nodes))
1208         do_nodes $nodes "lctl set_param -n mdt.*.async_commit_count=0"
1209
1210         $LFS mkdir -c 2 $DIR/$tdir
1211         mkdir $DIR/$tdir/subdir
1212         echo abc > $DIR/$tdir/$tfile
1213         do_node $client2 echo dfg >> $DIR/$tdir/$tfile
1214         do_node $client2 touch $DIR/$tdir/subdir
1215
1216         local async_commit_count=$(do_nodes $nodes \
1217                 "lctl get_param -n mdt.*.async_commit_count" | calc_sum)
1218         [ $async_commit_count -gt 0 ] && error "CoS triggerred"
1219
1220         return 0
1221 }
1222 run_test 33e "DNE local operation shouldn't trigger COS"
1223
1224 # End commit on sharing tests
1225
1226 get_ost_lock_timeouts() {
1227     local nodes=${1:-$(comma_list $(osts_nodes))}
1228
1229     local locks=$(do_nodes $nodes \
1230         "lctl get_param -n ldlm.namespaces.filter-*.lock_timeouts" | calc_sum)
1231
1232     echo $locks
1233 }
1234
1235 cleanup_34() {
1236         local i
1237         trap 0
1238         do_nodes $(comma_list $(osts_nodes)) \
1239                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1240         for i in $(seq $OSTCOUNT); do
1241                 wait_osc_import_ready client ost$i
1242         done
1243 }
1244
1245 test_34() { #16129
1246         remote_ost_nodsh && skip "remote OST with nodsh" && return
1247         local OPER
1248         local lock_in
1249         local lock_out
1250         trap cleanup_34 EXIT RETURN
1251         for OPER in notimeout timeout ; do
1252                 rm $DIR1/$tfile 2>/dev/null
1253                 lock_in=$(get_ost_lock_timeouts)
1254                 if [ $OPER == "timeout" ] ; then
1255                         for j in `seq $OSTCOUNT`; do
1256                                 #define OBD_FAIL_PTLRPC_HPREQ_TIMEOUT    0x511
1257                                 do_facet ost$j lctl set_param fail_loc=0x511
1258                         done
1259                         echo lock should expire
1260                 else
1261                         for j in `seq $OSTCOUNT`; do
1262                                 #define OBD_FAIL_PTLRPC_HPREQ_NOTIMEOUT  0x512
1263                                 do_facet ost$j lctl set_param fail_loc=0x512
1264                         done
1265                         echo lock should not expire
1266                 fi
1267                 echo writing on client1
1268                 dd if=/dev/zero of=$DIR1/$tfile count=100 conv=notrunc > /dev/null 2>&1
1269                 sync &
1270                 echo reading on client2
1271                 dd of=/dev/null if=$DIR2/$tfile > /dev/null 2>&1
1272                 # wait for a lock timeout
1273                 sleep 4
1274                 lock_out=$(get_ost_lock_timeouts)
1275                 if [ $OPER == "timeout" ] ; then
1276                         if [ $lock_in == $lock_out ]; then
1277                                 error "no lock timeout happened"
1278                         else
1279                                 echo "success"
1280                         fi
1281                 else
1282                         if [ $lock_in != $lock_out ]; then
1283                                 error "lock timeout happened"
1284                         else
1285                                 echo "success"
1286                         fi
1287                 fi
1288         done
1289         cleanup_34
1290 }
1291 run_test 34 "no lock timeout under IO"
1292
1293 test_35() { # bug 17645
1294         local generation=[]
1295         local count=0
1296         gen=$(lctl get_param mdc.$FSNAME-MDT*-mdc-*.import | grep generation |
1297               awk '/generation/{print $2}')
1298         for g in $gen; do
1299                 generation[count]=$g
1300                 let count=count+1
1301         done
1302
1303         test_mkdir $MOUNT1/$tdir
1304         cancel_lru_locks mdc
1305
1306         # Let's initiate -EINTR situation by setting fail_loc and take
1307         # write lock on same file from same client. This will not cause
1308         # bl_ast yet as lock is already in local cache.
1309         #define OBD_FAIL_LDLM_INTR_CP_AST        0x317
1310         do_facet client "lctl set_param fail_loc=0x80000317"
1311         local timeout=$(do_facet $SINGLEMDS lctl get_param  -n timeout)
1312         let timeout=timeout*3
1313         local nr=0
1314         while test $nr -lt 10; do
1315                 log "Race attempt $nr"
1316                 local blk1=$(lctl get_param -n ldlm.services.ldlm_cbd.stats |
1317                              awk '/ldlm_bl_callback/ { print $2 }')
1318                 test "x$blk1" = "x" && blk1=0
1319                 createmany -o $MOUNT2/$tdir/a 4000 &
1320                 pid1=$!
1321                 sleep 1
1322
1323                 # Let's make conflict and bl_ast
1324                 ls -la $MOUNT1/$tdir > /dev/null &
1325                 pid2=$!
1326
1327                 log "Wait for $pid1 $pid2 for $timeout sec..."
1328                 sleep $timeout
1329                 kill -9 $pid1 $pid2 > /dev/null 2>&1
1330                 wait
1331                 local blk2=$(lctl get_param -n ldlm.services.ldlm_cbd.stats |
1332                              awk '/ldlm_bl_callback/ { print $2 }')
1333                 test "x$blk2" = "x" && blk2=0
1334                 test $blk2 -gt $blk1 && break
1335                 rm -fr $MOUNT1/$tdir
1336                 cancel_lru_locks mdc
1337                 let nr=nr+1
1338         done
1339         do_facet client "lctl set_param fail_loc=0x0"
1340         df -h $MOUNT1 $MOUNT2
1341         count=0
1342         gen=$(lctl get_param mdc.$FSNAME-MDT*-mdc-*.import | grep generation |
1343                 awk '/generation/{print $2}')
1344         for g in $gen; do
1345             if ! test "$g" -eq "${generation[count]}"; then
1346                 list=$(lctl list_param mdc.$FSNAME-MDT*-mdc-*.import)
1347                 local c=0
1348                 for imp in $list; do
1349                         if [ $c = $count ]; then
1350                                 break
1351                         fi
1352                         c=c+1
1353                 done
1354                 imp=$(echo "$imp" | awk -F"." '{print $2}')
1355                 error "Eviction happened on import $imp"
1356             fi
1357             let count=count+1
1358         done
1359 }
1360 run_test 35 "-EINTR cp_ast vs. bl_ast race does not evict client"
1361
1362 test_36() { #bug 16417
1363         local SIZE
1364         local SIZE_B
1365         local i
1366
1367         test_mkdir $DIR1/$tdir
1368         $LFS setstripe -c -1 $DIR1/$tdir
1369         i=0
1370         SIZE=50
1371         let SIZE_B=SIZE*1024*1024
1372         sync; sleep 2; sync # wait for delete thread
1373         wait_mds_ost_sync || error "wait_mds_ost_sync failed"
1374         wait_destroy_complete || error "wait_destroy_complete failed"
1375
1376         while [ $i -le 10 ]; do
1377                 lctl mark "start test - cycle ($i)"
1378                 local before=$(lfs_df $MOUNT1 | awk '/^filesystem/{ print $4; exit }')
1379                 dd if=/dev/zero of=$DIR1/$tdir/$tfile bs=1M count=$SIZE ||
1380                         error "dd $DIR1/$tdir/$tfile ${SIZE}MB failed"
1381                 sync          # sync data from client cache
1382                 sync_all_data # sync data from server cache (delayed allocation)
1383                 sleep 2
1384                 local after_dd=$(lfs_df $MOUNT1 | awk '/^filesystem/{ print $4; exit }')
1385                 multiop_bg_pause $DIR2/$tdir/$tfile O_r${SIZE_B}c || return 3
1386                 read_pid=$!
1387                 rm -f $DIR1/$tdir/$tfile
1388                 kill -USR1 $read_pid
1389                 wait $read_pid
1390                 sync; sleep 2; sync # Ensure new statfs
1391                 wait_delete_completed
1392                 local after=$(lfs_df $MOUNT1 | awk '/^filesystem/{ print $4; exit }')
1393                 echo "*** cycle($i) *** before($before) after_dd($after_dd)" \
1394                         "after($after)"
1395                 # this free space! not used
1396                 (( $after_dd <= $after)) ||
1397                         error "space leaked after_dd:$after_dd > after:$after"
1398                 let i=i+1
1399         done
1400 }
1401 run_test 36 "handle ESTALE/open-unlink correctly"
1402
1403 test_37() { # bug 18695
1404         test_mkdir $DIR1/$tdir
1405         multiop_bg_pause $DIR1/$tdir D_c || return 1
1406         MULTIPID=$!
1407         # create large directory (32kB seems enough from e2fsck, ~= 1000 files)
1408         createmany -m $DIR2/$tdir/f 10000
1409         # set mtime/atime backward
1410         touch -t 198001010000 $DIR2/$tdir
1411         kill -USR1 $MULTIPID
1412         nr_files=`lfs find $DIR1/$tdir -type f | wc -l`
1413         [ $nr_files -eq 10000 ] || error "$nr_files != 10000 truncated directory?"
1414
1415 }
1416 run_test 37 "check i_size is not updated for directory on close (bug 18695) =============="
1417
1418 # this should be set to past
1419 TEST_39_MTIME=`date -d "1 year ago" +%s`
1420
1421 # bug 11063
1422 test_39a() {
1423         local client1=${CLIENT1:-`hostname`}
1424         local client2=${CLIENT2:-`hostname`}
1425
1426         do_node $client1 "touch $DIR1/$tfile"
1427
1428         do_node $client1 "touch -m -d @$TEST_39_MTIME $DIR1/$tfile"
1429         local mtime1=`do_node $client2 "stat -c %Y $DIR1/$tfile"`
1430         [ "$mtime1" = $TEST_39_MTIME ] || \
1431                 error "mtime is not set to past: $mtime1, should be $TEST_39_MTIME"
1432
1433         local d1=`do_node $client1 date +%s`
1434         do_node $client1 'echo hello >> '$DIR1/$tfile
1435         local d2=`do_node $client1 date +%s`
1436
1437         local mtime2=`do_node $client2 "stat -c %Y $DIR1/$tfile"`
1438         [ "$mtime2" -ge "$d1" ] && [ "$mtime2" -le "$d2" ] || \
1439                 error "mtime is not updated on write: $d1 <= $mtime2 <= $d2"
1440
1441         do_node $client1 "mv $DIR1/$tfile $DIR1/$tfile-1"
1442
1443         for (( i=0; i < 2; i++ )) ; do
1444                 local mtime3=`do_node $client2 "stat -c %Y $DIR1/$tfile-1"`
1445                 [ "$mtime2" = "$mtime3" ] || \
1446                         error "mtime ($mtime2) changed (to $mtime3) on rename"
1447
1448                 cancel_lru_locks osc
1449                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
1450         done
1451 }
1452 run_test 39a "test from 11063 =================================="
1453
1454 test_39b() {
1455         local client1=${CLIENT1:-`hostname`}
1456         local client2=${CLIENT2:-`hostname`}
1457
1458         touch $DIR1/$tfile
1459
1460         local mtime1=`stat -c %Y $DIR1/$tfile`
1461         local mtime2=`do_node $client2 "stat -c %Y $DIR1/$tfile"`
1462
1463         sleep 1
1464         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
1465
1466         for (( i=0; i < 2; i++ )) ; do
1467                 local mtime3=`stat -c %Y $DIR1/$tfile`
1468                 local mtime4=`do_node $client2 "stat -c %Y $DIR1/$tfile"`
1469
1470                 [ "$mtime3" = "$mtime4" ] || \
1471                         error "different mtime on clients: $mtime3, $mtime4"
1472                 [ "$mtime3" = $TEST_39_MTIME ] || \
1473                         error "lost mtime: $mtime3, should be $TEST_39_MTIME"
1474
1475                 cancel_lru_locks osc
1476                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
1477         done
1478 }
1479 run_test 39b "11063 problem 1 =================================="
1480
1481 test_39c() {
1482         local client1=${CLIENT1:-`hostname`}
1483         local client2=${CLIENT2:-`hostname`}
1484
1485         echo hello > $DIR1/$tfile
1486
1487         local mtime1=`stat -c %Y $DIR1/$tfile`
1488         local mtime2=`do_node $client2 "stat -c %Y $DIR1/$tfile"`
1489         [ "$mtime1" = "$mtime2" ] || \
1490                 error "create: different mtime on clients: $mtime1, $mtime2"
1491
1492         sleep 1
1493         $TRUNCATE $DIR1/$tfile 1
1494
1495         for (( i=0; i < 2; i++ )) ; do
1496                 local mtime3=`stat -c %Y $DIR1/$tfile`
1497                 local mtime4=`do_node $client2 "stat -c %Y $DIR1/$tfile"`
1498
1499                 [ "$mtime3" = "$mtime4" ] || \
1500                         error "different mtime on clients: $mtime3, $mtime4"
1501                 [ "$mtime3" -gt $mtime2 ] || \
1502                         error "truncate did not update mtime: $mtime2, $mtime3"
1503
1504                 cancel_lru_locks osc
1505                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
1506         done
1507 }
1508 run_test 39c "check truncate mtime update ======================"
1509
1510 test_39d() { # LU-7310
1511         touch $DIR1/$tfile
1512         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
1513
1514         local mtime1=$(stat -c %Y $DIR2/$tfile)
1515         [ "$mtime1" = $TEST_39_MTIME ] ||
1516                 error "mtime: $mtime1, should be $TEST_39_MTIME"
1517
1518         # force sync write
1519         # define OBD_FAIL_OSC_NO_GRANT 0x411
1520         $LCTL set_param fail_loc=0x411
1521
1522         local d1=$(date +%s)
1523         echo hello >> $DIR1/$tfile
1524         local d2=$(date +%s)
1525
1526         $LCTL set_param fail_loc=0
1527
1528         cancel_lru_locks $OSC
1529
1530         local mtime2=$(stat -c %Y $DIR2/$tfile)
1531         [ "$mtime2" -ge "$d1" ] && [ "$mtime2" -le "$d2" ] ||
1532                 error "mtime is not updated on write: $d1 <= $mtime2 <= $d2"
1533 }
1534 run_test 39d "sync write should update mtime"
1535
1536 pdo_sched() {
1537         # how long 40-47 take with specific delay
1538         # sleep 0.1 # 78s
1539         # sleep 0.2 # 103s
1540         # sleep 0.3 # 124s
1541         sleep 0.5 # 164s
1542 }
1543
1544 # for pdo testing, we must cancel MDT-MDT locks as well as client locks to
1545 # avoid unexpected delays due to previous tests
1546 pdo_lru_clear() {
1547         cancel_lru_locks mdc
1548         do_nodes $(comma_list $(mdts_nodes)) \
1549                 $LCTL set_param -n ldlm.namespaces.*mdt*.lru_size=clear
1550         do_nodes $(comma_list $(mdts_nodes)) \
1551                 $LCTL get_param ldlm.namespaces.*mdt*.lock_unused_count \
1552                         ldlm.namespaces.*mdt*.lock_count | grep -v '=0'
1553 }
1554
1555 # check that pid exists hence second operation wasn't blocked by first one
1556 # if it is so then there is no conflict, return 0
1557 # else second operation is conflicting with first one, return 1
1558 check_pdo_conflict() {
1559         local pid=$1
1560         local conflict=0
1561         pdo_sched # to ensure OP1 is finished on client if OP2 is blocked by OP1
1562         if [[ `ps --pid $pid | wc -l` == 1 ]]; then
1563                 conflict=1
1564                 echo "Conflict"
1565         else
1566                 echo "No conflict"
1567         fi
1568         return $conflict
1569 }
1570
1571 # pdirop tests
1572 # test 40: check non-blocking operations
1573 test_40a() {
1574         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1575         pdo_lru_clear
1576 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1577         do_nodes $(comma_list $(mdts_nodes)) \
1578                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1579         touch $DIR2
1580         mkdir $DIR1/$tfile &
1581         PID1=$!; pdo_sched
1582         touch $DIR2/$tfile-2
1583         check_pdo_conflict $PID1 || error "create is blocked"
1584         mkdir $DIR2/$tfile-3
1585         check_pdo_conflict $PID1 || error "mkdir is blocked"
1586         link $DIR2/$tfile-2 $DIR2/$tfile-4
1587         check_pdo_conflict $PID1 || error "link is blocked"
1588         mv $DIR2/$tfile-2 $DIR2/$tfile-5
1589         check_pdo_conflict $PID1 || error "rename is blocked"
1590         stat $DIR2/$tfile-3 $DIR2/$tfile-4 > /dev/null
1591         check_pdo_conflict $PID1 || error "getattr is blocked"
1592         rm $DIR2/$tfile-4 $DIR2/$tfile-5
1593         rmdir $DIR2/$tfile-3
1594         check_pdo_conflict $PID1 || error "unlink is blocked"
1595
1596         #  all operations above shouldn't wait the first one
1597         check_pdo_conflict $PID1 || error "parallel operation is blocked"
1598         do_nodes $(comma_list $(mdts_nodes)) \
1599                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1600         wait $PID1
1601         rm -rf $DIR/$tfile*
1602         return 0
1603 }
1604 run_test 40a "pdirops: create vs others =============="
1605
1606 test_40b() {
1607         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1608         pdo_lru_clear
1609 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1610         do_nodes $(comma_list $(mdts_nodes)) \
1611                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1612         touch $DIR1/$tfile &
1613         PID1=$!; pdo_sched
1614         # open|create
1615         touch $DIR2/$tfile-2
1616         check_pdo_conflict $PID1 || error "create is blocked"
1617         mkdir $DIR2/$tfile-3
1618         check_pdo_conflict $PID1 || error "mkdir is blocked"
1619         link $DIR2/$tfile-2 $DIR2/$tfile-4
1620         check_pdo_conflict $PID1 || error "link is blocked"
1621         mv $DIR2/$tfile-2 $DIR2/$tfile-5
1622         check_pdo_conflict $PID1 || error "rename is blocked"
1623         stat $DIR2/$tfile-3 $DIR2/$tfile-4 > /dev/null
1624         check_pdo_conflict $PID1 || error "getattr is blocked"
1625         rm $DIR2/$tfile-4 $DIR2/$tfile-5
1626         rmdir $DIR2/$tfile-3
1627         check_pdo_conflict $PID1 || error "unlink is blocked"
1628         # all operations above shouldn't wait the first one
1629
1630         check_pdo_conflict $PID1 || error "parallel operation is blocked"
1631         do_nodes $(comma_list $(mdts_nodes)) \
1632                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1633         wait $PID1
1634         rm -rf $DIR/$tfile*
1635         return 0
1636 }
1637 run_test 40b "pdirops: open|create and others =============="
1638
1639 test_40c() {
1640         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1641         pdo_lru_clear
1642         touch $DIR1/$tfile
1643 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1644         do_nodes $(comma_list $(mdts_nodes)) \
1645                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1646         link $DIR1/$tfile $DIR1/$tfile-0 &
1647         PID1=$!; pdo_sched
1648         # open|create
1649         touch $DIR2/$tfile-2
1650         check_pdo_conflict $PID1 || error "create is blocked"
1651         mkdir $DIR2/$tfile-3
1652         check_pdo_conflict $PID1 || error "mkdir is blocked"
1653         link $DIR2/$tfile-2 $DIR2/$tfile-4
1654         check_pdo_conflict $PID1 || error "link is blocked"
1655         mv $DIR2/$tfile-2 $DIR2/$tfile-5
1656         check_pdo_conflict $PID1 || error "rename is blocked"
1657         stat $DIR2/$tfile-3 $DIR2/$tfile-4 > /dev/null
1658         check_pdo_conflict $PID1 || error "getattr is blocked"
1659         rm $DIR2/$tfile-4 $DIR2/$tfile-5
1660         rmdir $DIR2/$tfile-3
1661         check_pdo_conflict $PID1 || error "unlink is blocked"
1662
1663         # all operations above shouldn't wait the first one
1664         check_pdo_conflict $PID1 || error "parallel operation is blocked"
1665         do_nodes $(comma_list $(mdts_nodes)) \
1666                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1667         wait $PID1
1668         rm -rf $DIR/$tfile*
1669         return 0
1670 }
1671 run_test 40c "pdirops: link and others =============="
1672
1673 test_40d() {
1674         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1675         pdo_lru_clear
1676         touch $DIR1/$tfile
1677 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1678         do_nodes $(comma_list $(mdts_nodes)) \
1679                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1680         rm $DIR1/$tfile &
1681         PID1=$!; pdo_sched
1682         # open|create
1683         touch $DIR2/$tfile-2
1684         check_pdo_conflict $PID1 || error "create is blocked"
1685         mkdir $DIR2/$tfile-3
1686         check_pdo_conflict $PID1 || error "mkdir is blocked"
1687         link $DIR2/$tfile-2 $DIR2/$tfile-4
1688         check_pdo_conflict $PID1 || error "link is blocked"
1689         mv $DIR2/$tfile-2 $DIR2/$tfile-5
1690         check_pdo_conflict $PID1 || error "rename is blocked"
1691         stat $DIR2/$tfile-3 $DIR2/$tfile-4 > /dev/null
1692         check_pdo_conflict $PID1 || error "getattr is blocked"
1693         rm $DIR2/$tfile-4 $DIR2/$tfile-5
1694         rmdir $DIR2/$tfile-3
1695         check_pdo_conflict $PID1 || error "unlink is blocked"
1696
1697         # all operations above shouldn't wait the first one
1698         check_pdo_conflict $PID1 || error "parallel operation is blocked"
1699         do_nodes $(comma_list $(mdts_nodes)) \
1700                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1701         wait $PID1
1702         return 0
1703 }
1704 run_test 40d "pdirops: unlink and others =============="
1705
1706 test_40e() {
1707         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1708         pdo_lru_clear
1709         touch $DIR1/$tfile
1710 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1711         do_nodes $(comma_list $(mdts_nodes)) \
1712                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1713         mv $DIR1/$tfile $DIR1/$tfile-0 &
1714         PID1=$!; pdo_sched
1715         # open|create
1716         touch $DIR2/$tfile-2
1717         check_pdo_conflict $PID1 || error "create is blocked"
1718         mkdir $DIR2/$tfile-3
1719         check_pdo_conflict $PID1 || error "mkdir is blocked"
1720         link $DIR2/$tfile-2 $DIR2/$tfile-4
1721         check_pdo_conflict $PID1 || error "link is blocked"
1722         stat $DIR2/$tfile-3 $DIR2/$tfile-4 > /dev/null
1723         check_pdo_conflict $PID1 || error "getattr is blocked"
1724         rm $DIR2/$tfile-4 $DIR2/$tfile-2
1725         rmdir $DIR2/$tfile-3
1726         check_pdo_conflict $PID1 || error "unlink is blocked"
1727
1728        # all operations above shouldn't wait the first one
1729         check_pdo_conflict $PID1 || error "parallel operation is blocked"
1730         do_nodes $(comma_list $(mdts_nodes)) \
1731                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1732         wait $PID1
1733         rm -rf $DIR/$tfile*
1734         return 0
1735 }
1736 run_test 40e "pdirops: rename and others =============="
1737
1738 # test 41: create blocking operations
1739 test_41a() {
1740         pdo_lru_clear
1741 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1742         do_nodes $(comma_list $(mdts_nodes)) \
1743                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1744         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
1745         PID1=$! ; pdo_sched
1746         mkdir $DIR2/$tfile &
1747         PID2=$! ; pdo_sched
1748         do_nodes $(comma_list $(mdts_nodes)) \
1749                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1750         check_pdo_conflict $PID1 && { wait $PID1; echo "mkdir isn't blocked"; }
1751         wait $PID2 ; [ $? -ne 0 ] || error "mkdir must fail"
1752         rm -rf $DIR/$tfile*
1753         return 0
1754 }
1755 run_test 41a "pdirops: create vs mkdir =============="
1756
1757 test_41b() {
1758         pdo_lru_clear
1759 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1760         do_nodes $(comma_list $(mdts_nodes)) \
1761                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1762         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
1763         PID1=$! ; pdo_sched
1764         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c &
1765         PID2=$! ; pdo_sched
1766         do_nodes $(comma_list $(mdts_nodes)) \
1767                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1768         check_pdo_conflict $PID1 && { wait $PID1; error "create isn't blocked"; }
1769         wait $PID2 ; [ $? -ne 0 ] || error "create must fail"
1770         rm -rf $DIR/$tfile*
1771         return 0
1772 }
1773 run_test 41b "pdirops: create vs create =============="
1774
1775 test_41c() {
1776         pdo_lru_clear
1777         touch $DIR1/$tfile-2
1778 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1779         do_nodes $(comma_list $(mdts_nodes)) \
1780                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1781         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
1782         PID1=$! ; pdo_sched
1783         link $DIR2/$tfile-2 $DIR2/$tfile &
1784         PID2=$! ; pdo_sched
1785         do_nodes $(comma_list $(mdts_nodes)) \
1786                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1787         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
1788         wait $PID2 ; [ $? -ne 0 ] || error "link must fail"
1789         rm -rf $DIR/$tfile*
1790         return 0
1791 }
1792 run_test 41c "pdirops: create vs link =============="
1793
1794 test_41d() {
1795         pdo_lru_clear
1796 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1797         do_nodes $(comma_list $(mdts_nodes)) \
1798                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1799         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
1800         PID1=$! ; pdo_sched
1801         rm $DIR2/$tfile &
1802         PID2=$! ; pdo_sched
1803         do_nodes $(comma_list $(mdts_nodes)) \
1804                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1805         check_pdo_conflict $PID1 && { wait $PID1; error "unlink isn't blocked"; }
1806         wait $PID2 ; [ $? -eq 0 ] || error "unlink must succeed"
1807         rm -rf $DIR/$tfile*
1808         return 0
1809 }
1810 run_test 41d "pdirops: create vs unlink =============="
1811
1812 test_41e() {
1813         pdo_lru_clear
1814         touch $DIR1/$tfile-2
1815 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1816         do_nodes $(comma_list $(mdts_nodes)) \
1817                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1818         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
1819         PID1=$! ; pdo_sched
1820         mv $DIR2/$tfile-2 $DIR2/$tfile &
1821         PID2=$! ; pdo_sched
1822         do_nodes $(comma_list $(mdts_nodes)) \
1823                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1824         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
1825         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
1826         rm -rf $DIR/$tfile*
1827         return 0
1828 }
1829 run_test 41e "pdirops: create and rename (tgt) =============="
1830
1831 test_41f() {
1832         pdo_lru_clear
1833 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1834         do_nodes $(comma_list $(mdts_nodes)) \
1835                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1836         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
1837         PID1=$! ; pdo_sched
1838         mv $DIR2/$tfile $DIR2/$tfile-2 &
1839         PID2=$! ; pdo_sched
1840         do_nodes $(comma_list $(mdts_nodes)) \
1841                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1842         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
1843         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
1844         rm -rf $DIR/$tfile*
1845         return 0
1846 }
1847 run_test 41f "pdirops: create and rename (src) =============="
1848
1849 test_41g() {
1850         pdo_lru_clear
1851 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1852         do_nodes $(comma_list $(mdts_nodes)) \
1853                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1854         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
1855         PID1=$! ; pdo_sched
1856         stat $DIR2/$tfile > /dev/null &
1857         PID2=$! ; pdo_sched
1858         do_nodes $(comma_list $(mdts_nodes)) \
1859                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1860         check_pdo_conflict $PID1 && { wait $PID1; error "getattr isn't blocked"; }
1861         wait $PID2 ; [ $? -eq 0 ] || error "stat must succeed"
1862         rm -rf $DIR/$tfile*
1863         return 0
1864 }
1865 run_test 41g "pdirops: create vs getattr =============="
1866
1867 test_41h() {
1868         pdo_lru_clear
1869 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1870         do_nodes $(comma_list $(mdts_nodes)) \
1871                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1872         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
1873         PID1=$! ; pdo_sched
1874         ls -lia $DIR2/ > /dev/null &
1875         PID2=$! ; pdo_sched
1876         do_nodes $(comma_list $(mdts_nodes)) \
1877                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1878         check_pdo_conflict $PID1 && { wait $PID1; error "readdir isn't blocked"; }
1879         wait $PID2
1880         rm -rf $DIR/$tfile*
1881         return 0
1882 }
1883 run_test 41h "pdirops: create vs readdir =============="
1884
1885 sub_test_41i() {
1886         local PID1 PID2
1887         local fail_loc="$1"
1888         local ret=0
1889
1890         do_nodes $(comma_list $(mdts_nodes)) \
1891                 "lctl set_param -n fail_loc=${fail_loc} || true" &>/dev/null
1892
1893         $MULTIOP $DIR1/$tfile oO_CREAT:O_EXCL:c 2>/dev/null &
1894         PID1=$!
1895         sleep 0.2
1896         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c 2>/dev/null &
1897         PID2=$!
1898
1899         if ! wait $PID1 && ! wait $PID2; then
1900                 echo "Both creates failed (1 should fail, 1 should succeed)"
1901                 ret=1
1902         elif wait $PID1 && wait $PID2; then
1903                 echo "Both creates succeeded (1 should fail, 1 should succeed)"
1904                 ret=2
1905         fi
1906
1907         #Clean
1908         do_nodes $(comma_list $(mdts_nodes)) \
1909                 "lctl set_param -n fail_loc=0x0 || true" &>/dev/null
1910         rm -f $DIR/$tfile
1911
1912         return $ret
1913 }
1914
1915 test_41i() {
1916         [[ $MDS1_VERSION -le $(version_code 2.13.56) ]] ||
1917                 skip "Need MDS version newer than 2.13.56"
1918         local msg fail_loc
1919
1920 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_REINT_OPEN         0x169
1921 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_REINT_OPEN2        0x16a
1922         for fail_loc in "0x80000169" "0x8000016a"; do
1923                 echo "Begin 100 tests with fail_loc=$fail_loc"
1924                 printf "Progress: "
1925                 for i in {1..100}; do
1926                         printf "*"
1927                         msg=$(sub_test_41i "$fail_loc") ||
1928                                 { echo; error "iter=$i : $msg"; }
1929                 done
1930                 echo
1931         done
1932 }
1933 run_test 41i "reint_open: create vs create"
1934
1935
1936 # test 42: unlink and blocking operations
1937 test_42a() {
1938         pdo_lru_clear
1939 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1940         do_nodes $(comma_list $(mdts_nodes)) \
1941                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1942         mkdir $DIR1/$tfile &
1943         PID1=$! ; pdo_sched
1944         mkdir $DIR2/$tfile &
1945         PID2=$! ; pdo_sched
1946         do_nodes $(comma_list $(mdts_nodes)) \
1947                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1948         check_pdo_conflict $PID1 && { wait $PID1; error "mkdir isn't blocked"; }
1949         wait $PID2 ; [ $? -ne 0 ] || error "mkdir must fail"
1950         rm -rf $DIR/$tfile*
1951         return 0
1952 }
1953 run_test 42a "pdirops: mkdir vs mkdir =============="
1954
1955 test_42b() {
1956         pdo_lru_clear
1957 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1958         do_nodes $(comma_list $(mdts_nodes)) \
1959                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1960         mkdir $DIR1/$tfile &
1961         PID1=$! ; pdo_sched
1962         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c &
1963         PID2=$! ; pdo_sched
1964         do_nodes $(comma_list $(mdts_nodes)) \
1965                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1966         check_pdo_conflict $PID1 && { wait $PID1; error "create isn't blocked"; }
1967         wait $PID2 ; [ $? -ne 0 ] || error "create must fail"
1968         rm -rf $DIR/$tfile*
1969         return 0
1970 }
1971 run_test 42b "pdirops: mkdir vs create =============="
1972
1973 test_42c() {
1974         pdo_lru_clear
1975         touch $DIR1/$tfile-2
1976 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1977         do_nodes $(comma_list $(mdts_nodes)) \
1978                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1979         mkdir $DIR1/$tfile &
1980         PID1=$! ; pdo_sched
1981         link $DIR2/$tfile-2 $DIR2/$tfile &
1982         PID2=$! ; pdo_sched
1983         do_nodes $(comma_list $(mdts_nodes)) \
1984                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1985         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
1986         wait $PID2 ; [ $? -ne 0 ] || error "link must fail"
1987         rm -rf $DIR/$tfile*
1988         return 0
1989 }
1990 run_test 42c "pdirops: mkdir vs link =============="
1991
1992 test_42d() {
1993         pdo_lru_clear
1994 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1995         do_nodes $(comma_list $(mdts_nodes)) \
1996                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1997         mkdir $DIR1/$tfile &
1998         PID1=$! ; pdo_sched
1999         rmdir $DIR2/$tfile &
2000         PID2=$! ; pdo_sched
2001         do_nodes $(comma_list $(mdts_nodes)) \
2002                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2003         check_pdo_conflict $PID1 && { wait $PID1; error "unlink isn't blocked"; }
2004         wait $PID2 ; [ $? -eq 0 ] || error "unlink must succeed"
2005         rm -rf $DIR/$tfile*
2006         return 0
2007 }
2008 run_test 42d "pdirops: mkdir vs unlink =============="
2009
2010 test_42e() {
2011         pdo_lru_clear
2012         touch $DIR1/$tfile-2
2013 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2014         do_nodes $(comma_list $(mdts_nodes)) \
2015                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2016         mkdir $DIR1/$tfile &
2017         PID1=$! ; pdo_sched
2018         mv -T $DIR2/$tfile-2 $DIR2/$tfile &
2019         PID2=$! ; pdo_sched
2020         do_nodes $(comma_list $(mdts_nodes)) \
2021                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2022         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2023         wait $PID2 ; [ $? -ne 0 ] || error "rename must fail"
2024         rm -rf $DIR/$tfile*
2025         return 0
2026 }
2027 run_test 42e "pdirops: mkdir and rename (tgt) =============="
2028
2029 test_42f() {
2030         pdo_lru_clear
2031 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2032         do_nodes $(comma_list $(mdts_nodes)) \
2033                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2034         mkdir $DIR1/$tfile &
2035         PID1=$! ; pdo_sched
2036         mv $DIR2/$tfile $DIR2/$tfile-2 &
2037         PID2=$! ; pdo_sched
2038         do_nodes $(comma_list $(mdts_nodes)) \
2039                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2040         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2041         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2042         rm -rf $DIR/$tfile*
2043         return 0
2044 }
2045 run_test 42f "pdirops: mkdir and rename (src) =============="
2046
2047 test_42g() {
2048         pdo_lru_clear
2049 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2050         do_nodes $(comma_list $(mdts_nodes)) \
2051                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2052         mkdir $DIR1/$tfile &
2053         PID1=$! ; pdo_sched
2054         stat $DIR2/$tfile > /dev/null &
2055         PID2=$! ; pdo_sched
2056         do_nodes $(comma_list $(mdts_nodes)) \
2057                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2058         check_pdo_conflict $PID1 && { wait $PID1; error "getattr isn't blocked"; }
2059         wait $PID2 ; [ $? -eq 0 ] || error "stat must succeed"
2060         rm -rf $DIR/$tfile*
2061         return 0
2062 }
2063 run_test 42g "pdirops: mkdir vs getattr =============="
2064
2065 test_42h() {
2066         pdo_lru_clear
2067 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2068         do_nodes $(comma_list $(mdts_nodes)) \
2069                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2070         mkdir $DIR1/$tfile &
2071         PID1=$! ; pdo_sched
2072         ls -lia $DIR2/ > /dev/null &
2073         PID2=$! ; pdo_sched
2074         do_nodes $(comma_list $(mdts_nodes)) \
2075                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2076         check_pdo_conflict $PID1 && { wait $PID1; error "readdir isn't blocked"; }
2077         wait $PID2
2078         rm -rf $DIR/$tfile*
2079         return 0
2080 }
2081 run_test 42h "pdirops: mkdir vs readdir =============="
2082
2083 # test 43: rmdir,mkdir won't return -EEXIST
2084 test_43a() {
2085         for i in {1..1000}; do
2086                 mkdir $DIR1/$tdir || error "mkdir $tdir failed"
2087                 rmdir $DIR2/$tdir || error "rmdir $tdir failed"
2088         done
2089         return 0
2090 }
2091 run_test 43a "rmdir,mkdir doesn't return -EEXIST =============="
2092
2093 test_43b() {
2094         pdo_lru_clear
2095         touch $DIR1/$tfile
2096 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2097         do_nodes $(comma_list $(mdts_nodes)) \
2098                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2099         rm $DIR1/$tfile &
2100         PID1=$! ; pdo_sched
2101         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c &
2102         PID2=$! ; pdo_sched
2103         do_nodes $(comma_list $(mdts_nodes)) \
2104                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2105         check_pdo_conflict $PID1 && { wait $PID1; error "create isn't blocked"; }
2106         wait $PID2 ; [ $? -eq 0 ] || error "create must succeed"
2107         rm -rf $DIR/$tfile*
2108         return 0
2109 }
2110 run_test 43b "pdirops: unlink vs create =============="
2111
2112 test_43c() {
2113         pdo_lru_clear
2114         touch $DIR1/$tfile
2115         touch $DIR1/$tfile-2
2116 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2117         do_nodes $(comma_list $(mdts_nodes)) \
2118                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2119         rm $DIR1/$tfile &
2120         PID1=$! ; pdo_sched
2121         link $DIR2/$tfile-2 $DIR2/$tfile &
2122         PID2=$! ; pdo_sched
2123         do_nodes $(comma_list $(mdts_nodes)) \
2124                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2125         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
2126         wait $PID2 ; [ $? -eq 0 ] || error "link must succeed"
2127         rm -rf $DIR/$tfile*
2128         return 0
2129 }
2130 run_test 43c "pdirops: unlink vs link =============="
2131
2132 test_43d() {
2133         pdo_lru_clear
2134         touch $DIR1/$tfile
2135 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2136         do_nodes $(comma_list $(mdts_nodes)) \
2137                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2138         rm $DIR1/$tfile &
2139         PID1=$! ; pdo_sched
2140         rm $DIR2/$tfile &
2141         PID2=$! ; pdo_sched
2142         do_nodes $(comma_list $(mdts_nodes)) \
2143                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2144         check_pdo_conflict $PID1 && { wait $PID1; error "unlink isn't blocked"; }
2145         wait $PID2 ; [ $? -ne 0 ] || error "unlink must fail"
2146         rm -rf $DIR/$tfile*
2147         return 0
2148 }
2149 run_test 43d "pdirops: unlink vs unlink =============="
2150
2151 test_43e() {
2152         pdo_lru_clear
2153         touch $DIR1/$tfile
2154         touch $DIR1/$tfile-2
2155 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2156         do_nodes $(comma_list $(mdts_nodes)) \
2157                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2158         rm $DIR1/$tfile &
2159         PID1=$! ; pdo_sched
2160         mv -u $DIR2/$tfile-2 $DIR2/$tfile &
2161         PID2=$! ; pdo_sched
2162         do_nodes $(comma_list $(mdts_nodes)) \
2163                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2164         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2165         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2166         rm -rf $DIR/$tfile*
2167         return 0
2168 }
2169 run_test 43e "pdirops: unlink and rename (tgt) =============="
2170
2171 test_43f() {
2172         pdo_lru_clear
2173         touch $DIR1/$tfile
2174 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2175         do_nodes $(comma_list $(mdts_nodes)) \
2176                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2177         rm $DIR1/$tfile &
2178         PID1=$! ; pdo_sched
2179         mv $DIR2/$tfile $DIR2/$tfile-2 &
2180         PID2=$! ; pdo_sched
2181         do_nodes $(comma_list $(mdts_nodes)) \
2182                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2183         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2184         wait $PID2 ; [ $? -ne 0 ] || error "rename must fail"
2185         rm -rf $DIR/$tfile*
2186         return 0
2187 }
2188 run_test 43f "pdirops: unlink and rename (src) =============="
2189
2190 test_43g() {
2191         pdo_lru_clear
2192         touch $DIR1/$tfile
2193 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2194         do_nodes $(comma_list $(mdts_nodes)) \
2195                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2196         rm $DIR1/$tfile &
2197         PID1=$! ; pdo_sched
2198         stat $DIR2/$tfile > /dev/null &
2199         PID2=$! ; pdo_sched
2200         do_nodes $(comma_list $(mdts_nodes)) \
2201                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2202         check_pdo_conflict $PID1 && { wait $PID1; error "getattr isn't blocked"; }
2203         wait $PID2 ; [ $? -ne 0 ] || error "stat must fail"
2204         rm -rf $DIR/$tfile*
2205         return 0
2206 }
2207 run_test 43g "pdirops: unlink vs getattr =============="
2208
2209 test_43h() {
2210         pdo_lru_clear
2211         touch $DIR1/$tfile
2212 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2213         do_nodes $(comma_list $(mdts_nodes)) \
2214                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2215         rm $DIR1/$tfile &
2216         PID1=$! ; pdo_sched
2217         ls -lia $DIR2/ > /dev/null &
2218         PID2=$! ; pdo_sched
2219         do_nodes $(comma_list $(mdts_nodes)) \
2220                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2221         check_pdo_conflict $PID1 && { wait $PID1; error "readdir isn't blocked"; }
2222         wait $PID2
2223         rm -rf $DIR/$tfile*
2224         return 0
2225 }
2226 run_test 43h "pdirops: unlink vs readdir =============="
2227
2228 test_43i() {
2229         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2230         pdo_lru_clear
2231         touch $DIR1/$tfile
2232 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2233         do_nodes $(comma_list $(mdts_nodes)) \
2234                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2235         rm $DIR1/$tfile &
2236         PID1=$! ; pdo_sched
2237         $LFS mkdir -i 1 $DIR2/$tfile &
2238         PID2=$! ; pdo_sched
2239         do_nodes $(comma_list $(mdts_nodes)) \
2240                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2241         check_pdo_conflict $PID1 &&
2242                 { wait $PID1; error "remote mkdir isn't blocked"; }
2243         wait $PID2 ; [ $? -eq 0 ] || error "remote mkdir must succeed"
2244         rm -rf $DIR/$tfile*
2245         return 0
2246 }
2247 run_test 43i "pdirops: unlink vs remote mkdir"
2248
2249 test_43j() {
2250         [[ $MDS1_VERSION -lt $(version_code 2.13.52) ]] &&
2251                 skip "Need MDS version newer than 2.13.52"
2252
2253         for i in {1..100}; do
2254 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_CREATE_RACE         0x167
2255                 do_nodes $(comma_list $(mdts_nodes)) \
2256                         "lctl set_param -n fail_loc=0x80000167 2>/dev/null ||
2257                                 true"
2258                 OK=0
2259                 mkdir $DIR1/$tdir &
2260                 PID1=$!
2261                 mkdir $DIR2/$tdir && ((OK++))
2262                 wait $PID1 && ((OK++))
2263                 (( OK == 1 )) || error "exactly one mkdir should succeed"
2264
2265                 rmdir $DIR1/$tdir || error "rmdir failed"
2266         done
2267         return 0
2268 }
2269 run_test 43j "racy mkdir return EEXIST =============="
2270
2271 sub_test_43k() {
2272         local PID1 PID2
2273         local fail_loc="$1"
2274         local ret=0
2275
2276         # We test in a separate directory to be able to unblock server thread in
2277         # cfs_race() if LCK_PW is taken on the parent by mdt_reint_unlink.
2278         test_mkdir $DIR2/$tdir
2279         touch $DIR2/$tdir/$tfile
2280
2281         do_nodes $(comma_list $(mdts_nodes)) \
2282                 "lctl set_param -n fail_loc=${fail_loc} || true" &>/dev/null
2283         echo content > $DIR1/$tdir/$tfile & PID1=$!
2284         pdo_sched
2285         multiop $DIR2/$tdir/$tfile u & PID2=$!
2286
2287         wait $PID1 ||
2288                 { ret=$?; \
2289                 echo -n "overwriting $tfile should succeed (err=$ret); "; }
2290         wait $PID2 ||
2291                 { ret=$?; \
2292                 echo -n "unlinking $tfile should succeed (err=$ret);"; }
2293
2294         #Clean
2295         do_nodes $(comma_list $(mdts_nodes)) \
2296                 "lctl set_param -n fail_loc=0x0 || true" &>/dev/null
2297         rm -rf $DIR/$tdir
2298
2299         return $ret
2300 }
2301
2302 test_43k() {
2303         [[ $MDS1_VERSION -le $(version_code 2.13.56) ]] ||
2304                 skip "Need MDS version newer than 2.13.56"
2305         local msg fail_loc
2306
2307 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_REINT_OPEN         0x169
2308 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_REINT_OPEN2        0x16a
2309         for fail_loc in "0x80000169" "0x8000016a"; do
2310                 echo "Begin 100 tests with fail_loc=$fail_loc"
2311                 printf "Progress: "
2312                 for i in {1..100}; do
2313                         printf "*"
2314                         msg=$(sub_test_43k "$fail_loc") ||
2315                                 { echo; error "iter=$i : $msg"; }
2316                 done
2317                 echo
2318         done
2319
2320         #Clean
2321         reset_fail_loc
2322
2323         return 0
2324 }
2325 run_test 43k "unlink vs create"
2326
2327 # test 44: rename tgt and blocking operations
2328 test_44a() {
2329         pdo_lru_clear
2330         touch $DIR1/$tfile-2
2331 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2   0x146
2332         do_nodes $(comma_list $(mdts_nodes)) \
2333                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2334         mv $DIR1/$tfile-2 $DIR1/$tfile &
2335         PID1=$! ; pdo_sched
2336         mkdir $DIR2/$tfile &
2337         PID2=$! ; pdo_sched
2338         do_nodes $(comma_list $(mdts_nodes)) \
2339                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2340         check_pdo_conflict $PID1 && { wait $PID1; date;error "mkdir isn't blocked"; }
2341         wait $PID2 ; [ $? -ne 0 ] || error "mkdir must fail"
2342         date
2343         rm -rf $DIR/$tfile*
2344         return 0
2345 }
2346 run_test 44a "pdirops: rename tgt vs mkdir =============="
2347
2348 test_44b() {
2349         pdo_lru_clear
2350         touch $DIR1/$tfile-2
2351 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2352         do_nodes $(comma_list $(mdts_nodes)) \
2353                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2354         mv $DIR1/$tfile-2 $DIR1/$tfile &
2355         PID1=$! ; pdo_sched
2356         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c &
2357         PID2=$! ; pdo_sched
2358         do_nodes $(comma_list $(mdts_nodes)) \
2359                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2360         check_pdo_conflict $PID1 && { wait $PID1; error "create isn't blocked"; }
2361         wait $PID2 ; [ $? -ne 0 ] || error "create must fail"
2362         rm -rf $DIR/$tfile*
2363         return 0
2364 }
2365 run_test 44b "pdirops: rename tgt vs create =============="
2366
2367 test_44c() {
2368         pdo_lru_clear
2369         touch $DIR1/$tfile-2
2370         touch $DIR1/$tfile-3
2371 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2372         do_nodes $(comma_list $(mdts_nodes)) \
2373                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2374         mv $DIR1/$tfile-2 $DIR1/$tfile &
2375         PID1=$! ; pdo_sched
2376         link $DIR2/$tfile-3 $DIR2/$tfile &
2377         PID2=$! ; pdo_sched
2378         do_nodes $(comma_list $(mdts_nodes)) \
2379                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2380         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
2381         wait $PID2 ; [ $? -ne 0 ] || error "link must fail"
2382         rm -rf $DIR/$tfile*
2383         return 0
2384 }
2385 run_test 44c "pdirops: rename tgt vs link =============="
2386
2387 test_44d() {
2388         pdo_lru_clear
2389         touch $DIR1/$tfile-2
2390 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2391         do_nodes $(comma_list $(mdts_nodes)) \
2392                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2393         mv $DIR1/$tfile-2 $DIR1/$tfile &
2394         PID1=$! ; pdo_sched
2395         rm $DIR2/$tfile &
2396         PID2=$! ; pdo_sched
2397         do_nodes $(comma_list $(mdts_nodes)) \
2398                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2399         check_pdo_conflict $PID1 && { wait $PID1; error "unlink isn't blocked"; }
2400         wait $PID2 ; [ $? -eq 0 ] || error "unlink must succeed"
2401         rm -rf $DIR/$tfile*
2402         return 0
2403 }
2404 run_test 44d "pdirops: rename tgt vs unlink =============="
2405
2406 test_44e() {
2407         pdo_lru_clear
2408         touch $DIR1/$tfile
2409         touch $DIR1/$tfile-2
2410         touch $DIR1/$tfile-3
2411 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2412         do_nodes $(comma_list $(mdts_nodes)) \
2413                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2414         mv $DIR1/$tfile-2 $DIR1/$tfile &
2415         PID1=$! ; pdo_sched
2416         mv $DIR2/$tfile-3 $DIR2/$tfile &
2417         PID2=$! ; pdo_sched
2418         do_nodes $(comma_list $(mdts_nodes)) \
2419                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2420         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2421         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2422         rm -rf $DIR/$tfile*
2423         return 0
2424 }
2425 run_test 44e "pdirops: rename tgt and rename (tgt) =============="
2426
2427 test_44f() {
2428         pdo_lru_clear
2429         touch $DIR1/$tfile-2
2430         touch $DIR1/$tfile-3
2431 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2432         do_nodes $(comma_list $(mdts_nodes)) \
2433                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2434         mv $DIR1/$tfile-2 $DIR1/$tfile &
2435         PID1=$! ; pdo_sched
2436         mv $DIR2/$tfile $DIR2/$tfile-3 &
2437         PID2=$! ; pdo_sched
2438         do_nodes $(comma_list $(mdts_nodes)) \
2439                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2440         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2441         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2442         rm -rf $DIR/$tfile*
2443         return 0
2444 }
2445 run_test 44f "pdirops: rename tgt and rename (src) =============="
2446
2447 test_44g() {
2448         pdo_lru_clear
2449         touch $DIR1/$tfile-2
2450 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2451         do_nodes $(comma_list $(mdts_nodes)) \
2452                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2453         mv $DIR1/$tfile-2 $DIR1/$tfile &
2454         PID1=$! ; pdo_sched
2455         stat $DIR2/$tfile > /dev/null &
2456         PID2=$! ; pdo_sched
2457         do_nodes $(comma_list $(mdts_nodes)) \
2458                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2459         check_pdo_conflict $PID1 && { wait $PID1; error "getattr isn't blocked"; }
2460         wait $PID2 ; [ $? -eq 0 ] || error "stat must succeed"
2461         rm -rf $DIR/$tfile*
2462         return 0
2463 }
2464 run_test 44g "pdirops: rename tgt vs getattr =============="
2465
2466 test_44h() {
2467         pdo_lru_clear
2468         touch $DIR1/$tfile-2
2469 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2470         do_nodes $(comma_list $(mdts_nodes)) \
2471                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2472         mv $DIR1/$tfile-2 $DIR1/$tfile &
2473         PID1=$! ; pdo_sched
2474         ls -lia $DIR2/ > /dev/null &
2475         PID2=$! ; pdo_sched
2476         do_nodes $(comma_list $(mdts_nodes)) \
2477                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2478         check_pdo_conflict $PID1 && { wait $PID1; error "readdir isn't blocked"; }
2479         wait $PID2
2480         rm -rf $DIR/$tfile*
2481         return 0
2482 }
2483 run_test 44h "pdirops: rename tgt vs readdir =============="
2484
2485 # test 44: rename tgt and blocking operations
2486 test_44i() {
2487         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2488         pdo_lru_clear
2489         touch $DIR1/$tfile-2
2490 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2   0x146
2491         do_nodes $(comma_list $(mdts_nodes)) \
2492                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2493         mv $DIR1/$tfile-2 $DIR1/$tfile &
2494         PID1=$! ; pdo_sched
2495         $LFS mkdir -i 1 $DIR2/$tfile &
2496         PID2=$! ; pdo_sched
2497         do_nodes $(comma_list $(mdts_nodes)) \
2498                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2499         check_pdo_conflict $PID1 && { wait $PID1;
2500                                 error "remote mkdir isn't blocked"; }
2501         wait $PID2 ; [ $? -ne 0 ] || error "remote mkdir must fail"
2502         rm -rf $DIR/$tfile*
2503         return 0
2504 }
2505 run_test 44i "pdirops: rename tgt vs remote mkdir"
2506
2507 # test 45: rename,mkdir doesn't fail with -EEXIST
2508 test_45a() {
2509         for i in {1..1000}; do
2510                 mkdir $DIR1/$tdir || error "mkdir $tdir failed"
2511                 mrename $DIR2/$tdir $DIR2/$tdir.$i > /dev/null ||
2512                         error "mrename to $tdir.$i failed"
2513         done
2514         rm -rf $DIR/$tdir*
2515         return 0
2516 }
2517 run_test 45a "rename,mkdir doesn't return -EEXIST =============="
2518
2519 test_45b() {
2520         pdo_lru_clear
2521         touch $DIR1/$tfile
2522 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2523         do_nodes $(comma_list $(mdts_nodes)) \
2524                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2525         mv $DIR1/$tfile $DIR1/$tfile-2 &
2526         PID1=$! ; pdo_sched
2527         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c &
2528         PID2=$! ; pdo_sched
2529         do_nodes $(comma_list $(mdts_nodes)) \
2530                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2531         check_pdo_conflict $PID1 && { wait $PID1; error "create isn't blocked"; }
2532         wait $PID2 ; [ $? -eq 0 ] || error "create must succeed"
2533         rm -rf $DIR/$tfile*
2534         return 0
2535 }
2536 run_test 45b "pdirops: rename src vs create =============="
2537
2538 test_45c() {
2539         pdo_lru_clear
2540         touch $DIR1/$tfile
2541         touch $DIR1/$tfile-3
2542 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2543         do_nodes $(comma_list $(mdts_nodes)) \
2544                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2545         mv $DIR1/$tfile $DIR1/$tfile-2 &
2546         PID1=$! ; pdo_sched
2547         link $DIR2/$tfile-3 $DIR2/$tfile &
2548         PID2=$! ; pdo_sched
2549         do_nodes $(comma_list $(mdts_nodes)) \
2550                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2551         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
2552         wait $PID2 ; [ $? -eq 0 ] || error "link must succeed"
2553         rm -rf $DIR/$tfile*
2554         return 0
2555 }
2556 run_test 45c "pdirops: rename src vs link =============="
2557
2558 test_45d() {
2559         pdo_lru_clear
2560         touch $DIR1/$tfile
2561 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2562         do_nodes $(comma_list $(mdts_nodes)) \
2563                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2564         mv $DIR1/$tfile $DIR1/$tfile-2 &
2565         PID1=$! ; pdo_sched
2566         rm $DIR2/$tfile &
2567         PID2=$! ; pdo_sched
2568         do_nodes $(comma_list $(mdts_nodes)) \
2569                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2570         check_pdo_conflict $PID1 && { wait $PID1; error "unlink isn't blocked"; }
2571         wait $PID2 ; [ $? -ne 0 ] || error "unlink must fail"
2572         rm -rf $DIR/$tfile*
2573         return 0
2574 }
2575 run_test 45d "pdirops: rename src vs unlink =============="
2576
2577 test_45e() {
2578         pdo_lru_clear
2579         touch $DIR1/$tfile
2580         touch $DIR1/$tfile-3
2581 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2582         do_nodes $(comma_list $(mdts_nodes)) \
2583                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2584         mv $DIR1/$tfile $DIR1/$tfile-2 &
2585         PID1=$! ; pdo_sched
2586         mv $DIR2/$tfile-3 $DIR2/$tfile &
2587         PID2=$! ; pdo_sched
2588         do_nodes $(comma_list $(mdts_nodes)) \
2589                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2590         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2591         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2592         rm -rf $DIR/$tfile*
2593         return 0
2594 }
2595 run_test 45e "pdirops: rename src and rename (tgt) =============="
2596
2597 test_45f() {
2598         pdo_lru_clear
2599         touch $DIR1/$tfile
2600 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2601         do_nodes $(comma_list $(mdts_nodes)) \
2602                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2603         mv $DIR1/$tfile $DIR1/$tfile-2 &
2604         PID1=$! ; pdo_sched
2605         mv $DIR2/$tfile $DIR2/$tfile-3 &
2606         PID2=$! ; pdo_sched
2607         do_nodes $(comma_list $(mdts_nodes)) \
2608                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2609         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2610         wait $PID2 ; [ $? -ne 0 ] || error "rename must fail"
2611         rm -rf $DIR/$tfile*
2612         return 0
2613 }
2614 run_test 45f "pdirops: rename src and rename (src) =============="
2615
2616 test_45g() {
2617         pdo_lru_clear
2618         touch $DIR1/$tfile
2619 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2620         do_nodes $(comma_list $(mdts_nodes)) \
2621                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2622         mv $DIR1/$tfile $DIR1/$tfile-2 &
2623         PID1=$! ; pdo_sched
2624         stat $DIR2/$tfile > /dev/null &
2625         PID2=$! ; pdo_sched
2626         do_nodes $(comma_list $(mdts_nodes)) \
2627                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2628         check_pdo_conflict $PID1 && { wait $PID1; error "getattr isn't blocked"; }
2629         wait $PID2 ; [ $? -ne 0 ] || error "stat must fail"
2630         rm -rf $DIR/$tfile*
2631         return 0
2632 }
2633 run_test 45g "pdirops: rename src vs getattr =============="
2634
2635 test_45h() {
2636         pdo_lru_clear
2637         touch $DIR1/$tfile
2638 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2639         do_nodes $(comma_list $(mdts_nodes)) \
2640                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2641         mv $DIR1/$tfile $DIR1/$tfile-2 &
2642         PID1=$! ; pdo_sched
2643         ls -lia $DIR2/ > /dev/null &
2644         do_nodes $(comma_list $(mdts_nodes)) \
2645                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2646         check_pdo_conflict $PID1 && { wait $PID1; error "readdir isn't blocked"; }
2647         wait $PID2
2648         rm -rf $DIR/$tfile*
2649         return 0
2650 }
2651 run_test 45h "pdirops: unlink vs readdir =============="
2652
2653 test_45i() {
2654         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2655         pdo_lru_clear
2656         touch $DIR1/$tfile
2657 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2658         do_nodes $(comma_list $(mdts_nodes)) \
2659                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2660         mv $DIR1/$tfile $DIR1/$tfile-2 &
2661         PID1=$! ; pdo_sched
2662         $LFS mkdir -i 1 $DIR2/$tfile &
2663         PID2=$! ; pdo_sched
2664         do_nodes $(comma_list $(mdts_nodes)) \
2665                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2666         check_pdo_conflict $PID1 && { wait $PID1;
2667                                 error "create remote dir isn't blocked"; }
2668         wait $PID2 ; [ $? -eq 0 ] || error "create remote dir must succeed"
2669         rm -rf $DIR/$tfile*
2670         return 0
2671 }
2672 run_test 45i "pdirops: rename src vs remote mkdir"
2673
2674 sub_test_45j() {
2675         local PID1 PID2
2676         local fail_loc="$1"
2677         local ret=0
2678
2679         # We test in a sparate directory to be able to unblock server thread in
2680         # cfs_race if LCK_PW is taken on the parent by mdt_reint_rename.
2681         test_mkdir $DIR2/$tdir
2682         echo file1 > $DIR2/$tdir/$tfile
2683         echo file2 > $DIR2/$tdir/$tfile-2
2684
2685         do_nodes $(comma_list $(mdts_nodes)) \
2686                 "lctl set_param -n fail_loc=${fail_loc} || true" &>/dev/null
2687
2688         cat $DIR1/$tdir/$tfile >/dev/null &
2689         PID1=$!
2690         pdo_sched
2691         mrename $DIR2/$tdir/$tfile-2 $DIR2/$tdir/$tfile > /dev/null &
2692         PID2=$!
2693
2694         wait $PID1 ||
2695                 { ret=$?; echo -n "cat $tfile should succeed (err=$ret); "; }
2696         wait $PID2 ||
2697                 { ret=$?; \
2698                 echo -n "mrename $tfile-2 to $tfile failed (err=$ret);"; }
2699
2700         #Clean
2701         do_nodes $(comma_list $(mdts_nodes)) \
2702                 "lctl set_param -n fail_loc=0x0 || true" &>/dev/null
2703         rm -rf $DIR/$tdir
2704
2705         return $ret
2706 }
2707
2708 test_45j() {
2709         [[ $MDS1_VERSION -le $(version_code 2.13.56) ]] ||
2710                 skip "Need MDS version newer than 2.13.56"
2711         local msg fail_loc
2712
2713 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_REINT_OPEN         0x169
2714 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_REINT_OPEN2        0x16a
2715         for fail_loc in "0x80000169" "0x8000016a"; do
2716                 echo "Begin 100 tests with fail_loc=$fail_loc"
2717                 printf "Progress: "
2718                 for i in {1..100}; do
2719                         printf "*"
2720                         msg=$(sub_test_45j "$fail_loc") ||
2721                                 { echo; error "iter=$i : $msg"; }
2722                 done
2723                 echo
2724         done
2725 }
2726 run_test 45j "read vs rename =============="
2727
2728 # test 46: link and blocking operations
2729 test_46a() {
2730         pdo_lru_clear
2731         touch $DIR1/$tfile-2
2732 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2733         do_nodes $(comma_list $(mdts_nodes)) \
2734                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2735         link $DIR1/$tfile-2 $DIR1/$tfile &
2736         PID1=$! ; pdo_sched
2737         mkdir $DIR2/$tfile &
2738         PID2=$! ; pdo_sched
2739         do_nodes $(comma_list $(mdts_nodes)) \
2740                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2741         check_pdo_conflict $PID1 && { wait $PID1; error "mkdir isn't blocked"; }
2742         wait $PID2 ; [ $? -ne 0 ] || error "mkdir must fail"
2743         rm -rf $DIR/$tfile*
2744         return 0
2745 }
2746 run_test 46a "pdirops: link vs mkdir =============="
2747
2748 test_46b() {
2749         pdo_lru_clear
2750         touch $DIR1/$tfile-2
2751 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2752         do_nodes $(comma_list $(mdts_nodes)) \
2753                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2754         link $DIR1/$tfile-2 $DIR1/$tfile &
2755         PID1=$! ; pdo_sched
2756         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c &
2757         PID2=$! ; pdo_sched
2758         do_nodes $(comma_list $(mdts_nodes)) \
2759                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2760         check_pdo_conflict $PID1 && { wait $PID1; error "create isn't blocked"; }
2761         wait $PID2 ; [ $? -ne 0 ] || error "create must fail"
2762         rm -rf $DIR/$tfile*
2763         return 0
2764 }
2765 run_test 46b "pdirops: link vs create =============="
2766
2767 test_46c() {
2768         pdo_lru_clear
2769         touch $DIR1/$tfile-2
2770 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2771         do_nodes $(comma_list $(mdts_nodes)) \
2772                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2773         link $DIR1/$tfile-2 $DIR1/$tfile &
2774         PID1=$! ; pdo_sched
2775         link $DIR2/$tfile $DIR2/$tfile &
2776         PID2=$! ; pdo_sched
2777         do_nodes $(comma_list $(mdts_nodes)) \
2778                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2779         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
2780         wait $PID2 ; [ $? -ne 0 ] || error "link must fail"
2781         rm -rf $DIR/$tfile*
2782         return 0
2783 }
2784 run_test 46c "pdirops: link vs link =============="
2785
2786 test_46d() {
2787         pdo_lru_clear
2788         touch $DIR1/$tfile-2
2789 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2790         do_nodes $(comma_list $(mdts_nodes)) \
2791                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2792         link $DIR1/$tfile-2 $DIR1/$tfile &
2793         PID1=$! ; pdo_sched
2794         rm $DIR2/$tfile &
2795         PID2=$! ; pdo_sched
2796         do_nodes $(comma_list $(mdts_nodes)) \
2797                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2798         check_pdo_conflict $PID1 && { wait $PID1; error "unlink isn't blocked"; }
2799         wait $PID2 ; [ $? -eq 0 ] || error "unlink must succeed"
2800         rm -rf $DIR/$tfile*
2801         return 0
2802 }
2803 run_test 46d "pdirops: link vs unlink =============="
2804
2805 test_46e() {
2806         pdo_lru_clear
2807         touch $DIR1/$tfile-2
2808         touch $DIR1/$tfile-3
2809 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2810         do_nodes $(comma_list $(mdts_nodes)) \
2811                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2812         link $DIR1/$tfile-2 $DIR1/$tfile &
2813         PID1=$! ; pdo_sched
2814         mv $DIR2/$tfile-3 $DIR2/$tfile &
2815         PID2=$! ; pdo_sched
2816         do_nodes $(comma_list $(mdts_nodes)) \
2817                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2818         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2819         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2820         rm -rf $DIR/$tfile*
2821         return 0
2822 }
2823 run_test 46e "pdirops: link and rename (tgt) =============="
2824
2825 test_46f() {
2826         pdo_lru_clear
2827         touch $DIR1/$tfile-2
2828         touch $DIR1/$tfile-3
2829 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2830         do_nodes $(comma_list $(mdts_nodes)) \
2831                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2832         link $DIR1/$tfile-2 $DIR1/$tfile &
2833         PID1=$! ; pdo_sched
2834         mv $DIR2/$tfile $DIR2/$tfile-3 &
2835         PID2=$! ; pdo_sched
2836         do_nodes $(comma_list $(mdts_nodes)) \
2837                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2838         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2839         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2840         rm -rf $DIR/$tfile*
2841         return 0
2842 }
2843 run_test 46f "pdirops: link and rename (src) =============="
2844
2845 test_46g() {
2846         pdo_lru_clear
2847         touch $DIR1/$tfile-2
2848 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2849         do_nodes $(comma_list $(mdts_nodes)) \
2850                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2851         link $DIR1/$tfile-2 $DIR1/$tfile &
2852         PID1=$! ; pdo_sched
2853         stat $DIR2/$tfile > /dev/null &
2854         PID2=$! ; pdo_sched
2855         do_nodes $(comma_list $(mdts_nodes)) \
2856                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2857         check_pdo_conflict $PID1 && { wait $PID1; error "getattr isn't blocked"; }
2858         wait $PID2 ; [ $? -eq 0 ] || error "stat must succeed"
2859         rm -rf $DIR/$tfile*
2860         return 0
2861 }
2862 run_test 46g "pdirops: link vs getattr =============="
2863
2864 test_46h() {
2865         pdo_lru_clear
2866         touch $DIR1/$tfile-2
2867 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2868         do_nodes $(comma_list $(mdts_nodes)) \
2869                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2870         link $DIR1/$tfile-2 $DIR1/$tfile &
2871         PID1=$! ; pdo_sched
2872         ls -lia $DIR2/ > /dev/null &
2873         PID2=$! ; pdo_sched
2874         do_nodes $(comma_list $(mdts_nodes)) \
2875                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2876         check_pdo_conflict $PID1 && { wait $PID1; error "readdir isn't blocked"; }
2877         wait $PID2
2878         rm -rf $DIR/$tfile*
2879         return 0
2880 }
2881 run_test 46h "pdirops: link vs readdir =============="
2882
2883 test_46i() {
2884         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2885         pdo_lru_clear
2886         touch $DIR1/$tfile-2
2887 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2888         do_nodes $(comma_list $(mdts_nodes)) \
2889                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2890         link $DIR1/$tfile-2 $DIR1/$tfile &
2891         PID1=$! ; pdo_sched
2892         $LFS mkdir -i 1 $DIR2/$tfile &
2893         PID2=$! ; pdo_sched
2894         do_nodes $(comma_list $(mdts_nodes)) \
2895                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2896         check_pdo_conflict $PID1 && { wait $PID1;
2897                                 error "remote mkdir isn't blocked"; }
2898         wait $PID2 ; [ $? -ne 0 ] || error "remote mkdir must fail"
2899         rm -rf $DIR/$tfile*
2900         return 0
2901 }
2902 run_test 46i "pdirops: link vs remote mkdir"
2903
2904 # test 47: remote mkdir and blocking operations
2905 test_47a() {
2906 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2907         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2908         pdo_lru_clear
2909         do_nodes $(comma_list $(mdts_nodes)) \
2910                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2911         $LFS mkdir -i 1 $DIR1/$tfile &
2912         PID1=$! ; pdo_sched
2913         mkdir $DIR2/$tfile &
2914         PID2=$! ; pdo_sched
2915         do_nodes $(comma_list $(mdts_nodes)) \
2916                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2917         check_pdo_conflict $PID1 && { wait $PID1; error "mkdir isn't blocked"; }
2918         wait $PID2 ; [ $? -ne 0 ] || error "mkdir must fail"
2919         rm -rf $DIR/$tfile*
2920         return 0
2921 }
2922 run_test 47a "pdirops: remote mkdir vs mkdir"
2923
2924 test_47b() {
2925 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2926         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2927         pdo_lru_clear
2928         do_nodes $(comma_list $(mdts_nodes)) \
2929                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2930         $LFS mkdir -i 1 $DIR1/$tfile &
2931         PID1=$! ; pdo_sched
2932         sleep 1 # please do not remove this sleep, see LU-10754
2933         multiop $DIR2/$tfile oO_CREAT:O_EXCL:c &
2934         PID2=$! ; pdo_sched
2935         do_nodes $(comma_list $(mdts_nodes)) \
2936                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2937         check_pdo_conflict $PID1 && { wait $PID1;
2938                                         error "create isn't blocked"; }
2939         wait $PID2 ; [ $? -ne 0 ] || error "create must fail"
2940         rm -rf $DIR/$tfile*
2941         return 0
2942 }
2943 run_test 47b "pdirops: remote mkdir vs create"
2944
2945 test_47c() {
2946         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2947         pdo_lru_clear
2948         touch $DIR1/$tfile-2
2949 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2950         do_nodes $(comma_list $(mdts_nodes)) \
2951                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2952         $LFS mkdir -i 1 $DIR1/$tfile &
2953         PID1=$! ; pdo_sched
2954         link $DIR2/$tfile-2 $DIR2/$tfile &
2955         PID2=$! ; pdo_sched
2956         do_nodes $(comma_list $(mdts_nodes)) \
2957                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2958         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
2959         wait $PID2 ; [ $? -ne 0 ] || error "link must fail"
2960         rm -rf $DIR/$tfile*
2961         return 0
2962 }
2963 run_test 47c "pdirops: remote mkdir vs link"
2964
2965 test_47d() {
2966         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2967         pdo_lru_clear
2968 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2969         do_nodes $(comma_list $(mdts_nodes)) \
2970                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2971         $LFS mkdir -i 1 $DIR1/$tfile &
2972         PID1=$! ; pdo_sched
2973         rmdir $DIR2/$tfile &
2974         PID2=$! ; pdo_sched
2975         do_nodes $(comma_list $(mdts_nodes)) \
2976                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2977         check_pdo_conflict $PID1 && { wait $PID1;
2978                                         error "unlink isn't blocked"; }
2979         wait $PID2 ; [ $? -eq 0 ] || error "rmdir must succeed"
2980         rm -rf $DIR/$tfile*
2981         return 0
2982 }
2983 run_test 47d "pdirops: remote mkdir vs unlink"
2984
2985 test_47e() {
2986         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2987         pdo_lru_clear
2988         touch $DIR1/$tfile-2
2989 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2990         do_nodes $(comma_list $(mdts_nodes)) \
2991                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2992         $LFS mkdir -i 1 $DIR1/$tfile &
2993         PID1=$! ; pdo_sched
2994         mv -T $DIR2/$tfile-2 $DIR2/$tfile &
2995         PID2=$! ; pdo_sched
2996         do_nodes $(comma_list $(mdts_nodes)) \
2997                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2998         check_pdo_conflict $PID1 && { wait $PID1;
2999                                         error "rename isn't blocked"; }
3000         wait $PID2 ; [ $? -ne 0 ] || error "rename must fail"
3001         rm -rf $DIR/$tfile*
3002         return 0
3003 }
3004 run_test 47e "pdirops: remote mkdir and rename (tgt)"
3005
3006 test_47f() {
3007         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
3008         pdo_lru_clear
3009 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3010         do_nodes $(comma_list $(mdts_nodes)) \
3011                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3012         $LFS mkdir -i 1 $DIR1/$tfile &
3013         PID1=$! ; pdo_sched
3014         mv $DIR2/$tfile $DIR2/$tfile-2 &
3015         PID2=$! ; pdo_sched
3016         do_nodes $(comma_list $(mdts_nodes)) \
3017                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3018         check_pdo_conflict $PID1 && { wait $PID1;
3019                                         error "rename isn't blocked"; }
3020         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
3021         rm -rf $DIR/$tfile*
3022         return 0
3023 }
3024 run_test 47f "pdirops: remote mkdir and rename (src)"
3025
3026 test_47g() {
3027         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
3028         sync
3029         sync_all_data
3030         pdo_lru_clear
3031 #define OBD_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3032         do_nodes $(comma_list $(mdts_nodes)) \
3033                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3034         $LFS mkdir -i 1 $DIR1/$tfile &
3035         PID1=$! ; pdo_sched
3036         stat $DIR2/$tfile > /dev/null &
3037         PID2=$! ; pdo_sched
3038         do_nodes $(comma_list $(mdts_nodes)) \
3039                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3040         check_pdo_conflict $PID1 && { wait $PID1;
3041                                         error "getattr isn't blocked"; }
3042         wait $PID2 ; [ $? -eq 0 ] || error "stat must succeed"
3043         rm -rf $DIR/$tfile*
3044         return 0
3045 }
3046 run_test 47g "pdirops: remote mkdir vs getattr"
3047
3048 test_50() {
3049         trunc_size=4096
3050         dd if=/dev/zero of=$DIR1/$tfile bs=1K count=10
3051 #define OBD_FAIL_OSC_CP_ENQ_RACE         0x410
3052         do_facet client "lctl set_param fail_loc=0x410"
3053         $TRUNCATE $DIR2/$tfile $trunc_size
3054         do_facet client "lctl set_param fail_loc=0x0"
3055         sleep 3
3056         size=`stat -c %s $DIR2/$tfile`
3057         [ $size -eq $trunc_size ] || error "wrong size"
3058 }
3059 run_test 50 "osc lvb attrs: enqueue vs. CP AST =============="
3060
3061 test_51a() {
3062         local filesize
3063         local origfile=/etc/hosts
3064
3065         filesize=$(stat -c %s $origfile)
3066
3067         # create an empty file
3068         $MCREATE $DIR1/$tfile || error "can't create $DIR1/$tfile"
3069         # cache layout lock on both mount point
3070         stat $DIR1/$tfile > /dev/null || error "stat $DIR1/$tfile failed"
3071         stat $DIR2/$tfile > /dev/null || error "stat $DIR2/$tfile failed"
3072
3073         # open and sleep 2 seconds then read
3074         $MULTIOP $DIR2/$tfile o_2r${filesize}c &
3075         local pid=$!
3076         sleep 1
3077
3078         # create the layout of testing file
3079         dd if=$origfile of=$DIR1/$tfile conv=notrunc > /dev/null ||
3080                 error "dd $DIR1/$tfile failed"
3081
3082         # MULTIOP proc should be able to read enough bytes and exit
3083         for ((i = 0; i < 6; i++)); do
3084                 sleep 1
3085                 kill -0 $pid || break
3086         done
3087         kill -0 $pid 2> /dev/null && error "multiop is still there"
3088         cmp $origfile $DIR2/$tfile || error "$origfile and $DIR2/$tfile differs"
3089
3090         rm -f $DIR1/$tfile
3091 }
3092 run_test 51a "layout lock: refresh layout should work"
3093
3094 test_51b() {
3095         [[ "$MDS1_VERSION" -ge $(version_code 2.3.59) ]] ||
3096                 skip "Need MDS version at least 2.3.59"
3097
3098         local tmpfile=`mktemp`
3099
3100         $LFS setstripe -E 1M -c 1 -E -1 --extension-size 64M $DIR1/$tfile ||
3101                 error "Create $DIR1/$tfile failed"
3102
3103         dd if=/dev/zero of=$DIR1/$tfile bs=1k count=1 conv=notrunc ||
3104                 error "dd $DIR1/$tfile failed"
3105
3106         # delay glimpse so that layout has changed when glimpse finish
3107 #define OBD_FAIL_GLIMPSE_DELAY 0x1404
3108         $LCTL set_param fail_loc=0x1404 fail_val=4
3109         stat -c %s $DIR2/$tfile |tee $tmpfile &
3110         local pid=$!
3111         sleep 0.2
3112
3113         # extend layout of testing file
3114         dd if=/dev/zero of=$DIR1/$tfile bs=1M count=1 seek=2 conv=notrunc ||
3115                 error "dd $DIR1/$tfile failed"
3116
3117         wait $pid
3118         local fsize=$(cat $tmpfile)
3119
3120         [ x$fsize = x3145728 ] || error "file size is $fsize, should be 3145728"
3121
3122         rm -f $DIR1/$tfile $tmpfile
3123 }
3124 run_test 51b "layout lock: glimpse should be able to restart if layout changed"
3125
3126 test_51c() {
3127         [ $OSTCOUNT -ge 2 ] || { skip "needs >= 2 osts"; return; }
3128
3129         # set default layout to have 1 stripe
3130         mkdir $DIR1/$tdir
3131         $LFS setstripe -c 1 $DIR1/$tdir
3132
3133         # create a file with empty layout
3134         $MCREATE $DIR1/$tdir/$tfile ||
3135                 error "$MCREATE $DIR1/$tdir/$tfile failed"
3136
3137 #define OBD_FAIL_MDS_LL_BLOCK 0x172
3138         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x172
3139
3140         # change the layout of testing file
3141         echo "Setting layout to have $OSTCOUNT stripes ..."
3142         $LFS setstripe -c $OSTCOUNT $DIR1/$tdir/$tfile &
3143         pid=$!
3144         sleep 1
3145
3146         # write something to the file, it should be blocked on fetching layout
3147         dd if=/dev/zero of=$DIR2/$tdir/$tfile bs=1k count=1 conv=notrunc
3148         local stripe_count=$($LFS getstripe -c $DIR2/$tdir/$tfile)
3149         wait $pid
3150
3151         # lod_qos.c::min_stripe_count() allows setstripe with a default stripe
3152         # count to succeed with only 3/4 of the number of stripes (rounded up),
3153         # so creating striped files does not fail if an OST is offline or full
3154         [ $stripe_count -ge $((OSTCOUNT - $OSTCOUNT / 4)) ] ||
3155                 error "bad layout: getstripe -c $stripe_count < $OSTCOUNT * 3/4"
3156
3157         rm -fr $DIR1/$tdir
3158 }
3159 run_test 51c "layout lock: IT_LAYOUT blocked and correct layout can be returned"
3160
3161 test_51d() {
3162         dd if=/dev/zero of=/$DIR1/$tfile bs=1M count=1
3163         cancel_lru_locks mdc
3164
3165         # open should grant LAYOUT lock, mmap and read will install pages
3166         $MULTIOP $DIR1/$tfile oO_RDWR:SMR_Uc &
3167         local PID=$!
3168         sleep 1
3169
3170         # rss before revoking
3171         local br=$(grep -A 10 $tfile /proc/$PID/smaps | awk '/^Rss/{print $2}')
3172         echo "Before revoking layout lock: $br KB mapped"
3173
3174         # cancel layout lock manually
3175         cancel_lru_locks mdc
3176
3177         # rss after revoking
3178         local ar=$(grep -A 10 $tfile /proc/$PID/smaps | awk '/^Rss/{print $2}')
3179
3180         kill -USR1 $PID
3181         wait $PID || error "wait PID $PID failed"
3182
3183         [ $ar -eq 0 ] || error "rss before: $br, after $ar, some pages remained"
3184 }
3185 run_test 51d "layout lock: losing layout lock should clean up memory map region"
3186
3187 test_51e() {
3188         local pid
3189
3190         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:eW_E+eUc &
3191         pid=$!
3192         sleep 1
3193
3194         $LFS getstripe $DIR2/$tfile
3195         kill -USR1 $pid
3196         wait $pid || error "multiop failed"
3197
3198         $MULTIOP $DIR/$tfile oO_RDONLY:eR_E+eUc &
3199         pid=$!
3200         sleep 1
3201
3202         $LFS getstripe $DIR2/$tfile
3203         kill -USR1 $pid
3204         wait $pid || error "multiop failed"
3205 }
3206 run_test 51e "lfs getstripe does not break leases, part 2"
3207
3208 test_54_part1()
3209 {
3210         echo "==> rename vs getattr vs setxattr should not deadlock"
3211         mkdir -p $DIR/d1/d2/d3 || error "(1) mkdir failed"
3212
3213         do_facet mds1 $LCTL set_param fail_loc=$1
3214
3215         mv -T $DIR/d1/d2/d3 $DIR/d1/d3 &
3216         PID1=$!
3217         sleep 1
3218
3219         stat $DIR/d1/d2 &
3220         PID2=$!
3221         sleep 1
3222
3223         setfattr -n user.attr1 -v value1 $DIR2/d1 || error "(2) setfattr failed"
3224         wait $PID1 || error "(3) mv failed"
3225         wait $PID2 || error "(4) stat failed"
3226         echo
3227
3228         rm -rf $DIR/d1
3229 }
3230
3231 test_54_part2() {
3232         echo "==> rename vs getattr vs open vs getattr should not deadlock"
3233         mkdir -p $DIR/d1/d2/d3 || error "(1) mkdir failed"
3234
3235         do_facet mds1 $LCTL set_param fail_loc=$1
3236
3237         mv -T $DIR/d1/d2/d3 $DIR/d1/d3 &
3238         PID1=$!
3239         sleep 1
3240
3241         stat $DIR/d1/d2 &
3242         PID2=$!
3243         sleep 1
3244
3245         $MULTIOP $DIR2/d1/d2 Oc &
3246         PID3=$!
3247         sleep 1
3248
3249         stat $DIR/d1 || error "(2) stat failed"
3250
3251         wait $PID1 || error "(3) mv failed"
3252         wait $PID2 || error "(4) stat failed"
3253         wait $PID3 && error "(5) multiop failed"
3254         echo
3255         rm -rf $DIR/d1
3256 }
3257
3258 test_54() {
3259         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
3260         save_lustre_params client "llite.*.xattr_cache" > $p
3261         lctl set_param llite.*.xattr_cache 1 ||
3262                 { skip "xattr cache is not supported"; return 0; }
3263
3264 #define OBD_FAIL_MDS_RENAME              0x153
3265 #define OBD_FAIL_MDS_RENAME2             0x154
3266         test_54_part1 0x80000153 || error 10
3267         test_54_part1 0x80000154 || error 11
3268         test_54_part2 0x80000153 || error 12
3269         test_54_part2 0x80000154 || error 13
3270
3271         restore_lustre_params < $p
3272         rm -f $p
3273 }
3274 run_test 54 "rename locking"
3275
3276 test_55a() {
3277         mkdir -p $DIR/d1/d2 $DIR/d3 || error "(1) mkdir failed"
3278
3279 #define OBD_FAIL_MDS_RENAME4              0x156
3280         do_facet mds1 $LCTL set_param fail_loc=0x80000156
3281
3282         mv -T $DIR/d1/d2 $DIR/d3/d2 &
3283         PID1=$!
3284         sleep 1
3285
3286         rm -r $DIR2/d3
3287         wait $PID1 && error "(2) mv succeeded"
3288
3289         rm -rf $DIR/d1
3290 }
3291 run_test 55a "rename vs unlink target dir"
3292
3293 test_55b()
3294 {
3295         mkdir -p $DIR/d1/d2 $DIR/d3 || error "(1) mkdir failed"
3296
3297 #define OBD_FAIL_MDS_RENAME4             0x156
3298         do_facet mds1 $LCTL set_param fail_loc=0x80000156
3299
3300         mv -T $DIR/d1/d2 $DIR/d3/d2 &
3301         PID1=$!
3302         sleep 1
3303
3304         rm -r $DIR2/d1
3305         wait $PID1 && error "(2) mv succeeded"
3306
3307         rm -rf $DIR/d3
3308 }
3309 run_test 55b "rename vs unlink source dir"
3310
3311 test_55c()
3312 {
3313         mkdir -p $DIR/d1/d2 $DIR/d3 || error "(1) mkdir failed"
3314
3315 #define OBD_FAIL_MDS_RENAME4              0x156
3316         do_facet mds1 $LCTL set_param fail_loc=0x156
3317
3318         mv -T $DIR/d1/d2 $DIR/d3/d2 &
3319         PID1=$!
3320         sleep 1
3321
3322         # while rename is sleeping, open and remove d3
3323         $MULTIOP $DIR2/d3 D_c &
3324         PID2=$!
3325         sleep 1
3326         rm -rf $DIR2/d3
3327         sleep 5
3328
3329         # while rename is sleeping 2nd time, close d3
3330         kill -USR1 $PID2
3331         wait $PID2 || error "(3) multiop failed"
3332
3333         wait $PID1 && error "(2) mv succeeded"
3334
3335         rm -rf $DIR/d1
3336 }
3337 run_test 55c "rename vs unlink orphan target dir"
3338