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 if [ $mds1_FSTYPE = "zfs" ]; then
  26         # bug number:    LU-15757 (test_102() causes crash in umount later)
  27         ALWAYS_EXCEPT+=" 102"
  28         # LU-2829 / LU-2887 - make allowances for ZFS slowness
  29         TEST33_NFILES=${TEST33_NFILES:-1000}
  30 fi
  31
  32 #                                  23   (min)"
  33 [ "$SLOW" = "no" ] && EXCEPT_SLOW="33a"
  34
  35 build_test_filter
  36
  37 FAIL_ON_ERROR=false
  38
  39 SETUP=${SETUP:-:}
  40 TRACE=${TRACE:-""}
  41
  42 check_and_setup_lustre
  43
  44 OSC=${OSC:-"osc"}
  45
  46 assert_DIR
  47 rm -rf $DIR1/[df][0-9]* $DIR1/lnk $DIR/[df].${TESTSUITE}*
  48
  49 SAMPLE_FILE=$TMP/$(basename $0 .sh).junk
  50 dd if=/dev/urandom of=$SAMPLE_FILE bs=1M count=1
  51
  52 # $RUNAS_ID may get set incorrectly somewhere else
  53 [ $UID -eq 0 -a $RUNAS_ID -eq 0 ] && error "\$RUNAS_ID set to 0, but \$UID is also 0!"
  54
  55 check_runas_id $RUNAS_ID $RUNAS_GID $RUNAS
  56
  57 test_0() {
  58         local client2=${CLIENT2:-$HOSTNAME}
  59         local tmp=$(mktemp)
  60
  61         printf 'a b\n' > $tmp
  62
  63         do_node_vp "$HOSTNAME" printf 'a b\n' |
  64         diff $tmp - || error "do_node_vp mismatch"
  65
  66         do_node_vp "$client2" printf 'a b\n' |
  67         diff $tmp - || error "do_node_vp mismatch"
  68
  69         do_facet_vp mds1 printf 'a b\n' |
  70         diff $tmp - || error "do_facet_vp mismatch"
  71
  72         printf '%s' 1 2 3 4 5 6 7 8 \ 9 10 ' ' '"' "'" \! \' \( \) $'\n' > $tmp
  73
  74         do_node_vp "$HOSTNAME" printf '%s' 1 2 3 4 5 6 7 8 \ 9 10 ' ' '"' "'" \! \' \( \) $'\n' |
  75         diff $tmp - || error "do_node_vp mismatch"
  76
  77         do_node_vp "$client2" printf '%s' 1 2 3 4 5 6 7 8 \ 9 10 ' ' '"' "'" \! \' \( \) $'\n' |
  78         diff $tmp - || error "do_node_vp mismatch"
  79
  80         do_facet_vp mds1 printf '%s' 1 2 3 4 5 6 7 8 \ 9 10 ' ' '"' "'" \! \' \( \) $'\n' |
  81         diff $tmp - || error "do_facet_vp mismatch"
  82 }
  83 run_test 0 "do_node_vp() and do_facet_vp() do the right thing"
  84
  85 test_1() {
  86         touch $DIR1/$tfile
  87         [ -f $DIR2/$tfile ] || error "Check create"
  88         chmod 777 $DIR2/$tfile
  89         $CHECKSTAT -t file -p 0777 $DIR1/$tfile ||
  90                 error "Check attribute update for 0777"
  91
  92         chmod a-x $DIR2/$tfile
  93         $CHECKSTAT -t file -p 0666 $DIR1/$tfile ||
  94                 error "Check attribute update for 0666"
  95
  96         rm $DIR2/$tfile
  97         $CHECKSTAT -a $DIR1/$tfile ||
  98                 error "Check unlink - removes file on other mountpoint"
  99 }
 100 run_test 1 "Check attribute updates on 2 mount points"
 101
 102 test_2a() {
 103         touch $DIR1/f2a
 104         ls -l $DIR2/f2a
 105         chmod 777 $DIR2/f2a
 106         $CHECKSTAT -t file -p 0777 $DIR1/f2a ||
 107                 error "Either not file type or perms not 0777"
 108 }
 109 run_test 2a "check cached attribute updates on 2 mtpt's ========"
 110
 111 test_2b() {
 112         touch $DIR1/f2b
 113         ls -l $DIR2/f2b
 114         chmod 777 $DIR1/f2b
 115         $CHECKSTAT -t file -p 0777 $DIR2/f2b ||
 116                 error "Either not file type or perms not 0777"
 117 }
 118 run_test 2b "check cached attribute updates on 2 mtpt's ========"
 119
 120 # NEED TO SAVE ROOT DIR MODE
 121 test_2c() {
 122         chmod 777 $DIR1
 123         $CHECKSTAT -t dir -p 0777 $DIR2 ||
 124                 error "Either not dir type or perms not 0777"
 125 }
 126 run_test 2c "check cached attribute updates on 2 mtpt's root ==="
 127
 128 test_2d() {
 129         chmod 755 $DIR1
 130         $CHECKSTAT -t dir -p 0755 $DIR2 ||
 131                 error "Either not file type or perms not 0775"
 132 }
 133 run_test 2d "check cached attribute updates on 2 mtpt's root ==="
 134
 135 test_2e() {
 136         chmod 755 $DIR1
 137         ls -l $DIR1
 138         ls -l $DIR2
 139         chmod 777 $DIR1
 140                 $RUNAS dd if=/dev/zero of=$DIR2/$tfile count=1 ||
 141                         error "dd failed"
 142 }
 143 run_test 2e "check chmod on root is propagated to others"
 144
 145 test_2f() {
 146         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
 147         local MDTIDX=1
 148         local remote_dir=$tdir/remote_dir
 149
 150         mkdir -p $DIR1/$tdir
 151         $LFS mkdir -i $MDTIDX $DIR1/$remote_dir ||
 152                    error "Create remote directory failed"
 153
 154         touch $DIR1/$remote_dir/$tfile ||
 155                 error "Create file under remote directory failed"
 156         chmod 777 $DIR1/$remote_dir/$tfile ||
 157                 error "Chmod file under remote directory failed"
 158
 159         $CHECKSTAT -t file -p 0777 $DIR2/$remote_dir/$tfile ||
 160                 error "Check attr of file under remote directory failed"
 161
 162         chown $RUNAS_ID:$RUNAS_GID $DIR1/$remote_dir/$tfile ||
 163                 error "Chown file under remote directory failed"
 164
 165         $CHECKSTAT -u \#$RUNAS_ID -g \#$RUNAS_GID $DIR2/$remote_dir/$tfile ||
 166                 error "Check owner of file under remote directory failed"
 167
 168         cd $DIR2/$remote_dir || error "enter remote dir"
 169         rm -rf $DIR1/$remote_dir/$tfile ||
 170                 error "Unlink remote directory failed"
 171
 172         $CHECKSTAT -t file $DIR2/$remote_dir/$tfile &&
 173                 error "unlink file still exists!"
 174
 175         cd $DIR2/$tdir || error "exit remote dir"
 176         rm -rf $DIR1/$tdir || error "unlink directory failed"
 177 }
 178 run_test 2f "check attr/owner updates on DNE with 2 mtpt's"
 179
 180 test_2g() {
 181         dd if=/dev/zero of=$DIR1/$tfile oflag=sync bs=1M count=2
 182
 183         local block1=$(stat $DIR1/$tfile | awk '/Blocks/ {print $4} ')
 184         cancel_lru_locks osc
 185         local block2=$(stat $DIR2/$tfile | awk '/Blocks/ {print $4} ')
 186         echo "$DIR1/$tfile has $block1 blocks"
 187         echo "$DIR2/$tfile has $block2 blocks"
 188         [ $block1 -eq $block2 ] || error "$block1 not equal to $block2"
 189 }
 190 run_test 2g "check blocks update on sync write"
 191
 192 test_3() {
 193         local target="this/is/good"
 194         ln -s $target $DIR1/$tfile || error "ln -s $target $DIR1/$tfile failed"
 195         [ "$(ls -l $DIR2/$tfile | sed -e 's/.* -> //')" = "$target" ] ||
 196                 error "link $DIR2/$tfile not as expected"
 197 }
 198 run_test 3 "symlink on one mtpt, readlink on another ==========="
 199
 200 test_4() {
 201         multifstat $DIR1/f4 $DIR2/f4
 202 }
 203 run_test 4 "fstat validation on multiple mount points =========="
 204
 205 test_5() {
 206         mcreate $DIR1/f5
 207         $TRUNCATE $DIR2/f5 100
 208         $CHECKSTAT -t file -s 100 $DIR1/f5 ||
 209                 error "Either not file type or size not equal to 100 bytes"
 210         rm $DIR1/f5
 211 }
 212 run_test 5 "create a file on one mount, truncate it on the other"
 213
 214 test_6() {
 215         openunlink $DIR1/$tfile $DIR2/$tfile || \
 216                 error "openunlink $DIR1/$tfile $DIR2/$tfile"
 217 }
 218 run_test 6 "remove of open file on other node =================="
 219
 220 test_7() {
 221         local dir=d7
 222         opendirunlink $DIR1/$dir $DIR2/$dir || \
 223                 error "opendirunlink $DIR1/$dir $DIR2/$dir"
 224 }
 225 run_test 7 "remove of open directory on other node ============="
 226
 227 test_8() {
 228         opendevunlink $DIR1/$tfile $DIR2/$tfile || \
 229                 error "opendevunlink $DIR1/$tfile $DIR2/$tfile"
 230 }
 231 run_test 8 "remove of open special file on other node =========="
 232
 233 test_9a() {
 234         MTPT=1
 235         local dir
 236         > $DIR2/f9
 237         for C in a b c d e f g h i j k l; do
 238                 dir=`eval echo \\$DIR$MTPT`
 239                 echo -n $C >> $dir/f9
 240                 [ "$MTPT" -eq 1 ] && MTPT=2 || MTPT=1
 241         done
 242         [ "`cat $DIR1/f9`" = "abcdefghijkl" ] || \
 243                 error "`od -a $DIR1/f9` != abcdefghijkl"
 244 }
 245 run_test 9a "append of file with sub-page size on multiple mounts"
 246
 247 #LU-10681 - tiny writes & appending to sparse striped file
 248 test_9b() {
 249         [[ $OSTCOUNT -ge 2 ]] || { skip "needs >= 2 OSTs"; return; }
 250
 251         $LFS setstripe -c 2 -S 1M $DIR/$tfile
 252         echo "foo" >> $DIR/$tfile
 253         dd if=/dev/zero of=$DIR2/$tfile bs=1M count=1 seek=1 conv=notrunc ||
 254                 error "sparse dd $DIR2/$tfile failed"
 255         echo "foo" >> $DIR/$tfile
 256
 257         data=$(dd if=$DIR2/$tfile bs=1 count=3 skip=$((2 * 1048576)) conv=notrunc)
 258         echo "Data read (expecting 'foo')": $data
 259         [ "$data" = "foo" ] || error "append to sparse striped file failed"
 260 }
 261 run_test 9b "append to striped sparse file"
 262
 263 test_10a() {
 264         MTPT=1
 265         local dir
 266         OFFSET=0
 267         > $DIR2/f10
 268         for C in a b c d e f g h i j k l; do
 269                 dir=`eval echo \\$DIR$MTPT`
 270                 echo -n $C | dd of=$dir/f10 bs=1 seek=$OFFSET count=1
 271                 [ "$MTPT" -eq 1 ] && MTPT=2 || MTPT=1
 272                 OFFSET=`expr $OFFSET + 1`
 273         done
 274         [ "`cat $DIR1/f10`" = "abcdefghijkl" ] || \
 275                 error "`od -a $DIR1/f10` != abcdefghijkl"
 276 }
 277 run_test 10a "write of file with sub-page size on multiple mounts "
 278
 279 test_10b() {
 280         # create a seed file
 281         yes "R" | head -c 4000 >$TMP/f10b-seed
 282         dd if=$TMP/f10b-seed of=$DIR1/f10b bs=3k count=1 || error "dd $DIR1"
 283
 284         $TRUNCATE $DIR1/f10b 4096 || error "truncate 4096"
 285
 286         dd if=$DIR2/f10b of=$TMP/f10b-lustre bs=4k count=1 || error "dd $DIR2"
 287
 288         # create a test file locally to compare
 289         dd if=$TMP/f10b-seed of=$TMP/f10b bs=3k count=1 || error "dd random"
 290         $TRUNCATE $TMP/f10b 4096 || error "truncate 4096"
 291         cmp $TMP/f10b $TMP/f10b-lustre || error "file miscompare"
 292         rm $TMP/f10b $TMP/f10b-lustre $TMP/f10b-seed
 293 }
 294 run_test 10b "write of file with sub-page size on multiple mounts "
 295
 296 test_11() {
 297         test_mkdir $DIR1/d11
 298         multiop_bg_pause $DIR1/d11/f O_c || return 1
 299         MULTIPID=$!
 300         cp -p /bin/ls $DIR1/d11/f
 301         $DIR2/d11/f
 302         RC=$?
 303         kill -USR1 $MULTIPID
 304         wait $MULTIPID || error "wait for PID $MULTIPID failed"
 305         [ $RC -eq 0 ] && error || true
 306 }
 307 run_test 11 "execution of file opened for write should return error ===="
 308
 309 test_12() {
 310         DIR=$DIR DIR2=$DIR2 bash lockorder.sh
 311 }
 312 run_test 12 "test lock ordering (link, stat, unlink)"
 313
 314 test_13() {     # bug 2451 - directory coherency
 315         test_mkdir $DIR1/d13
 316         cd $DIR1/d13 || error "cd to $DIR1/d13 failed"
 317         ls
 318         ( touch $DIR1/d13/f13 ) # needs to be a separate shell
 319         ls
 320         rm -f $DIR2/d13/f13 || error "Cannot remove $DIR2/d13/f13"
 321         ls 2>&1 | grep f13 && error "f13 shouldn't return an error (1)" || true
 322         # need to run it twice
 323         ( touch $DIR1/d13/f13 ) # needs to be a separate shell
 324         ls
 325         rm -f $DIR2/d13/f13 || error "Cannot remove $DIR2/d13/f13"
 326         ls 2>&1 | grep f13 && error "f13 shouldn't return an error (2)" || true
 327 }
 328 run_test 13 "test directory page revocation"
 329
 330 test_14aa() {
 331         test_mkdir $DIR1/$tdir
 332         cp -p /bin/ls $DIR1/$tdir/$tfile
 333         multiop_bg_pause $DIR1/$tdir/$tfile Ow_c || return 1
 334         MULTIPID=$!
 335
 336         $DIR2/$tdir/$tfile && error || true
 337         kill $MULTIPID
 338 }
 339 run_test 14aa "execution of file open for write returns -ETXTBSY"
 340
 341 test_14ab() {
 342         test_mkdir $DIR1/$tdir
 343         cp -p $(which sleep) $DIR1/$tdir/sleep || error "cp failed"
 344         $DIR1/$tdir/sleep 60 &
 345         SLEEP_PID=$!
 346         $MULTIOP $DIR2/$tdir/sleep Oc && error "expected error, got success"
 347         kill $SLEEP_PID
 348 }
 349 run_test 14ab "open(RDWR) of executing file returns -ETXTBSY"
 350
 351 test_14b() { # bug 3192, 7040
 352         test_mkdir $DIR1/$tdir
 353         cp -p $(which sleep) $DIR1/$tdir/sleep || error "cp failed"
 354         $DIR1/$tdir/sleep 60 &
 355         SLEEP_PID=$!
 356         $TRUNCATE $DIR2/$tdir/sleep 60 && kill -9 $SLEEP_PID && \
 357                 error "expected truncate error, got success"
 358         kill $SLEEP_PID
 359         cmp $(which sleep) $DIR1/$tdir/sleep || error "binary changed"
 360 }
 361 run_test 14b "truncate of executing file returns -ETXTBSY ======"
 362
 363 test_14c() { # bug 3430, 7040
 364         test_mkdir $DIR1/$tdir
 365         cp -p $(which sleep) $DIR1/$tdir/sleep || error "cp failed"
 366         $DIR1/$tdir/sleep 60 &
 367         SLEEP_PID=$!
 368         cp /etc/hosts $DIR2/$tdir/sleep && error "expected error, got success"
 369         kill $SLEEP_PID
 370         cmp $(which sleep) $DIR1/$tdir/sleep || error "binary changed"
 371 }
 372 run_test 14c "open(O_TRUNC) of executing file return -ETXTBSY =="
 373
 374 test_14d() { # bug 10921
 375         test_mkdir $DIR1/$tdir
 376         cp -p $(which sleep) $DIR1/$tdir/sleep || error "cp failed"
 377         $DIR1/$tdir/sleep 60 &
 378         SLEEP_PID=$!
 379         log chmod
 380         chmod 600 $DIR1/$tdir/sleep || error "chmod failed"
 381         kill $SLEEP_PID
 382         cmp $(which sleep) $DIR1/$tdir/sleep || error "binary changed"
 383 }
 384 run_test 14d "chmod of executing file is still possible ========"
 385
 386 test_15() {     # bug 974 - ENOSPC
 387         echo "PATH=$PATH"
 388         bash oos2.sh $MOUNT1 $MOUNT2
 389         wait_delete_completed
 390         grant_error=$(dmesg | grep "< tot_grant")
 391         [ -z "$grant_error" ] || error "$grant_error"
 392 }
 393 run_test 15 "test out-of-space with multiple writers ==========="
 394
 395 COUNT=${COUNT:-2500}
 396 # The FSXNUM reduction for ZFS is needed until ORI-487 is fixed.
 397 # We don't want to skip it entirely, but ZFS is VERY slow and cannot
 398 # pass a 2500 operation dual-mount run within the time limit.
 399 if [ "$ost1_FSTYPE" = "zfs" ]; then
 400         FSXNUM=$((COUNT / 5))
 401         FSXP=1
 402 elif [ "$SLOW" = "yes" ]; then
 403         FSXNUM=$((COUNT * 5))
 404         FSXP=500
 405 else
 406         FSXNUM=$COUNT
 407         FSXP=100
 408 fi
 409
 410 test_16a() {
 411         local file1=$DIR1/$tfile
 412         local file2=$DIR2/$tfile
 413         local stripe_size=$(do_facet $SINGLEMDS \
 414                 "$LCTL get_param -n lod.$(facet_svc $SINGLEMDS)*.stripesize")
 415
 416         check_set_fallocate
 417
 418         # to allocate grant because it may run out due to test_15.
 419         $LFS setstripe -c -1 $file1
 420         dd if=/dev/zero of=$file1 bs=$stripe_size count=$OSTCOUNT oflag=sync
 421         dd if=/dev/zero of=$file2 bs=$stripe_size count=$OSTCOUNT oflag=sync
 422         rm -f $file1
 423
 424         $LFS setstripe -c -1 $file1 # b=10919
 425         $FSX -c 50 -p $FSXP -N $FSXNUM -l $((SIZE * 256)) -S 0 $file1 $file2 ||
 426                 error "fsx failed"
 427         rm -f $file1
 428
 429         # O_DIRECT reads and writes must be aligned to the PAGE_SIZE.
 430         $FSX -c 50 -p $FSXP -N $FSXNUM -l $((SIZE * 256)) -S 0 -Z -r $PAGE_SIZE \
 431                 -w $PAGE_SIZE $file1 $file2 || error "fsx with O_DIRECT failed."
 432 }
 433 run_test 16a "$FSXNUM iterations of dual-mount fsx"
 434
 435 # Consistency check for tiny writes, LU-9409
 436 test_16b() {
 437         local file1=$DIR1/$tfile
 438         local file2=$DIR2/$tfile
 439         local stripe_size=($($LFS getstripe -S $DIR))
 440
 441         check_set_fallocate
 442
 443         # to allocate grant because it may run out due to test_15.
 444         lfs setstripe -c -1 $file1
 445         dd if=/dev/zero of=$file1 bs=$stripe_size count=$OSTCOUNT oflag=sync ||
 446                 error "dd failed writing to file=$file1"
 447         dd if=/dev/zero of=$file2 bs=$stripe_size count=$OSTCOUNT oflag=sync ||
 448                 error "dd failed writing to file=$file2"
 449         rm -f $file1
 450
 451         lfs setstripe -c -1 $file1 # b=10919
 452         # -o is set to 8192 because writes < 1 page and between 1 and 2 pages
 453         # create a mix of tiny writes & normal writes
 454         $FSX -c 50 -p $FSXP -N $FSXNUM -l $((SIZE * 256)) -o 8192 -S 0 \
 455                 $file1 $file2 || error "fsx with tiny write failed."
 456 }
 457 run_test 16b "$FSXNUM iterations of dual-mount fsx at small size"
 458
 459 test_16c() {
 460         local file1=$DIR1/$tfile
 461         local file2=$DIR2/$tfile
 462         local stripe_size=$(do_facet $SINGLEMDS \
 463                 "$LCTL get_param -n lod.$(facet_svc $SINGLEMDS)*.stripesize")
 464
 465         [ "$ost1_FSTYPE" != ldiskfs ] && skip "dio on ldiskfs only"
 466
 467         check_set_fallocate
 468
 469         # to allocate grant because it may run out due to test_15.
 470         $LFS setstripe -c -1 $file1
 471         dd if=/dev/zero of=$file1 bs=$stripe_size count=$OSTCOUNT oflag=sync
 472         dd if=/dev/zero of=$file2 bs=$stripe_size count=$OSTCOUNT oflag=sync
 473         rm -f $file1
 474         wait_delete_completed
 475
 476         local list=$(comma_list $(osts_nodes))
 477         if ! get_osd_param $list '' read_cache_enable >/dev/null; then
 478                 skip "not cache-capable obdfilter"
 479         fi
 480
 481         set_osd_param $list '' read_cache_enable 0
 482         set_osd_param $list '' writethrough_cache_enable 0
 483
 484         $LFS setstripe -c -1 $file1 # b=10919
 485         $FSX -c 50 -p $FSXP -N $FSXNUM -l $((SIZE * 256)) -S 0 $file1 $file2 ||
 486                 error "fsx failed"
 487         rm -f $file1
 488
 489         set_osd_param $list '' read_cache_enable 1
 490         set_osd_param $list '' writethrough_cache_enable 1
 491
 492         return 0
 493 }
 494 run_test 16c "verify data consistency on ldiskfs with cache disabled (b=17397)"
 495
 496 test_16d() {
 497         local file1=$DIR1/$tfile
 498         local file2=$DIR2/$tfile
 499         local file3=$DIR1/file
 500         local tmpfile=$(mktemp)
 501         local stripe_size=$(do_facet $SINGLEMDS \
 502                 "$LCTL get_param -n lod.$(facet_svc $SINGLEMDS)*.stripesize")
 503
 504         # to allocate grant because it may run out due to test_15.
 505         $LFS setstripe -c -1 $file1
 506         stack_trap "rm -f $file1 $file2 $file3 $tmpfile"
 507         dd if=/dev/zero of=$file1 bs=$stripe_size count=$OSTCOUNT oflag=sync
 508         dd if=/dev/zero of=$file2 bs=$stripe_size count=$OSTCOUNT oflag=sync
 509         rm -f $file1
 510
 511         $LFS setstripe -c -1 $file1 # b=10919
 512         $LCTL set_param ldlm.namespaces.*.lru_size=clear
 513
 514         # direct write on one client and direct read from another
 515         dd if=/dev/urandom of=$file1 bs=1M count=100 oflag=direct
 516         dd if=$file2 of=$tmpfile iflag=direct bs=1M
 517         diff $file1 $tmpfile || error "file different(1)"
 518         rm -f $file1
 519
 520         # buffer write on one client, but direct read from another
 521         dd if=$tmpfile of=$file1 bs=1M count=100
 522         dd if=$file2 of=$file3 bs=1M iflag=direct count=100
 523         diff $file3 $tmpfile || error "file different(2)"
 524
 525         rm -f $file3 $file2 $file1
 526         # direct write on one client
 527         dd if=$tmpfile of=$file1 bs=1M count=100 oflag=direct
 528         # buffer read from another client
 529         dd if=$file2 of=$file3 bs=1M count=100
 530         diff $file3 $tmpfile || error "file different(3)"
 531 }
 532 run_test 16d "Verify DIO and buffer IO with two clients"
 533
 534 test_16e() { # LU-13227
 535         # issue:        LU-14314
 536
 537         (( "$MDS1_VERSION" >= $(version_code 2.13.53) )) ||
 538                 skip "Need MDS version at least 2.13.53"
 539
 540         local file1=$DIR1/$tfile
 541         local file2=$DIR2/$tfile
 542
 543         # client1 write 10M data
 544         dd if=/dev/zero of=$file1 bs=1M count=10
 545         # drop locks
 546         cancel_lru_locks osc > /dev/null
 547         # use lockahead to generate one PW lock to keep LVB loaded.
 548         $LFS ladvise -a lockahead --start 0 --length 1M \
 549                 --mode WRITE $file1
 550         # direct write to extend file size on client2
 551         dd if=/dev/zero of=$file2 bs=1M seek=20 count=1 \
 552                 oflag=direct conv=notrunc
 553         local filesize=$(stat -c %s $file2)
 554         [ "$filesize" -eq 22020096 ] ||
 555                 error "expected filesize 22020096 got $filesize"
 556         rm -f $file1
 557 }
 558 run_test 16e "Verify size consistency for O_DIRECT write"
 559
 560 test_16f() { # LU-14541
 561         local file1=$DIR1/$tfile
 562         local file2=$DIR2/$tfile
 563         local duration=20
 564         local status
 565
 566         (( $MDS1_VERSION > $(version_code 2.15.51) )) ||
 567                 skip "Need MDS version at least 2.15.51"
 568
 569         timeout --preserve-status --signal=USR1 $duration \
 570                 rw_seq_cst_vs_drop_caches $file1 $file2
 571         status=$?
 572
 573         case $((status & 0x7f)) in
 574                 0)
 575                         echo OK # Computers must be fast now.
 576                         ;;
 577                 6) # SIGABRT
 578                         error "sequential consistency violation detected"
 579                         ;;
 580                 10) # SIGUSR1
 581                         echo TIMEOUT # This is fine.
 582                         ;;
 583                 *)
 584                         error "strange status '$status'"
 585                         ;;
 586         esac
 587
 588         rm -f $file1
 589 }
 590 run_test 16f "rw sequential consistency vs drop_caches"
 591
 592 test_16g() {
 593         local file1=$DIR1/$tfile
 594         local file2=$DIR2/$tfile
 595         local duration=20
 596         local status
 597
 598         timeout --preserve-status --signal=USR1 $duration \
 599                 rw_seq_cst_vs_drop_caches -m $file1 $file2
 600         status=$?
 601
 602         case $((status & 0x7f)) in
 603                 0)
 604                         echo OK # Computers must be fast now.
 605                         ;;
 606                 6) # SIGABRT
 607                         error "sequential consistency violation detected"
 608                         ;;
 609                 10) # SIGUSR1
 610                         echo TIMEOUT # This is fine.
 611                         ;;
 612                 *)
 613                         error "strange status '$status'"
 614                         ;;
 615         esac
 616
 617         rm -f $file1
 618 }
 619 run_test 16g "mmap rw sequential consistency vs drop_caches"
 620
 621 test_16h() {
 622         local tf=$DIR/$tdir/$tfile
 623         local tf2=$DIR2/$tdir/$tfile
 624         local cmd="$MMAP_CAT $tf | od -x | tail -q -n4"
 625         local cmd2="$MMAP_CAT $tf2 | od -x | tail -q -n4"
 626
 627         test_mkdir $DIR/$tdir
 628
 629         # create file and populate data
 630         cp /etc/passwd $tf || error "cp failed"
 631
 632         local size=$(stat -c %s $tf)
 633         c1=$(eval $cmd)
 634         c2=$(eval $cmd2)
 635         if [[ "$c1" != "$c2" ]]; then
 636                 echo "  ------- mount 1 read --------"
 637                 echo $c1
 638                 echo "  ------- mount 2 read --------"
 639                 echo $c2
 640                 error "content mismatch"
 641         fi
 642
 643         echo "  ------- before truncate --------"
 644         echo $c1
 645
 646         # truncate file
 647         $TRUNCATE $tf $((size / 2)) || error "truncate file"
 648
 649         #cancel_lru_locks
 650         echo "  ------- after truncate --------"
 651
 652         # repeat the comparison
 653         c1=$(eval $cmd)
 654         c2=$(eval $cmd2)
 655         if [[ "$c1" != "$c2" ]]; then
 656                 echo "  ------- mount 1 read --------"
 657                 echo $c1
 658                 echo "  ------- mount 2 read --------"
 659                 echo $c2
 660                 error "content mismatch after truncate"
 661         fi
 662         echo $c2
 663 }
 664 run_test 16h "mmap read after truncate file"
 665
 666 test_16i() {
 667         local tf=$DIR/$tdir/$tfile
 668         local tf2=$DIR2/$tdir/$tfile
 669
 670         test_mkdir $DIR/$tdir
 671
 672         # create file and populate data
 673         cp /etc/passwd $tf || error "cp failed"
 674
 675         local size=$(stat -c %s $tf)
 676
 677         c1=$(dd if=$tf bs=1 2>/dev/null | od -x | tail -q -n4)
 678         c2=$(dd if=$tf2 bs=1 2>/dev/null | od -x | tail -q -n4)
 679
 680         if [[ "$c1" != "$c2" ]]; then
 681                 echo "  ------- mount 1 read --------"
 682                 echo $c1
 683                 echo "  ------- mount 2 read --------"
 684                 echo $c2
 685                 error "content mismatch"
 686         fi
 687
 688         echo "  ------- before truncate --------"
 689         echo $c1
 690
 691         # truncate file
 692         $TRUNCATE $tf $((size / 2)) || error "truncate file"
 693
 694         echo "  ------- after truncate --------"
 695
 696         # repeat the comparison
 697         c1=$(dd if=$tf bs=1 2>/dev/null | od -x | tail -q -n4)
 698         c2=$(dd if=$tf2 bs=1 2>/dev/null | od -x | tail -q -n4)
 699
 700         if [[ "$c1" != "$c2" ]]; then
 701                 echo "  ------- mount 1 read --------"
 702                 echo $c1
 703                 echo "  ------- mount 2 read --------"
 704                 echo $c2
 705                 error "content mismatch after truncate"
 706         fi
 707         echo $c2
 708 }
 709 run_test 16i "read after truncate file"
 710
 711 test_16j()
 712 {
 713         (( $OSTCOUNT >= 2 )) || skip "needs >= 2 OSTs"
 714
 715         local stripe_size=$((1024 * 1024)) #1 MiB
 716         # Max i/o below is ~ 4 * stripe_size, so this gives ~5 i/os
 717         local file_size=$((25 * stripe_size))
 718         local bsizes
 719
 720         $LFS setstripe -c 2 -S $stripe_size $DIR/$tfile.1
 721         stack_trap "rm -f $DIR/$tfile.1"
 722
 723         # Just a bit bigger than the largest size in the test set below
 724         dd if=/dev/urandom bs=$file_size count=1 of=$DIR/$tfile.1 ||
 725                 error "buffered i/o to create file failed"
 726
 727         if zfs_or_rotational; then
 728                 # DIO on ZFS can take up to 2 seconds per IO
 729                 # rotational is better, but still slow.
 730                 # Limit testing on those media to larger sizes
 731                 bsizes="$((stripe_size - PAGE_SIZE)) $stripe_size \
 732                         $((stripe_size + 1024))"
 733         else
 734                 bsizes="$((PAGE_SIZE / 4)) $((PAGE_SIZE - 1024)) \
 735                         $((PAGE_SIZE - 1)) $PAGE_SIZE $((PAGE_SIZE + 1024)) \
 736                         $((PAGE_SIZE * 3/2)) $((PAGE_SIZE * 4)) \
 737                         $((stripe_size - 1)) $stripe_size \
 738                         $((stripe_size + 1)) $((stripe_size * 3/2)) \
 739                         $((stripe_size * 4)) $((stripe_size * 4 + 1))"
 740         fi
 741
 742         # 1 process (BIO or DIO) on each client
 743         for bs in $bsizes; do
 744                 $LFS setstripe -c 2 -S $stripe_size $DIR/$tfile.2
 745                 echo "bs: $bs, file_size $file_size"
 746                 dd if=$DIR/$tfile.1 bs=$((bs *2 )) of=$DIR/tfile.2 \
 747                         conv=notrunc oflag=direct iflag=direct &
 748                 pid_dio1=$!
 749                 # Buffered I/O with similar but not the same block size
 750                 dd if=$DIR2/$tfile.1 bs=$((bs * 2)) of=$DIR2/$tfile.2 \
 751                         conv=notrunc &
 752                 pid_bio2=$!
 753                 wait $pid_dio1
 754                 rc1=$?
 755                 wait $pid_bio2
 756                 rc2=$?
 757                 if (( rc1 != 0 )); then
 758                         error "dio copy 1 w/bsize $bs failed: $rc1"
 759                 fi
 760                 if (( rc2 != 0 )); then
 761                         error "buffered copy 2 w/bsize $bs failed: $rc2"
 762                 fi
 763
 764                 $CHECKSTAT -t file -s $file_size $DIR/$tfile.2 ||
 765                         error "size incorrect"
 766                 $CHECKSTAT -t file -s $file_size $DIR2/$tfile.2 ||
 767                         error "size incorrect - mount 2"
 768                 cmp --verbose $DIR/$tfile.1 $DIR/$tfile.2 ||
 769                         error "files differ, bsize $bs"
 770                 cmp --verbose $DIR2/$tfile.1 $DIR2/$tfile.2 ||
 771                         error "files differ, bsize $bs - mount 2"
 772                 rm -f $DIR/$tfile.2
 773         done
 774
 775         # 2 processes - both DIO and BIO - on each client
 776         for bs in $bsizes; do
 777                 $LFS setstripe -c 2 -S $stripe_size $DIR/$tfile.2
 778                 echo "bs: $bs, file_size $file_size"
 779                 # Client 1
 780                 dd if=$DIR/$tfile.1 bs=$((bs *2 )) of=$DIR/tfile.2 \
 781                         conv=notrunc oflag=direct iflag=direct &
 782                 pid_dio1=$!
 783                 # Buffered I/O with similar but not the same block size
 784                 dd if=$DIR/$tfile.1 bs=$((bs * 2)) of=$DIR/$tfile.2 \
 785                         conv=notrunc &
 786                 pid_bio2=$!
 787                 # Client 2
 788                 dd if=$DIR2/$tfile.1 bs=$((bs *2 )) of=$DIR2/tfile.2 \
 789                         conv=notrunc oflag=direct iflag=direct &
 790                 pid_dio3=$!
 791                 # Buffered I/O with similar but not the same block size
 792                 dd if=$DIR2/$tfile.1 bs=$((bs * 2)) of=$DIR2/$tfile.2 \
 793                         conv=notrunc &
 794                 pid_bio4=$!
 795                 wait $pid_dio1
 796                 rc1=$?
 797                 wait $pid_bio2
 798                 rc2=$?
 799                 wait $pid_dio3
 800                 rc3=$?
 801                 wait $pid_bio4
 802                 rc4=$?
 803
 804                 if (( rc1 != 0 )); then
 805                         error "dio copy 1 w/bsize $bs failed: $rc1"
 806                 fi
 807                 if (( rc2 != 0 )); then
 808                         error "buffered copy 2 w/bsize $bs failed: $rc2"
 809                 fi
 810                 if (( rc3 != 0 )); then
 811                         error "dio copy 3 w/bsize $bs failed: $rc1"
 812                 fi
 813                 if (( rc4 != 0 )); then
 814                         error "buffered copy 4 w/bsize $bs failed: $rc2"
 815                 fi
 816
 817                 $CHECKSTAT -t file -s $file_size $DIR/$tfile.2 ||
 818                         error "size incorrect"
 819                 $CHECKSTAT -t file -s $file_size $DIR2/$tfile.2 ||
 820                         error "size incorrect - mount 2"
 821                 cmp --verbose $DIR/$tfile.1 $DIR/$tfile.2 ||
 822                         error "files differ, bsize $bs"
 823                 cmp --verbose $DIR2/$tfile.1 $DIR2/$tfile.2 ||
 824                         error "files differ, bsize $bs - mount 2"
 825                 rm -f $DIR/$tfile.2
 826         done
 827 }
 828 run_test 16j "race dio with buffered i/o"
 829
 830 test_16k() {
 831         local fsxN=${FSX_NP:-5}
 832         local fsxNops=${FSX_NOPS:-10000}
 833         local fsxNparams=${FSXPARAMS_16k:-""}
 834         local dropsleep=${DROP_SLEEP:-3}
 835         local dpipd
 836         local -a fsxpids
 837         local cmd
 838
 839         [ "$SLOW" = "no" ] && fsxNops=1000
 840
 841         while true; do
 842                 echo 3 > /proc/sys/vm/drop_caches
 843                 sleep $dropsleep
 844         done &
 845         dpipd=$!
 846         stack_trap "kill -9 $dpipd"
 847
 848         for ((i = 1; i <= fsxN; i++)); do
 849                 cmd="$FSX $fsxNparams -N $fsxNops $DIR/fsxfile.${i} -l $((64 * 1024 * 1024))"
 850                 echo "+ $cmd"
 851                 eval $cmd &
 852                 fsxpids[$i]=$!
 853         done
 854         for ((i = 1; i <= fsxN; i++)); do
 855                 wait ${fsxpids[$i]} && echo "+ fsx $i done: rc=$?" ||
 856                         error "- fsx $i FAILURE! rc=$?"
 857                 date
 858         done
 859 }
 860 run_test 16k "Parallel FSX and drop caches should not panic"
 861
 862 test_17() { # bug 3513, 3667
 863         remote_ost_nodsh && skip "remote OST with nodsh" && return
 864
 865         lfs setstripe $DIR1/$tfile -i 0 -c 1
 866         cp $SAMPLE_FILE $DIR1/$tfile
 867         cancel_lru_locks osc > /dev/null
 868         #define CFS_FAIL_ONCE|OBD_FAIL_LDLM_CREATE_RESOURCE    0x30a
 869         do_facet ost1 lctl set_param fail_loc=0x8000030a
 870         ls -ls $DIR1/$tfile | awk '{ print $1,$6 }' > $DIR1/$tfile-1 & \
 871         ls -ls $DIR2/$tfile | awk '{ print $1,$6 }' > $DIR2/$tfile-2
 872         wait
 873         diff -u $DIR1/$tfile-1 $DIR2/$tfile-2 || error "files are different"
 874 }
 875 run_test 17 "resource creation/LVB creation race ==============="
 876
 877 test_18() {
 878         # turn e.g. ALWAYS_EXCEPT="18c" into "-e 3"
 879         local idx
 880         local excepts=
 881         for idx in {a..z}; do
 882                 local ptr=EXCEPT_ALWAYS_18$idx
 883                 [ x${!ptr} = xtrue ] || continue
 884
 885                 excepts="$excepts -e $(($(printf %d \'$idx)-96))"
 886         done
 887
 888         excepts="$excepts -e 7 -e 8 -e 9"
 889         $LUSTRE/tests/mmap_sanity -d $MOUNT1 -m $MOUNT2 $excepts ||
 890                 error "mmap_sanity test failed"
 891         sync; sleep 1; sync
 892 }
 893 run_test 18 "mmap sanity check ================================="
 894
 895 test_19() { # bug3811
 896         local node=$(facet_active_host ost1)
 897         local device="$FSNAME-OST*"
 898
 899         [ "x$DOM" = "xyes" ] && node=$(facet_active_host $SINGLEMDS) &&
 900                 device="$FSNAME-MDT*"
 901
 902         # check whether obdfilter is cache capable at all
 903         get_osd_param $node $device read_cache_enable >/dev/null ||
 904                 skip "not cache-capable obdfilter"
 905
 906         local max=$(get_osd_param $node $device readcache_max_filesize |\
 907                 head -n 1)
 908         set_osd_param $node $device readcache_max_filesize 4096
 909         dd if=/dev/urandom of=$TMP/$tfile bs=512k count=32
 910         local SUM=$(cksum $TMP/$tfile | cut -d" " -f 1,2)
 911         cp $TMP/$tfile $DIR1/$tfile
 912         for i in `seq 1 20`; do
 913                 [ $((i % 5)) -eq 0 ] && log "$testname loop $i"
 914                 cancel_lru_locks $OSC > /dev/null
 915                 cksum $DIR1/$tfile | cut -d" " -f 1,2 > $TMP/sum1 & \
 916                 cksum $DIR2/$tfile | cut -d" " -f 1,2 > $TMP/sum2
 917                 wait
 918                 [ "$(cat $TMP/sum1)" = "$SUM" ] || \
 919                         error "$DIR1/$tfile $(cat $TMP/sum1) != $SUM"
 920                 [ "$(cat $TMP/sum2)" = "$SUM" ] || \
 921                         error "$DIR2/$tfile $(cat $TMP/sum2) != $SUM"
 922         done
 923         set_osd_param $node $device readcache_max_filesize $max
 924         rm $DIR1/$tfile
 925 }
 926 run_test 19 "test concurrent uncached read races ==============="
 927
 928 test_20() {
 929         test_mkdir $DIR1/$tdir
 930         cancel_lru_locks
 931         CNT=$($LCTL get_param -n llite.*.dump_page_cache | wc -l)
 932         $MULTIOP $DIR1/$tdir/$tfile Ow8190c
 933         $MULTIOP $DIR2/$tdir/$tfile Oz8194w8190c
 934         $MULTIOP $DIR1/$tdir/$tfile Oz0r8190c
 935         cancel_lru_locks
 936         CNT2=$($LCTL get_param -n llite.*.dump_page_cache | wc -l)
 937         [[ $CNT2 == $CNT ]] ||
 938                 error $((CNT2 - CNT))" page left in cache after lock cancel"
 939 }
 940 run_test 20 "test extra readahead page left in cache ===="
 941
 942 cleanup_21() {
 943         trap 0
 944         umount $DIR1/$tdir
 945 }
 946
 947 test_21() { # Bug 5907
 948         test_mkdir $DIR1/$tdir
 949         mount /etc $DIR1/$tdir --bind || error "mount failed" # Poor man's mount.
 950         trap cleanup_21 EXIT
 951         rmdir -v $DIR1/$tdir && error "Removed mounted directory"
 952         rmdir -v $DIR2/$tdir && echo "Removed mounted directory from another mountpoint, needs to be fixed"
 953         test -d $DIR1/$tdir || error "Mounted directory disappeared"
 954         cleanup_21
 955         test -d $DIR2/$tdir || test -d $DIR1/$tdir && error "Removed dir still visible after umount"
 956         true
 957 }
 958 run_test 21 " Try to remove mountpoint on another dir ===="
 959
 960 test_23() { # Bug 5972
 961         local at_diff=$(do_facet $SINGLEMDS \
 962                 $LCTL get_param -n mdd.*MDT0000*.atime_diff | head -n1)
 963         echo "atime should be updated while another read" > $DIR1/$tfile
 964
 965         # clear the lock(mode: LCK_PW) gotten from creating operation
 966         cancel_lru_locks $OSC
 967         time1=$(date +%s)
 968         echo "now is $time1"
 969         sleep $((at_diff + 1))
 970
 971         echo "starting reads"
 972         multiop_bg_pause $DIR1/$tfile or20_c || return 1
 973         # with SOM and opencache enabled, we need to close a file and cancel
 974         # open lock to get atime propogated to MDS
 975         kill -USR1 $! || return 2
 976         cancel_lru_locks mdc
 977
 978         time2=$(stat -c "%X" $DIR/$tfile)
 979         echo "new atime is $time2"
 980
 981         [ $time2 -gt $time1 ] || error "atime was not updated"
 982         rm -f $DIR1/$tfile || error "rm -f $DIR1/$tfile failed"
 983         true
 984 }
 985 run_test 23 " others should see updated atime while another read===="
 986
 987 test_24a() {
 988         touch $DIR1/$tfile
 989         lfs df || error "lfs df failed"
 990         lfs df -ih || error "lfs df -ih failed"
 991         lfs df -h $DIR1 || error "lfs df -h $DIR1 failed"
 992         lfs df -i $DIR2 || error "lfs df -i $DIR2 failed"
 993         lfs df $DIR1/$tfile || error "lfs df $DIR1/$tfile failed"
 994         lfs df -ih $DIR2/$tfile || error "lfs df -ih $DIR2/$tfile failed"
 995
 996         OSC=`lctl dl | awk '/-osc-|OSC.*MNT/ {print $4}' | head -n 1`
 997 #       OSC=`lctl dl | awk '/-osc-/ {print $4}' | head -n 1`
 998         lctl --device %osc deactivate
 999         lfs df -i || error "lfs df -i with deactivated OSC failed"
1000         lctl --device %osc activate
1001         lfs df || error "lfs df with reactivated OSC failed"
1002 }
1003 run_test 24a "lfs df [-ih] [path] test ========================="
1004
1005 test_24b() {
1006         touch $DIR1/$tfile
1007         fsnum=$(lfs_df | grep -c "summary")
1008         [ $fsnum -eq 2 ] || error "lfs df shows $fsnum != 2 filesystems."
1009 }
1010 run_test 24b "lfs df should show both filesystems ==============="
1011
1012 test_25a() {
1013         local acl=$(lctl get_param -n mdc.*MDT0000-mdc-*.connect_flags |
1014                                                                 grep -c acl)
1015         [ "$acl" -lt 1 ] && skip "must have acl, skipping" && return
1016
1017         mkdir -p $DIR1/$tdir
1018         touch $DIR1/$tdir/f1 || error "touch $DIR1/$tdir/f1"
1019         chmod 0755 $DIR1/$tdir/f1 || error "chmod 0755 $DIR1/$tdir/f1"
1020
1021         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 || error "checkstat $DIR2/$tdir/f1 #1"
1022         setfacl -m u:$RUNAS_ID:--- -m g:$RUNAS_GID:--- $DIR1/$tdir ||
1023                 error "setfacl $DIR2/$tdir #1"
1024         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 && error "checkstat $DIR2/$tdir/f1 #2"
1025         setfacl -m u:$RUNAS_ID:r-x -m g:$RUNAS_GID:r-x $DIR1/$tdir ||
1026                 error "setfacl $DIR2/$tdir #2"
1027         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 || error "checkstat $DIR2/$tdir/f1 #3"
1028         setfacl -m u:$RUNAS_ID:--- -m g:$RUNAS_GID:--- $DIR1/$tdir ||
1029                 error "setfacl $DIR2/$tdir #3"
1030         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 && error "checkstat $DIR2/$tdir/f1 #4"
1031         setfacl -x u:$RUNAS_ID: -x g:$RUNAS_GID: $DIR1/$tdir ||
1032                 error "setfacl $DIR2/$tdir #4"
1033         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 || error "checkstat $DIR2/$tdir/f1 #5"
1034
1035         rm -rf $DIR1/$tdir
1036 }
1037 run_test 25a "change ACL on one mountpoint be seen on another ==="
1038
1039 test_25b() {
1040         local acl=$(lctl get_param -n mdc.*MDT0000-mdc-*.connect_flags |
1041                                                         grep -c acl)
1042         [ "$acl" -lt 1 ] && skip "must have acl, skipping" && return
1043
1044         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
1045
1046         rm -rf $DIR1/$tdir
1047         $LFS mkdir -i 1 $DIR1/$tdir
1048         touch $DIR1/$tdir/f1 || error "touch $DIR1/$tdir/f1"
1049         chmod 0755 $DIR1/$tdir/f1 || error "chmod 0755 $DIR1/$tdir/f1"
1050
1051         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 || error "checkstat $DIR2/$tdir/f1 #1"
1052         setfacl -m u:$RUNAS_ID:--- -m g:$RUNAS_GID:--- $DIR1/$tdir ||
1053                 error "setfacl $DIR2/$tdir #1"
1054         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 && error "checkstat $DIR2/$tdir/f1 #2"
1055         setfacl -m u:$RUNAS_ID:r-x -m g:$RUNAS_GID:r-x $DIR1/$tdir ||
1056                 error "setfacl $DIR2/$tdir #2"
1057         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 || error "checkstat $DIR2/$tdir/f1 #3"
1058         setfacl -m u:$RUNAS_ID:--- -m g:$RUNAS_GID:--- $DIR1/$tdir ||
1059                 error "setfacl $DIR2/$tdir #3"
1060         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 && error "checkstat $DIR2/$tdir/f1 #4"
1061         setfacl -x u:$RUNAS_ID: -x g:$RUNAS_GID: $DIR1/$tdir ||
1062                 error "setfacl $DIR2/$tdir #4"
1063         $RUNAS $CHECKSTAT $DIR2/$tdir/f1 || error "checkstat $DIR2/$tdir/f1 #5"
1064
1065         rm -rf $DIR1/$tdir
1066 }
1067 run_test 25b "change ACL under remote dir on one mountpoint be seen on another"
1068
1069 test_26a() {
1070         utime $DIR1/f26a -s $DIR2/f26a || error "utime failed for $DIR1/f26a"
1071 }
1072 run_test 26a "allow mtime to get older"
1073
1074 test_26b() {
1075         touch $DIR1/$tfile
1076         sleep 1
1077         echo "aaa" >> $DIR1/$tfile
1078         sleep 1
1079         chmod a+x $DIR2/$tfile
1080         mt1=`stat -c %Y $DIR1/$tfile`
1081         mt2=`stat -c %Y $DIR2/$tfile`
1082
1083         if [ x"$mt1" != x"$mt2" ]; then
1084                 error "not equal mtime, client1: "$mt1", client2: "$mt2"."
1085         fi
1086 }
1087 run_test 26b "sync mtime between ost and mds"
1088
1089 test_26c() {
1090         (( $MDS1_VERSION >= $(version_code 2.15.61) )) ||
1091                 skip "Need MDS version at least 2.15.61"
1092
1093         multiop_bg_pause $DIR1/$tfile O_c || error "multiop failed"
1094         MULTIPID=$!
1095         touch -am -d @978261179 $DIR2/$tfile
1096         kill -USR1 $MULTIPID
1097         wait $MULTIPID || error "wait for PID $MULTIPID failed"
1098         sleep 1
1099
1100         echo
1101         stat $DIR/$tfile
1102         local times="$(stat -c"%X %Y" $DIR/$tfile)"
1103         [[ "$times" == "978261179 978261179" ]] ||
1104                 error "[am]times are not set in past on $DIR: $times"
1105         echo
1106         stat $DIR2/$tfile
1107         local times="$(stat -c"%X %Y" $DIR2/$tfile)"
1108         [[ "$times" == "978261179 978261179" ]] ||
1109                 error "[am]times are not set in past on $DIR2: $times"
1110         echo
1111 }
1112 run_test 26c "set-in-past on open file is not lost on close"
1113
1114 test_27() {
1115         cancel_lru_locks $OSC
1116         lctl clear
1117         dd if=/dev/zero of=$DIR2/$tfile bs=$((4096+4))k conv=notrunc count=4 seek=3 &
1118         DD2_PID=$!
1119         sleep 0.5
1120         log "dd 1 started"
1121
1122         dd if=/dev/zero of=$DIR1/$tfile bs=$((16384-1024))k conv=notrunc count=1 seek=4 &
1123         DD1_PID=$!
1124         log "dd 2 started"
1125
1126         sleep 1
1127         dd if=/dev/zero of=$DIR1/$tfile bs=8k conv=notrunc count=1 seek=0
1128         log "dd 3 finished"
1129         lctl set_param -n ldlm.dump_namespaces ""
1130         wait $DD1_PID $DD2_PID
1131         [ $? -ne 0 ] && lctl dk $TMP/debug || true
1132 }
1133 run_test 27 "align non-overlapping extent locks from request ==="
1134
1135 test_28() { # bug 9977
1136         skip "echo_client on osc is no longer supported"
1137 }
1138 run_test 28 "read/write/truncate file with lost stripes"
1139
1140 test_30() { #b=11110, LU-2523
1141         test_mkdir $DIR1/$tdir
1142         cp -f /bin/bash $DIR1/$tdir/bash
1143         bash -c 'sleep 1; rm -f $DIR2/$tdir/bash; cp /bin/bash $DIR2/$tdir' &
1144         $DIR1/$tdir/bash -c 'sleep 2;
1145                 openfile -f O_RDONLY /proc/$$/exe >& /dev/null; echo $?'
1146         wait
1147         true
1148 }
1149 run_test 30 "recreate file race"
1150
1151 test_31a() {
1152         test_mkdir $DIR1/$tdir
1153         local writes=$(LANG=C dd if=/dev/zero of=$DIR/$tdir/$tfile \
1154                        count=1 2>&1 | awk 'BEGIN { FS="+" } /out/ {print $1}')
1155         #define OBD_FAIL_LDLM_CANCEL_BL_CB_RACE   0x314
1156         lctl set_param fail_loc=0x314
1157         local reads=$(LANG=C dd if=$DIR2/$tdir/$tfile of=/dev/null 2>&1 |
1158                       awk 'BEGIN { FS="+" } /in/ {print $1}')
1159         [ $reads -eq $writes ] || error "read" $reads "blocks, must be" $writes
1160 }
1161 run_test 31a "voluntary cancel / blocking ast race=============="
1162
1163 test_31b() {
1164         remote_ost || { skip "local OST" && return 0; }
1165         remote_ost_nodsh && skip "remote OST w/o dsh" && return 0
1166
1167         # make sure there is no local locks due to destroy
1168         wait_mds_ost_sync || error "wait_mds_ost_sync()"
1169         wait_delete_completed || error "wait_delete_completed()"
1170
1171         test_mkdir $DIR1/$tdir
1172         lfs setstripe $DIR/$tdir/$tfile -i 0 -c 1
1173         cp /etc/hosts $DIR/$tdir/$tfile
1174         #define OBD_FAIL_LDLM_CANCEL_BL_CB_RACE   0x314
1175         lctl set_param fail_loc=0x314
1176         #define OBD_FAIL_LDLM_OST_FAIL_RACE      0x316
1177         do_facet ost1 lctl set_param fail_loc=0x316
1178         # Don't crash kernel
1179         cat $DIR2/$tdir/$tfile > /dev/null 2>&1
1180         lctl set_param fail_loc=0
1181         do_facet ost1 lctl set_param fail_loc=0
1182         # cleanup: reconnect the client back
1183         df $DIR2
1184 }
1185 run_test 31b "voluntary OST cancel / blocking ast race=============="
1186
1187 #LU-14949 - multi-client version of the test 31r in sanity.
1188 test_31r() {
1189         touch $DIR/$tfile.target
1190         touch $DIR/$tfile.source
1191
1192         ls -l $DIR/$tfile.target # cache it for sure
1193
1194         #OBD_FAIL_LLITE_OPEN_DELAY 0x1419
1195         $LCTL set_param fail_loc=0x1419 fail_val=3
1196         cat $DIR/$tfile.target &
1197         CATPID=$!
1198
1199         # Guarantee open is waiting before we get here
1200         sleep 1
1201         mv $DIR2/$tfile.source $DIR2/$tfile.target
1202
1203         wait $CATPID
1204         RC=$?
1205         if [[ $RC -ne 0 ]]; then
1206                 error "open with cat failed, rc=$RC"
1207         fi
1208 }
1209 run_test 31r "open-rename(replace) race"
1210
1211 test_32b() { # bug 11270
1212         remote_ost_nodsh && skip "remote OST with nodsh" && return
1213
1214         local node
1215         local facets=$(get_facets OST)
1216         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
1217
1218         save_lustre_params client "osc.*.contention_seconds" > $p
1219         save_lustre_params $facets \
1220                 "ldlm.namespaces.filter-*.max_nolock_bytes" >> $p
1221         save_lustre_params $facets \
1222                 "ldlm.namespaces.filter-*.contended_locks" >> $p
1223         save_lustre_params $facets \
1224                 "ldlm.namespaces.filter-*.contention_seconds" >> $p
1225         clear_stats $OSC.*.${OSC}_stats
1226
1227         # agressive lockless i/o settings
1228         do_nodes $(comma_list $(osts_nodes)) \
1229                 "lctl set_param -n ldlm.namespaces.*.max_nolock_bytes=2000000 \
1230                         ldlm.namespaces.filter-*.contended_locks=0 \
1231                         ldlm.namespaces.filter-*.contention_seconds=60"
1232         lctl set_param -n $OSC.*.contention_seconds=60
1233         for i in {1..5}; do
1234                 dd if=/dev/zero of=$DIR1/$tfile bs=4k count=1 conv=notrunc > \
1235                         /dev/null 2>&1
1236                 dd if=/dev/zero of=$DIR2/$tfile bs=4k count=1 conv=notrunc > \
1237                         /dev/null 2>&1
1238         done
1239         [ $(calc_stats $OSC.*.${OSC}_stats lockless_write_bytes) -ne 0 ] ||
1240                 error "lockless i/o was not triggered"
1241         # disable lockless i/o (it is disabled by default)
1242         do_nodes $(comma_list $(osts_nodes)) \
1243                 "lctl set_param -n ldlm.namespaces.filter-*.max_nolock_bytes=0 \
1244                         ldlm.namespaces.filter-*.contended_locks=32 \
1245                         ldlm.namespaces.filter-*.contention_seconds=0"
1246         # set contention_seconds to 0 at client too, otherwise Lustre still
1247         # remembers lock contention
1248         lctl set_param -n $OSC.*.contention_seconds=0
1249         clear_stats $OSC.*.${OSC}_stats
1250         for i in {1..1}; do
1251                 dd if=/dev/zero of=$DIR1/$tfile bs=4k count=1 conv=notrunc > \
1252                         /dev/null 2>&1
1253                 dd if=/dev/zero of=$DIR2/$tfile bs=4k count=1 conv=notrunc > \
1254                         /dev/null 2>&1
1255         done
1256         [ $(calc_stats $OSC.*.${OSC}_stats lockless_write_bytes) -eq 0 ] ||
1257                 error "lockless i/o works when disabled"
1258         rm -f $DIR1/$tfile
1259         restore_lustre_params <$p
1260         rm -f $p
1261 }
1262 # Disable test 32b prior to full removal
1263 #run_test 32b "lockless i/o"
1264
1265 print_jbd_stat () {
1266         local mdts=$(get_facets MDS)
1267         local stat=0
1268         local varsvc
1269         local dev
1270         local mds
1271
1272         for mds in ${mdts//,/ }; do
1273                 varsvc=${mds}_svc
1274
1275                 dev=$(basename $(do_facet $mds "lctl get_param -n \
1276                         osd*.${!varsvc}.mntdev | xargs readlink -f"))
1277                 val=$(do_facet $mds "cat /proc/fs/jbd*/${dev}{,:*,-*}/info \
1278                         2>/dev/null | head -n1")
1279                 val=${val%% *};
1280                 stat=$((stat + val))
1281         done
1282         echo $stat
1283 }
1284
1285 # commit on sharing tests
1286 test_33a() {
1287         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1288
1289         [ $CLIENTCOUNT -lt 2 ] &&
1290                 skip "Need two or more clients, have $CLIENTCOUNT"
1291
1292         local nfiles=${TEST33_NFILES:-10000}
1293         local param_file=$TMP/$tfile-params
1294         local COS
1295         local jbdold="N/A"
1296         local jbdnew="N/A"
1297         local jbd
1298
1299         save_lustre_params $(get_facets MDS) \
1300                 "mdt.*.commit_on_sharing" > $param_file
1301
1302         for COS in 0 1; do
1303                 do_facet $SINGLEMDS lctl set_param mdt.*.commit_on_sharing=$COS
1304                 avgjbd=0
1305                 avgtime=0
1306                 for i in 1 2 3; do
1307                         do_nodes $CLIENT1,$CLIENT2 "mkdir -p $DIR1/$tdir-\\\$(hostname)-$i"
1308
1309                 [ "$mds1_FSTYPE" = ldiskfs ] && jbdold=$(print_jbd_stat)
1310                 echo "=== START createmany old: $jbdold transaction"
1311                 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")
1312                 [ "$mds1_FSTYPE" = ldiskfs ] && jbdnew=$(print_jbd_stat)
1313                 [ "$mds1_FSTYPE" = ldiskfs ] && jbd=$(( jbdnew - jbdold ))
1314                 echo "=== END   createmany new: $jbdnew transaction :  $jbd transactions  nfiles $nfiles time $elapsed COS=$COS"
1315                 [ "$mds1_FSTYPE" = ldiskfs ] && avgjbd=$(( avgjbd + jbd ))
1316                 avgtime=$(( avgtime + elapsed ))
1317                 done
1318         eval cos${COS}_jbd=$((avgjbd / 3))
1319         eval cos${COS}_time=$((avgtime / 3))
1320         done
1321
1322         echo "COS=0 transactions (avg): $cos0_jbd  time (avg): $cos0_time"
1323         echo "COS=1 transactions (avg): $cos1_jbd  time (avg): $cos1_time"
1324         [ "$cos0_jbd" != 0 ] &&
1325                 echo "COS=1 vs COS=0 jbd:  $((((cos1_jbd/cos0_jbd - 1)) * 100 )) %"
1326         [ "$cos0_time" != 0 ] &&
1327                 echo "COS=1 vs COS=0 time: $((((cos1_time/cos0_time - 1)) * 100 )) %"
1328
1329         restore_lustre_params < $param_file
1330         rm -f $param_file
1331         return 0
1332 }
1333 run_test 33a "commit on sharing, cross crete/delete, 2 clients, benchmark"
1334
1335 # commit on sharing tests
1336 test_33b() {
1337         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1338
1339         [ $CLIENTCOUNT -ge 2 ] ||
1340                 { skip "Need two or more clients, have $CLIENTCOUNT" &&
1341                                                                 return 0; }
1342         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
1343
1344         local nfiles=${TEST33_NFILES:-10000}
1345         local param_file=$TMP/$tfile-params
1346
1347         save_lustre_params $(get_facets MDS) \
1348                 "mdt.*.commit_on_sharing" > $param_file
1349
1350         local COS
1351         local jbdold
1352         local jbdnew
1353         local jbd
1354         local MDTIDX=1
1355
1356         for COS in 0 1; do
1357                 do_facet $SINGLEMDS lctl set_param mdt.*.commit_on_sharing=$COS
1358                 avgjbd=0
1359                 avgtime=0
1360                 for i in 1 2 3; do
1361                         do_node $CLIENT1 "$LFS mkdir -i $MDTIDX \
1362                                           $DIR1/$tdir-\\\$(hostname)-$i"
1363
1364                         jbdold=$(print_jbd_stat)
1365                         echo "=== START createmany old: $jbdold transaction"
1366                         local elapsed=$(do_and_time "do_nodes $CLIENT1,$CLIENT2\
1367                                 createmany -o $DIR1/$tdir-\\\$(hostname)-$i/f- \
1368                                 -r$DIR2/$tdir-\\\$(hostname)-$i/f- $nfiles > \
1369                                                                 /dev/null 2>&1")
1370                         jbdnew=$(print_jbd_stat)
1371                         jbd=$(( jbdnew - jbdold ))
1372                         echo "=== END   createmany new: $jbdnew transaction : \
1373                         $jbd transactions nfiles $nfiles time $elapsed COS=$COS"
1374                         avgjbd=$(( avgjbd + jbd ))
1375                         avgtime=$(( avgtime + elapsed ))
1376                 done
1377                 eval cos${COS}_jbd=$((avgjbd / 3))
1378                 eval cos${COS}_time=$((avgtime / 3))
1379         done
1380
1381         echo "COS=0 transactions (avg): $cos0_jbd  time (avg): $cos0_time"
1382         echo "COS=1 transactions (avg): $cos1_jbd  time (avg): $cos1_time"
1383         [ "$cos0_jbd" != 0 ] &&
1384             echo "COS=1 vs COS=0 jbd: $(((cos1_jbd/cos0_jbd - 1) * 100)) %"
1385         [ "$cos0_time" != 0 ] &&
1386             echo "COS=1 vs COS=0 time: $(((cos1_time/cos0_time - 1) * 100)) %"
1387
1388         restore_lustre_params < $param_file
1389         rm -f $param_file
1390         return 0
1391 }
1392 run_test 33b "COS: cross create/delete, 2 clients, benchmark under remote dir"
1393
1394 # arg1 is description, arg2 is operations before Sync-on-Lock-Cancel, arg3 is
1395 # the operation that triggers SoLC
1396 op_trigger_solc() {
1397         local sync_count
1398         local total=0
1399         local nodes=$(comma_list $(mdts_nodes))
1400
1401         sync_all_data
1402
1403         # trigger CoS twice in case transaction commit before unlock
1404         for i in 1 2; do
1405                 bash -c "$2"
1406                 do_nodes $nodes "$LCTL set_param -n mdt.*.sync_count=0"
1407                 bash -c "$3"
1408                 sync_count=$(do_nodes $nodes \
1409                         "lctl get_param -n mdt.*MDT*.sync_count" | calc_sum)
1410                 total=$((total + sync_count));
1411                 rm -rf $DIR/$tdir/*
1412                 sync_all_data
1413         done
1414
1415         echo $1
1416         echo "  $2"
1417         echo "  $3"
1418         echo "  SoLC count $total"
1419         (( total > 0 )) || error "$3 didn't trigger SoLC"
1420 }
1421
1422 test_33_run() {
1423         echo $1
1424         echo "  $2"
1425         eval $2
1426 }
1427
1428 test_33c() {
1429         (( MDSCOUNT >= 2 )) || skip "needs >= 2 MDTs"
1430         (( MDS1_VERSION >= $(version_code 2.7.63) )) ||
1431                 skip "DNE CoS not supported"
1432
1433         # LU-13522
1434         stop mds1
1435         start mds1 $(mdsdevname 1) $MDS_MOUNT_OPTS || error "start mds1 failed"
1436
1437         mkdir_on_mdt0 $DIR/$tdir
1438         sync_all_data
1439
1440         if (( MDS1_VERSION < $(version_code 2.15.55.204) )); then
1441                 op_trigger_solc "create remote dir and local dir" \
1442                         "$LFS mkdir -i 1 $DIR/$tdir/remote" \
1443                         "$LFS mkdir -i 0 $DIR/$tdir/local"
1444                 (( MDSCOUNT > 2 )) &&
1445                 op_trigger_solc "create remote dirs on different MDTs" \
1446                         "$LFS mkdir -i 1 $DIR/$tdir/remote.1" \
1447                         "$LFS mkdir -i 2 $DIR/$tdir/remote.2"
1448         fi
1449         op_trigger_solc "create file on 2nd stripe under striped directory" \
1450                 "$LFS mkdir -i 0 -c 2 $DIR/$tdir/striped" \
1451                 "touch $DIR2/$tdir/striped/subfile"
1452
1453         echo
1454         echo "Below operations shouldn't trigger Solc:"
1455         $LFS mkdir -i 0 -c 2 $DIR/$tdir/striped
1456         sync_all_data
1457         do_facet mds1 "lctl set_param -n mdt.*.sync_count=0"
1458         if (( MDS1_VERSION >= $(version_code 2.15.55.204) )); then
1459                 test_33_run "create file on 2nd stripe after setattr" \
1460                         "chmod 777 $DIR/$tdir/striped; \
1461                          touch $DIR2/$tdir/striped/subfile"
1462                 test_33_run "create remote dir and local dir" \
1463                         "$LFS mkdir -i 1 $DIR/$tdir/remote" \
1464                         "$LFS mkdir -i 0 $DIR/$tdir/local"
1465                 (( MDSCOUNT > 2 )) &&
1466                 test_33_run "create remote dirs on different MDTs" \
1467                         "$LFS mkdir -i 1 $DIR/$tdir/remote.1" \
1468                         "$LFS mkdir -i 2 $DIR/$tdir/remote.2"
1469         fi
1470         test_33_run "create local dir after remote dir creation transaction commit" \
1471                 "$LFS mkdir -i 1 $DIR/$tdir/remote.3; \
1472                  do_facet mds2 $LCTL set_param -n osd*.*MDT0001.force_sync 1;
1473                  mkdir $DIR/$tdir/local.3"
1474         sync_count=$(do_facet mds1 "lctl get_param -n mdt.*MDT0000.sync_count")
1475         echo "Solc count $sync_count"
1476         [ $sync_count -eq 0 ] || error "Sync-Lock-Cancel triggered"
1477 }
1478 run_test 33c "Cancel cross-MDT lock should trigger Sync-on-Lock-Cancel"
1479
1480 # arg1 is description, arg2 is operations done before CoS, arg3 is the operation
1481 # that triggers CoS
1482 op_trigger_cos() {
1483         local commit_nr
1484         local total=0
1485         local nodes=$(comma_list $(mdts_nodes))
1486
1487         sync_all_data
1488
1489         # trigger CoS twice in case transaction commit before unlock
1490         for i in 1 2; do
1491                 bash -c "$2"
1492                 do_nodes $nodes "lctl set_param -n mdt.*.async_commit_count=0"
1493                 bash -c "$3"
1494                 commit_nr=$(do_nodes $nodes \
1495                         "lctl get_param -n mdt.*.async_commit_count" | calc_sum)
1496                 total=$((total + commit_nr));
1497                 rm -rf $DIR/$tdir
1498                 sync_all_data
1499         done
1500
1501         echo $1
1502         echo "  $2"
1503         echo "  $3"
1504         echo "  CoS count $total"
1505         (( total > 0 )) || error "$3 didn't trigger CoS"
1506 }
1507
1508 test_33d() {
1509         (( MDSCOUNT > 1 )) || skip "needs >= 2 MDTs"
1510         (( MDS1_VERSION >= $(version_code 2.7.63) )) ||
1511                 skip "DNE CoS not supported"
1512
1513         if (( $MDS1_VERSION < $(version_code 2.15.55.133) )); then
1514                 op_trigger_cos "remote directory unlink" \
1515                         "$LFS mkdir -i 1 $DIR/$tdir" "rmdir $DIR2/$tdir"
1516                 op_trigger_cos "striped directory create" "mkdir $DIR/$tdir" \
1517                         "$LFS mkdir -c 2 $DIR2/$tdir/subdir"
1518                 op_trigger_cos "striped directory setattr" \
1519                         "$LFS mkdir -c 2 $DIR/$tdir" "chmod 713 $DIR2/$tdir"
1520                 op_trigger_cos "striped directory unlink" \
1521                         "$LFS mkdir -c 2 $DIR/$tdir" "rmdir $DIR2/$tdir"
1522                 op_trigger_cos "cross-MDT link" \
1523                         "mkdir $DIR/$tdir; \
1524                         $LFS mkdir -i 0 $DIR/$tdir/d1; \
1525                         $LFS mkdir -i 1 $DIR/$tdir/d2; \
1526                         touch $DIR/$tdir/d1/tgt" \
1527                         "ln $DIR2/$tdir/d1/tgt $DIR2/$tdir/d2/src"
1528         fi
1529
1530         op_trigger_cos "remote directory create" "$LFS mkdir -i 0 $DIR/$tdir" \
1531                 "$LFS mkdir -i 1 $DIR2/$tdir/subdir"
1532         op_trigger_cos "cross-MDT rename" \
1533                 "mkdir $DIR/$tdir; \
1534                 $LFS mkdir -i 0 $DIR/$tdir/d1; \
1535                 $LFS mkdir -i 1 $DIR/$tdir/d2; \
1536                 touch $DIR/$tdir/d1/src" \
1537                 "mv $DIR2/$tdir/d1/src $DIR2/$tdir/d2/tgt"
1538         op_trigger_cos "migrate" \
1539                 "$LFS mkdir -i 0 $DIR/$tdir" \
1540                 "$LFS migrate -m 1 $DIR2/$tdir"
1541
1542         return 0
1543 }
1544 run_test 33d "dependent transactions should trigger COS"
1545
1546 test_33e() {
1547         (( MDSCOUNT > 1 )) || skip "needs >= 2 MDTs"
1548         (( MDS1_VERSION >= $(version_code 2.7.63) )) ||
1549                 skip "DNE CoS not supported"
1550
1551         $LFS mkdir -i 0 $DIR/$tdir
1552         $LFS mkdir -i 0 $DIR/$tdir/d1
1553         $LFS mkdir -i 1 $DIR/$tdir/d2
1554
1555         local nodes=$(comma_list $(mdts_nodes))
1556         do_nodes $nodes "lctl set_param -n mdt.*.async_commit_count=0"
1557
1558         test_33_run "plain dir creation" "mkdir $DIR2/$tdir/plain"
1559         test_33_run "open file and write" "echo abc > $DIR2/$tdir/$tfile"
1560         test_33_run "append write" "echo dfg >> $DIR2/$tdir/$tfile"
1561         test_33_run "setattr" "touch $DIR2/$tdir/$tfile"
1562         test_33_run "file unlink" "rm $DIR2/$tdir/$tfile"
1563         test_33_run "plain dir unlink" "rmdir $DIR2/$tdir/plain"
1564         if (( MDS1_VERSION >= $(version_code 2.15.55.133) )); then
1565                 test_33_run "striped directory creation" \
1566                         "$LFS mkdir -i 0 -c 2 $DIR2/$tdir/striped"
1567                 test_33_run "set default LMV to create striped subdir" \
1568                         "$LFS setdirstripe -D -c 2 $DIR/$tdir"
1569                 test_33_run "striped subdir creation" \
1570                         "createmany -d $DIR/$tdir/subdir 100"
1571                 test_33_run "sub file creation and write" \
1572                         "createmany -o $DIR/$tdir/subfile 100; \
1573                         echo abc > $DIR/$tdir/subfile1"
1574                 test_33_run "sub file append write" \
1575                         "echo dfg >> $DIR2/$tdir/subfile2"
1576                 test_33_run "subdir setatttr" "touch $DIR2/$tdir/subdir1"
1577                 test_33_run "subdir unlink" \
1578                         "unlinkmany -d $DIR/$tdir/subdir 100"
1579                 test_33_run "sub file unlink" \
1580                         "unlinkmany $DIR2/$tdir/subfile 100"
1581                 test_33_run "sub file creation follows striped dir chmod" \
1582                         "chmod 777 $DIR/$tdir/striped; \
1583                          touch $DIR/$tdir/striped/subfile"
1584                 test_33_run "striped directory unlink" \
1585                         "rm -rf $DIR2/$tdir/striped"
1586         fi
1587
1588         test_33_run "directory unlink" "rm -rf $DIR2/$tdir"
1589
1590         local async_commit_count=$(do_nodes $nodes \
1591                 "lctl get_param -n mdt.*.async_commit_count" | calc_sum)
1592         echo "CoS count $async_commit_count"
1593         (( async_commit_count == 0 )) || error "CoS triggerred"
1594 }
1595 run_test 33e "independent transactions shouldn't trigger COS"
1596
1597 # End commit on sharing tests
1598
1599 get_ost_lock_timeouts() {
1600     local nodes=${1:-$(comma_list $(osts_nodes))}
1601
1602     local locks=$(do_nodes $nodes \
1603         "lctl get_param -n ldlm.namespaces.filter-*.lock_timeouts" | calc_sum)
1604
1605     echo $locks
1606 }
1607
1608 cleanup_34() {
1609         local i
1610         trap 0
1611         do_nodes $(comma_list $(osts_nodes)) \
1612                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1613         for i in $(seq $OSTCOUNT); do
1614                 wait_osc_import_ready client ost$i
1615         done
1616 }
1617
1618 test_34() { #16129
1619         remote_ost_nodsh && skip "remote OST with nodsh" && return
1620         local OPER
1621         local lock_in
1622         local lock_out
1623         trap cleanup_34 EXIT RETURN
1624         for OPER in notimeout timeout ; do
1625                 rm $DIR1/$tfile 2>/dev/null
1626                 lock_in=$(get_ost_lock_timeouts)
1627                 if [ $OPER == "timeout" ] ; then
1628                         for j in `seq $OSTCOUNT`; do
1629                                 #define OBD_FAIL_PTLRPC_HPREQ_TIMEOUT    0x511
1630                                 do_facet ost$j lctl set_param fail_loc=0x511
1631                         done
1632                         echo lock should expire
1633                 else
1634                         for j in `seq $OSTCOUNT`; do
1635                                 #define OBD_FAIL_PTLRPC_HPREQ_NOTIMEOUT  0x512
1636                                 do_facet ost$j lctl set_param fail_loc=0x512
1637                         done
1638                         echo lock should not expire
1639                 fi
1640                 echo writing on client1
1641                 dd if=/dev/zero of=$DIR1/$tfile count=100 conv=notrunc > /dev/null 2>&1
1642                 sync &
1643                 echo reading on client2
1644                 dd of=/dev/null if=$DIR2/$tfile > /dev/null 2>&1
1645                 # wait for a lock timeout
1646                 sleep 4
1647                 lock_out=$(get_ost_lock_timeouts)
1648                 if [ $OPER == "timeout" ] ; then
1649                         if [ $lock_in == $lock_out ]; then
1650                                 error "no lock timeout happened"
1651                         else
1652                                 echo "success"
1653                         fi
1654                 else
1655                         if [ $lock_in != $lock_out ]; then
1656                                 error "lock timeout happened"
1657                         else
1658                                 echo "success"
1659                         fi
1660                 fi
1661         done
1662         cleanup_34
1663 }
1664 run_test 34 "no lock timeout under IO"
1665
1666 test_35() { # bug 17645
1667         local generation=[]
1668         local count=0
1669         gen=$(lctl get_param mdc.$FSNAME-MDT*-mdc-*.import | grep generation |
1670               awk '/generation/{print $2}')
1671         for g in $gen; do
1672                 generation[count]=$g
1673                 let count=count+1
1674         done
1675
1676         test_mkdir $MOUNT1/$tdir
1677         cancel_lru_locks mdc
1678
1679         # Let's initiate -EINTR situation by setting fail_loc and take
1680         # write lock on same file from same client. This will not cause
1681         # bl_ast yet as lock is already in local cache.
1682         #define OBD_FAIL_LDLM_INTR_CP_AST        0x317
1683         do_facet client "lctl set_param fail_loc=0x80000317"
1684         local timeout=$(do_facet $SINGLEMDS lctl get_param  -n timeout)
1685         let timeout=timeout*3
1686         local nr=0
1687         while test $nr -lt 10; do
1688                 log "Race attempt $nr"
1689                 local blk1=$(lctl get_param -n ldlm.services.ldlm_cbd.stats |
1690                              awk '/ldlm_bl_callback/ { print $2 }')
1691                 test "x$blk1" = "x" && blk1=0
1692                 createmany -o $MOUNT2/$tdir/a 4000 &
1693                 pid1=$!
1694                 sleep 1
1695
1696                 # Let's make conflict and bl_ast
1697                 ls -la $MOUNT1/$tdir > /dev/null &
1698                 pid2=$!
1699
1700                 log "Wait for $pid1 $pid2 for $timeout sec..."
1701                 sleep $timeout
1702                 kill -9 $pid1 $pid2 > /dev/null 2>&1
1703                 wait
1704                 local blk2=$(lctl get_param -n ldlm.services.ldlm_cbd.stats |
1705                              awk '/ldlm_bl_callback/ { print $2 }')
1706                 test "x$blk2" = "x" && blk2=0
1707                 test $blk2 -gt $blk1 && break
1708                 rm -fr $MOUNT1/$tdir
1709                 cancel_lru_locks mdc
1710                 let nr=nr+1
1711         done
1712         do_facet client "lctl set_param fail_loc=0x0"
1713         df -h $MOUNT1 $MOUNT2
1714         count=0
1715         gen=$(lctl get_param mdc.$FSNAME-MDT*-mdc-*.import | grep generation |
1716                 awk '/generation/{print $2}')
1717         for g in $gen; do
1718             if ! test "$g" -eq "${generation[count]}"; then
1719                 list=$(lctl list_param mdc.$FSNAME-MDT*-mdc-*.import)
1720                 local c=0
1721                 for imp in $list; do
1722                         if [ $c = $count ]; then
1723                                 break
1724                         fi
1725                         c=c+1
1726                 done
1727                 imp=$(echo "$imp" | awk -F"." '{print $2}')
1728                 error "Eviction happened on import $imp"
1729             fi
1730             let count=count+1
1731         done
1732 }
1733 run_test 35 "-EINTR cp_ast vs. bl_ast race does not evict client"
1734
1735 test_36() { #bug 16417
1736         local SIZE
1737         local SIZE_B
1738         local i
1739
1740         test_mkdir $DIR1/$tdir
1741         $LFS setstripe -c -1 $DIR1/$tdir
1742         i=0
1743         SIZE=50
1744         let SIZE_B=SIZE*1024*1024
1745         sync; sleep 2; sync # wait for delete thread
1746         wait_mds_ost_sync || error "wait_mds_ost_sync failed"
1747         wait_destroy_complete || error "wait_destroy_complete failed"
1748
1749         while [ $i -le 10 ]; do
1750                 lctl mark "start test - cycle ($i)"
1751                 local before=$(lfs_df $MOUNT1 | awk '/^filesystem/{ print $4; exit }')
1752                 dd if=/dev/zero of=$DIR1/$tdir/$tfile bs=1M count=$SIZE ||
1753                         error "dd $DIR1/$tdir/$tfile ${SIZE}MB failed"
1754                 sync          # sync data from client cache
1755                 sync_all_data # sync data from server cache (delayed allocation)
1756                 sleep 2
1757                 local after_dd=$(lfs_df $MOUNT1 | awk '/^filesystem/{ print $4; exit }')
1758                 multiop_bg_pause $DIR2/$tdir/$tfile O_r${SIZE_B}c || return 3
1759                 read_pid=$!
1760                 rm -f $DIR1/$tdir/$tfile
1761                 kill -USR1 $read_pid
1762                 wait $read_pid
1763                 sync; sleep 2; sync # Ensure new statfs
1764                 wait_delete_completed
1765                 local after=$(lfs_df $MOUNT1 | awk '/^filesystem/{ print $4; exit }')
1766                 echo "*** cycle($i) *** before($before) after_dd($after_dd)" \
1767                         "after($after)"
1768                 # this free space! not used
1769                 (( $after_dd <= $after)) ||
1770                         error "space leaked after_dd:$after_dd > after:$after"
1771                 let i=i+1
1772         done
1773 }
1774 run_test 36 "handle ESTALE/open-unlink correctly"
1775
1776 test_37() { # bug 18695
1777         test_mkdir $DIR1/$tdir
1778         multiop_bg_pause $DIR1/$tdir D_c || return 1
1779         MULTIPID=$!
1780         # create large directory (32kB seems enough from e2fsck, ~= 1000 files)
1781         createmany -m $DIR2/$tdir/f 10000
1782         # set mtime/atime backward
1783         touch -t 198001010000 $DIR2/$tdir
1784         kill -USR1 $MULTIPID
1785         nr_files=`lfs find $DIR1/$tdir -type f | wc -l`
1786         [ $nr_files -eq 10000 ] || error "$nr_files != 10000 truncated directory?"
1787
1788 }
1789 run_test 37 "check i_size is not updated for directory on close (bug 18695) =============="
1790
1791 # this should be set to past
1792 TEST_39_MTIME=`date -d "1 year ago" +%s`
1793
1794 # bug 11063
1795 test_39a() {
1796         local client1=${CLIENT1:-`hostname`}
1797         local client2=${CLIENT2:-`hostname`}
1798
1799         do_node $client1 "touch $DIR1/$tfile"
1800
1801         do_node $client1 "touch -m -d @$TEST_39_MTIME $DIR1/$tfile"
1802         local mtime1=`do_node $client2 "stat -c %Y $DIR1/$tfile"`
1803         [ "$mtime1" = $TEST_39_MTIME ] || \
1804                 error "mtime is not set to past: $mtime1, should be $TEST_39_MTIME"
1805
1806         local d1=`do_node $client1 date +%s`
1807         do_node $client1 'echo hello >> '$DIR1/$tfile
1808         local d2=`do_node $client1 date +%s`
1809
1810         local mtime2=`do_node $client2 "stat -c %Y $DIR1/$tfile"`
1811         [ "$mtime2" -ge "$d1" ] && [ "$mtime2" -le "$d2" ] || \
1812                 error "mtime is not updated on write: $d1 <= $mtime2 <= $d2"
1813
1814         do_node $client1 "mv $DIR1/$tfile $DIR1/$tfile-1"
1815
1816         for (( i=0; i < 2; i++ )) ; do
1817                 local mtime3=`do_node $client2 "stat -c %Y $DIR1/$tfile-1"`
1818                 [ "$mtime2" = "$mtime3" ] || \
1819                         error "mtime ($mtime2) changed (to $mtime3) on rename"
1820
1821                 cancel_lru_locks osc
1822                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
1823         done
1824 }
1825 run_test 39a "file mtime does not change after rename"
1826
1827 test_39b() {
1828         local client1=${CLIENT1:-`hostname`}
1829         local client2=${CLIENT2:-`hostname`}
1830
1831         touch $DIR1/$tfile
1832
1833         local mtime1=`stat -c %Y $DIR1/$tfile`
1834         local mtime2=`do_node $client2 "stat -c %Y $DIR1/$tfile"`
1835
1836         sleep 1
1837         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
1838
1839         for (( i=0; i < 2; i++ )) ; do
1840                 local mtime3=`stat -c %Y $DIR1/$tfile`
1841                 local mtime4=`do_node $client2 "stat -c %Y $DIR1/$tfile"`
1842
1843                 [ "$mtime3" = "$mtime4" ] || \
1844                         error "different mtime on clients: $mtime3, $mtime4"
1845                 [ "$mtime3" = $TEST_39_MTIME ] || \
1846                         error "lost mtime: $mtime3, should be $TEST_39_MTIME"
1847
1848                 cancel_lru_locks osc
1849                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
1850         done
1851 }
1852 run_test 39b "file mtime the same on clients with/out lock"
1853
1854 test_39c() {
1855         local client1=${CLIENT1:-`hostname`}
1856         local client2=${CLIENT2:-`hostname`}
1857
1858         echo hello > $DIR1/$tfile
1859
1860         local mtime1=`stat -c %Y $DIR1/$tfile`
1861         local mtime2=`do_node $client2 "stat -c %Y $DIR1/$tfile"`
1862         [ "$mtime1" = "$mtime2" ] || \
1863                 error "create: different mtime on clients: $mtime1, $mtime2"
1864
1865         sleep 1
1866         $TRUNCATE $DIR1/$tfile 1
1867
1868         for (( i=0; i < 2; i++ )) ; do
1869                 local mtime3=`stat -c %Y $DIR1/$tfile`
1870                 local mtime4=`do_node $client2 "stat -c %Y $DIR1/$tfile"`
1871
1872                 [ "$mtime3" = "$mtime4" ] || \
1873                         error "different mtime on clients: $mtime3, $mtime4"
1874                 [ "$mtime3" -gt $mtime2 ] || \
1875                         error "truncate did not update mtime: $mtime2, $mtime3"
1876
1877                 cancel_lru_locks osc
1878                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
1879         done
1880 }
1881 run_test 39c "check truncate mtime update ======================"
1882
1883 test_39d() { # LU-7310
1884         touch $DIR1/$tfile
1885         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
1886
1887         local mtime1=$(stat -c %Y $DIR2/$tfile)
1888         [ "$mtime1" = $TEST_39_MTIME ] ||
1889                 error "mtime: $mtime1, should be $TEST_39_MTIME"
1890
1891         # force sync write
1892         # define OBD_FAIL_OSC_NO_GRANT 0x411
1893         $LCTL set_param fail_loc=0x411
1894
1895         local d1=$(date +%s)
1896         echo hello >> $DIR1/$tfile
1897         local d2=$(date +%s)
1898
1899         $LCTL set_param fail_loc=0
1900
1901         cancel_lru_locks $OSC
1902
1903         local mtime2=$(stat -c %Y $DIR2/$tfile)
1904         [ "$mtime2" -ge "$d1" ] && [ "$mtime2" -le "$d2" ] ||
1905                 error "mtime is not updated on write: $d1 <= $mtime2 <= $d2"
1906 }
1907 run_test 39d "sync write should update mtime"
1908
1909 pdo_sched() {
1910         # how long 40-47 take with specific delay
1911         # sleep 0.1 # 78s
1912         # sleep 0.2 # 103s
1913         # sleep 0.3 # 124s
1914         sleep 0.5 # 164s
1915 }
1916
1917 # for pdo testing, we must cancel MDT-MDT locks as well as client locks to
1918 # avoid unexpected delays due to previous tests
1919 pdo_lru_clear() {
1920         cancel_lru_locks mdc
1921         do_nodes $(comma_list $(mdts_nodes)) \
1922                 $LCTL set_param -n ldlm.namespaces.*mdt*.lru_size=clear
1923         do_nodes $(comma_list $(mdts_nodes)) \
1924                 $LCTL get_param ldlm.namespaces.*mdt*.lock_unused_count \
1925                         ldlm.namespaces.*mdt*.lock_count | grep -v '=0'
1926 }
1927
1928 # check that pid exists hence second operation wasn't blocked by first one
1929 # if it is so then there is no conflict, return 0
1930 # else second operation is conflicting with first one, return 1
1931 check_pdo_conflict() {
1932         local pid=$1
1933         local conflict=0
1934         pdo_sched # to ensure OP1 is finished on client if OP2 is blocked by OP1
1935         if [[ `ps --pid $pid | wc -l` == 1 ]]; then
1936                 conflict=1
1937                 echo "Conflict"
1938         else
1939                 echo "No conflict"
1940         fi
1941         return $conflict
1942 }
1943
1944 # pdirop tests
1945 # test 40: check non-blocking operations
1946 test_40a() {
1947         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1948
1949         mkdir_on_mdt0 $DIR2/$tdir
1950         pdo_lru_clear
1951 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1952         do_nodes $(comma_list $(mdts_nodes)) \
1953                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1954         mkdir $DIR1/$tdir/$tfile &
1955         PID1=$!; pdo_sched
1956         touch $DIR2/$tdir/$tfile-2
1957         check_pdo_conflict $PID1 || error "create is blocked"
1958         mkdir $DIR2/$tdir/$tfile-3
1959         check_pdo_conflict $PID1 || error "mkdir is blocked"
1960         link $DIR2/$tdir/$tfile-2 $DIR2/$tdir/$tfile-4
1961         check_pdo_conflict $PID1 || error "link is blocked"
1962         mv $DIR2/$tdir/$tfile-2 $DIR2/$tdir/$tfile-5
1963         check_pdo_conflict $PID1 || error "rename is blocked"
1964         stat $DIR2/$tdir/$tfile-3 $DIR2/$tdir/$tfile-4 > /dev/null
1965         check_pdo_conflict $PID1 || error "getattr is blocked"
1966         rm $DIR2/$tdir/$tfile-4 $DIR2/$tdir/$tfile-5
1967         rmdir $DIR2/$tdir/$tfile-3
1968         check_pdo_conflict $PID1 || error "unlink is blocked"
1969
1970         #  all operations above shouldn't wait the first one
1971         check_pdo_conflict $PID1 || error "parallel operation is blocked"
1972         do_nodes $(comma_list $(mdts_nodes)) \
1973                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
1974         wait $PID1
1975         rm -rf $DIR/$tdir
1976         return 0
1977 }
1978 run_test 40a "pdirops: create vs others =============="
1979
1980 test_40b() {
1981         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1982
1983         mkdir_on_mdt0 $DIR2/$tdir
1984         pdo_lru_clear
1985 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
1986         do_nodes $(comma_list $(mdts_nodes)) \
1987                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
1988         touch $DIR1/$tdir/$tfile &
1989         PID1=$!; pdo_sched
1990         # open|create
1991         touch $DIR2/$tdir/$tfile-2
1992         check_pdo_conflict $PID1 || error "create is blocked"
1993         mkdir $DIR2/$tdir/$tfile-3
1994         check_pdo_conflict $PID1 || error "mkdir is blocked"
1995         link $DIR2/$tdir/$tfile-2 $DIR2/$tdir/$tfile-4
1996         check_pdo_conflict $PID1 || error "link is blocked"
1997         mv $DIR2/$tdir/$tfile-2 $DIR2/$tdir/$tfile-5
1998         check_pdo_conflict $PID1 || error "rename is blocked"
1999         stat $DIR2/$tdir/$tfile-3 $DIR2/$tdir/$tfile-4 > /dev/null
2000         check_pdo_conflict $PID1 || error "getattr is blocked"
2001         rm $DIR2/$tdir/$tfile-4 $DIR2/$tdir/$tfile-5
2002         rmdir $DIR2/$tdir/$tfile-3
2003         check_pdo_conflict $PID1 || error "unlink is blocked"
2004         # all operations above shouldn't wait the first one
2005
2006         check_pdo_conflict $PID1 || error "parallel operation is blocked"
2007         do_nodes $(comma_list $(mdts_nodes)) \
2008                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2009         wait $PID1
2010         rm -rf $DIR/$tdir
2011         return 0
2012 }
2013 run_test 40b "pdirops: open|create and others =============="
2014
2015 test_40c() {
2016         remote_mds_nodsh && skip "remote MDS with nodsh" && return
2017
2018         mkdir_on_mdt0 $DIR2/$tdir
2019         pdo_lru_clear
2020         touch $DIR1/$tdir/$tfile
2021 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2022         do_nodes $(comma_list $(mdts_nodes)) \
2023                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2024         link $DIR1/$tdir/$tfile $DIR1/$tdir/$tfile-0 &
2025         PID1=$!; pdo_sched
2026         # open|create
2027         touch $DIR2/$tdir/$tfile-2
2028         check_pdo_conflict $PID1 || error "create is blocked"
2029         mkdir $DIR2/$tdir/$tfile-3
2030         check_pdo_conflict $PID1 || error "mkdir is blocked"
2031         link $DIR2/$tdir/$tfile-2 $DIR2/$tdir/$tfile-4
2032         check_pdo_conflict $PID1 || error "link is blocked"
2033         mv $DIR2/$tdir/$tfile-2 $DIR2/$tdir/$tfile-5
2034         check_pdo_conflict $PID1 || error "rename is blocked"
2035         stat $DIR2/$tdir/$tfile-3 $DIR2/$tdir/$tfile-4 > /dev/null
2036         check_pdo_conflict $PID1 || error "getattr is blocked"
2037         rm $DIR2/$tdir/$tfile-4 $DIR2/$tdir/$tfile-5
2038         rmdir $DIR2/$tdir/$tfile-3
2039         check_pdo_conflict $PID1 || error "unlink is blocked"
2040
2041         # all operations above shouldn't wait the first one
2042         check_pdo_conflict $PID1 || error "parallel operation is blocked"
2043         do_nodes $(comma_list $(mdts_nodes)) \
2044                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2045         wait $PID1
2046         rm -rf $DIR/$tdir
2047         return 0
2048 }
2049 run_test 40c "pdirops: link and others =============="
2050
2051 test_40d() {
2052         remote_mds_nodsh && skip "remote MDS with nodsh" && return
2053
2054         mkdir_on_mdt0 $DIR2/$tdir
2055         pdo_lru_clear
2056         touch $DIR1/$tdir/$tfile
2057 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2058         do_nodes $(comma_list $(mdts_nodes)) \
2059                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2060         rm $DIR1/$tdir/$tfile &
2061         PID1=$!; pdo_sched
2062         # open|create
2063         touch $DIR2/$tdir/$tfile-2
2064         check_pdo_conflict $PID1 || error "create is blocked"
2065         mkdir $DIR2/$tdir/$tfile-3
2066         check_pdo_conflict $PID1 || error "mkdir is blocked"
2067         link $DIR2/$tdir/$tfile-2 $DIR2/$tdir/$tfile-4
2068         check_pdo_conflict $PID1 || error "link is blocked"
2069         mv $DIR2/$tdir/$tfile-2 $DIR2/$tdir/$tfile-5
2070         check_pdo_conflict $PID1 || error "rename is blocked"
2071         stat $DIR2/$tdir/$tfile-3 $DIR2/$tdir/$tfile-4 > /dev/null
2072         check_pdo_conflict $PID1 || error "getattr is blocked"
2073         rm $DIR2/$tdir/$tfile-4 $DIR2/$tdir/$tfile-5
2074         rmdir $DIR2/$tdir/$tfile-3
2075         check_pdo_conflict $PID1 || error "unlink is blocked"
2076
2077         # all operations above shouldn't wait the first one
2078         check_pdo_conflict $PID1 || error "parallel operation is blocked"
2079         do_nodes $(comma_list $(mdts_nodes)) \
2080                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2081         wait $PID1
2082         return 0
2083 }
2084 run_test 40d "pdirops: unlink and others =============="
2085
2086 test_40e() {
2087         remote_mds_nodsh && skip "remote MDS with nodsh" && return
2088
2089         mkdir_on_mdt0 $DIR2/$tdir
2090         pdo_lru_clear
2091         touch $DIR1/$tdir/$tfile
2092 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2093         do_nodes $(comma_list $(mdts_nodes)) \
2094                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2095         mv $DIR1/$tdir/$tfile $DIR1/$tdir/$tfile-0 &
2096         PID1=$!; pdo_sched
2097         # open|create
2098         touch $DIR2/$tdir/$tfile-2
2099         check_pdo_conflict $PID1 || error "create is blocked"
2100         mkdir $DIR2/$tdir/$tfile-3
2101         check_pdo_conflict $PID1 || error "mkdir is blocked"
2102         link $DIR2/$tdir/$tfile-2 $DIR2/$tdir/$tfile-4
2103         check_pdo_conflict $PID1 || error "link is blocked"
2104         stat $DIR2/$tdir/$tfile-3 $DIR2/$tdir/$tfile-4 > /dev/null
2105         check_pdo_conflict $PID1 || error "getattr is blocked"
2106         rm $DIR2/$tdir/$tfile-4 $DIR2/$tdir/$tfile-2
2107         rmdir $DIR2/$tdir/$tfile-3
2108         check_pdo_conflict $PID1 || error "unlink is blocked"
2109
2110        # all operations above shouldn't wait the first one
2111         check_pdo_conflict $PID1 || error "parallel operation is blocked"
2112         do_nodes $(comma_list $(mdts_nodes)) \
2113                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2114         wait $PID1
2115         rm -rf $DIR/$tdir
2116         return 0
2117 }
2118 run_test 40e "pdirops: rename and others =============="
2119
2120 # test 41: create blocking operations
2121 test_41a() {
2122         pdo_lru_clear
2123 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2124         do_nodes $(comma_list $(mdts_nodes)) \
2125                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2126         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
2127         PID1=$! ; pdo_sched
2128         mkdir $DIR2/$tfile &
2129         PID2=$! ; pdo_sched
2130         do_nodes $(comma_list $(mdts_nodes)) \
2131                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2132         check_pdo_conflict $PID1 && { wait $PID1; echo "mkdir isn't blocked"; }
2133         wait $PID2 ; [ $? -ne 0 ] || error "mkdir must fail"
2134         rm -rf $DIR/$tfile*
2135         return 0
2136 }
2137 run_test 41a "pdirops: create vs mkdir =============="
2138
2139 test_41b() {
2140         pdo_lru_clear
2141 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2142         do_nodes $(comma_list $(mdts_nodes)) \
2143                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2144         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
2145         PID1=$! ; pdo_sched
2146         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c &
2147         PID2=$! ; pdo_sched
2148         do_nodes $(comma_list $(mdts_nodes)) \
2149                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2150         check_pdo_conflict $PID1 && { wait $PID1; error "create isn't blocked"; }
2151         wait $PID2 ; [ $? -ne 0 ] || error "create must fail"
2152         rm -rf $DIR/$tfile*
2153         return 0
2154 }
2155 run_test 41b "pdirops: create vs create =============="
2156
2157 test_41c() {
2158         pdo_lru_clear
2159         touch $DIR1/$tfile-2
2160 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2161         do_nodes $(comma_list $(mdts_nodes)) \
2162                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2163         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
2164         PID1=$! ; pdo_sched
2165         link $DIR2/$tfile-2 $DIR2/$tfile &
2166         PID2=$! ; pdo_sched
2167         do_nodes $(comma_list $(mdts_nodes)) \
2168                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2169         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
2170         wait $PID2 ; [ $? -ne 0 ] || error "link must fail"
2171         rm -rf $DIR/$tfile*
2172         return 0
2173 }
2174 run_test 41c "pdirops: create vs link =============="
2175
2176 test_41d() {
2177         pdo_lru_clear
2178 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2179         do_nodes $(comma_list $(mdts_nodes)) \
2180                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2181         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
2182         PID1=$! ; pdo_sched
2183         rm $DIR2/$tfile &
2184         PID2=$! ; pdo_sched
2185         do_nodes $(comma_list $(mdts_nodes)) \
2186                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2187         check_pdo_conflict $PID1 && { wait $PID1; error "unlink isn't blocked"; }
2188         wait $PID2 ; [ $? -eq 0 ] || error "unlink must succeed"
2189         rm -rf $DIR/$tfile*
2190         return 0
2191 }
2192 run_test 41d "pdirops: create vs unlink =============="
2193
2194 test_41e() {
2195         pdo_lru_clear
2196         touch $DIR1/$tfile-2
2197 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2198         do_nodes $(comma_list $(mdts_nodes)) \
2199                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2200         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
2201         PID1=$! ; pdo_sched
2202         mv $DIR2/$tfile-2 $DIR2/$tfile &
2203         PID2=$! ; pdo_sched
2204         do_nodes $(comma_list $(mdts_nodes)) \
2205                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2206         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2207         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2208         rm -rf $DIR/$tfile*
2209         return 0
2210 }
2211 run_test 41e "pdirops: create and rename (tgt) =============="
2212
2213 test_41f() {
2214         pdo_lru_clear
2215 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2216         do_nodes $(comma_list $(mdts_nodes)) \
2217                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2218         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
2219         PID1=$! ; pdo_sched
2220         mv $DIR2/$tfile $DIR2/$tfile-2 &
2221         PID2=$! ; pdo_sched
2222         do_nodes $(comma_list $(mdts_nodes)) \
2223                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2224         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2225         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2226         rm -rf $DIR/$tfile*
2227         return 0
2228 }
2229 run_test 41f "pdirops: create and rename (src) =============="
2230
2231 test_41g() {
2232         pdo_lru_clear
2233 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2234         do_nodes $(comma_list $(mdts_nodes)) \
2235                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2236         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
2237         PID1=$! ; pdo_sched
2238         stat $DIR2/$tfile > /dev/null &
2239         PID2=$! ; pdo_sched
2240         do_nodes $(comma_list $(mdts_nodes)) \
2241                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2242         check_pdo_conflict $PID1 && { wait $PID1; error "getattr isn't blocked"; }
2243         wait $PID2 ; [ $? -eq 0 ] || error "stat must succeed"
2244         rm -rf $DIR/$tfile*
2245         return 0
2246 }
2247 run_test 41g "pdirops: create vs getattr =============="
2248
2249 test_41h() {
2250         pdo_lru_clear
2251 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2252         do_nodes $(comma_list $(mdts_nodes)) \
2253                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2254         $MULTIOP $DIR1/$tfile oO_CREAT:O_RDWR:c &
2255         PID1=$! ; pdo_sched
2256         ls -lia $DIR2/ > /dev/null &
2257         PID2=$! ; pdo_sched
2258         do_nodes $(comma_list $(mdts_nodes)) \
2259                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2260         check_pdo_conflict $PID1 && { wait $PID1; error "readdir isn't blocked"; }
2261         wait $PID2
2262         rm -rf $DIR/$tfile*
2263         return 0
2264 }
2265 run_test 41h "pdirops: create vs readdir =============="
2266
2267 sub_test_41i() {
2268         local PID1 PID2
2269         local fail_loc="$1"
2270         local ret=0
2271
2272         do_nodes $(comma_list $(mdts_nodes)) \
2273                 "lctl set_param -n fail_loc=${fail_loc} || true" &>/dev/null
2274
2275         $MULTIOP $DIR1/$tfile oO_CREAT:O_EXCL:c 2>/dev/null &
2276         PID1=$!
2277         sleep 0.2
2278         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c 2>/dev/null &
2279         PID2=$!
2280
2281         if ! wait $PID1 && ! wait $PID2; then
2282                 echo "Both creates failed (1 should fail, 1 should succeed)"
2283                 ret=1
2284         elif wait $PID1 && wait $PID2; then
2285                 echo "Both creates succeeded (1 should fail, 1 should succeed)"
2286                 ret=2
2287         fi
2288
2289         #Clean
2290         do_nodes $(comma_list $(mdts_nodes)) \
2291                 "lctl set_param -n fail_loc=0x0 || true" &>/dev/null
2292         rm -f $DIR/$tfile
2293
2294         return $ret
2295 }
2296
2297 test_41i() {
2298         (( $MDS1_VERSION >= $(version_code 2.13.56) )) ||
2299                 skip "Need MDS version newer than 2.13.56"
2300         local msg fail_loc
2301
2302 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_REINT_OPEN         0x169
2303 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_REINT_OPEN2        0x16a
2304         for fail_loc in "0x80000169" "0x8000016a"; do
2305                 echo "Begin 100 tests with fail_loc=$fail_loc"
2306                 printf "Progress: "
2307                 for i in {1..100}; do
2308                         printf "*"
2309                         msg=$(sub_test_41i "$fail_loc") ||
2310                                 { echo; error "iter=$i : $msg"; }
2311                 done
2312                 echo
2313         done
2314 }
2315 run_test 41i "reint_open: create vs create"
2316
2317
2318 # test 42: unlink and blocking operations
2319 test_42a() {
2320         pdo_lru_clear
2321 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2322         do_nodes $(comma_list $(mdts_nodes)) \
2323                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2324         mkdir $DIR1/$tfile &
2325         PID1=$! ; pdo_sched
2326         mkdir $DIR2/$tfile &
2327         PID2=$! ; pdo_sched
2328         do_nodes $(comma_list $(mdts_nodes)) \
2329                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2330         check_pdo_conflict $PID1 && { wait $PID1; error "mkdir isn't blocked"; }
2331         wait $PID2 ; [ $? -ne 0 ] || error "mkdir must fail"
2332         rm -rf $DIR/$tfile*
2333         return 0
2334 }
2335 run_test 42a "pdirops: mkdir vs mkdir =============="
2336
2337 test_42b() {
2338         pdo_lru_clear
2339 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2340         do_nodes $(comma_list $(mdts_nodes)) \
2341                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2342         mkdir $DIR1/$tfile &
2343         PID1=$! ; pdo_sched
2344         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c &
2345         PID2=$! ; pdo_sched
2346         do_nodes $(comma_list $(mdts_nodes)) \
2347                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2348         check_pdo_conflict $PID1 && { wait $PID1; error "create isn't blocked"; }
2349         wait $PID2 ; [ $? -ne 0 ] || error "create must fail"
2350         rm -rf $DIR/$tfile*
2351         return 0
2352 }
2353 run_test 42b "pdirops: mkdir vs create =============="
2354
2355 test_42c() {
2356         pdo_lru_clear
2357         touch $DIR1/$tfile-2
2358 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2359         do_nodes $(comma_list $(mdts_nodes)) \
2360                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2361         mkdir $DIR1/$tfile &
2362         PID1=$! ; pdo_sched
2363         link $DIR2/$tfile-2 $DIR2/$tfile &
2364         PID2=$! ; pdo_sched
2365         do_nodes $(comma_list $(mdts_nodes)) \
2366                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2367         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
2368         wait $PID2 ; [ $? -ne 0 ] || error "link must fail"
2369         rm -rf $DIR/$tfile*
2370         return 0
2371 }
2372 run_test 42c "pdirops: mkdir vs link =============="
2373
2374 test_42d() {
2375         pdo_lru_clear
2376 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2377         do_nodes $(comma_list $(mdts_nodes)) \
2378                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2379         mkdir $DIR1/$tfile &
2380         PID1=$! ; pdo_sched
2381         rmdir $DIR2/$tfile &
2382         PID2=$! ; pdo_sched
2383         do_nodes $(comma_list $(mdts_nodes)) \
2384                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2385         check_pdo_conflict $PID1 && { wait $PID1; error "unlink isn't blocked"; }
2386         wait $PID2 ; [ $? -eq 0 ] || error "unlink must succeed"
2387         rm -rf $DIR/$tfile*
2388         return 0
2389 }
2390 run_test 42d "pdirops: mkdir vs unlink =============="
2391
2392 test_42e() {
2393         pdo_lru_clear
2394         touch $DIR1/$tfile-2
2395 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2396         do_nodes $(comma_list $(mdts_nodes)) \
2397                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2398         mkdir $DIR1/$tfile &
2399         PID1=$! ; pdo_sched
2400         mv -T $DIR2/$tfile-2 $DIR2/$tfile &
2401         PID2=$! ; pdo_sched
2402         do_nodes $(comma_list $(mdts_nodes)) \
2403                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2404         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2405         wait $PID2 ; [ $? -ne 0 ] || error "rename must fail"
2406         rm -rf $DIR/$tfile*
2407         return 0
2408 }
2409 run_test 42e "pdirops: mkdir and rename (tgt) =============="
2410
2411 test_42f() {
2412         pdo_lru_clear
2413 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2414         do_nodes $(comma_list $(mdts_nodes)) \
2415                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2416         mkdir $DIR1/$tfile &
2417         PID1=$! ; pdo_sched
2418         mv $DIR2/$tfile $DIR2/$tfile-2 &
2419         PID2=$! ; pdo_sched
2420         do_nodes $(comma_list $(mdts_nodes)) \
2421                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2422         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2423         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2424         rm -rf $DIR/$tfile*
2425         return 0
2426 }
2427 run_test 42f "pdirops: mkdir and rename (src) =============="
2428
2429 test_42g() {
2430         mkdir_on_mdt0 $DIR1/$tdir
2431         pdo_lru_clear
2432 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2433         do_nodes $(comma_list $(mdts_nodes)) \
2434                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2435         mkdir $DIR1/$tdir/$tfile &
2436         PID1=$! ; pdo_sched
2437         stat $DIR2/$tdir/$tfile > /dev/null &
2438         PID2=$! ; pdo_sched
2439         do_nodes $(comma_list $(mdts_nodes)) \
2440                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2441         check_pdo_conflict $PID1 && { wait $PID1; error "getattr isn't blocked"; }
2442         wait $PID2 ; [ $? -eq 0 ] || error "stat must succeed"
2443         rm -rf $DIR/$tdir
2444 }
2445 run_test 42g "pdirops: mkdir vs getattr =============="
2446
2447 test_42h() {
2448         pdo_lru_clear
2449 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2450         do_nodes $(comma_list $(mdts_nodes)) \
2451                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2452         mkdir $DIR1/$tfile &
2453         PID1=$! ; pdo_sched
2454         ls -lia $DIR2/ > /dev/null &
2455         PID2=$! ; pdo_sched
2456         do_nodes $(comma_list $(mdts_nodes)) \
2457                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2458         check_pdo_conflict $PID1 && { wait $PID1; error "readdir isn't blocked"; }
2459         wait $PID2
2460         rm -rf $DIR/$tfile*
2461         return 0
2462 }
2463 run_test 42h "pdirops: mkdir vs readdir =============="
2464
2465 # test 43: rmdir,mkdir won't return -EEXIST
2466 test_43a() {
2467         for i in {1..1000}; do
2468                 mkdir $DIR1/$tdir || error "mkdir $tdir failed"
2469                 rmdir $DIR2/$tdir || error "rmdir $tdir failed"
2470         done
2471         return 0
2472 }
2473 run_test 43a "rmdir,mkdir doesn't return -EEXIST =============="
2474
2475 test_43b() {
2476         pdo_lru_clear
2477         touch $DIR1/$tfile
2478 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2479         do_nodes $(comma_list $(mdts_nodes)) \
2480                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2481         rm $DIR1/$tfile &
2482         PID1=$! ; pdo_sched
2483         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c &
2484         PID2=$! ; pdo_sched
2485         do_nodes $(comma_list $(mdts_nodes)) \
2486                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2487         check_pdo_conflict $PID1 && { wait $PID1; error "create isn't blocked"; }
2488         wait $PID2 ; [ $? -eq 0 ] || error "create must succeed"
2489         rm -rf $DIR/$tfile*
2490         return 0
2491 }
2492 run_test 43b "pdirops: unlink vs create =============="
2493
2494 test_43c() {
2495         pdo_lru_clear
2496         touch $DIR1/$tfile
2497         touch $DIR1/$tfile-2
2498 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2499         do_nodes $(comma_list $(mdts_nodes)) \
2500                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2501         rm $DIR1/$tfile &
2502         PID1=$! ; pdo_sched
2503         link $DIR2/$tfile-2 $DIR2/$tfile &
2504         PID2=$! ; pdo_sched
2505         do_nodes $(comma_list $(mdts_nodes)) \
2506                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2507         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
2508         wait $PID2 ; [ $? -eq 0 ] || error "link must succeed"
2509         rm -rf $DIR/$tfile*
2510         return 0
2511 }
2512 run_test 43c "pdirops: unlink vs link =============="
2513
2514 test_43d() {
2515         pdo_lru_clear
2516         touch $DIR1/$tfile
2517 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2518         do_nodes $(comma_list $(mdts_nodes)) \
2519                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2520         rm $DIR1/$tfile &
2521         PID1=$! ; pdo_sched
2522         rm $DIR2/$tfile &
2523         PID2=$! ; pdo_sched
2524         do_nodes $(comma_list $(mdts_nodes)) \
2525                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2526         check_pdo_conflict $PID1 && { wait $PID1; error "unlink isn't blocked"; }
2527         wait $PID2 ; [ $? -ne 0 ] || error "unlink must fail"
2528         rm -rf $DIR/$tfile*
2529         return 0
2530 }
2531 run_test 43d "pdirops: unlink vs unlink =============="
2532
2533 test_43e() {
2534         pdo_lru_clear
2535         touch $DIR1/$tfile
2536         touch $DIR1/$tfile-2
2537 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2538         do_nodes $(comma_list $(mdts_nodes)) \
2539                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2540         rm $DIR1/$tfile &
2541         PID1=$! ; pdo_sched
2542         mv -u $DIR2/$tfile-2 $DIR2/$tfile &
2543         PID2=$! ; pdo_sched
2544         do_nodes $(comma_list $(mdts_nodes)) \
2545                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2546         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2547         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2548         rm -rf $DIR/$tfile*
2549         return 0
2550 }
2551 run_test 43e "pdirops: unlink and rename (tgt) =============="
2552
2553 test_43f() {
2554         pdo_lru_clear
2555         touch $DIR1/$tfile
2556 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2557         do_nodes $(comma_list $(mdts_nodes)) \
2558                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2559         rm $DIR1/$tfile &
2560         PID1=$! ; pdo_sched
2561         mv $DIR2/$tfile $DIR2/$tfile-2 &
2562         PID2=$! ; pdo_sched
2563         do_nodes $(comma_list $(mdts_nodes)) \
2564                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2565         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2566         wait $PID2 ; [ $? -ne 0 ] || error "rename must fail"
2567         rm -rf $DIR/$tfile*
2568         return 0
2569 }
2570 run_test 43f "pdirops: unlink and rename (src) =============="
2571
2572 test_43g() {
2573         pdo_lru_clear
2574         touch $DIR1/$tfile
2575 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2576         do_nodes $(comma_list $(mdts_nodes)) \
2577                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2578         rm $DIR1/$tfile &
2579         PID1=$! ; pdo_sched
2580         stat $DIR2/$tfile > /dev/null &
2581         PID2=$! ; pdo_sched
2582         do_nodes $(comma_list $(mdts_nodes)) \
2583                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2584         check_pdo_conflict $PID1 && { wait $PID1; error "getattr isn't blocked"; }
2585         wait $PID2 ; [ $? -ne 0 ] || error "stat must fail"
2586         rm -rf $DIR/$tfile*
2587         return 0
2588 }
2589 run_test 43g "pdirops: unlink vs getattr =============="
2590
2591 test_43h() {
2592         pdo_lru_clear
2593         touch $DIR1/$tfile
2594 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2595         do_nodes $(comma_list $(mdts_nodes)) \
2596                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2597         rm $DIR1/$tfile &
2598         PID1=$! ; pdo_sched
2599         ls -lia $DIR2/ > /dev/null &
2600         PID2=$! ; pdo_sched
2601         do_nodes $(comma_list $(mdts_nodes)) \
2602                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2603         check_pdo_conflict $PID1 && { wait $PID1; error "readdir isn't blocked"; }
2604         wait $PID2
2605         rm -rf $DIR/$tfile*
2606         return 0
2607 }
2608 run_test 43h "pdirops: unlink vs readdir =============="
2609
2610 test_43i() {
2611         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2612         pdo_lru_clear
2613         touch $DIR1/$tfile
2614 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2615         do_nodes $(comma_list $(mdts_nodes)) \
2616                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2617         rm $DIR1/$tfile &
2618         PID1=$! ; pdo_sched
2619         $LFS mkdir -i 1 $DIR2/$tfile &
2620         PID2=$! ; pdo_sched
2621         do_nodes $(comma_list $(mdts_nodes)) \
2622                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2623         check_pdo_conflict $PID1 &&
2624                 { wait $PID1; error "remote mkdir isn't blocked"; }
2625         wait $PID2 ; [ $? -eq 0 ] || error "remote mkdir must succeed"
2626         rm -rf $DIR/$tfile*
2627         return 0
2628 }
2629 run_test 43i "pdirops: unlink vs remote mkdir"
2630
2631 test_43j() {
2632         [[ $MDS1_VERSION -lt $(version_code 2.13.52) ]] &&
2633                 skip "Need MDS version newer than 2.13.52"
2634
2635         mkdir_on_mdt0 $DIR1/$tdir
2636         for i in {1..100}; do
2637 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_CREATE_RACE         0x167
2638                 do_nodes $(comma_list $(mdts_nodes)) \
2639                         "lctl set_param -n fail_loc=0x80000167 2>/dev/null ||
2640                                 true"
2641                 OK=0
2642                 mkdir $DIR1/$tdir/sub &
2643                 PID1=$!
2644                 mkdir $DIR2/$tdir/sub && ((OK++))
2645                 wait $PID1 && ((OK++))
2646                 (( OK == 1 )) || error "exactly one mkdir should succeed"
2647
2648                 rmdir $DIR1/$tdir/sub || error "rmdir failed"
2649         done
2650         return 0
2651 }
2652 run_test 43j "racy mkdir return EEXIST =============="
2653
2654 sub_test_43k() {
2655         local PID1 PID2
2656         local fail_loc="$1"
2657         local ret=0
2658
2659         # We test in a separate directory to be able to unblock server thread in
2660         # cfs_race() if LCK_PW is taken on the parent by mdt_reint_unlink.
2661         test_mkdir $DIR2/$tdir
2662         touch $DIR2/$tdir/$tfile
2663         pdo_lru_clear
2664
2665         do_nodes $(comma_list $(mdts_nodes)) \
2666                 "lctl set_param -n fail_loc=${fail_loc} || true" &>/dev/null
2667         echo content > $DIR1/$tdir/$tfile & PID1=$!
2668         pdo_sched
2669         multiop $DIR2/$tdir/$tfile u & PID2=$!
2670
2671         wait $PID1 ||
2672                 { ret=$?; \
2673                 echo -n "overwriting $tfile should succeed (err=$ret); "; }
2674         wait $PID2 ||
2675                 { ret=$?; \
2676                 echo -n "unlinking $tfile should succeed (err=$ret);"; }
2677
2678         #Clean
2679         do_nodes $(comma_list $(mdts_nodes)) \
2680                 "lctl set_param -n fail_loc=0x0 || true" &>/dev/null
2681         rm -rf $DIR/$tdir
2682
2683         return $ret
2684 }
2685
2686 test_43k() {
2687         (( $MDS1_VERSION >= $(version_code 2.13.56) )) ||
2688                 skip "Need MDS version newer than 2.13.56"
2689         local msg fail_loc
2690
2691 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_REINT_OPEN         0x169
2692 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_REINT_OPEN2        0x16a
2693         for fail_loc in "0x80000169" "0x8000016a"; do
2694                 echo "Begin 100 tests with fail_loc=$fail_loc"
2695                 printf "Progress: "
2696                 for i in {1..100}; do
2697                         printf "*"
2698                         msg=$(sub_test_43k "$fail_loc") ||
2699                                 { echo; error "iter=$i : $msg"; }
2700                 done
2701                 echo
2702         done
2703
2704         #Clean
2705         reset_fail_loc
2706
2707         return 0
2708 }
2709 run_test 43k "unlink vs create"
2710
2711 # test 44: rename tgt and blocking operations
2712 test_44a() {
2713         pdo_lru_clear
2714         touch $DIR1/$tfile-2
2715 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2   0x146
2716         do_nodes $(comma_list $(mdts_nodes)) \
2717                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2718         mv $DIR1/$tfile-2 $DIR1/$tfile &
2719         PID1=$! ; pdo_sched
2720         mkdir $DIR2/$tfile &
2721         PID2=$! ; pdo_sched
2722         do_nodes $(comma_list $(mdts_nodes)) \
2723                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2724         check_pdo_conflict $PID1 && { wait $PID1; date;error "mkdir isn't blocked"; }
2725         wait $PID2 ; [ $? -ne 0 ] || error "mkdir must fail"
2726         date
2727         rm -rf $DIR/$tfile*
2728         return 0
2729 }
2730 run_test 44a "pdirops: rename tgt vs mkdir =============="
2731
2732 test_44b() {
2733         pdo_lru_clear
2734         touch $DIR1/$tfile-2
2735 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2736         do_nodes $(comma_list $(mdts_nodes)) \
2737                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2738         mv $DIR1/$tfile-2 $DIR1/$tfile &
2739         PID1=$! ; pdo_sched
2740         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c &
2741         PID2=$! ; pdo_sched
2742         do_nodes $(comma_list $(mdts_nodes)) \
2743                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2744         check_pdo_conflict $PID1 && { wait $PID1; error "create isn't blocked"; }
2745         wait $PID2 ; [ $? -ne 0 ] || error "create must fail"
2746         rm -rf $DIR/$tfile*
2747         return 0
2748 }
2749 run_test 44b "pdirops: rename tgt vs create =============="
2750
2751 test_44c() {
2752         pdo_lru_clear
2753         touch $DIR1/$tfile-2
2754         touch $DIR1/$tfile-3
2755 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2756         do_nodes $(comma_list $(mdts_nodes)) \
2757                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2758         mv $DIR1/$tfile-2 $DIR1/$tfile &
2759         PID1=$! ; pdo_sched
2760         link $DIR2/$tfile-3 $DIR2/$tfile &
2761         PID2=$! ; pdo_sched
2762         do_nodes $(comma_list $(mdts_nodes)) \
2763                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2764         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
2765         wait $PID2 ; [ $? -ne 0 ] || error "link must fail"
2766         rm -rf $DIR/$tfile*
2767         return 0
2768 }
2769 run_test 44c "pdirops: rename tgt vs link =============="
2770
2771 test_44d() {
2772         pdo_lru_clear
2773         touch $DIR1/$tfile-2
2774 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2775         do_nodes $(comma_list $(mdts_nodes)) \
2776                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2777         mv $DIR1/$tfile-2 $DIR1/$tfile &
2778         PID1=$! ; pdo_sched
2779         rm $DIR2/$tfile &
2780         PID2=$! ; pdo_sched
2781         do_nodes $(comma_list $(mdts_nodes)) \
2782                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2783         check_pdo_conflict $PID1 && { wait $PID1; error "unlink isn't blocked"; }
2784         wait $PID2 ; [ $? -eq 0 ] || error "unlink must succeed"
2785         rm -rf $DIR/$tfile*
2786         return 0
2787 }
2788 run_test 44d "pdirops: rename tgt vs unlink =============="
2789
2790 test_44e() {
2791         pdo_lru_clear
2792         touch $DIR1/$tfile
2793         touch $DIR1/$tfile-2
2794         touch $DIR1/$tfile-3
2795 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2796         do_nodes $(comma_list $(mdts_nodes)) \
2797                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2798         mv $DIR1/$tfile-2 $DIR1/$tfile &
2799         PID1=$! ; pdo_sched
2800         mv $DIR2/$tfile-3 $DIR2/$tfile &
2801         PID2=$! ; pdo_sched
2802         do_nodes $(comma_list $(mdts_nodes)) \
2803                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2804         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2805         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2806         rm -rf $DIR/$tfile*
2807         return 0
2808 }
2809 run_test 44e "pdirops: rename tgt and rename (tgt) =============="
2810
2811 test_44f() {
2812         pdo_lru_clear
2813         touch $DIR1/$tfile-2
2814         touch $DIR1/$tfile-3
2815 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2816         do_nodes $(comma_list $(mdts_nodes)) \
2817                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2818         mv $DIR1/$tfile-2 $DIR1/$tfile &
2819         PID1=$! ; pdo_sched
2820         mv $DIR2/$tfile $DIR2/$tfile-3 &
2821         PID2=$! ; pdo_sched
2822         do_nodes $(comma_list $(mdts_nodes)) \
2823                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2824         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2825         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2826         rm -rf $DIR/$tfile*
2827         return 0
2828 }
2829 run_test 44f "pdirops: rename tgt and rename (src) =============="
2830
2831 test_44g() {
2832         pdo_lru_clear
2833         touch $DIR1/$tfile-2
2834 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2835         do_nodes $(comma_list $(mdts_nodes)) \
2836                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2837         mv $DIR1/$tfile-2 $DIR1/$tfile &
2838         PID1=$! ; pdo_sched
2839         stat $DIR2/$tfile > /dev/null &
2840         PID2=$! ; pdo_sched
2841         do_nodes $(comma_list $(mdts_nodes)) \
2842                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2843         check_pdo_conflict $PID1 && { wait $PID1; error "getattr isn't blocked"; }
2844         wait $PID2 ; [ $? -eq 0 ] || error "stat must succeed"
2845         rm -rf $DIR/$tfile*
2846         return 0
2847 }
2848 run_test 44g "pdirops: rename tgt vs getattr =============="
2849
2850 test_44h() {
2851         pdo_lru_clear
2852         touch $DIR1/$tfile-2
2853 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2    0x146
2854         do_nodes $(comma_list $(mdts_nodes)) \
2855                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2856         mv $DIR1/$tfile-2 $DIR1/$tfile &
2857         PID1=$! ; pdo_sched
2858         ls -lia $DIR2/ > /dev/null &
2859         PID2=$! ; pdo_sched
2860         do_nodes $(comma_list $(mdts_nodes)) \
2861                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2862         check_pdo_conflict $PID1 && { wait $PID1; error "readdir isn't blocked"; }
2863         wait $PID2
2864         rm -rf $DIR/$tfile*
2865         return 0
2866 }
2867 run_test 44h "pdirops: rename tgt vs readdir =============="
2868
2869 # test 44: rename tgt and blocking operations
2870 test_44i() {
2871         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2872         pdo_lru_clear
2873         touch $DIR1/$tfile-2
2874 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK2   0x146
2875         do_nodes $(comma_list $(mdts_nodes)) \
2876                 "lctl set_param -n fail_loc=0x80000146 2>/dev/null || true"
2877         mv $DIR1/$tfile-2 $DIR1/$tfile &
2878         PID1=$! ; pdo_sched
2879         $LFS mkdir -i 1 $DIR2/$tfile &
2880         PID2=$! ; pdo_sched
2881         do_nodes $(comma_list $(mdts_nodes)) \
2882                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2883         check_pdo_conflict $PID1 && { wait $PID1;
2884                                 error "remote mkdir isn't blocked"; }
2885         wait $PID2 ; [ $? -ne 0 ] || error "remote mkdir must fail"
2886         rm -rf $DIR/$tfile*
2887         return 0
2888 }
2889 run_test 44i "pdirops: rename tgt vs remote mkdir"
2890
2891 # test 45: rename,mkdir doesn't fail with -EEXIST
2892 test_45a() {
2893         for i in {1..1000}; do
2894                 mkdir $DIR1/$tdir || error "mkdir $tdir failed"
2895                 mrename $DIR2/$tdir $DIR2/$tdir.$i > /dev/null ||
2896                         error "mrename to $tdir.$i failed"
2897         done
2898         rm -rf $DIR/$tdir*
2899         return 0
2900 }
2901 run_test 45a "rename,mkdir doesn't return -EEXIST =============="
2902
2903 test_45b() {
2904         pdo_lru_clear
2905         touch $DIR1/$tfile
2906 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2907         do_nodes $(comma_list $(mdts_nodes)) \
2908                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2909         mv $DIR1/$tfile $DIR1/$tfile-2 &
2910         PID1=$! ; pdo_sched
2911         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c &
2912         PID2=$! ; pdo_sched
2913         do_nodes $(comma_list $(mdts_nodes)) \
2914                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2915         check_pdo_conflict $PID1 && { wait $PID1; error "create isn't blocked"; }
2916         wait $PID2 ; [ $? -eq 0 ] || error "create must succeed"
2917         rm -rf $DIR/$tfile*
2918         return 0
2919 }
2920 run_test 45b "pdirops: rename src vs create =============="
2921
2922 test_45c() {
2923         pdo_lru_clear
2924         touch $DIR1/$tfile
2925         touch $DIR1/$tfile-3
2926 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2927         do_nodes $(comma_list $(mdts_nodes)) \
2928                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2929         mv $DIR1/$tfile $DIR1/$tfile-2 &
2930         PID1=$! ; pdo_sched
2931         link $DIR2/$tfile-3 $DIR2/$tfile &
2932         PID2=$! ; pdo_sched
2933         do_nodes $(comma_list $(mdts_nodes)) \
2934                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2935         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
2936         wait $PID2 ; [ $? -eq 0 ] || error "link must succeed"
2937         rm -rf $DIR/$tfile*
2938         return 0
2939 }
2940 run_test 45c "pdirops: rename src vs link =============="
2941
2942 test_45d() {
2943         pdo_lru_clear
2944         touch $DIR1/$tfile
2945 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2946         do_nodes $(comma_list $(mdts_nodes)) \
2947                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2948         mv $DIR1/$tfile $DIR1/$tfile-2 &
2949         PID1=$! ; pdo_sched
2950         rm $DIR2/$tfile &
2951         PID2=$! ; pdo_sched
2952         do_nodes $(comma_list $(mdts_nodes)) \
2953                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2954         check_pdo_conflict $PID1 && { wait $PID1; error "unlink isn't blocked"; }
2955         wait $PID2 ; [ $? -ne 0 ] || error "unlink must fail"
2956         rm -rf $DIR/$tfile*
2957         return 0
2958 }
2959 run_test 45d "pdirops: rename src vs unlink =============="
2960
2961 test_45e() {
2962         pdo_lru_clear
2963         touch $DIR1/$tfile
2964         touch $DIR1/$tfile-3
2965 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2966         do_nodes $(comma_list $(mdts_nodes)) \
2967                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2968         mv $DIR1/$tfile $DIR1/$tfile-2 &
2969         PID1=$! ; pdo_sched
2970         mv $DIR2/$tfile-3 $DIR2/$tfile &
2971         PID2=$! ; pdo_sched
2972         do_nodes $(comma_list $(mdts_nodes)) \
2973                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2974         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2975         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
2976         rm -rf $DIR/$tfile*
2977         return 0
2978 }
2979 run_test 45e "pdirops: rename src and rename (tgt) =============="
2980
2981 test_45f() {
2982         pdo_lru_clear
2983         touch $DIR1/$tfile
2984 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
2985         do_nodes $(comma_list $(mdts_nodes)) \
2986                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
2987         mv $DIR1/$tfile $DIR1/$tfile-2 &
2988         PID1=$! ; pdo_sched
2989         mv $DIR2/$tfile $DIR2/$tfile-3 &
2990         PID2=$! ; pdo_sched
2991         do_nodes $(comma_list $(mdts_nodes)) \
2992                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
2993         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
2994         wait $PID2 ; [ $? -ne 0 ] || error "rename must fail"
2995         rm -rf $DIR/$tfile*
2996         return 0
2997 }
2998 run_test 45f "pdirops: rename src and rename (src) =============="
2999
3000 test_45g() {
3001         pdo_lru_clear
3002         touch $DIR1/$tfile
3003 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3004         do_nodes $(comma_list $(mdts_nodes)) \
3005                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3006         mv $DIR1/$tfile $DIR1/$tfile-2 &
3007         PID1=$! ; pdo_sched
3008         stat $DIR2/$tfile > /dev/null &
3009         PID2=$! ; pdo_sched
3010         do_nodes $(comma_list $(mdts_nodes)) \
3011                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3012         check_pdo_conflict $PID1 && { wait $PID1; error "getattr isn't blocked"; }
3013         wait $PID2 ; [ $? -ne 0 ] || error "stat must fail"
3014         rm -rf $DIR/$tfile*
3015         return 0
3016 }
3017 run_test 45g "pdirops: rename src vs getattr =============="
3018
3019 test_45h() {
3020         pdo_lru_clear
3021         touch $DIR1/$tfile
3022 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3023         do_nodes $(comma_list $(mdts_nodes)) \
3024                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3025         mv $DIR1/$tfile $DIR1/$tfile-2 &
3026         PID1=$! ; pdo_sched
3027         ls -lia $DIR2/ > /dev/null &
3028         do_nodes $(comma_list $(mdts_nodes)) \
3029                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3030         check_pdo_conflict $PID1 && { wait $PID1; error "readdir isn't blocked"; }
3031         wait $PID2
3032         rm -rf $DIR/$tfile*
3033         return 0
3034 }
3035 run_test 45h "pdirops: unlink vs readdir =============="
3036
3037 test_45i() {
3038         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
3039         pdo_lru_clear
3040         touch $DIR1/$tfile
3041 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3042         do_nodes $(comma_list $(mdts_nodes)) \
3043                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3044         mv $DIR1/$tfile $DIR1/$tfile-2 &
3045         PID1=$! ; pdo_sched
3046         $LFS mkdir -i 1 $DIR2/$tfile &
3047         PID2=$! ; pdo_sched
3048         do_nodes $(comma_list $(mdts_nodes)) \
3049                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3050         check_pdo_conflict $PID1 && { wait $PID1;
3051                                 error "create remote dir isn't blocked"; }
3052         wait $PID2 ; [ $? -eq 0 ] || error "create remote dir must succeed"
3053         rm -rf $DIR/$tfile*
3054         return 0
3055 }
3056 run_test 45i "pdirops: rename src vs remote mkdir"
3057
3058 sub_test_45j() {
3059         local PID1 PID2
3060         local fail_loc="$1"
3061         local ret=0
3062
3063         # We test in a sparate directory to be able to unblock server thread in
3064         # cfs_race if LCK_PW is taken on the parent by mdt_reint_rename.
3065         test_mkdir $DIR2/$tdir
3066         echo file1 > $DIR2/$tdir/$tfile
3067         echo file2 > $DIR2/$tdir/$tfile-2
3068         pdo_lru_clear
3069
3070         do_nodes $(comma_list $(mdts_nodes)) \
3071                 "lctl set_param -n fail_loc=${fail_loc} || true" &>/dev/null
3072
3073         cat $DIR1/$tdir/$tfile >/dev/null &
3074         PID1=$!
3075         pdo_sched
3076         mrename $DIR2/$tdir/$tfile-2 $DIR2/$tdir/$tfile > /dev/null &
3077         PID2=$!
3078
3079         wait $PID1 ||
3080                 { ret=$?; echo -n "cat $tfile should succeed (err=$ret); "; }
3081         wait $PID2 ||
3082                 { ret=$?; \
3083                 echo -n "mrename $tfile-2 to $tfile failed (err=$ret);"; }
3084
3085         #Clean
3086         do_nodes $(comma_list $(mdts_nodes)) \
3087                 "lctl set_param -n fail_loc=0x0 || true" &>/dev/null
3088         rm -rf $DIR/$tdir
3089
3090         return $ret
3091 }
3092
3093 test_45j() {
3094         (( $MDS1_VERSION >= $(version_code 2.13.56) )) ||
3095                 skip "Need MDS version newer than 2.13.56"
3096         local msg fail_loc
3097
3098 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_REINT_OPEN         0x169
3099 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_REINT_OPEN2        0x16a
3100         for fail_loc in "0x80000169" "0x8000016a"; do
3101                 echo "Begin 100 tests with fail_loc=$fail_loc"
3102                 printf "Progress: "
3103                 for i in {1..100}; do
3104                         printf "*"
3105                         msg=$(sub_test_45j "$fail_loc") ||
3106                                 { echo; error "iter=$i : $msg"; }
3107                 done
3108                 echo
3109         done
3110 }
3111 run_test 45j "read vs rename =============="
3112
3113 # test 46: link and blocking operations
3114 test_46a() {
3115         pdo_lru_clear
3116         touch $DIR1/$tfile-2
3117 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3118         do_nodes $(comma_list $(mdts_nodes)) \
3119                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3120         link $DIR1/$tfile-2 $DIR1/$tfile &
3121         PID1=$! ; pdo_sched
3122         mkdir $DIR2/$tfile &
3123         PID2=$! ; pdo_sched
3124         do_nodes $(comma_list $(mdts_nodes)) \
3125                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3126         check_pdo_conflict $PID1 && { wait $PID1; error "mkdir isn't blocked"; }
3127         wait $PID2 ; [ $? -ne 0 ] || error "mkdir must fail"
3128         rm -rf $DIR/$tfile*
3129         return 0
3130 }
3131 run_test 46a "pdirops: link vs mkdir =============="
3132
3133 test_46b() {
3134         pdo_lru_clear
3135         touch $DIR1/$tfile-2
3136 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3137         do_nodes $(comma_list $(mdts_nodes)) \
3138                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3139         link $DIR1/$tfile-2 $DIR1/$tfile &
3140         PID1=$! ; pdo_sched
3141         $MULTIOP $DIR2/$tfile oO_CREAT:O_EXCL:c &
3142         PID2=$! ; pdo_sched
3143         do_nodes $(comma_list $(mdts_nodes)) \
3144                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3145         check_pdo_conflict $PID1 && { wait $PID1; error "create isn't blocked"; }
3146         wait $PID2 ; [ $? -ne 0 ] || error "create must fail"
3147         rm -rf $DIR/$tfile*
3148         return 0
3149 }
3150 run_test 46b "pdirops: link vs create =============="
3151
3152 test_46c() {
3153         pdo_lru_clear
3154         touch $DIR1/$tfile-2
3155 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3156         do_nodes $(comma_list $(mdts_nodes)) \
3157                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3158         link $DIR1/$tfile-2 $DIR1/$tfile &
3159         PID1=$! ; pdo_sched
3160         link $DIR2/$tfile $DIR2/$tfile &
3161         PID2=$! ; pdo_sched
3162         do_nodes $(comma_list $(mdts_nodes)) \
3163                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3164         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
3165         wait $PID2 ; [ $? -ne 0 ] || error "link must fail"
3166         rm -rf $DIR/$tfile*
3167         return 0
3168 }
3169 run_test 46c "pdirops: link vs link =============="
3170
3171 test_46d() {
3172         pdo_lru_clear
3173         touch $DIR1/$tfile-2
3174 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3175         do_nodes $(comma_list $(mdts_nodes)) \
3176                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3177         link $DIR1/$tfile-2 $DIR1/$tfile &
3178         PID1=$! ; pdo_sched
3179         rm $DIR2/$tfile &
3180         PID2=$! ; pdo_sched
3181         do_nodes $(comma_list $(mdts_nodes)) \
3182                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3183         check_pdo_conflict $PID1 && { wait $PID1; error "unlink isn't blocked"; }
3184         wait $PID2 ; [ $? -eq 0 ] || error "unlink must succeed"
3185         rm -rf $DIR/$tfile*
3186         return 0
3187 }
3188 run_test 46d "pdirops: link vs unlink =============="
3189
3190 test_46e() {
3191         pdo_lru_clear
3192         touch $DIR1/$tfile-2
3193         touch $DIR1/$tfile-3
3194 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3195         do_nodes $(comma_list $(mdts_nodes)) \
3196                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3197         link $DIR1/$tfile-2 $DIR1/$tfile &
3198         PID1=$! ; pdo_sched
3199         mv $DIR2/$tfile-3 $DIR2/$tfile &
3200         PID2=$! ; pdo_sched
3201         do_nodes $(comma_list $(mdts_nodes)) \
3202                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3203         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
3204         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
3205         rm -rf $DIR/$tfile*
3206         return 0
3207 }
3208 run_test 46e "pdirops: link and rename (tgt) =============="
3209
3210 test_46f() {
3211         pdo_lru_clear
3212         touch $DIR1/$tfile-2
3213         touch $DIR1/$tfile-3
3214 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3215         do_nodes $(comma_list $(mdts_nodes)) \
3216                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3217         link $DIR1/$tfile-2 $DIR1/$tfile &
3218         PID1=$! ; pdo_sched
3219         mv $DIR2/$tfile $DIR2/$tfile-3 &
3220         PID2=$! ; pdo_sched
3221         do_nodes $(comma_list $(mdts_nodes)) \
3222                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3223         check_pdo_conflict $PID1 && { wait $PID1; error "rename isn't blocked"; }
3224         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
3225         rm -rf $DIR/$tfile*
3226         return 0
3227 }
3228 run_test 46f "pdirops: link and rename (src) =============="
3229
3230 test_46g() {
3231         pdo_lru_clear
3232         touch $DIR1/$tfile-2
3233 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3234         do_nodes $(comma_list $(mdts_nodes)) \
3235                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3236         link $DIR1/$tfile-2 $DIR1/$tfile &
3237         PID1=$! ; pdo_sched
3238         stat $DIR2/$tfile > /dev/null &
3239         PID2=$! ; pdo_sched
3240         do_nodes $(comma_list $(mdts_nodes)) \
3241                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3242         check_pdo_conflict $PID1 && { wait $PID1; error "getattr isn't blocked"; }
3243         wait $PID2 ; [ $? -eq 0 ] || error "stat must succeed"
3244         rm -rf $DIR/$tfile*
3245         return 0
3246 }
3247 run_test 46g "pdirops: link vs getattr =============="
3248
3249 test_46h() {
3250         pdo_lru_clear
3251         touch $DIR1/$tfile-2
3252 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3253         do_nodes $(comma_list $(mdts_nodes)) \
3254                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3255         link $DIR1/$tfile-2 $DIR1/$tfile &
3256         PID1=$! ; pdo_sched
3257         ls -lia $DIR2/ > /dev/null &
3258         PID2=$! ; pdo_sched
3259         do_nodes $(comma_list $(mdts_nodes)) \
3260                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3261         check_pdo_conflict $PID1 && { wait $PID1; error "readdir isn't blocked"; }
3262         wait $PID2
3263         rm -rf $DIR/$tfile*
3264         return 0
3265 }
3266 run_test 46h "pdirops: link vs readdir =============="
3267
3268 test_46i() {
3269         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
3270         pdo_lru_clear
3271         touch $DIR1/$tfile-2
3272 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3273         do_nodes $(comma_list $(mdts_nodes)) \
3274                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3275         link $DIR1/$tfile-2 $DIR1/$tfile &
3276         PID1=$! ; pdo_sched
3277         $LFS mkdir -i 1 $DIR2/$tfile &
3278         PID2=$! ; pdo_sched
3279         do_nodes $(comma_list $(mdts_nodes)) \
3280                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3281         check_pdo_conflict $PID1 && { wait $PID1;
3282                                 error "remote mkdir isn't blocked"; }
3283         wait $PID2 ; [ $? -ne 0 ] || error "remote mkdir must fail"
3284         rm -rf $DIR/$tfile*
3285         return 0
3286 }
3287 run_test 46i "pdirops: link vs remote mkdir"
3288
3289 # test 47: remote mkdir and blocking operations
3290 test_47a() {
3291 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3292         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
3293         pdo_lru_clear
3294         do_nodes $(comma_list $(mdts_nodes)) \
3295                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3296         $LFS mkdir -i 1 $DIR1/$tfile &
3297         PID1=$! ; pdo_sched
3298         mkdir $DIR2/$tfile &
3299         PID2=$! ; pdo_sched
3300         do_nodes $(comma_list $(mdts_nodes)) \
3301                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3302         check_pdo_conflict $PID1 && { wait $PID1; error "mkdir isn't blocked"; }
3303         wait $PID2 ; [ $? -ne 0 ] || error "mkdir must fail"
3304         rm -rf $DIR/$tfile*
3305         return 0
3306 }
3307 run_test 47a "pdirops: remote mkdir vs mkdir"
3308
3309 test_47b() {
3310 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3311         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
3312         pdo_lru_clear
3313         do_nodes $(comma_list $(mdts_nodes)) \
3314                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3315         $LFS mkdir -i 1 $DIR1/$tfile &
3316         PID1=$! ; pdo_sched
3317         sleep 1 # please do not remove this sleep, see LU-10754
3318         multiop $DIR2/$tfile oO_CREAT:O_EXCL:c &
3319         PID2=$! ; pdo_sched
3320         do_nodes $(comma_list $(mdts_nodes)) \
3321                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3322         check_pdo_conflict $PID1 && { wait $PID1;
3323                                         error "create isn't blocked"; }
3324         wait $PID2 ; [ $? -ne 0 ] || error "create must fail"
3325         rm -rf $DIR/$tfile*
3326         return 0
3327 }
3328 run_test 47b "pdirops: remote mkdir vs create"
3329
3330 test_47c() {
3331         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
3332         pdo_lru_clear
3333         touch $DIR1/$tfile-2
3334 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3335         do_nodes $(comma_list $(mdts_nodes)) \
3336                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3337         $LFS mkdir -i 1 $DIR1/$tfile &
3338         PID1=$! ; pdo_sched
3339         link $DIR2/$tfile-2 $DIR2/$tfile &
3340         PID2=$! ; pdo_sched
3341         do_nodes $(comma_list $(mdts_nodes)) \
3342                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3343         check_pdo_conflict $PID1 && { wait $PID1; error "link isn't blocked"; }
3344         wait $PID2 ; [ $? -ne 0 ] || error "link must fail"
3345         rm -rf $DIR/$tfile*
3346         return 0
3347 }
3348 run_test 47c "pdirops: remote mkdir vs link"
3349
3350 test_47d() {
3351         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
3352         pdo_lru_clear
3353 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3354         do_nodes $(comma_list $(mdts_nodes)) \
3355                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3356         $LFS mkdir -i 1 $DIR1/$tfile &
3357         PID1=$! ; pdo_sched
3358         rmdir $DIR2/$tfile &
3359         PID2=$! ; pdo_sched
3360         do_nodes $(comma_list $(mdts_nodes)) \
3361                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3362         check_pdo_conflict $PID1 && { wait $PID1;
3363                                         error "unlink isn't blocked"; }
3364         wait $PID2 ; [ $? -eq 0 ] || error "rmdir must succeed"
3365         rm -rf $DIR/$tfile*
3366         return 0
3367 }
3368 run_test 47d "pdirops: remote mkdir vs unlink"
3369
3370 test_47e() {
3371         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
3372         pdo_lru_clear
3373         touch $DIR1/$tfile-2
3374 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3375         do_nodes $(comma_list $(mdts_nodes)) \
3376                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3377         $LFS mkdir -i 1 $DIR1/$tfile &
3378         PID1=$! ; pdo_sched
3379         mv -T $DIR2/$tfile-2 $DIR2/$tfile &
3380         PID2=$! ; pdo_sched
3381         do_nodes $(comma_list $(mdts_nodes)) \
3382                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3383         check_pdo_conflict $PID1 && { wait $PID1;
3384                                         error "rename isn't blocked"; }
3385         wait $PID2 ; [ $? -ne 0 ] || error "rename must fail"
3386         rm -rf $DIR/$tfile*
3387         return 0
3388 }
3389 run_test 47e "pdirops: remote mkdir and rename (tgt)"
3390
3391 test_47f() {
3392         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
3393         pdo_lru_clear
3394 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3395         do_nodes $(comma_list $(mdts_nodes)) \
3396                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3397         $LFS mkdir -i 1 $DIR1/$tfile &
3398         PID1=$! ; pdo_sched
3399         mv $DIR2/$tfile $DIR2/$tfile-2 &
3400         PID2=$! ; pdo_sched
3401         do_nodes $(comma_list $(mdts_nodes)) \
3402                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3403         check_pdo_conflict $PID1 && { wait $PID1;
3404                                         error "rename isn't blocked"; }
3405         wait $PID2 ; [ $? -eq 0 ] || error "rename must succeed"
3406         rm -rf $DIR/$tfile*
3407         return 0
3408 }
3409 run_test 47f "pdirops: remote mkdir and rename (src)"
3410
3411 test_47g() {
3412         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
3413         sync
3414         sync_all_data
3415         pdo_lru_clear
3416 #define CFS_FAIL_ONCE|OBD_FAIL_MDS_PDO_LOCK    0x145
3417         do_nodes $(comma_list $(mdts_nodes)) \
3418                 "lctl set_param -n fail_loc=0x80000145 2>/dev/null || true"
3419         $LFS mkdir -i 1 $DIR1/$tfile &
3420         PID1=$! ; pdo_sched
3421         stat $DIR2/$tfile > /dev/null &
3422         PID2=$! ; pdo_sched
3423         do_nodes $(comma_list $(mdts_nodes)) \
3424                 "lctl set_param -n fail_loc=0 2>/dev/null || true"
3425         check_pdo_conflict $PID1 && { wait $PID1;
3426                                         error "getattr isn't blocked"; }
3427         wait $PID2 ; [ $? -eq 0 ] || error "stat must succeed"
3428         rm -rf $DIR/$tfile*
3429         return 0
3430 }
3431 run_test 47g "pdirops: remote mkdir vs getattr"
3432
3433 test_50() {
3434         trunc_size=4096
3435         dd if=/dev/zero of=$DIR1/$tfile bs=1K count=10
3436 #define OBD_FAIL_OSC_CP_ENQ_RACE         0x410
3437         do_facet client "lctl set_param fail_loc=0x410"
3438         $TRUNCATE $DIR2/$tfile $trunc_size
3439         do_facet client "lctl set_param fail_loc=0x0"
3440         sleep 3
3441         size=`stat -c %s $DIR2/$tfile`
3442         [ $size -eq $trunc_size ] || error "wrong size"
3443 }
3444 run_test 50 "osc lvb attrs: enqueue vs. CP AST =============="
3445
3446 test_51a() {
3447         local filesize
3448         local origfile=/etc/hosts
3449
3450         filesize=$(stat -c %s $origfile)
3451
3452         # create an empty file
3453         $MCREATE $DIR1/$tfile || error "can't create $DIR1/$tfile"
3454         # cache layout lock on both mount point
3455         stat $DIR1/$tfile > /dev/null || error "stat $DIR1/$tfile failed"
3456         stat $DIR2/$tfile > /dev/null || error "stat $DIR2/$tfile failed"
3457
3458         # open and sleep 2 seconds then read
3459         $MULTIOP $DIR2/$tfile o_2r${filesize}c &
3460         local pid=$!
3461         sleep 1
3462
3463         # create the layout of testing file
3464         dd if=$origfile of=$DIR1/$tfile conv=notrunc > /dev/null ||
3465                 error "dd $DIR1/$tfile failed"
3466
3467         # MULTIOP proc should be able to read enough bytes and exit
3468         for ((i = 0; i < 6; i++)); do
3469                 sleep 1
3470                 kill -0 $pid || break
3471         done
3472         kill -0 $pid 2> /dev/null && error "multiop is still there"
3473         cmp $origfile $DIR2/$tfile || error "$origfile and $DIR2/$tfile differs"
3474
3475         rm -f $DIR1/$tfile
3476 }
3477 run_test 51a "layout lock: refresh layout should work"
3478
3479 test_51b() {
3480         (( $MDS1_VERSION >= $(version_code 2.3.59) )) ||
3481                 skip "Need MDS version at least 2.3.59"
3482
3483         local tmpfile=`mktemp`
3484
3485         $LFS setstripe -E 1m -S 1M -c 1 -E -1 -c 1 $DIR1/$tfile ||
3486                 error "Create $DIR1/$tfile failed"
3487
3488         dd if=/dev/zero of=$DIR1/$tfile bs=1k count=1 conv=notrunc ||
3489                 error "dd $DIR1/$tfile failed"
3490
3491         # delay glimpse so that layout has changed when glimpse finish
3492 #define OBD_FAIL_GLIMPSE_DELAY 0x1404
3493         $LCTL set_param fail_loc=0x1404 fail_val=4
3494         stat -c %s $DIR2/$tfile |tee $tmpfile &
3495         local pid=$!
3496         sleep 0.2
3497
3498         # extend layout of testing file
3499         dd if=/dev/zero of=$DIR1/$tfile bs=1M count=1 seek=2 conv=notrunc ||
3500                 error "dd $DIR1/$tfile failed"
3501
3502         wait $pid
3503         local fsize=$(cat $tmpfile)
3504
3505         [ x$fsize = x3145728 ] || error "file size is $fsize, should be 3145728"
3506
3507         rm -f $DIR1/$tfile $tmpfile
3508 }
3509 run_test 51b "layout lock: glimpse should be able to restart if layout changed"
3510
3511 test_51c() {
3512         [ $OSTCOUNT -ge 2 ] || { skip "needs >= 2 osts"; return; }
3513
3514         # set default layout to have 1 stripe
3515         mkdir $DIR1/$tdir
3516         $LFS setstripe -c 1 $DIR1/$tdir
3517
3518         # create a file with empty layout
3519         $MCREATE $DIR1/$tdir/$tfile ||
3520                 error "$MCREATE $DIR1/$tdir/$tfile failed"
3521
3522 #define OBD_FAIL_MDS_LL_BLOCK 0x172
3523         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x172
3524
3525         # change the layout of testing file
3526         echo "Setting layout to have $OSTCOUNT stripes ..."
3527         $LFS setstripe -c $OSTCOUNT $DIR1/$tdir/$tfile &
3528         pid=$!
3529         sleep 1
3530
3531         # write something to the file, it should be blocked on fetching layout
3532         dd if=/dev/zero of=$DIR2/$tdir/$tfile bs=1k count=1 conv=notrunc
3533         local stripe_count=$($LFS getstripe -c $DIR2/$tdir/$tfile)
3534         wait $pid
3535
3536         # lod_qos.c::min_stripe_count() allows setstripe with a default stripe
3537         # count to succeed with only 3/4 of the number of stripes (rounded up),
3538         # so creating striped files does not fail if an OST is offline or full
3539         [ $stripe_count -ge $((OSTCOUNT - $OSTCOUNT / 4)) ] ||
3540                 error "bad layout: getstripe -c $stripe_count < $OSTCOUNT * 3/4"
3541
3542         rm -fr $DIR1/$tdir
3543 }
3544 run_test 51c "layout lock: IT_LAYOUT blocked and correct layout can be returned"
3545
3546 test_51d() {
3547         dd if=/dev/zero of=/$DIR1/$tfile bs=1M count=1
3548         cancel_lru_locks mdc
3549
3550         # open should grant LAYOUT lock, mmap and read will install pages
3551         $MULTIOP $DIR1/$tfile oO_RDWR:SMR_Uc &
3552         local PID=$!
3553         sleep 1
3554
3555         # rss before revoking
3556         local br=$(grep -A 10 $tfile /proc/$PID/smaps | awk '/^Rss/{print $2}')
3557         echo "Before revoking layout lock: $br KB mapped"
3558
3559         # cancel layout lock manually
3560         cancel_lru_locks mdc
3561
3562         # rss after revoking
3563         local ar=$(grep -A 10 $tfile /proc/$PID/smaps | awk '/^Rss/{print $2}')
3564
3565         kill -USR1 $PID
3566         wait $PID || error "wait PID $PID failed"
3567
3568         [ $ar -eq 0 ] || error "rss before: $br, after $ar, some pages remained"
3569 }
3570 run_test 51d "layout lock: losing layout lock should clean up memory map region"
3571
3572 test_51e() {
3573         (( $MDS1_VERSION >= $(version_code 2.13.54.148) )) ||
3574                 skip "MDS version must be at least 2.13.54.148"
3575
3576         local pid
3577
3578         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:eW_E+eUc &
3579         pid=$!
3580         sleep 1
3581
3582         $LFS getstripe $DIR2/$tfile
3583         kill -USR1 $pid
3584         wait $pid || error "multiop failed"
3585
3586         $MULTIOP $DIR/$tfile oO_RDONLY:eR_E+eUc &
3587         pid=$!
3588         sleep 1
3589
3590         $LFS getstripe $DIR2/$tfile
3591         kill -USR1 $pid
3592         wait $pid || error "multiop failed"
3593 }
3594 run_test 51e "lfs getstripe does not break leases, part 2"
3595
3596 test_54_part1()
3597 {
3598         echo "==> rename vs getattr vs setxattr should not deadlock"
3599         mkdir -p $DIR/d1/d2/d3 || error "(1) mkdir failed"
3600
3601         do_facet mds1 $LCTL set_param fail_loc=$1
3602
3603         mv -T $DIR/d1/d2/d3 $DIR/d1/d3 &
3604         PID1=$!
3605         sleep 1
3606
3607         stat $DIR/d1/d2 &
3608         PID2=$!
3609         sleep 1
3610
3611         setfattr -n user.attr1 -v value1 $DIR2/d1 || error "(2) setfattr failed"
3612         wait $PID1 || error "(3) mv failed"
3613         wait $PID2 || error "(4) stat failed"
3614         echo
3615
3616         rm -rf $DIR/d1
3617 }
3618
3619 test_54_part2() {
3620         echo "==> rename vs getattr vs open vs getattr should not deadlock"
3621         mkdir -p $DIR/d1/d2/d3 || error "(1) mkdir failed"
3622
3623         do_facet mds1 $LCTL set_param fail_loc=$1
3624
3625         mv -T $DIR/d1/d2/d3 $DIR/d1/d3 &
3626         PID1=$!
3627         sleep 1
3628
3629         stat $DIR/d1/d2 &
3630         PID2=$!
3631         sleep 1
3632
3633         $MULTIOP $DIR2/d1/d2 Oc &
3634         PID3=$!
3635         sleep 1
3636
3637         stat $DIR/d1 || error "(2) stat failed"
3638
3639         wait $PID1 || error "(3) mv failed"
3640         wait $PID2 || error "(4) stat failed"
3641         wait $PID3 && error "(5) multiop failed"
3642         echo
3643         rm -rf $DIR/d1
3644 }
3645
3646 test_54() {
3647         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
3648         save_lustre_params client "llite.*.xattr_cache" > $p
3649         lctl set_param llite.*.xattr_cache 1 ||
3650                 { skip "xattr cache is not supported"; return 0; }
3651
3652 #define OBD_FAIL_MDS_RENAME              0x153
3653 #define OBD_FAIL_MDS_RENAME2             0x154
3654         test_54_part1 0x80000153 || error 10
3655         test_54_part1 0x80000154 || error 11
3656         test_54_part2 0x80000153 || error 12
3657         test_54_part2 0x80000154 || error 13
3658
3659         restore_lustre_params < $p
3660         rm -f $p
3661 }
3662 run_test 54 "rename locking"
3663
3664 test_55a() {
3665         mkdir_on_mdt0 $DIR/$tdir
3666         mkdir -p $DIR/$tdir/d1/d2 $DIR/$tdir/d3 || error "(1) mkdir failed"
3667
3668 #define OBD_FAIL_MDS_RENAME4              0x156
3669         do_facet mds1 $LCTL set_param fail_loc=0x80000156
3670
3671         mv -T $DIR/$tdir/d1/d2 $DIR/$tdir/d3/d2 &
3672         PID1=$!
3673         sleep 1
3674
3675         rm -r $DIR2/$tdir/d3
3676         wait $PID1 && error "(2) mv succeeded"
3677
3678         rm -rf $DIR/$tdir
3679 }
3680 run_test 55a "rename vs unlink target dir"
3681
3682 test_55b()
3683 {
3684         mkdir_on_mdt0 $DIR/$tdir
3685         mkdir -p $DIR/$tdir/d1/d2 $DIR/$tdir/d3 || error "(1) mkdir failed"
3686
3687 #define OBD_FAIL_MDS_RENAME4             0x156
3688         do_facet mds1 $LCTL set_param fail_loc=0x80000156
3689
3690         mv -T $DIR/$tdir/d1/d2 $DIR/$tdir/d3/d2 &
3691         PID1=$!
3692         sleep 1
3693
3694         rm -r $DIR2/$tdir/d1
3695         wait $PID1 && error "(2) mv succeeded"
3696
3697         rm -rf $DIR/$tdir
3698 }
3699 run_test 55b "rename vs unlink source dir"
3700
3701 test_55c()
3702 {
3703         mkdir_on_mdt0 $DIR/$tdir
3704         mkdir -p $DIR/$tdir/d1/d2 $DIR/$tdir/d3 || error "(1) mkdir failed"
3705
3706 #define OBD_FAIL_MDS_RENAME4              0x156
3707         do_facet mds1 $LCTL set_param fail_loc=0x156
3708
3709         mv -T $DIR/$tdir/d1/d2 $DIR/$tdir/d3/d2 &
3710         PID1=$!
3711         sleep 1
3712
3713         # while rename is sleeping, open and remove d3
3714         $MULTIOP $DIR2/$tdir/d3 D_c &
3715         PID2=$!
3716         sleep 1
3717         rm -rf $DIR2/$tdir/d3
3718         sleep 5
3719
3720         # while rename is sleeping 2nd time, close d3
3721         kill -USR1 $PID2
3722         wait $PID2 || error "(3) multiop failed"
3723
3724         wait $PID1 && error "(2) mv succeeded"
3725
3726         rm -rf $DIR/$tdir
3727 }
3728 run_test 55c "rename vs unlink orphan target dir"
3729
3730 test_55d()
3731 {
3732         mkdir_on_mdt0 $DIR/$tdir
3733
3734         touch $DIR/$tdir/f1
3735
3736 #define OBD_FAIL_MDS_RENAME3              0x155
3737         do_facet mds1 $LCTL set_param fail_loc=0x155
3738         mv $DIR/$tdir/f1 $DIR/$tdir/$tdir &
3739         PID1=$!
3740         sleep 2
3741
3742         # while rename is sleeping, create $tdir, but as a directory
3743         mkdir -p $DIR2/$tdir/$tdir || error "(1) mkdir failed"
3744
3745         # link in reverse locking order
3746         ln $DIR2/$tdir/f1 $DIR2/$tdir/$tdir/f1 || error "(2) ln failed"
3747
3748         ! wait $PID1 || error "(3) mv succeeded"
3749         rm -rf $DIR/$tdir
3750 }
3751 run_test 55d "rename file vs link"
3752
3753 test_56a() {
3754         $LFS setstripe -c 1 $MOUNT/$tfile || error "creating $MOUNT/$tfile"
3755         stack_trap "rm -f $MOUNT/$tfile"
3756         echo "run_llverdev $MOUNT/$tfile -p -s $((16000000)) -c 4k"
3757         run_llverdev $MOUNT/$tfile -p -s $((16000000)) -c 4k ||
3758                 error "llverdev failed with rc=$?"
3759 }
3760 run_test 56a "test llverdev with single large stripe"
3761
3762 test_56b() {
3763         $LFS setstripe -C 2000 $MOUNT/$tfile || error "creating $MOUNT/$tfile"
3764         stack_trap "rm -f $MOUNT/$tfile"
3765         echo "run_llverdev $MOUNT/$tfile -p -s $((16000000 * OSTCOUNT)) -c 4k"
3766         run_llverdev $MOUNT/$tfile -p -s $((16000000 * OSTCOUNT)) -c 4k ||
3767                 error "llverdev failed with rc=$?"
3768 }
3769 run_test 56b "test llverdev and partial verify of wide stripe file"
3770
3771 test_60() {
3772         [ $MDS1_VERSION -lt $(version_code 2.3.0) ] &&
3773                 skip "MDS version must be >= 2.3.0"
3774
3775         # Create a file
3776         test_mkdir $DIR1/$tdir
3777         file1=$DIR1/$tdir/file
3778         file2=$DIR2/$tdir/file
3779
3780         echo orig > $file2 || error "Could not create $file2"
3781         version=$($LFS data_version $file1)
3782
3783         # Append data
3784         echo append >> $file2 || error "Could not append to $file2"
3785         version2=$($LFS data_version $file1)
3786         [ "$version" != "$version2" ] ||
3787             error "append did not change data version: $version"
3788
3789         # Overwrite data
3790         echo overwrite > $file2 || error "Could not overwrite $file2"
3791         version3=$($LFS data_version $file1)
3792         [ "$version2" != "$version3" ] ||
3793             error "overwrite did not change data version: $version2"
3794
3795         # Truncate before EOF
3796         $TRUNCATE $file2 3 || error "Could not truncate $file2"
3797         version4=$($LFS data_version $file1)
3798         [ "$version3" != "$version4" ] ||
3799             error "truncate did not change data version: $version3"
3800
3801         # Truncate after EOF
3802         $TRUNCATE $file2 123456 || error "Could not truncate $file2"
3803         version5=$($LFS data_version $file1)
3804         [ "$version4" != "$version5" ] ||
3805             error "truncate did not change data version: $version4"
3806
3807         # Chmod do not change version
3808         chmod 400 $file2 || error "Could not chmod 400 $file2"
3809         version6=$($LFS data_version $file1)
3810         [ "$version5" == "$version6" ] ||
3811             error "chmod should not change data version: $version5 != $version6"
3812
3813         # Chown do not change version
3814         chown $RUNAS_ID $file2 || error "Could not chown $RUNAS_ID $file2"
3815         version7=$($LFS data_version $file1)
3816         [ "$version5" == "$version7" ] ||
3817             error "chown should not change data version: $version5 != $version7"
3818 }
3819 run_test 60 "Verify data_version behaviour"
3820
3821 test_70a() {
3822         local test_dir=$tdir/test_dir
3823
3824         mkdir -p $DIR1/$tdir
3825         if [ $MDSCOUNT -ge 2 ]; then
3826                 local MDTIDX=1
3827                 $LFS mkdir -i $MDTIDX $DIR1/$test_dir ||
3828                         error "Create remote directory failed"
3829         else
3830                 mkdir -p $DIR1/$test_dir
3831         fi
3832         cd $DIR2/$test_dir || error "cd directory failed"
3833         rm -rf $DIR1/$test_dir || error "unlink directory failed"
3834
3835         cd $DIR2/$tdir || error "exit directory"
3836 }
3837 run_test 70a "cd directory && rm directory"
3838
3839 test_70b() { # LU-2781
3840         local i
3841         mkdir -p $DIR1/$tdir
3842
3843         touch $DIR1/$tdir/file
3844         for ((i = 0; i < 32; i++)); do
3845             $LFS rm_entry $DIR1/$tdir/non_existent_dir &>/dev/null
3846         done
3847         rm $DIR1/$tdir/file || error "cannot remove file after rm_entry"
3848
3849         touch $DIR1/$tdir/file
3850         $LFS mkdir -i0 $DIR1/$tdir/test_dir
3851         $LFS rm_entry $DIR1/$tdir/test_dir &>/dev/null
3852         rm -rf $DIR1/$tdir/test_dir ||
3853                 error "cannot remove directory after rm_entry"
3854         rm $DIR1/$tdir/file || error "cannot remove file after rm_entry"
3855 }
3856 run_test 70b "remove files after calling rm_entry"
3857
3858 test_71a() {
3859         [[ "$MDS1_VERSION" -lt $(version_code 2.1.6) ]] &&
3860                 skip "Need MDS version at least 2.1.6"
3861
3862         # Patch not applied to 2.2 and 2.3 branches
3863         [[ "$MDS1_VERSION" -ge $(version_code 2.2.0) ]] &&
3864         [[ "$MDS1_VERSION" -lt $(version_code 2.4.0) ]] &&
3865                 skip "Need MDS version earlier than 2.2.0 or at least 2.4.0"
3866
3867         checkfiemap --test ||
3868                 skip "checkfiemap not runnable: $?"
3869         # write data this way: hole - data - hole - data
3870         dd if=/dev/urandom of=$DIR1/$tfile bs=64K seek=1 count=1
3871         [ "$(facet_fstype ost$(($($LFS getstripe -i $DIR1/$tfile) + 1)))" = \
3872                 "zfs" ] &&
3873                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS" && return 0
3874         dd if=/dev/urandom of=$DIR1/$tfile bs=64K seek=3 count=1
3875         GET_STAT="lctl get_param -n ldlm.services.ldlm_cbd.stats"
3876         stat $DIR2/$tfile
3877         local can1=$($GET_STAT | awk '/ldlm_bl_callback/ {print $2}')
3878         echo $can1
3879         checkfiemap $DIR2/$tfile 131072 ||
3880                 error "data is not flushed from client"
3881         local can2=$($GET_STAT | awk '/ldlm_bl_callback/ {print $2}')
3882         echo $can2
3883
3884         # common case of "create file, copy file" on a single node
3885         # should not flush data from ost
3886         dd if=/dev/urandom of=$DIR1/$tfile bs=64K seek=1 count=1
3887         dd if=/dev/urandom of=$DIR1/$tfile bs=64K seek=3 count=1
3888         stat $DIR1/$tfile
3889         local can3=$($GET_STAT | awk '/ldlm_bl_callback/ {print $2}')
3890         echo $can3
3891         checkfiemap $DIR1/$tfile 131072 ||
3892         error 4
3893         local can4=$($GET_STAT | awk '/ldlm_bl_callback/ {print $2}')
3894         echo $can2
3895         [ $can3 -eq $can4 ] || error $((can2-can1)) "cancel RPC occured."
3896 }
3897 run_test 71a "correct file map just after write operation is finished"
3898
3899 test_71b() {
3900         [[ "$MDS1_VERSION" -lt $(version_code 2.1.6) ]] &&
3901                 skip "Need MDS version at least 2.1.6"
3902
3903         # Patch not applied to 2.2 and 2.3 branches
3904         [[ "$MDS1_VERSION" -ge $(version_code 2.2.0) ]] &&
3905         [[ "$MDS1_VERSION" -lt $(version_code 2.4.0) ]] &&
3906                 skip "Need MDS version earlier than 2.2.0 or at least 2.4.0"
3907         [[ $OSTCOUNT -ge 2 ]] || skip "needs >= 2 OSTs"
3908
3909         checkfiemap --test ||
3910                 skip "error $?: checkfiemap failed"
3911
3912         mkdir -p $DIR1/$tdir
3913
3914         $LFS setstripe -c -1 $DIR1/$tdir || error "setstripe failed"
3915         dd if=/dev/urandom of=$DIR1/$tdir/$tfile bs=64K count=1
3916         [ "$(facet_fstype ost$(($($LFS getstripe -i $DIR1/$tdir/$tfile) + 1)))" = \
3917                 "zfs" ] &&
3918                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS" && return 0
3919         checkfiemap $DIR1/$tdir/$tfile 65536 || error "checkfiemap failed"
3920 }
3921 run_test 71b "check fiemap support for stripecount > 1"
3922
3923 _check_last_flag_with_filefrag()
3924 {
3925         local file=$1
3926         local count=$2
3927         local i
3928         local offset
3929
3930         echo "check last flag for file with $count extents"
3931         rm -f $file
3932         for ((i=0; i<$count; i++)); do
3933                 offset=$((i * 256))
3934                 dd if=/dev/zero of=$file bs=4K count=1 seek=$offset 2> /dev/null
3935         done
3936
3937         filefrag -s -v $file | grep "last" ||
3938                 error "test file with $i extents failed"
3939
3940         rm -f $file
3941 }
3942
3943 test_71c() {
3944         local file="$DIR1/$tdir/$tfile"
3945
3946         (( $CLIENT_VERSION >= $(version_code 2.15.57) )) ||
3947                 skip "Need client version >= 2.15.57"
3948         [ $(facet_fstype ost1) = "ldiskfs" ] ||
3949                 skip "support only ldiskfs ost"
3950         filefrag -V | grep wc ||
3951                 skip "need whamcloud version of e2fsprogs"
3952
3953         mkdir -p $DIR1/$tdir
3954
3955         # filefrag uses u64[2028] buffer to fetch fiemap. The number of extents
3956         # in the buffer is (8 * 2048 - 32) / 56 = 292. Test file with 291, 292
3957         # and 293 extents
3958         _check_last_flag_with_filefrag $file 291
3959         _check_last_flag_with_filefrag $file 292
3960         _check_last_flag_with_filefrag $file 293
3961 }
3962 run_test 71c "check FIEMAP_EXTENT_LAST flag with different extents number"
3963
3964 test_71d() { #LU-17110
3965         checkfiemap --test ||
3966                 skip "error $?: checkfiemap failed"
3967
3968         local f=$DIR/$tfile
3969
3970         # write data this way: hole - data - hole - data
3971         dd if=/dev/urandom of=$f bs=64K count=1
3972         [[ "$(facet_fstype ost$(($($LFS getstripe -i $f) + 1)))" != "zfs" ]] ||
3973                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS"
3974         dd if=/dev/urandom of=$f bs=64K seek=2 count=1
3975         dd if=/dev/urandom of=$f bs=64K seek=4 count=1
3976         dd if=/dev/urandom of=$f bs=64K seek=6 count=1 conv=fsync
3977         echo "disk usage: $(du -B1 $f)"
3978         echo "file size: $(du -b $f)"
3979
3980         checkfiemap --corruption_test $f $((4 * 64 *1024)) ||
3981                 error "checkfiemap failed"
3982 }
3983 run_test 71d "fiemap corruption test with fm_extent_count=0"
3984
3985 test_72() {
3986         local p="$TMP/sanityN-$TESTNAME.parameters"
3987         local tlink1
3988         local tlink2
3989         save_lustre_params client "llite.*.xattr_cache" > $p
3990         lctl set_param llite.*.xattr_cache 1 ||
3991                 { skip "xattr cache is not supported"; return 0; }
3992
3993         touch $DIR1/$tfile
3994         setfattr -n user.attr1 -v value1 $DIR1/$tfile ||
3995                 error "setfattr1 failed"
3996         getfattr -n user.attr1 $DIR2/$tfile | grep value1 ||
3997                 error "getfattr1 failed"
3998         setfattr -n user.attr1 -v value2 $DIR2/$tfile ||
3999                 error "setfattr2 failed"
4000         getfattr -n user.attr1 $DIR1/$tfile | grep value2 ||
4001                 error "getfattr2 failed"
4002
4003         # check that trusted.link is consistent
4004         tlink1=$(getfattr -n trusted.link $DIR1/$tfile | md5sum)
4005         ln $DIR2/$tfile $DIR2/$tfile-2 || error "failed to link"
4006         tlink2=$(getfattr -n trusted.link $DIR1/$tfile | md5sum)
4007         echo "$tlink1 $tlink2"
4008         [ "$tlink1" = "$tlink2" ] && error "trusted.link should have changed!"
4009
4010         rm -f $DIR2/$tfile
4011
4012         restore_lustre_params < $p
4013         rm -f $p
4014 }
4015 run_test 72 "getxattr/setxattr cache should be consistent between nodes"
4016
4017 test_73() {
4018         local p="$TMP/sanityN-$TESTNAME.parameters"
4019         save_lustre_params client "llite.*.xattr_cache" > $p
4020         lctl set_param llite.*.xattr_cache 1 ||
4021                 { skip "xattr cache is not supported"; return 0; }
4022
4023         touch $DIR1/$tfile
4024         setfattr -n user.attr1 -v value1 $DIR1/$tfile ||
4025                 error "setfattr1 failed"
4026         getfattr -n user.attr1 $DIR2/$tfile || error "getfattr1 failed"
4027         getfattr -n user.attr1 $DIR1/$tfile || error "getfattr2 failed"
4028         clear_stats llite.*.stats
4029         # PR lock should be cached by now on both clients
4030         getfattr -n user.attr1 $DIR1/$tfile || error "getfattr3 failed"
4031         # 2 hits for getfattr(0)+getfattr(size)
4032         [ $(calc_stats llite.*.stats getxattr_hits) -eq 2 ] ||
4033                 error "not cached in $DIR1"
4034         getfattr -n user.attr1 $DIR2/$tfile || error "getfattr4 failed"
4035         # 4 hits for more getfattr(0)+getfattr(size)
4036         [ $(calc_stats llite.*.stats getxattr_hits) -eq 4 ] ||
4037                 error "not cached in $DIR2"
4038         rm -f $DIR2/$tfile
4039
4040         restore_lustre_params < $p
4041         rm -f $p
4042 }
4043 run_test 73 "getxattr should not cause xattr lock cancellation"
4044
4045 test_74() {
4046         [ "$MDS1_VERSION" -lt $(version_code 2.4.93) ] &&
4047                 skip "Need MDS version at least 2.4.93"
4048
4049         dd if=/dev/zero of=$DIR1/$tfile-1 bs=1K count=1
4050         dd if=/dev/zero of=$DIR1/$tfile-2 bs=1K count=1
4051         flocks_test 4 $DIR1/$tfile-1 $DIR2/$tfile-2
4052 }
4053 run_test 74 "flock deadlock: different mounts =============="
4054
4055 # LU-3889
4056 test_75() {
4057         $LFS setstripe -c 2 -S 1m -i 0 $DIR1/$tfile
4058         dd if=/dev/zero of=$DIR1/$tfile bs=1M count=2
4059         cancel_lru_locks osc
4060
4061         dd of=$DIR1/$tfile if=/dev/zero bs=1M count=1 seek=1 conv=notrunc
4062         sync
4063
4064         # define OBD_FAIL_LDLM_ENQUEUE_HANG 0x31d
4065         $LCTL set_param fail_loc=0x31d
4066         stat -c %s $DIR1/$tfile &
4067         local pid=$!
4068         sleep 1
4069         kill -9 $pid
4070
4071         # For bad lock error handler we should ASSERT and got kernel panic here
4072         sleep 4
4073         $LCTL set_param fail_loc=0
4074 }
4075 run_test 75 "osc: upcall after unuse lock==================="
4076
4077 test_76() { #LU-946
4078         [[ "$MDS1_VERSION" -lt $(version_code 2.5.53) ]] &&
4079                 skip "Need MDS version at least 2.5.53"
4080
4081         remote_mds_nodsh && skip "remote MDS with nodsh"
4082         local fcount=$((MDSCOUNT * 256))
4083         declare -a fd_list
4084         declare -a fid_list
4085
4086         if remote_mds; then
4087                 nid=$($LCTL list_nids | sed  "s/\./\\\./g")
4088         else
4089                 nid="0@lo"
4090         fi
4091
4092         rm -rf $DIR/$tdir
4093         test_mkdir $DIR/$tdir
4094
4095         # drop all open locks and close any cached "open" files on the client
4096         cancel_lru_locks mdc
4097
4098         local open_fids_cmd="$LCTL get_param -n mdt.*.exports.'$nid'.open_files"
4099         local fid_list=($(do_nodes $(comma_list $(mdts_nodes)) $open_fids_cmd))
4100         local already=${#fid_list[@]}
4101         for (( i = 0; i < $already; i++ )) ; do
4102                 log "already open[$i]: $($LFS fid2path $DIR2 ${fid_list[i]})"
4103         done
4104
4105         echo -n "opening files: "
4106         ulimit -n $((fcount + 50))
4107         for ((i = 0; i < $fcount; i++)); do
4108                 touch $DIR/$tdir/f_$i
4109                 local fd=$(free_fd ${fd_list[i]})
4110                 local open_cmd="exec $fd<$DIR/$tdir/f_$i"
4111                 eval $open_cmd
4112
4113                 fd_list[i]=$fd
4114
4115                 (( $i % 32 == 0 )) && echo -n "."
4116         done
4117         echo
4118
4119         fid_list=($(do_nodes $(comma_list $(mdts_nodes)) $open_fids_cmd))
4120
4121         # Possible errors in openfiles FID list.
4122         # 1. Missing FIDs. Check 1
4123         # 2. Extra FIDs. Check 1
4124         # 3. Duplicated FID. Check 2
4125         # 4. Invalid FIDs. Check 2
4126         # 5. Valid FID, points to some other file. Check 3
4127
4128         # Check 1
4129         [ ${#fid_list[@]} -ne $((fcount + already)) ] &&
4130                 error "${#fid_list[@]} != $fcount (+$already old) open files"
4131
4132         echo -n "closing files: "
4133         for (( fd = 0, fid = 0; fd < $fcount; fd++, fid++ )) ; do
4134                 local close_cmd="exec ${fd_list[fd]}<&-"
4135                 eval $close_cmd
4136                 filename=$($LFS fid2path $DIR2 ${fid_list[fid]})
4137
4138                 while [[ ! "$filename" =~ "$DIR2/$tdir/f_" ]]; do
4139                         echo "skip old open file $filename"
4140                         ((fid++))
4141                         filename=$($LFS fid2path $DIR2 ${fid_list[fid]})
4142                 done
4143
4144                 # Check 2
4145                 rm --interactive=no $filename
4146                 [ $? -ne 0 ] &&
4147                         error "Nonexisting fid ${fid_list[fid]} listed."
4148                 (( $fd % 32 == 0 )) && echo -n "."
4149         done
4150         echo
4151
4152         # Check 3
4153         ls_op=$(ls $DIR2/$tdir | wc -l)
4154         [ $ls_op -ne 0 ] &&
4155                 error "Some openfiles are missing in lproc output"
4156
4157         rm -rf $DIR/$tdir
4158 }
4159 run_test 76 "Verify MDT open_files listing"
4160
4161 nrs_write_read() {
4162         local n=16
4163         local dir=$DIR/$tdir
4164         local myRUNAS="$1"
4165         local create_as="$2"
4166
4167         mkdir $dir || error "mkdir $dir failed"
4168         $LFS setstripe -c $OSTCOUNT $dir || error "setstripe to $dir failed"
4169         chmod 777 $dir
4170
4171         if [[ -n "$create_as" ]]; then
4172                 do_nodes $CLIENTS $create_as "touch $dir/nrs_r_\$HOSTNAME;" ||
4173                         error "touch failed for $dir/nrs_r_*"
4174                 do_nodes $CLIENTS $create_as touch "$dir/nrs_w_\$HOSTNAME" ||
4175                         error "touch failed for $dir/nrs_w_*"
4176                 do_nodes $CLIENTS $create_as "chmod 777 $dir/nrs_*_\$HOSTNAME;" ||
4177                         error "chmod failed for $dir/nrs_*"
4178         fi
4179
4180         do_nodes $CLIENTS $myRUNAS \
4181                 dd if=/dev/zero of="$dir/nrs_r_\$HOSTNAME" bs=1M count=$n ||
4182                 error "dd at 0 on client failed (1)"
4183
4184         do_nodes $CLIENTS $myRUNAS \
4185                 "declare -a pids_w;
4186                 for ((i = 0; i < $n; i++)); do
4187                         dd if=/dev/zero of=$dir/nrs_w_\$HOSTNAME bs=1M \
4188 seek=\\\$i count=1 conv=notrunc &
4189                         pids_w[\\\$i]=\\\$!;
4190                 done;
4191                 rc_w=0;
4192                 for ((i = 0; i < $n; i++)); do
4193                         wait \\\${pids_w[\\\$i]};
4194                         newrc=\\\$?;
4195                         [ \\\$newrc -gt \\\$rc_w ] && rc_w=\\\$newrc;
4196                 done;
4197                 exit \\\$rc_w" &
4198         local pid_w=$!
4199         do_nodes $CLIENTS sync;
4200         cancel_lru_locks osc
4201
4202         do_nodes $CLIENTS $myRUNAS \
4203                 "declare -a pids_r;
4204                 for ((i = 0; i < $n; i++)); do
4205                         dd if=$dir/nrs_r_\$HOSTNAME bs=1M of=/dev/null \
4206 seek=\\\$i count=1 &
4207                         pids_r[\\\$i]=\\\$!;
4208                 done;
4209                 rc_r=0;
4210                 for ((i = 0; i < $n; i++)); do
4211                         wait \\\${pids_r[\\\$i]};
4212                         newrc=\\\$?;
4213                         [ \\\$newrc -gt \\\$rc_r ] && rc_r=\\\$newrc;
4214                 done;
4215                 exit \\\$rc_r" &
4216         local pid_r=$!
4217         cancel_lru_locks osc
4218
4219         wait $pid_w || error "dd (write) failed (2)"
4220         wait $pid_r || error "dd (read) failed (3)"
4221         rm -rvf $dir || error "rm -rf $dir failed"
4222 }
4223
4224 test_77a() { #LU-3266
4225         local rc
4226
4227         oss=$(comma_list $(osts_nodes))
4228         do_nodes $oss lctl set_param ost.OSS.*.nrs_policies="fifo" ||
4229                 rc=$?
4230         [[ $rc -eq 3 ]] && skip "no NRS exists" && return
4231         [[ $rc -ne 0 ]] && error "failed to set fifo policy"
4232         nrs_write_read
4233
4234         return 0
4235 }
4236 run_test 77a "check FIFO NRS policy"
4237
4238 test_77b() { #LU-3266
4239         local rc
4240
4241         oss=$(comma_list $(osts_nodes))
4242
4243         do_nodes $oss lctl set_param ost.OSS.*.nrs_policies="crrn" \
4244                 ost.OSS.*.nrs_crrn_quantum=1 || rc=$?
4245         [[ $rc -eq 3 ]] && skip "no NRS exists" && return
4246         [[ $rc -ne 0 ]] && error "failed to set crrn_quantum to 1"
4247
4248         echo "policy: crr-n, crrn_quantum 1"
4249         nrs_write_read
4250
4251         do_nodes $oss lctl set_param \
4252                 ost.OSS.*.nrs_crrn_quantum=64 || rc=$?
4253         [[ $rc -ne 0 ]] && error "failed to set crrn_quantum to 64"
4254
4255         echo "policy: crr-n, crrn_quantum 64"
4256         nrs_write_read
4257
4258         # cleanup
4259         do_nodes $oss lctl set_param \
4260                 ost.OSS.ost_io.nrs_policies="fifo" || rc=$?
4261         [[ $rc -ne 0 ]] && error "failed to set fifo policy"
4262         return 0
4263 }
4264 run_test 77b "check CRR-N NRS policy"
4265
4266 orr_trr() {
4267         local policy=$1
4268
4269         oss=$(comma_list $(osts_nodes))
4270
4271         do_nodes $oss lctl set_param ost.OSS.ost_io.nrs_policies=$policy \
4272                 ost.OSS.*.nrs_"$policy"_quantum=1 \
4273                 ost.OSS.*.nrs_"$policy"_offset_type="physical" \
4274                 ost.OSS.*.nrs_"$policy"_supported="reads" || return $?
4275
4276         echo "policy: $policy, ${policy}_quantum 1, ${policy}_offset_type " \
4277                 "physical, ${policy}_supported reads"
4278         nrs_write_read
4279
4280         do_nodes $oss lctl set_param \
4281                 ost.OSS.*.nrs_${policy}_supported="writes" \
4282                 ost.OSS.*.nrs_${policy}_quantum=64 || return $?
4283
4284         echo "policy: $policy, ${policy}_quantum 64, ${policy}_offset_type " \
4285                 "physical, ${policy}_supported writes"
4286         nrs_write_read
4287
4288         do_nodes $oss lctl set_param \
4289                 ost.OSS.*.nrs_${policy}_supported="reads_and_writes" \
4290                 ost.OSS.*.nrs_${policy}_offset_type="logical" || return $?
4291         echo "policy: $policy, ${policy}_quantum 64, ${policy}_offset_type " \
4292                 "logical, ${policy}_supported reads_and_writes"
4293         nrs_write_read
4294
4295         # cleanup
4296         do_nodes $oss lctl set_param ost.OSS.ost_io.nrs_policies="fifo" ||
4297                 return $?
4298         return 0
4299 }
4300
4301 test_77c() { #LU-3266
4302         local rc
4303         orr_trr "orr" || rc=$?
4304         [[ $rc -eq 3 ]] && skip "no NRS exists" && return
4305         [[ $rc -ne 0 ]] && error "orr_trr failed rc:$rc"
4306         return 0
4307 }
4308 run_test 77c "check ORR NRS policy"
4309
4310 test_77d() { #LU-3266
4311         local rc
4312         orr_trr "trr" || rc=$?
4313         [[ $rc -eq 3 ]] && skip "no NRS exists" && return
4314         [[ $rc -ne 0 ]] && error "orr_trr failed rc:$rc"
4315         return 0
4316 }
4317 run_test 77d "check TRR nrs policy"
4318
4319 tbf_rule_operate()
4320 {
4321         local facet=$1
4322         shift 1
4323
4324         do_facet $facet lctl set_param \
4325                 ost.OSS.ost_io.nrs_tbf_rule="$*"
4326         [ $? -ne 0 ] &&
4327                 error "failed to run operate '$*' on TBF rules"
4328 }
4329
4330 cleanup_tbf_verify()
4331 {
4332         local rc=0
4333         trap 0
4334         echo "cleanup_tbf $DIR/$tdir"
4335         rm -rf $DIR/$tdir
4336         rc=$?
4337         wait_delete_completed
4338         return $rc
4339 }
4340
4341 tbf_verify() {
4342         local dir=$DIR/$tdir
4343         local client1=${CLIENT1:-$(hostname)}
4344         local myRUNAS="$3"
4345         local create_as="$4"
4346
4347         local np=$(check_cpt_number ost1)
4348         [ $np -gt 0 ] || error "CPU partitions should not be $np."
4349         echo "cpu_npartitions on ost1 is $np"
4350
4351         mkdir $dir || error "mkdir $dir failed"
4352         $LFS setstripe -c 1 -i 0 $dir || error "setstripe to $dir failed"
4353         chmod 777 $dir
4354
4355         if [[ -n "$create_as" ]]; then
4356                 $create_as touch $dir/tbf
4357                 chmod 777 $dir/tbf
4358         fi
4359
4360         trap cleanup_tbf_verify EXIT
4361         echo "Limited write rate: $1, read rate: $2"
4362         echo "Verify the write rate is under TBF control"
4363         local start=$SECONDS
4364         do_node $client1 $myRUNAS dd if=/dev/zero of=$dir/tbf \
4365                 bs=1M count=100 oflag=direct 2>&1
4366         local runtime=$((SECONDS - start + 1))
4367         local rate=$(bc <<< "scale=6; 100 / $runtime")
4368         echo "Write runtime is $runtime s, speed is $rate IOPS"
4369
4370         # verify the write rate does not exceed TBF rate limit
4371         [ $(bc <<< "$rate < 1.1 * $np * $1") -eq 1 ] ||
4372                 error "The write rate ($rate) exceeds 110% of rate limit ($1 * $np)"
4373
4374         cancel_lru_locks osc
4375
4376         echo "Verify the read rate is under TBF control"
4377         start=$SECONDS
4378         do_node $client1 $myRUNAS dd if=$dir/tbf of=/dev/null \
4379                 bs=1M count=100 iflag=direct 2>&1
4380         runtime=$((SECONDS - start + 1))
4381         rate=$(bc <<< "scale=6; 100 / $runtime")
4382         echo "Read runtime is $runtime s, speed is $rate IOPS"
4383
4384         # verify the read rate does not exceed TBF rate limit
4385         [ $(bc <<< "$rate < 1.1 * $np * $2") -eq 1 ] ||
4386                 error "The read rate ($rate) exceeds 110% of rate limit ($2 * $np)"
4387
4388         cancel_lru_locks osc
4389         cleanup_tbf_verify || error "rm -rf $dir failed"
4390 }
4391
4392 test_77e() {
4393         local rc
4394
4395         oss=$(comma_list $(osts_nodes))
4396
4397         do_nodes $oss lctl set_param ost.OSS.ost_io.nrs_policies="tbf\ nid" ||
4398                 rc=$?
4399         [[ $rc -eq 3 ]] && skip "no NRS TBF exists" && return
4400         [[ $rc -ne 0 ]] && error "failed to set TBF NID policy"
4401
4402         local idis
4403         local rateis
4404         if [ "$OST1_VERSION" -ge $(version_code 2.8.54) ]; then
4405                 idis="nid="
4406                 rateis="rate="
4407         fi
4408
4409         # Only operate rules on ost1 since OSTs might run on the same OSS
4410         # Add some rules
4411         tbf_rule_operate ost1 "start\ localhost\ ${idis}{0@lo}\ ${rateis}1000"
4412         local address=$(comma_list "$(host_nids_address $CLIENTS $NETTYPE)")
4413         local client_nids=$(nids_list $address "\\")
4414         tbf_rule_operate ost1 "start\ clients\ ${idis}{$client_nids}\ ${rateis}100"
4415         tbf_rule_operate ost1 "start\ others\ ${idis}{*.*.*.*@$NETTYPE}\ ${rateis}50"
4416         nrs_write_read
4417
4418         # Change the rules
4419         tbf_rule_operate ost1 "change\ localhost\ ${rateis}1001"
4420         tbf_rule_operate ost1 "change\ clients\ ${rateis}101"
4421         tbf_rule_operate ost1 "change\ others\ ${rateis}51"
4422         nrs_write_read
4423
4424         # Stop the rules
4425         tbf_rule_operate ost1 "stop\ localhost"
4426         tbf_rule_operate ost1 "stop\ clients"
4427         tbf_rule_operate ost1 "stop\ others"
4428         nrs_write_read
4429
4430         # Cleanup the TBF policy
4431         do_nodes $oss lctl set_param ost.OSS.ost_io.nrs_policies="fifo"
4432         [ $? -ne 0 ] && error "failed to set policy back to fifo"
4433         nrs_write_read
4434         return 0
4435 }
4436 run_test 77e "check TBF NID nrs policy"
4437
4438 test_77f() {
4439         local rc
4440
4441         oss=$(comma_list $(osts_nodes))
4442
4443         do_nodes $oss $LCTL set_param \
4444                 ost.OSS.ost_io.nrs_policies="tbf\ jobid" || rc=$?
4445         [[ $rc -eq 3 ]] && skip "no NRS TBF exists" && return
4446         [[ $rc -ne 0 ]] && error "failed to set TBF JOBID policy"
4447
4448         # Configure jobid_var
4449         local saved_jobid_var=$($LCTL get_param -n jobid_var)
4450         rc=$?
4451         [[ $rc -eq 3 ]] && skip "jobid_var not found" && return
4452         [[ $rc -ne 0 ]] && error "failed to get param jobid_var"
4453         if [ $saved_jobid_var != procname_uid ]; then
4454                 set_persistent_param_and_check client \
4455                         "jobid_var" "$FSNAME.sys.jobid_var" procname_uid
4456         fi
4457
4458         local idis
4459         local rateis
4460         if [ "$OST1_VERSION" -ge $(version_code 2.8.54) ]; then
4461                 idis="jobid="
4462                 rateis="rate="
4463         fi
4464
4465         # Only operate rules on ost1 since OSTs might run on the same OSS
4466         # Add some rules
4467         tbf_rule_operate ost1 "start\ runas\ ${idis}{iozone.$RUNAS_ID\ dd.$RUNAS_ID\ tiotest.$RUNAS_ID}\ ${rateis}1000"
4468         tbf_rule_operate ost1 "start\ iozone_runas\ ${idis}{iozone.$RUNAS_ID}\ ${rateis}100"
4469         tbf_rule_operate ost1 "start\ dd_runas\ ${idis}{dd.$RUNAS_ID}\ ${rateis}50"
4470         nrs_write_read "$RUNAS"
4471
4472         # Change the rules
4473         tbf_rule_operate ost1 "change\ runas\ ${rateis}1001"
4474         tbf_rule_operate ost1 "change\ iozone_runas\ ${rateis}101"
4475         tbf_rule_operate ost1 "change\ dd_runas\ ${rateis}51"
4476         nrs_write_read "$RUNAS"
4477
4478         # Stop the rules
4479         tbf_rule_operate ost1 "stop\ runas"
4480         tbf_rule_operate ost1 "stop\ iozone_runas"
4481         tbf_rule_operate ost1 "stop\ dd_runas"
4482         nrs_write_read "$RUNAS"
4483
4484         # Cleanup the TBF policy
4485         do_nodes $oss lctl set_param ost.OSS.ost_io.nrs_policies="fifo"
4486         [ $? -ne 0 ] && error "failed to set policy back to fifo"
4487         nrs_write_read "$RUNAS"
4488
4489         local current_jobid_var=$($LCTL get_param -n jobid_var)
4490         [[ $? -ne 0 ]] && error "failed to get param jobid_var"
4491         if [ $saved_jobid_var != $current_jobid_var ]; then
4492                 set_persistent_param_and_check client \
4493                         "jobid_var" "$FSNAME.sys.jobid_var" $saved_jobid_var
4494         fi
4495         return 0
4496 }
4497 run_test 77f "check TBF JobID nrs policy"
4498
4499 test_77g() {
4500         local rc=0
4501
4502         oss=$(comma_list $(osts_nodes))
4503
4504         do_nodes $oss lctl set_param ost.OSS.ost_io.nrs_policies="tbf\ nid" ||
4505                 rc=$?
4506         [[ $rc -eq 3 ]] && skip "no NRS TBF exists" && return
4507         [[ $rc -ne 0 ]] && error "failed to set TBF NID policy"
4508
4509         do_nodes $oss lctl set_param \
4510                 ost.OSS.ost_io.nrs_policies="tbf\ jobid" || rc=$?
4511         [[ $rc -ne 0 ]] && error "failed to set TBF JOBID policy"
4512
4513         local idis
4514         local rateis
4515         if [ "$OST1_VERSION" -ge $(version_code 2.8.54) ]; then
4516                 idis="jobid="
4517                 rateis="rate="
4518         fi
4519
4520         # Add a rule that only valid for Jobid TBF. If direct change between
4521         # TBF types is not supported, this operation will fail.
4522         tbf_rule_operate ost1 "start\ dd_runas\ ${idis}{dd.$RUNAS_ID}\ ${rateis}50"
4523
4524         # Cleanup the TBF policy
4525         do_nodes $oss lctl set_param ost.OSS.ost_io.nrs_policies="fifo"
4526         [ $? -ne 0 ] && error "failed to set policy back to fifo"
4527         return 0
4528 }
4529 run_test 77g "Change TBF type directly"
4530
4531 test_77h() {
4532         [ "$OST1_VERSION" -ge $(version_code 2.8.55) ] ||
4533                 skip "Need OST version at least 2.8.55"
4534
4535         local old_policy=$(do_facet ost1 \
4536                 lctl get_param ost.OSS.ost_io.nrs_policies)
4537         local new_policy
4538
4539         do_facet ost1 lctl set_param \
4540                 ost.OSS.ost_io.nrs_policies="abc"
4541         [ $? -eq 0 ] && error "should return error"
4542
4543         do_facet ost1 lctl set_param \
4544                 ost.OSS.ost_io.nrs_policies="tbf\ abc"
4545         [ $? -eq 0 ] && error "should return error"
4546
4547         do_facet ost1 lctl set_param \
4548                 ost.OSS.ost_io.nrs_policies="tbf\ reg\ abc"
4549         [ $? -eq 0 ] && error "should return error"
4550
4551         do_facet ost1 lctl set_param \
4552                 ost.OSS.ost_io.nrs_policies="tbf\ abc\ efg"
4553         [ $? -eq 0 ] && error "should return error"
4554
4555         new_policy=$(do_facet ost1 lctl get_param ost.OSS.ost_io.nrs_policies)
4556         [ $? -eq 0 ] || error "shouldn't LBUG"
4557
4558         [ "$old_policy" = "$new_policy" ] || error "NRS policy should be same"
4559
4560         return 0
4561 }
4562 run_test 77h "Wrong policy name should report error, not LBUG"
4563
4564 tbf_rule_check()
4565 {
4566         local facet=$1
4567         local expected=$2
4568         local error_message=$3
4569         local rule_number=0
4570         for rule in $expected; do
4571                 rule_number=$((rule_number + 1))
4572         done
4573         local stop_line=$(($rule_number + 3))
4574         local awk_command="awk 'NR >= 4 && NR <= $stop_line {print \$1}'"
4575
4576         local output=$(do_facet $facet lctl get_param \
4577                 ost.OSS.ost_io.nrs_tbf_rule |
4578                 eval $awk_command |
4579                 tr "\n" " " |
4580                 sed 's/[ ]*$//')
4581         if [ "$output" != "$expected" ]; then
4582                 error "$error_message, expected '$expected', got '$output'"
4583         fi
4584 }
4585
4586 test_77i() {
4587         [ "$OST1_VERSION" -ge $(version_code 2.8.55) ] ||
4588                 skip "Need OST version at least 2.8.55"
4589
4590         for i in $(seq 1 $OSTCOUNT)
4591         do
4592                 do_facet ost"$i" lctl set_param \
4593                         ost.OSS.ost_io.nrs_policies="tbf\ jobid"
4594                 [ $? -ne 0 ] &&
4595                         error "failed to set TBF policy"
4596         done
4597
4598         tbf_rule_check ost1 "default" "error before inserting any rule"
4599
4600         tbf_rule_operate ost1 "start\ before\ jobid={jobid}\ rate=1000"
4601         tbf_rule_check ost1 "before default" \
4602                 "error when inserting rule 'before'"
4603
4604         tbf_rule_operate ost1 "start\ after\ jobid={jobid}\ rate=1000\ rank=default"
4605         tbf_rule_check ost1 "before after default" \
4606                 "error when inserting rule 'after'"
4607
4608         tbf_rule_operate ost1 "start\ target\ jobid={jobid}\ rate=1000\ rank=after"
4609         tbf_rule_check ost1 "before target after default" \
4610                 "error when inserting rule 'target'"
4611
4612         echo "Move before itself"
4613         tbf_rule_operate ost1 "change\ target\ rank=target"
4614         tbf_rule_check ost1 "before target after default" \
4615                 "error when moving before itself"
4616
4617         echo "Move to higher rank"
4618         tbf_rule_operate ost1 "change\ target\ rank=before"
4619         tbf_rule_check ost1 "target before after default" \
4620                 "error when moving to higher rank"
4621
4622         echo "Move to lower rank"
4623         tbf_rule_operate ost1 "change\ target\ rank=after"
4624         tbf_rule_check ost1 "before target after default" \
4625                 "error when moving to lower rank"
4626
4627         echo "Move before default"
4628         tbf_rule_operate ost1 "change\ target\ rank=default"
4629         tbf_rule_check ost1 "before after target default" \
4630                 error "error when moving before default"
4631
4632         # Cleanup the TBF policy
4633         do_nodes $(comma_list $(osts_nodes)) \
4634                 $LCTL set_param ost.OSS.ost_io.nrs_policies=fifo
4635         return 0
4636 }
4637 run_test 77i "Change rank of TBF rule"
4638
4639 test_77j() {
4640         local idis
4641         local rateis
4642
4643         [ "$OST1_VERSION" -ge $(version_code 2.9.53) ] ||
4644                 skip "Need OST version at least 2.9.53"
4645         if [ "$OST1_VERSION" -ge $(version_code 2.8.60) ]; then
4646                 idis="opcode="
4647                 rateis="rate="
4648         fi
4649
4650         do_nodes $(comma_list $(osts_nodes)) \
4651                 lctl set_param jobid_var=procname_uid \
4652                         ost.OSS.ost_io.nrs_policies="tbf\ opcode" \
4653                         ost.OSS.ost_io.nrs_tbf_rule="start\ ost_r\ ${idis}{ost_read}\ ${rateis}5" \
4654                         ost.OSS.ost_io.nrs_tbf_rule="start\ ost_w\ ${idis}{ost_write}\ ${rateis}20"
4655         [ $? -ne 0 ] && error "failed to set TBF OPCode policy"
4656
4657         nrs_write_read
4658         tbf_verify 20 5
4659
4660         do_nodes $(comma_list $(osts_nodes)) \
4661                 lctl set_param ost.OSS.ost_io.nrs_tbf_rule="stop\ ost_r" \
4662                         ost.OSS.ost_io.nrs_tbf_rule="stop\ ost_w" \
4663                         ost.OSS.ost_io.nrs_policies="fifo"
4664
4665         # sleep 3 seconds to wait the tbf policy stop completely,
4666         # or the next test case is possible get -EAGAIN when
4667         # setting the tbf policy
4668         sleep 3
4669 }
4670 run_test 77j "check TBF-OPCode NRS policy"
4671
4672 test_id() {
4673         local idstr="${1}id"
4674         local policy="${idstr}={$2}"
4675         local rate="rate=$3"
4676         local runas_args="$4"
4677         local createas_args="${5:-$runas_args}"
4678
4679         do_nodes $(comma_list $(osts_nodes)) \
4680                 lctl set_param jobid_var=procname_uid \
4681                         ost.OSS.ost_io.nrs_policies="tbf\ ${idstr}" \
4682                         ost.OSS.ost_io.nrs_tbf_rule="start\ ost_${idstr}\ ${policy}\ ${rate}"
4683         [ $? -ne 0 ] && error "failed to set tbf ${idstr} policy"
4684
4685         nrs_write_read "runas $runas_args" "runas $createas_args"
4686         tbf_verify $3 $3 "runas $runas_args" "runas $createas_args"
4687
4688         do_nodes $(comma_list $(osts_nodes)) \
4689                 lctl set_param ost.OSS.ost_io.nrs_tbf_rule="stop\ ost_${idstr}" \
4690                         ost.OSS.ost_io.nrs_policies="fifo"
4691
4692         # sleep 3 seconds to wait the tbf policy stop completely,
4693         # or the next test case is possible get -eagain when
4694         # setting the tbf policy
4695         sleep 3
4696 }
4697
4698 test_77ja(){
4699         if [ "$OST1_VERSION" -lt $(version_code 2.11.50) ]; then
4700                 skip "Need OST version at least 2.11.50"
4701         fi
4702
4703         test_id "u" "$RUNAS_ID" "5" "-u $RUNAS_ID"
4704         test_id "g" "$RUNAS_GID" "5" "-u $RUNAS_ID -g $RUNAS_GID"
4705 }
4706 run_test 77ja "check TBF-UID/GID NRS policy"
4707
4708 test_77jb() { # LU-16077
4709         (( "$OST1_VERSION" >= $(version_code 2.15.51) )) ||
4710                 skip "Need OST version at least 2.15.51"
4711
4712         test_id "u" "$RUNAS_ID" "5" "-u $RUNAS_ID" "-u 0 -g $RUNAS_GID"
4713         test_id "g" "$RUNAS_GID" "5" "-u $RUNAS_ID -g $RUNAS_GID" "-u $RUNAS_ID -g 0"
4714 }
4715 run_test 77jb "check TBF-UID/GID NRS policy on files that don't belong to us"
4716
4717 cleanup_77k()
4718 {
4719         local rule_lists=$1
4720         local old_nrs=$2
4721
4722         trap 0
4723         for rule in $rule_lists; do
4724                 do_nodes $(comma_list $(osts_nodes)) \
4725                         lctl set_param ost.OSS.ost_io.nrs_tbf_rule="stop\ $rule"
4726         done
4727
4728         do_nodes $(comma_list $(osts_nodes)) \
4729                 lctl set_param ost.OSS.ost_io.nrs_policies="$old_nrs"
4730
4731         sleep 3
4732 }
4733
4734 test_77k() {
4735         [[ "$OST1_VERSION" -ge $(version_code 2.9.53) ]] ||
4736                 skip "Need OST version at least 2.9.53"
4737
4738         do_nodes $(comma_list $(osts_nodes)) \
4739                 lctl set_param ost.OSS.ost_io.nrs_policies="tbf" \
4740                         ost.OSS.ost_io.nrs_tbf_rule="start\ ext_w\ jobid={dd.$RUNAS_ID}\&opcode={ost_write}\ rate=20" \
4741                         ost.OSS.ost_io.nrs_tbf_rule="start\ ext_r\ jobid={dd.$RUNAS_ID}\&opcode={ost_read}\ rate=10"
4742
4743         nrs_write_read "$RUNAS"
4744         tbf_verify 20 10 "$RUNAS"
4745
4746         local address=$(comma_list "$(host_nids_address $CLIENTS $NETTYPE)")
4747         local client_nids=$(nids_list $address "\\")
4748         do_nodes $(comma_list $(osts_nodes)) \
4749                 lctl set_param ost.OSS.ost_io.nrs_tbf_rule="stop\ ext_w" \
4750                         ost.OSS.ost_io.nrs_tbf_rule="stop\ ext_r" \
4751                         ost.OSS.ost_io.nrs_tbf_rule="start\ ext_w\ nid={0@lo\ $client_nids}\&opcode={ost_write}\ rate=20" \
4752                         ost.OSS.ost_io.nrs_tbf_rule="start\ ext_r\ nid={0@lo\ $client_nids}\&opcode={ost_read}\ rate=10"
4753
4754         nrs_write_read
4755         tbf_verify 20 10
4756
4757         do_nodes $(comma_list $(osts_nodes)) \
4758                 lctl set_param ost.OSS.ost_io.nrs_tbf_rule="stop\ ext_w" \
4759                         ost.OSS.ost_io.nrs_tbf_rule="stop\ ext_r" \
4760                         ost.OSS.ost_io.nrs_tbf_rule="start\ ext\ nid={0@lo\ $client_nids}\&jobid={dd.$RUNAS_ID}\ rate=20"
4761
4762         nrs_write_read "$RUNAS"
4763         tbf_verify 20 20 "$RUNAS"
4764
4765         do_nodes $(comma_list $(osts_nodes)) \
4766                 lctl set_param ost.OSS.ost_io.nrs_tbf_rule="stop\ ext" \
4767                         ost.OSS.ost_io.nrs_tbf_rule="start\ ext_a\ jobid={dd.$RUNAS_ID},opcode={ost_write}\ rate=20" \
4768                         ost.OSS.ost_io.nrs_tbf_rule="start\ ext_b\ jobid={dd.$RUNAS_ID},opcode={ost_read}\ rate=10"
4769
4770         nrs_write_read "$RUNAS"
4771         # with parameter "RUNAS", it will match the latest rule
4772         # "ext_b" first, so the limited write rate is 10.
4773         tbf_verify 10 10 "$RUNAS"
4774         tbf_verify 20 10
4775
4776         trap "cleanup_77k \"ext_a ext_b\" \"fifo\"" EXIT
4777
4778         [[ "$OST1_VERSION" -ge $(version_code 2.10.58) ]] ||
4779                 skip "Need OST version at least 2.10.58"
4780
4781         do_nodes $(comma_list $(osts_nodes)) \
4782                 lctl set_param ost.OSS.ost_io.nrs_tbf_rule="stop\ ext_a" \
4783                         ost.OSS.ost_io.nrs_tbf_rule="stop\ ext_b" \
4784                         ost.OSS.ost_io.nrs_tbf_rule="start\ ext_ug\ uid={$RUNAS_ID}\&gid={$RUNAS_GID}\ rate=5"
4785         nrs_write_read "runas -u $RUNAS_ID -g $RUNAS_GID"
4786         tbf_verify 5 5 "runas -u $RUNAS_ID -g $RUNAS_GID"
4787
4788         do_nodes $(comma_list $(osts_nodes)) \
4789                 lctl set_param ost.OSS.ost_io.nrs_tbf_rule="stop\ ext_ug" \
4790                         ost.OSS.ost_io.nrs_tbf_rule="start\ ext_uw\ uid={$RUNAS_ID}\&opcode={ost_write}\ rate=20" \
4791                         ost.OSS.ost_io.nrs_tbf_rule="start\ ext_ur\ uid={$RUNAS_ID}\&opcode={ost_read}\ rate=10"
4792
4793         nrs_write_read "runas -u $RUNAS_ID"
4794         tbf_verify 20 10 "runas -u $RUNAS_ID"
4795
4796         do_nodes $(comma_list $(osts_nodes)) \
4797                 lctl set_param ost.OSS.ost_io.nrs_tbf_rule="stop\ ext_uw" \
4798                         ost.OSS.ost_io.nrs_tbf_rule="stop\ ext_ur" \
4799                         ost.OSS.ost_io.nrs_tbf_rule="start\ ext_a\ uid={$RUNAS_ID},opcode={ost_write}\ rate=20" \
4800                         ost.OSS.ost_io.nrs_tbf_rule="start\ ext_b\ uid={$RUNAS_ID},opcode={ost_read}\ rate=10"
4801         nrs_write_read "runas -u $RUNAS_ID"
4802         tbf_verify 10 10 "runas -u $RUNAS_ID"
4803         tbf_verify 20 10 "runas -u $RUNAS_ID"
4804         cleanup_77k "ext_a ext_b" "fifo"
4805 }
4806 run_test 77k "check TBF policy with UID/GID/JobID/OPCode expression"
4807
4808 test_77l() {
4809         [[ "$OST1_VERSION" -ge $(version_code 2.10.56) ]] ||
4810                 skip "Need OST version at least 2.10.56"
4811
4812         do_facet ost1 lctl set_param ost.OSS.ost_io.nrs_policies="tbf\ nid"
4813         do_facet ost1 lctl set_param ost.OSS.ost_io.nrs_policies="tbf"
4814
4815         local output=$(do_facet ost1 lctl get_param \
4816                         ost.OSS.ost_io.nrs_policies | \
4817                         awk '/name: tbf/ {print;exit}' | \
4818                         awk -F ': ' '{print $2}')
4819
4820         if [ "$output" != "tbf" ]; then
4821                 error "The generic TBF output is '$output', not 'tbf'"
4822         fi
4823
4824         do_facet ost1 lctl set_param ost.OSS.ost_io.nrs_policies="fifo"
4825 }
4826 run_test 77l "check the output of NRS policies for generic TBF"
4827
4828 test_77m() {
4829         if [ "$OST1_VERSION" -lt $(version_code 2.9.54) ]; then
4830                 skip "Need OST version at least 2.9.54"
4831         fi
4832
4833         local dir=$DIR/$tdir
4834
4835         mkdir $dir || error "mkdir $dir failed"
4836         $LFS setstripe -c $OSTCOUNT $dir || error "setstripe to $dir failed"
4837         chmod 777 $dir
4838
4839         local nodes=$(comma_list $(osts_nodes))
4840         do_nodes $nodes lctl set_param ost.OSS.ost_io.nrs_policies=delay \
4841                                        ost.OSS.ost_io.nrs_delay_min=4 \
4842                                        ost.OSS.ost_io.nrs_delay_max=4 \
4843                                        ost.OSS.ost_io.nrs_delay_pct=100
4844         [ $? -ne 0 ] && error "Failed to set delay policy"
4845
4846         local start=$SECONDS
4847         do_nodes "${SINGLECLIENT:-$HOSTNAME}" "$RUNAS" \
4848                  dd if=/dev/zero of="$dir/nrs_delay_$HOSTNAME" bs=1M count=1 \
4849                    oflag=direct conv=fdatasync ||
4850                 { do_nodes $nodes lctl set_param ost.OSS.ost_io.nrs_policies="fifo";
4851                   error "dd on client failed (1)"; }
4852         local elapsed=$((SECONDS - start))
4853
4854         # NRS delay doesn't do sub-second timing, so a request enqueued at
4855         # 0.9 seconds can be dequeued at 4.0
4856         [ $elapsed -lt 3 ] &&
4857                 { do_nodes $nodes lctl set_param ost.OSS.ost_io.nrs_policies="fifo";
4858                   error "Single 1M write should take at least 3 seconds"; }
4859
4860         start=$SECONDS
4861         do_nodes "${SINGLECLIENT:-$HOSTNAME}" "$RUNAS" \
4862                  dd if=/dev/zero of="$dir/nrs_delay_$HOSTNAME" bs=1M count=10 \
4863                    oflag=direct conv=fdatasync ||
4864                 { do_nodes $nodes lctl set_param ost.OSS.ost_io.nrs_policies="fifo";
4865                   error "dd on client failed (2)"; }
4866         elapsed=$((SECONDS - start))
4867
4868         [ $elapsed -lt 30 ] &&
4869                 { do_nodes $nodes lctl set_param ost.OSS.ost_io.nrs_policies="fifo";
4870                   error "Ten 1M writes should take at least 30 seconds"; }
4871
4872         do_nodes $nodes lctl set_param ost.OSS.ost_io.nrs_policies="fifo"
4873         [ $? -ne 0 ] && error "failed to set policy back to fifo"
4874
4875         return 0
4876 }
4877 run_test 77m "check NRS Delay slows write RPC processing"
4878
4879 test_77n() { #LU-10802
4880         if [ "$OST1_VERSION" -lt $(version_code 2.10.58) ]; then
4881                 skip "Need OST version at least 2.10.58"
4882         fi
4883
4884         # Configure jobid_var
4885         local saved_jobid_var=$($LCTL get_param -n jobid_var)
4886         if [ $saved_jobid_var != procname_uid ]; then
4887                 set_persistent_param_and_check client \
4888                         "jobid_var" "$FSNAME.sys.jobid_var" procname_uid
4889         fi
4890
4891         do_nodes $(comma_list $(osts_nodes)) \
4892                 lctl set_param ost.OSS.ost_io.nrs_policies="tbf\ jobid" \
4893                         ost.OSS.ost_io.nrs_tbf_rule="stop\ dd_runas" \
4894                         ost.OSS.ost_io.nrs_tbf_rule="start\ dd_runas\ jobid={*.$RUNAS_ID}\ rate=20"
4895
4896         nrs_write_read
4897         tbf_verify 20 20 "$RUNAS"
4898
4899         do_nodes $(comma_list $(osts_nodes)) \
4900                 lctl set_param ost.OSS.ost_io.nrs_tbf_rule="stop\ dd_runas" \
4901                         ost.OSS.ost_io.nrs_tbf_rule="start\ dd_runas\ jobid={dd.*}\ rate=20"
4902
4903         nrs_write_read
4904         tbf_verify 20 20
4905
4906         do_nodes $(comma_list $(osts_nodes)) \
4907                 lctl set_param ost.OSS.ost_io.nrs_tbf_rule="stop\ dd_runas" \
4908                         ost.OSS.ost_io.nrs_policies="fifo"
4909
4910         sleep 3
4911
4912         local current_jobid_var=$($LCTL get_param -n jobid_var)
4913         if [ $saved_jobid_var != $current_jobid_var ]; then
4914                 set_persistent_param_and_check client \
4915                         "jobid_var" "$FSNAME.sys.jobid_var" $saved_jobid_var
4916         fi
4917 }
4918 run_test 77n "check wildcard support for TBF JobID NRS policy"
4919
4920 test_77o() {
4921         (( $OST1_VERSION > $(version_code 2.14.54) )) ||
4922                 skip "need OST > 2.14.54"
4923
4924         do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_policies="tbf\ nid"
4925         do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_tbf_rule="start\ name\ nid={192.168.*.*@tcp}\ rate=10000"
4926         do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_tbf_rule="start\ name1\ nid={192.168.*.*@tcp}\ rate=10000"
4927         do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_tbf_rule="change\ name1\ rank=name"
4928         do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_tbf_rule="stop\ name"
4929         do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_policies="fifo"
4930 }
4931 run_test 77o "Changing rank should not panic"
4932
4933 test_77q() {
4934         local i
4935         local gidlist="500 10 33   100 "
4936         local uidlist=" 500  11 3"
4937
4938         (( $MDS1_VERSION > $(version_code 2.14.54) )) ||
4939                 skip "need MDS >= 2.14.54"
4940
4941         do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_policies="tbf"
4942         stack_trap "do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_policies=fifo"
4943
4944         # require 44cc782/LU-9859 to support list with unexpected spaces
4945         (( MDS1_VERSION >= $(version_code 2.15.57) )) ||
4946                 gidlist=$(echo $gidlist) uidlist=$(echo $uidlist)
4947
4948         for i in {1..50}; do
4949                 local pid1 pid2
4950
4951                 do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_tbf_rule="'start rule77q_1 uid={$uidlist}&gid={$gidlist} rate=100'" &
4952                 pid1=$!
4953                 do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_tbf_rule="'start rule77q_2 uid={1000}&gid={1000} rate=100'" &
4954                 pid2=$!
4955                 wait $pid1 || error "$i: Fail to start TBF rule 'rule77q_1'"
4956                 wait $pid2 || error "$i: Fail to start TBF rule 'rule77q_2'"
4957
4958                 do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_tbf_rule="'stop rule77q_1'" &
4959                 pid1=$!
4960                 do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_tbf_rule="'stop rule77q_2'" &
4961                 pid2=$!
4962                 wait $pid1 || error "$i: Fail to stop TBF rule 'rule77q_1'"
4963                 wait $pid2 || error "$i: Fail to stop TBF rule 'rule77q_2'"
4964         done
4965 }
4966 run_test 77q "Parallel TBF rule definitions should not panic"
4967
4968 test_77p() {
4969         local c
4970         local -a spec_chars=(
4971                 '@' '.' '~' '#' '/' '^' '%' '*' ';' ',' '?' '<' '>' ':'
4972                 '+' '=' ')' '(' '{' '}' '|' '[' ']' '!' '&' '\$' '\`' '\\')
4973
4974         (( $MDS1_VERSION > $(version_code 2.14.54) )) ||
4975                 skip "need MDS >= 2.14.54"
4976
4977         do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_policies="tbf"
4978         stack_trap "do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_policies=fifo"
4979
4980         # TBF rule name size is 16 bytes
4981         do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_tbf_rule="start\ test_77p_overflo\ uid={500}\ rate=500" &&
4982                 error "The length of tbf rule name is not checked" || true
4983         do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_tbf_rule="start\ \ uid={500}\ rate=500" &&
4984                 error "The server should not accept empty tbf rule name" || true
4985         do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_tbf_rule="start\ test_77p_empty" &&
4986                 error "The server should not accept 'start <tbf_rule_name>' without an expression" || true
4987
4988         # Test with special chars
4989         for c in "${spec_chars[@]}"; do
4990                 do_facet mds1 $LCTL set_param mds.MDS.mdt.nrs_tbf_rule="'start test77p${c}spec uid={500} rate=500'" &&
4991                 error "Special char '${c}' should not be accepted in a tbf rule name" || true
4992         done
4993
4994 }
4995 run_test 77p "Check validity of rule names for TBF policies"
4996
4997 cleanup_77r() {
4998         local pid=$1
4999         local saved_jobid=$2
5000         local current_jobid_var
5001
5002         echo "cleanup 77r $pid"
5003
5004         do_facet mds1 $LCTL set_param -n mds.MDS.mdt.nrs_policies=fifo
5005         kill $pid || echo "fail to kill md thread"
5006
5007         current_jobid_var=$($LCTL get_param -n jobid_var)
5008         if [ $saved_jobid != $current_jobid_var ]; then
5009                 set_persistent_param_and_check client \
5010                         "jobid_var" "$FSNAME.sys.jobid_var" $saved_jobid
5011         fi
5012
5013         sleep 2
5014         rm -rf $DIR1/$tdir
5015 }
5016
5017 md_thread_run="true"
5018 md_thread_77r() {
5019         local pid
5020
5021         while $md_thread_run; do
5022                 printf '%s\n' {$DIR1,$DIR2}/$tdir/${tfile}-{01..20} |
5023                         xargs -P20 -I{} $RUNAS bash -c 'touch {}; rm -f {}' \
5024                                 &> /dev/null & pid=$!
5025                 trap "echo kill md_thread xargs; md_thread_run=false; kill $pid" INT TERM
5026                 wait $pid
5027         done
5028 }
5029
5030 wait_policy_state() {
5031         local state="$1"
5032         local policy="$2"
5033         local change_pid="$3"
5034         local time
5035
5036         for time in {1..60}; do
5037                 local nbr_started
5038
5039                 nbr_started=$(do_facet mds1 $LCTL get_param mds.MDS.mdt.nrs_policies |
5040                         egrep -A2 "name: ${policy}$" | grep -c "state: $state")
5041
5042                 [[ "$nbr_started" != 2 ]] || return 0
5043                 sleep 1
5044         done
5045
5046         [[ -z "$change_pid" ]] || kill $change_pid || true
5047         return 1
5048 }
5049
5050 test_77r() { #LU-14976
5051
5052         (( MDS1_VERSION > $(version_code 2.15.56) )) ||
5053                 skip "need MDS >= 2.15.56 c098c095 change nrs policies at run time"
5054
5055         local pid
5056         local -A rules
5057         local -a policies
5058         local saved_jobid_var
5059
5060         rules["tbf uid"]="start md_rule uid={$RUNAS_ID} rate=1"
5061         rules["tbf gid"]="start md_rule gid={$RUNAS_GID} rate=1"
5062         rules["tbf jobid"]="start md_rule jobid={*.$RUNAS_ID} rate=1"
5063         rules["tbf"]="start md_rule uid={$RUNAS_ID} rate=1"
5064         policies=(
5065         "tbf uid"
5066         "tbf gid"
5067         "tbf jobid"
5068         "tbf"
5069         "fifo"
5070         )
5071
5072         test_mkdir -i 0 -c 1 $DIR1/$tdir
5073         chmod 777 $DIR1/$tdir
5074
5075         # Configure jobid_var
5076         saved_jobid_var=$($LCTL get_param -n jobid_var)
5077         if [ $saved_jobid_var != procname_uid ]; then
5078                 set_persistent_param_and_check client \
5079                         "jobid_var" "$FSNAME.sys.jobid_var" procname_uid
5080         fi
5081
5082         # start md thread
5083         md_thread_77r & pid=$!
5084         stack_trap "cleanup_77r $pid '$saved_jobid_var'"
5085
5086         local policy
5087         for policy in "${policies[@]}"; do
5088                 local change_pid
5089
5090                 # wait to queue requests
5091                 sleep 5
5092
5093                 do_facet mds1 "$LCTL set_param mds.MDS.mdt.nrs_policies='$policy'" &
5094                 change_pid=$!
5095
5096                 wait_policy_state "started" "$policy" "$change_pid" ||
5097                         error "timeout to start '$policy' policy"
5098
5099                 [[ -n "${rules[$policy]}" ]] || continue
5100
5101                 do_facet mds1 "$LCTL set_param mds.MDS.mdt.nrs_tbf_rule='${rules[$policy]}'" ||
5102                         error "fail to set rule '${rules[$policy]}' to '$policy'"
5103         done
5104
5105         wait_policy_state "stopped" "tbf" ||
5106                 error "fail to stop tbf policy"
5107
5108         echo "check the number of requests in queue:"
5109         local awkcmd='/name: / {last = $3} '
5110         awkcmd+='/queued: / {printf "    %s: %d\n", last, $2;'
5111         awkcmd+='       if (last == "tbf" && $2 > 0) exit 1;}'
5112         do_facet mds1 $LCTL get_param mds.MDS.mdt.nrs_policies | awk "$awkcmd" ||
5113                 error "request leak in tbf policies"
5114 }
5115 run_test 77r "Change type of tbf policy at run time"
5116
5117 test_78() { #LU-6673
5118         local rc
5119
5120         oss=$(comma_list $(osts_nodes))
5121         do_nodes $oss lctl set_param ost.OSS.ost_io.nrs_policies="orr" &
5122         do_nodes $oss lctl set_param ost.OSS.*.nrs_orr_quantum=1
5123         rc=$?
5124         [[ $rc -eq 3 ]] && skip "no NRS exists" && return
5125         # Valid return codes are:
5126         # 0: Tuning succeeded
5127         # ENODEV: Policy is still stopped
5128         # EAGAIN: Policy is being initialized
5129         [ $rc -eq 0 -o $rc -eq 19 -o $rc -eq 11 ] ||
5130                 error "Expected set_param to return 0|ENODEV|EAGAIN"
5131
5132         # Cleanup the ORR policy
5133         do_nodes $oss lctl set_param ost.OSS.ost_io.nrs_policies="fifo"
5134         [ $? -ne 0 ] && error "failed to set policy back to fifo"
5135         return 0
5136 }
5137 run_test 78 "Enable policy and specify tunings right away"
5138
5139 test_79() {
5140         remote_mds_nodsh && skip "remote MDS with nodsh" && return
5141         test_mkdir $DIR/$tdir
5142
5143         # Prevent interference from layout intent RPCs due to
5144         # asynchronous writeback. These will be tested in 130c below.
5145         do_nodes ${CLIENTS:-$HOSTNAME} sync
5146
5147         setfattr -n trusted.name1 -v value1 $DIR/$tdir ||
5148                 error "setfattr -n trusted.name1=value1 $DIR/$tdir failed"
5149
5150 #define OBD_FAIL_MDS_INTENT_DELAY               0x160
5151         local mdtidx=$($LFS getstripe -m $DIR/$tdir)
5152         local facet=mds$((mdtidx + 1))
5153         stat $DIR/$tdir
5154         set_nodes_failloc $(facet_active_host $facet) 0x80000160
5155         getfattr -n trusted.name1 $DIR/$tdir 2> /dev/null  &
5156         local pid=$!
5157         sleep 2
5158
5159 #define OBD_FAIL_MDS_GETXATTR_PACK       0x131
5160         set_nodes_failloc $(facet_active_host $facet) 0x80000131
5161
5162         wait $pid
5163         return 0
5164 }
5165 run_test 79 "xattr: intent error"
5166
5167 test_80a() {
5168         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
5169         local MDTIDX=1
5170         local mdt_index
5171         local i
5172         local file
5173         local pid
5174
5175         mkdir_on_mdt0 $DIR1/$tdir
5176         mkdir -p $DIR1/$tdir/dir
5177         createmany -o $DIR1/$tdir/dir/f 10 ||
5178                 error "create files under remote dir failed $i"
5179
5180         cp /etc/passwd $DIR1/$tdir/$tfile
5181
5182         #migrate open file should fails
5183         multiop_bg_pause $DIR2/$tdir/$tfile O_c || error "open $file failed"
5184         pid=$!
5185         # give multiop a chance to open
5186         sleep 1
5187
5188         $LFS migrate -m $MDTIDX $DIR1/$tdir &&
5189                 error "migrate open files should failed with open files"
5190
5191         kill -USR1 $pid
5192
5193         $LFS migrate -m $MDTIDX $DIR1/$tdir ||
5194                         error "migrate remote dir error"
5195
5196         echo "Finish migration, then checking.."
5197         for file in $(find $DIR1/$tdir); do
5198                 mdt_index=$($LFS getstripe -m $file)
5199                 [ $mdt_index == $MDTIDX ] ||
5200                         error "$file is not on MDT${MDTIDX}"
5201         done
5202
5203         diff /etc/passwd $DIR1/$tdir/$tfile ||
5204                 error "file different after migration"
5205
5206         rm -rf $DIR1/$tdir || error "rm dir failed after migration"
5207 }
5208 run_test 80a "migrate directory when some children is being opened"
5209
5210 cleanup_80b() {
5211         trap 0
5212         kill -9 $migrate_pid
5213 }
5214
5215 success_count=0
5216 failure_count=0
5217
5218 run_and_count()
5219 {
5220         eval $@ &>/dev/null && success_count=$((success_count + 1)) ||
5221                 failure_count=$((failure_count + 1))
5222 }
5223
5224 test_80b() {
5225         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
5226         local migdir1=$DIR1/$tdir/migrate_dir
5227         local migdir2=$DIR2/$tdir/migrate_dir
5228         local start_time
5229         local mdt_idx
5230         local rc=0
5231         local rc1=0
5232
5233         trap cleanup_80b EXIT
5234         # prepare migrate directory
5235         mkdir -p $migdir1
5236         for F in {1,2,3,4,5}; do
5237                 echo "$F$F$F$F$F" > $migdir1/file$F
5238                 echo "$F$F$F$F$F" > $DIR/$tdir/file$F
5239         done
5240
5241         # migrate the directories among MDTs
5242         (
5243                 while true; do
5244                         mdt_idx=$((RANDOM % MDSCOUNT))
5245                         # migrate may fail
5246                         $LFS migrate -m $mdt_idx $migdir1 &>/dev/null
5247                 done
5248         ) &
5249         migrate_pid=$!
5250
5251         echo "start migration thread $migrate_pid"
5252         # access the files at the same time
5253         start_time=$SECONDS
5254         echo "accessing the migrating directory for 1 minute..."
5255         while ((SECONDS - start_time < 60)); do
5256                 run_and_count ls $migdir2
5257                 run_and_count diff -u $DIR2/$tdir/file1 $migdir2/file1
5258                 run_and_count "cat $migdir2/file2 > $migdir2/file3"
5259                 run_and_count "echo "aaaaa" > $migdir2/file4"
5260                 run_and_count stat $migdir2/file5
5261                 run_and_count touch $migdir2/source_file
5262                 if [ -e $migdir2/source_file ]; then
5263                         run_and_count ln $migdir2/source_file \
5264                                 $migdir2/link_file
5265
5266                         [ -e $migdir2/link_file ] &&
5267                                 rm -rf $migdir2/link_file
5268
5269                         run_and_count mrename $migdir2/source_file \
5270                                 $migdir2/target_file
5271
5272                         [ -e $migdir2/target_file ] &&
5273                                 run_and_count rm -rf $migdir2/target_file ||
5274                                 run_and_count rm -rf $migdir2/source_file
5275                 fi
5276
5277                 kill -0 $migrate_pid || {
5278                         echo "migration stopped 1"
5279                         break
5280                 }
5281         done
5282
5283         # check migration are still there
5284         kill -0 $migrate_pid || error "migration stopped 2"
5285         cleanup_80b
5286         # access during migration may fail
5287         echo "concurrent access $failure_count failures, $success_count successes"
5288 }
5289 run_test 80b "Accessing directory during migration"
5290
5291 test_81a() {
5292         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
5293
5294         rm -rf $DIR1/$tdir
5295
5296         mkdir -p $DIR1/$tdir
5297
5298         $LFS setdirstripe -i0 -c$MDSCOUNT  $DIR1/$tdir/d0
5299         $LFS setdirstripe -i0 -c$MDSCOUNT  $DIR1/$tdir/d1
5300
5301         cd $DIR1/$tdir
5302         touch d0/0      || error "create 0 failed"
5303         mv d0/0 d1/0    || error "rename d0/0 d1/0 failed"
5304         stat d0/0       && error "stat mv filed succeed"
5305         mv $DIR2/$tdir/d1/0 $DIR2/$tdir/d0/0 || error "rename d1/0 d0/0 failed"
5306         stat d0/0       || error "stat failed"
5307
5308         local t=$(ls -ai $DIR1/$tdir/d0 | sort -u | wc -l)
5309
5310         if [ $t -ne 3 ]; then
5311                 ls -ai $DIR1/$tdir/d0
5312                 error "expect 3 get $t"
5313         fi
5314
5315         return 0
5316 }
5317 run_test 81a "rename and stat under striped directory"
5318
5319 test_81b() {
5320         [ $MDSCOUNT -lt 2 ] &&
5321                 skip "We need at least 2 MDTs for this test"
5322
5323         local setattr_pid
5324
5325         $LFS mkdir -c $MDSCOUNT $DIR1/$tdir || error "$LFS mkdir"
5326         createmany -o $DIR1/$tdir/$tfile. $COUNT || error "createmany"
5327
5328         (
5329                 while true; do
5330                         touch $DIR1/$tdir
5331                 done
5332         ) &
5333         setattr_pid=$!
5334
5335         for ((i = 0; i < COUNT; i++)); do
5336                 mrename $DIR2/$tdir/$tfile.$i $DIR2/$tdir/$tfile-new.$i \
5337                         > /dev/null
5338         done
5339
5340         kill -9 $setattr_pid
5341 }
5342 run_test 81b "rename under striped directory doesn't deadlock"
5343
5344 test_81c() {
5345         [ $MDSCOUNT -lt 4 ] && skip_env "needs >= 4 MDTs"
5346         [ $MDS1_VERSION -lt $(version_code 2.13.52) ] &&
5347                 skip "Need MDS version at least 2.13.52"
5348
5349         # source is local, source parent is remote
5350         $LFS mkdir -i 0 $DIR1/${tdir}_src || error "mkdir ${tdir}_src"
5351         $LFS mkdir -i 1 $DIR1/${tdir}_tgt || error "mkdir ${tdir}_tgt"
5352         $LFS mkdir -i 3 $DIR1/${tdir}_src/sub || error "mkdir sub"
5353         $LFS mkdir -i 3 $DIR1/${tdir}_tgt/sub || error "mkdir sub"
5354         stat $DIR2/${tdir}_src/sub || error "stat sub failed"
5355         mv $DIR1/${tdir}_src/sub $DIR1/${tdir}_tgt/ || error "mv failed"
5356         [ -f $DIR2/${tdir}_src/sub ] && error "sub should be gone"
5357         rm -rf $DIR1/${tdir}_src $DIR1/${tdir}_tgt
5358
5359         # source is remote, source parent is local
5360         $LFS mkdir -i 3 $DIR1/${tdir}_src || error "mkdir ${tdir}_src"
5361         $LFS mkdir -i 1 $DIR1/${tdir}_tgt || error "mkdir ${tdir}_tgt"
5362         $LFS mkdir -i 0 $DIR1/${tdir}_src/sub || error "mkdir sub"
5363         $LFS mkdir -i 3 $DIR1/${tdir}_tgt/sub || error "mkdir sub"
5364         stat $DIR2/${tdir}_src/sub || error "stat sub failed"
5365         mv $DIR1/${tdir}_src/sub $DIR1/${tdir}_tgt/ || error "mv failed"
5366         [ -f $DIR2/${tdir}_src/sub ] && error "sub should be gone"
5367         rm -rf $DIR1/${tdir}_src $DIR1/${tdir}_tgt
5368
5369         # source and source parent are remote
5370         $LFS mkdir -i 0 $DIR1/${tdir}_src || error "mkdir ${tdir}_src"
5371         $LFS mkdir -i 1 $DIR1/${tdir}_tgt || error "mkdir ${tdir}_tgt"
5372         mkdir $DIR1/${tdir}_src/sub || error "mkdir sub"
5373         $LFS mkdir -i 3 $DIR1/${tdir}_tgt/sub || error "mkdir sub"
5374         stat $DIR2/${tdir}_src/sub || error "stat sub failed"
5375         mv $DIR1/${tdir}_src/sub $DIR1/${tdir}_tgt/ || error "mv failed"
5376         [ -f $DIR2/${tdir}_src/sub ] && error "sub should be gone"
5377         rm -rf $DIR1/${tdir}_src $DIR1/${tdir}_tgt
5378
5379         # source and source parent are remote, and source is remote object
5380         $LFS mkdir -i 0 $DIR1/${tdir}_src || error "mkdir ${tdir}_src"
5381         $LFS mkdir -i 1 $DIR1/${tdir}_tgt || error "mkdir ${tdir}_tgt"
5382         $LFS mkdir -i 2 $DIR1/${tdir}_src/sub || error "mkdir sub"
5383         $LFS mkdir -i 3 $DIR1/${tdir}_tgt/sub || error "mkdir sub"
5384         stat $DIR2/${tdir}_src/sub || error "stat sub failed"
5385         mv $DIR1/${tdir}_src/sub $DIR1/${tdir}_tgt/ || error "mv failed"
5386         [ -f $DIR2/${tdir}_src/sub ] && error "sub should be gone" || true
5387 }
5388 run_test 81c "rename revoke LOOKUP lock for remote object"
5389
5390 cleanup_81d() {
5391         for ((mds = 0; mds < $MDSCOUNT; mds++)); do
5392                 local d2=$DIR2/$tdir-$mds
5393
5394                 rm -rf $d2 &
5395         done
5396         wait || error "rm failed"
5397 }
5398
5399 test_81d() {
5400         local setattr_pid
5401         local mdts=$(comma_list $(mdts_nodes))
5402
5403         do_nodes $mdts "$LCTL set_param mdt.*.md_stats=clear > /dev/null"
5404
5405         stack_trap cleanup_81d
5406         for ((mds = 0; mds < $MDSCOUNT; mds++)); do
5407                 local d1=$DIR1/$tdir-$mds
5408
5409                 $LFS mkdir -i $mds $d1 $d1/_temporary || error "mkdir failed"
5410                 createmany -o $d1/_temporary/$tfile. $COUNT ||
5411                         error "createmany failed for $d1/_temporary"
5412         done
5413
5414         for ((mds = 0; mds < $MDSCOUNT; mds++)); do
5415                 local d1=$DIR1/$tdir-$mds
5416                 local d2=$DIR2/$tdir-$mds
5417
5418                 for ((i = 0; i < COUNT; i++)); do
5419                         mrename $d1/_temporary/$tfile.$i $d1/$tfile.$i &
5420                         ((i++))
5421                         mrename $d2/_temporary/$tfile.$i $d2/$tfile.$i &
5422                 done
5423         done
5424         wait || error "rename failed"
5425
5426         cleanup_81d
5427         local stats=$DIR1/md_stats
5428         local total=$((MDSCOUNT * COUNT))
5429
5430         do_nodes $mdts "$LCTL get_param -n mdt.*.md_stats" > $stats
5431         cat $stats
5432         crossdir=$(awk '/crossdir_rename/ {sum+=$2} END {print sum}' $stats)
5433         (( crossdir == total )) ||
5434                 error "not crossdir: $crossdir != $total"
5435         samedir=$(awk '/samedir_rename/ {sum+=$2} END {print sum}' $stats)
5436         (( samedir == 0 )) || error "considered samedir: $samedir"
5437         pardir=$(awk '/parallel_rename_dir/ {sum+=$2} END {print sum}' $stats)
5438         (( pardir == 0 )) || error "considered directory: $pardir"
5439
5440
5441         (( MDS1_VERSION >= $(version_code 2.15.60) )) ||
5442                 { echo "need MDS >= 2.15.60 for parallel cross-dir"; return 0; }
5443
5444         parfile=$(awk '/parallel_rename_file/ {sum+=$2} END {print sum}' $stats)
5445         (( parfile == total )) ||
5446                 error "not considered file: $parfile != $total"
5447 }
5448 run_test 81d "parallel rename file cross-dir on same MDT"
5449
5450 test_82() {
5451         [[ "$MDS1_VERSION" -gt $(version_code 2.6.91) ]] ||
5452                 skip "Need MDS version at least 2.6.92"
5453
5454         # Client 1 creates a file.
5455         multiop_bg_pause $DIR1/$tfile O_ac || error "multiop_bg_pause 1"
5456         pid1=$!
5457         # Client 2 opens the file.
5458         multiop_bg_pause $DIR2/$tfile o_Ac || error "multiop_bg_pause 2"
5459         pid2=$!
5460         # Client 1 makes the file an orphan.
5461         rm $DIR1/$tfile || error "rm"
5462         # Client 2 sets EA "user.multiop".
5463         kill -s USR1 $pid2
5464         wait $pid2 || error "multiop 2"
5465         # Client 1 gets EA "user.multiop".  This used to fail because the EA
5466         # cache refill would get "trusted.link" from mdd_xattr_list() but
5467         # -ENOENT when trying to get "trusted.link"'s value.  See also sanity
5468         # 102q.
5469         kill -s USR1 $pid1
5470         wait $pid1 || error "multiop 1"
5471 }
5472 run_test 82 "fsetxattr and fgetxattr on orphan files"
5473
5474 test_83() {
5475         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
5476         local pid1
5477         local pid2
5478
5479         (
5480                 cd $DIR1
5481                 while true; do
5482                         $LFS mkdir -i1 -c2 $tdir
5483                         rmdir $tdir
5484                 done
5485         ) &
5486         pid1=$!
5487         echo "start pid $pid1 to create/unlink striped directory"
5488
5489         # Access the directory at the same time
5490         (
5491                 cd $DIR2
5492                 while true; do
5493                         stat $tdir > /dev/null 2>&1
5494                 done
5495         ) &
5496         pid2=$!
5497         echo "start pid $pid2 to stat striped directory"
5498
5499         sleep 120
5500         kill $pid1 $pid2
5501         wait $pid1 $pid2
5502
5503         return 0
5504 }
5505 run_test 83 "access striped directory while it is being created/unlinked"
5506
5507 test_84() {
5508         [ $MDS1_VERSION -lt $(version_code 2.12.55) ] &&
5509                 skip "lustre < 2.12.55 does not contain LU-12485 fix"
5510
5511         local mtime
5512
5513         $MULTIOP $DIR/$tfile oO_RDWR:O_CREAT:O_LOV_DELAY_CREATE:c ||
5514                 error "create $tfile failed"
5515         mtime=$(stat -c%Y $DIR/$tfile)
5516         mtime=$((mtime + 200))
5517
5518         #define OBD_FAIL_OBD_0NLINK_RACE  0x60b
5519         do_facet mds1 $LCTL set_param fail_loc=0x8000060b
5520
5521         touch -c -m $mtime $DIR/$tfile &
5522         setattr_pid=$!
5523         # sleep a while to let 'touch' run first
5524         sleep 5
5525         rm -f $DIR2/$tfile || error "unlink $tfile failed"
5526
5527         # touch may fail
5528         wait $setattr_pid || true
5529 }
5530 run_test 84 "0-nlink race in lu_object_find()"
5531
5532 test_85() {
5533         llapi_root_test $DIR/$tfile $DIR2/$tfile
5534 }
5535 run_test 85 "Lustre API root cache race"
5536
5537 test_90() {
5538         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
5539         local pid1
5540         local pid2
5541         local duration=180
5542
5543         [ "$SLOW" = "yes" ] && duration=600
5544         # Open/Create under striped directory
5545         (
5546                 cd $DIR1
5547                 while true; do
5548                         $LFS mkdir -c$MDSCOUNT $tdir > /dev/null 2>&1
5549                         touch $tdir/f{0..3} > /dev/null 2>&1
5550                 done
5551         ) &
5552         pid1=$!
5553         echo "start pid $pid1 to open/create under striped directory"
5554
5555         # unlink the striped directory at the same time
5556         (
5557                 cd $DIR2
5558                 while true; do
5559                         rm -rf $tdir > /dev/null 2>&1
5560                 done
5561         ) &
5562         pid2=$!
5563         echo "start pid $pid2 to unlink striped directory"
5564
5565         sleep $duration
5566
5567         kill $pid1 $pid2
5568         wait $pid1 $pid2
5569
5570         return 0
5571 }
5572 run_test 90 "open/create and unlink striped directory"
5573
5574 test_91() {
5575         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
5576         local pid1
5577         local pid2
5578         local duration=180
5579
5580         [ "$SLOW" = "yes" ] && duration=600
5581         # chmod striped directory
5582         (
5583                 cd $DIR1
5584                 while true; do
5585                         $LFS mkdir -c$MDSCOUNT $tdir > /dev/null 2>&1
5586                         chmod go+w $tdir > /dev/null 2>&1
5587                 done
5588         ) &
5589         pid1=$!
5590         echo "start pid $pid1 to chmod striped directory"
5591
5592         # unlink the striped directory at the same time
5593         (
5594                 cd $DIR2
5595                 while true; do
5596                         rm -rf $tdir > /dev/null 2>&1
5597                 done
5598         ) &
5599         pid2=$!
5600         echo "start pid $pid2 to unlink striped directory"
5601
5602         sleep $duration
5603
5604         kill $pid1 $pid2
5605         wait $pid1 $pid2
5606
5607         return 0
5608 }
5609 run_test 91 "chmod and unlink striped directory"
5610
5611 test_92() {
5612         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
5613
5614         local fd=$(free_fd)
5615         local cmd="exec $fd<$DIR1/$tdir"
5616         $LFS setdirstripe -c$MDSCOUNT $DIR1/$tdir || error "mkdir $tdir fails"
5617         eval $cmd
5618         cmd="exec $fd<&-"
5619         trap "eval $cmd" EXIT
5620         cd $DIR1/$tdir || error "cd $DIR1/$tdir fails"
5621         rmdir ../$tdir || error "rmdir ../$tdir fails"
5622
5623         #define OBD_FAIL_LLITE_NO_CHECK_DEAD  0x1408
5624         $LCTL set_param fail_loc=0x1408
5625         mkdir $DIR2/$tdir/dir && error "create dir succeeds"
5626         $LFS setdirstripe -i1 $DIR2/$tdir/remote_dir &&
5627                 error "create remote dir succeeds"
5628         $LCTL set_param fail_loc=0
5629         eval $cmd
5630         return 0
5631 }
5632 run_test 92 "create remote directory under orphan directory"
5633
5634 test_93() {
5635         local rc1=0
5636         local rc2=0
5637         local old_rr
5638
5639         mkdir -p $DIR1/$tfile-1/
5640         mkdir -p $DIR2/$tfile-2/
5641         local old_rr=$(do_facet $SINGLEMDS "$LCTL get_param -n \
5642                 lod.$FSNAME-MDT0000-*/qos_threshold_rr" | sed -e 's/%//')
5643         do_facet $SINGLEMDS "$LCTL set_param -n \
5644                 lod.$FSNAME-MDT0000-*/qos_threshold_rr=100"
5645         #define OBD_FAIL_MDS_LOV_CREATE_RACE     0x163
5646         do_facet $SINGLEMDS "$LCTL set_param fail_loc=0x00000163"
5647
5648         $LFS setstripe -c -1 $DIR1/$tfile-1/file1 &
5649         local PID1=$!
5650         sleep 1
5651         $LFS setstripe -c -1 $DIR2/$tfile-2/file2 &
5652         local PID2=$!
5653         wait $PID2
5654         wait $PID1
5655         do_facet $SINGLEMDS "$LCTL set_param fail_loc=0x0"
5656         do_facet $SINGLEMDS "$LCTL set_param -n \
5657                 lod.$FSNAME-MDT0000-*/qos_threshold_rr=$old_rr"
5658
5659         $LFS getstripe $DIR1/$tfile-1/file1
5660         rc1=$($LFS getstripe -q $DIR1/$tfile-1/file1 |
5661                 awk '{if (/[0-9]/) print $1 }' | sort | uniq -d | wc -l)
5662         $LFS getstripe $DIR2/$tfile-2/file2
5663         rc2=$($LFS getstripe -q $DIR2/$tfile-2/file2 |
5664                 awk '{if (/[0-9]/) print $1 }' | sort | uniq -d | wc -l)
5665         echo "rc1=$rc1 and rc2=$rc2 "
5666         [ $rc1 -eq 0 ] && [ $rc2 -eq 0 ] ||
5667                 error "object allocate on same ost detected"
5668 }
5669 run_test 93 "alloc_rr should not allocate on same ost"
5670
5671 test_94() {
5672         $LCTL set_param osc.*.idle_timeout=0
5673         dd if=/dev/zero of=$DIR2/$tfile bs=4k count=2 conv=fsync
5674
5675         local before=$(date +%s)
5676         local evict
5677
5678         $LCTL mark write
5679 #define OBD_FAIL_LDLM_PAUSE_CANCEL       0x312
5680         $LCTL set_param fail_val=5 fail_loc=0x80000312
5681         dd if=/dev/zero of=$DIR/$tfile conv=notrunc oflag=append bs=4k count=1 &
5682         local pid=$!
5683         sleep 2
5684
5685 #define OBD_FAIL_LDLM_PAUSE_CANCEL_LOCAL 0x329
5686         $LCTL set_param fail_val=6 fail_loc=0x80000329
5687         $LCTL mark kill $pid
5688         kill -ALRM $pid
5689
5690         dd if=/dev/zero of=$DIR2/$tfile conv=notrunc oflag=append bs=4k count=1
5691
5692         wait $pid
5693         dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 conv=fsync
5694
5695         evict=$(do_facet client $LCTL get_param \
5696                 osc.$FSNAME-OST*-osc-*/state |
5697             awk -F"[ [,]" '/EVICTED ]$/ { if (t<$5) {t=$5;} } END { print t }')
5698
5699         [ -z "$evict" ] || [[ $evict -le $before ]] ||
5700                 (do_facet client $LCTL get_param \
5701                         osc.$FSNAME-OST*-osc-*/state;
5702                     error "eviction happened: $evict before:$before")
5703         $LCTL set_param osc.*.idle_timeout=debug
5704 }
5705 run_test 94 "signal vs CP callback race"
5706
5707 test_95a() {
5708         local file=$DIR/$tfile
5709         local file2=$DIR2/$tfile
5710         local fast_read_save
5711         local pid
5712
5713         fast_read_save=$($LCTL get_param -n llite.*.fast_read | head -n 1)
5714         [ -z "$fast_read_save" ] && skip "no fast read support"
5715
5716         stack_trap "$LCTL set_param llite.*.fast_read=$fast_read_save" EXIT
5717         $LCTL set_param llite.*.fast_read=0
5718
5719         $LFS setstripe -c $OSTCOUNT $file || error "failed to setstripe $file"
5720         dd if=/dev/zero of=$file bs=1M count=2 || error "failed to write $file"
5721         cancel_lru_locks $OSC
5722         $MULTIOP $file Oz1048576w4096c || error "failed to write $file"
5723         $MULTIOP $file oz1044480r4096c || error "failed to read $file"
5724
5725         # OBD_FAIL_LLITE_PAGE_INVALIDATE_PAUSE  0x1421
5726         $LCTL set_param fail_loc=0x80001421 fail_val=7
5727         $MULTIOP $file2 Oz1048576w4096_c &
5728         pid=$!
5729
5730         sleep 2
5731         # OBD_FAIL_LLITE_READPAGE_PAUSE         0x1422
5732         $LCTL set_param fail_loc=0x80001422 fail_val=10
5733         $MULTIOP $file oz1044480r4096c || error "failed to read $file"
5734
5735         kill -USR1 $pid && wait $pid || error "wait for PID $pid failed"
5736 }
5737 run_test 95a "Check readpage() on a page that was removed from page cache"
5738
5739 test_95b() {
5740         local file=$DIR/$tfile
5741         local file2=$DIR2/$tfile
5742         local fast_read_save
5743         local pid
5744
5745         fast_read_save=$($LCTL get_param -n llite.*.fast_read | head -n 1)
5746         [ -z "$fast_read_save" ] && skip "no fast read support"
5747
5748         stack_trap "$LCTL set_param llite.*.fast_read=$fast_read_save" EXIT
5749         $LCTL set_param llite.*.fast_read=0
5750
5751         $LFS setstripe -c $OSTCOUNT $file || error "failed to setstripe $file"
5752         dd if=/dev/zero of=$file bs=$((PAGE_SIZE * 3)) count=1 ||
5753                 error "failed to write $file"
5754
5755         # This does the read from the second mount, so this flushes the pages
5756         # the first mount and creates new ones on the second mount
5757         # OBD_FAIL_LLITE_READPAGE_PAUSE2        0x1424
5758         $LCTL set_param fail_loc=0x80001424 fail_val=5
5759         $MULTIOP $file2 or${PAGE_SIZE}c &
5760         pid=$!
5761
5762         sleep 2
5763         fadvise_dontneed_helper $file2
5764         $LCTL set_param fail_loc=0
5765         sleep 4
5766         wait $pid || error "failed to read file"
5767 }
5768 run_test 95b "Check readpage() on a page that is no longer uptodate"
5769
5770 # Data-on-MDT tests
5771 test_100a() {
5772         skip "Reserved for glimpse-ahead" && return
5773         [ "$MDS1_VERSION" -lt $(version_code 2.10.55) ] &&
5774                 skip "Need MDS version at least 2.10.55"
5775
5776         mkdir -p $DIR/$tdir
5777
5778         $LFS setstripe -E 1024K -L mdt -E EOF $DIR/$tdir/dom
5779
5780         lctl set_param -n mdc.*.stats=clear
5781         dd if=/dev/zero of=$DIR2/$tdir/dom bs=4096 count=1 || return 1
5782
5783         $CHECKSTAT -t file -s 4096 $DIR/$tdir/dom || error "stat #1"
5784         # first stat from server should return size data and save glimpse
5785         local gls=$(lctl get_param -n mdc.*.stats | grep -c ldlm_glimpse)
5786         [ $gls -eq 0 ] || error "Unexpected $gls glimpse RPCs"
5787         # second stat to check size is NOT cached on client without IO lock
5788         $CHECKSTAT -t file -s 4096 $DIR/$tdir/dom || error "stat #2"
5789
5790         local gls=$(lctl get_param -n mdc.*.stats | grep -c ldlm_glimpse)
5791         [ $gls -ge 1 ] || error "Expect glimpse RPCs but none"
5792         rm -f $dom
5793 }
5794 run_test 100a "DoM: glimpse RPCs for stat without IO lock (DoM only file)"
5795
5796 test_100b() {
5797         [ "$MDS1_VERSION" -lt $(version_code 2.10.55) ] &&
5798                 skip "Need MDS version at least 2.10.55"
5799
5800         mkdir -p $DIR/$tdir
5801
5802         $LFS setstripe -E 1024K -L mdt -E EOF $DIR/$tdir/dom
5803
5804         lctl set_param -n mdc.*.stats=clear
5805         dd if=/dev/zero of=$DIR2/$tdir/dom bs=4096 count=1 || return 1
5806         cancel_lru_locks mdc
5807         # first stat data from server should have size
5808         $CHECKSTAT -t file -s 4096 $DIR/$tdir/dom || error "stat #1"
5809         # second stat to check size is cached on client
5810         $CHECKSTAT -t file -s 4096 $DIR/$tdir/dom || error "stat #2"
5811
5812         local gls=$(lctl get_param -n mdc.*.stats | grep -c ldlm_glimpse)
5813         # both stats should cause no glimpse requests
5814         [ $gls == 0 ] || error "Unexpected $gls glimpse RPCs"
5815         rm -f $dom
5816 }
5817 run_test 100b "DoM: no glimpse RPC for stat with IO lock (DoM only file)"
5818
5819 test_100c() {
5820         [ "$MDS1_VERSION" -lt $(version_code 2.10.55) ] &&
5821                 skip "Need MDS version at least 2.10.55"
5822
5823         mkdir -p $DIR/$tdir
5824
5825         $LFS setstripe -E 1024K -L mdt -E EOF $DIR/$tdir/dom
5826
5827         lctl set_param -n mdc.*.stats=clear
5828         lctl set_param -n osc.*.stats=clear
5829         dd if=/dev/zero of=$DIR2/$tdir/dom bs=2048K count=1 || return 1
5830
5831         # check that size is merged from MDT and OST correctly
5832         $CHECKSTAT -t file -s 2097152 $DIR/$tdir/dom ||
5833                 error "Wrong size from stat #1"
5834
5835         local gls=$(lctl get_param -n osc.*.stats | grep -c ldlm_glimpse)
5836         [ $gls -eq 0 ] && error "Expect OST glimpse RPCs but got none"
5837
5838         rm -f $dom
5839 }
5840 run_test 100c "DoM: write vs stat without IO lock (combined file)"
5841
5842 test_100d() {
5843         [ "$MDS1_VERSION" -lt $(version_code 2.10.55) ] &&
5844                 skip "Need MDS version at least 2.10.55"
5845
5846         mkdir -p $DIR/$tdir
5847
5848         $LFS setstripe -E 1024K -L mdt -E EOF $DIR/$tdir/dom
5849
5850
5851         dd if=/dev/zero of=$DIR2/$tdir/dom bs=2048K count=1 || return 1
5852         lctl set_param -n mdc.*.stats=clear
5853         $TRUNCATE $DIR2/$tdir/dom 4096
5854
5855         # check that reported size is valid after file grows to OST and
5856         # is truncated back to MDT stripe size
5857         $CHECKSTAT -t file -s 4096 $DIR/$tdir/dom ||
5858                 error "Wrong size from stat #1"
5859
5860         local gls=$(lctl get_param -n osc.*.stats | grep -c ldlm_glimpse)
5861         [ $gls -eq 0 ] && error "Expect OST glimpse but got none"
5862
5863         rm -f $dom
5864 }
5865 run_test 100d "DoM: write+truncate vs stat without IO lock (combined file)"
5866
5867 test_100e() {
5868         [ "$MDS1_VERSION" -lt $(version_code 2.11.50) ] &&
5869                 skip "Need MDS version at least 2.11.50"
5870
5871         local dom=$DIR/$tdir/dom
5872         local dom2=$DIR2/$tdir/dom
5873         mkdir -p $DIR/$tdir
5874
5875         $LFS setstripe -E 1024K -L mdt $DIR/$tdir
5876
5877         cancel_lru_locks mdc
5878         dd if=/dev/urandom of=$dom bs=12000 count=1
5879         $TRUNCATE $dom2 6000
5880         cancel_lru_locks mdc
5881         lctl set_param -n mdc.*.stats=clear
5882         # expect read-on-open to return all data before write
5883         cat /etc/hosts >> $dom
5884         local read=$(lctl get_param -n mdc.*.stats | grep -c ost_read)
5885         [[ $read -eq 0 ]] || error "Unexpected $read READ RPCs"
5886 }
5887 run_test 100e "DoM: read on open and file size"
5888
5889 test_101a() {
5890         [ "$MDS1_VERSION" -lt $(version_code 2.10.55) ] &&
5891                 skip "Need MDS version at least 2.10.55"
5892
5893         $LFS setstripe -E 1024K -L mdt -E EOF $DIR1/$tfile
5894         # to get layout
5895         $CHECKSTAT -t file $DIR1/$tfile
5896
5897         local old_wb=$(sysctl -n vm.dirty_writeback_centisecs)
5898         sysctl -wq vm.dirty_writeback_centisecs=0
5899
5900         trap "sysctl -wq vm.dirty_writeback_centisecs=$old_wb" EXIT
5901
5902         # open + IO lock
5903         dd if=/dev/zero of=$DIR1/$tfile bs=4096 count=1 ||
5904                 error_noexit "Write fails"
5905         # must discard pages
5906         lctl set_param -n mdc.*.stats=clear
5907         rm $DIR2/$tfile || error "Unlink fails"
5908
5909         local writes=$(lctl get_param -n mdc.*.stats | grep -c ost_write)
5910         [ $writes -eq 0 ] || error "Found WRITE RPC but expect none"
5911 }
5912 run_test 101a "Discard DoM data on unlink"
5913
5914 test_101b() {
5915         [ "$MDS1_VERSION" -lt $(version_code 2.10.55) ] &&
5916                 skip "Need MDS version at least 2.10.55"
5917
5918         $LFS setstripe -E 1024K -L mdt -E EOF $DIR1/$tfile
5919         touch $DIR1/${tfile}_2
5920         # to get layout
5921         $CHECKSTAT -t file $DIR1/$tfile
5922
5923         local old_wb=$(sysctl -n vm.dirty_writeback_centisecs)
5924         sysctl -wq vm.dirty_writeback_centisecs=0
5925
5926         trap "sysctl -wq vm.dirty_writeback_centisecs=$old_wb" EXIT
5927
5928         # open + IO lock
5929         dd if=/dev/zero of=$DIR1/$tfile bs=4096 count=1 || error "Write fails"
5930         # must discard pages
5931         lctl set_param -n mdc.*.stats=clear
5932         mv $DIR2/${tfile}_2 $DIR2/$tfile || error "Rename fails"
5933
5934         local writes=$(lctl get_param -n mdc.*.stats | grep -c ost_write)
5935         [ $writes -eq 0 ] || error "Found WRITE RPC but expect none"
5936 }
5937 run_test 101b "Discard DoM data on rename"
5938
5939 test_101c() {
5940         [ "$MDS1_VERSION" -lt $(version_code 2.10.55) ] &&
5941                 skip "Need MDS version at least 2.10.55"
5942
5943         $LFS setstripe -E 1024K -L mdt -E EOF $DIR1/$tfile
5944         # to get layout
5945         $CHECKSTAT -t file $DIR1/$tfile
5946
5947         local old_wb=$(sysctl -n vm.dirty_writeback_centisecs)
5948         sysctl -wq vm.dirty_writeback_centisecs=0
5949
5950         trap "sysctl -wq vm.dirty_writeback_centisecs=$old_wb" EXIT
5951
5952         # open + IO lock
5953         dd if=/dev/zero of=$DIR1/$tfile bs=4096 count=1 || error "Write fails"
5954         $MULTIOP $DIR1/$tfile O_c &
5955         MULTIOP_PID=$!
5956         sleep 1
5957         lctl set_param -n mdc.*.stats=clear
5958         rm $DIR2/$tfile > /dev/null || error "Unlink fails for opened file"
5959         kill -USR1 $MULTIOP_PID && wait $MULTIOP_PID || error "multiop failure"
5960
5961         local writes=$(lctl get_param -n mdc.*.stats | grep -c ost_write)
5962         [ $writes -eq 0 ] || error "Found WRITE RPC but expect none"
5963 }
5964 run_test 101c "Discard DoM data on close-unlink"
5965
5966 # test to verify file handle related system calls
5967 # (name_to_handle_at/open_by_handle_at)
5968 # The new system calls are supported in glibc >= 2.14.
5969
5970 # test to verify we can open by handle an unlinked file from > 1 client
5971 # This test opens the file normally on $DIR1, which is on one mount, and then
5972 # opens it by handle on $DIR2, which is on a different mount.
5973 test_102() {
5974         (( "$MDS1_VERSION" >= $(version_code 2.11.57) )) ||
5975                 skip "Needs MDS version 2.11.57 or later"
5976
5977         echo "Test file_handle syscalls" > $DIR/$tfile ||
5978                 error "write failed"
5979         check_fhandle_syscalls $DIR/$tfile $DIR2 ||
5980                 error "check_fhandle_syscalls $tfile failed"
5981
5982         # test this is working on DNE directories also
5983         if (( MDSCOUNT > 1 && MDS1_VERSION >= $(version_code 2.14.52) )); then
5984                 $LFS mkdir -i 1 $DIR/$tdir.remote
5985                 cancel_lru_locks mdc
5986                 check_fhandle_syscalls $DIR/$tdir.remote $DIR2 ||
5987                         error "check_fhandle_syscalls $tdir.remote failed"
5988                 $LFS mkdir -c -1 $DIR/$tdir.remote/subdir
5989                 cancel_lru_locks mdc
5990                 check_fhandle_syscalls $DIR/$tdir.remote/subdir $DIR2 ||
5991                         error "check_fhandle_syscalls $tdir.remote/subdir fail"
5992
5993                 $LFS mkdir -c -1 $DIR/$tdir.stripe
5994                 cancel_lru_locks mdc
5995                 check_fhandle_syscalls $DIR/$tdir.stripe $DIR2 ||
5996                         error "check_fhandle_syscalls $tdir.stripe failed"
5997                 $LFS mkdir -c -1 $DIR/$tdir.stripe/subdir
5998                 cancel_lru_locks mdc
5999                 check_fhandle_syscalls $DIR/$tdir.stripe/subdir $DIR2 ||
6000                         error "check_fhandle_syscalls $tdir.stripe/subdir fail"
6001         fi
6002 }
6003 run_test 102 "Test open by handle of unlinked file"
6004
6005 # Compare file size between first & second mount, ensuring the client correctly
6006 # glimpses even with unused speculative locks - LU-11670
6007 test_103() {
6008         [ $OST1_VERSION -lt $(version_code 2.10.50) ] &&
6009                 skip "Lockahead needs OST version at least 2.10.50"
6010
6011         local locktest=23
6012
6013         test_mkdir -p $DIR/$tdir
6014
6015         # Force file on to OST0
6016         $LFS setstripe -i 0 $DIR/$tdir
6017
6018         # Do not check multiple locks on glimpse
6019         # OBD_FAIL_OSC_NO_SIZE_DATA 0x415
6020         $LCTL set_param fail_loc=0x415
6021
6022         # Delay write commit by 2 seconds to guarantee glimpse wins race
6023         # The same fail_loc is used on client & server so it can work in the
6024         # single node sanity setup
6025         do_facet ost1 $LCTL set_param fail_loc=0x415 fail_val=2
6026
6027         echo "Incorrect size expected (no glimpse fix):"
6028         lockahead_test -d $DIR/$tdir -D $DIR2/$tdir -t $locktest -f $tfile
6029         rc=$?
6030         if [ $rc -eq 0 ]; then
6031                 echo "This doesn't work 100%, but this is just reproducing the bug, not testing the fix, so OK to not fail test."
6032         fi
6033
6034         # guarantee write commit timeout has expired
6035         sleep 2
6036
6037         # Clear fail_loc on client
6038         $LCTL set_param fail_loc=0
6039
6040         # Delay write commit by 2 seconds to guarantee glimpse wins race
6041         # OBD_FAIL_OST_BRW_PAUSE_BULK 0x214
6042         do_facet ost1 $LCTL set_param fail_loc=0x214 fail_val=2
6043
6044         # Write commit is still delayed by 2 seconds
6045         lockahead_test -d $DIR/$tdir -D $DIR2/$tdir -t $locktest -f $tfile
6046         rc=$?
6047         [ $rc -eq 0 ] || error "Lockahead test$locktest failed, $rc"
6048
6049         # guarantee write commit timeout has expired
6050         sleep 2
6051
6052         rm -f $DIR/$tfile || error "unable to delete $DIR/$tfile"
6053 }
6054 run_test 103 "Test size correctness with lockahead"
6055
6056 get_stat_xtimes()
6057 {
6058         local xtimes
6059
6060         xtimes=$(stat -c "%X %Y %Z" $DIR/$tfile)
6061
6062         echo ${xtimes[*]}
6063 }
6064
6065 get_mdt_xtimes()
6066 {
6067         local mdtdev=$1
6068         local output
6069         local xtimes
6070
6071         output=$(do_facet mds1 "$DEBUGFS -c -R 'stat ROOT/$tfile' $mdtdev")
6072         ((xtimes[0]=$(awk -F ':' /atime/'{ print $2 }' <<< "$output")))
6073         ((xtimes[1]=$(awk -F ':' /mtime/'{ print $2 }' <<< "$output")))
6074         ((xtimes[2]=$(awk -F ':' /ctime/'{ print $2 }' <<< "$output")))
6075
6076         echo ${xtimes[*]}
6077 }
6078
6079 check_mdt_xtimes()
6080 {
6081         local mdtdev=$1
6082         local xtimes=($(get_stat_xtimes))
6083         local mdt_xtimes=($(get_mdt_xtimes $mdtdev))
6084
6085         echo "STAT a|m|ctime ${xtimes[*]}"
6086         echo "MDT a|m|ctime ${mdt_xtimes[*]}"
6087         [[ ${xtimes[0]} == ${mdt_xtimes[0]} ]] ||
6088                 error "$DIR/$tfile atime (${xtimes[0]}:${mdt_xtimes[0]}) diff"
6089         [[ ${xtimes[1]} == ${mdt_xtimes[1]} ]] ||
6090                 error "$DIR/$tfile mtime (${xtimes[1]}:${mdt_xtimes[1]}) diff"
6091         [[ ${xtimes[2]} == ${mdt_xtimes[2]} ]] ||
6092                 error "$DIR/$tfile ctime (${xtimes[2]}:${mdt_xtimes[2]}) diff"
6093 }
6094
6095 test_104() {
6096         [ "$mds1_FSTYPE" == "ldiskfs" ] || skip_env "ldiskfs only test"
6097         [ $MDS1_VERSION -lt $(version_code 2.12.4) ] &&
6098                 skip "Need MDS version at least 2.12.4"
6099
6100         local pid
6101         local mdtdev=$(mdsdevname ${SINGLEMDS//mds/})
6102         local atime_diff=$(do_facet $SINGLEMDS \
6103                 lctl get_param -n mdd.*MDT0000*.atime_diff)
6104
6105         do_facet $SINGLEMDS \
6106                 lctl set_param -n mdd.*MDT0000*.atime_diff=0
6107
6108         stack_trap "do_facet $SINGLEMDS \
6109                 lctl set_param -n mdd.*MDT0000*.atime_diff=$atime_diff" EXIT
6110
6111         dd if=/dev/zero of=$DIR/$tfile bs=1k count=1 conv=notrunc
6112         check_mdt_xtimes $mdtdev
6113         sleep 2
6114
6115         dd if=/dev/zero of=$DIR/$tfile bs=1k count=1 conv=notrunc
6116         check_mdt_xtimes $mdtdev
6117         sleep 2
6118         $MULTIOP $DIR2/$tfile Oz8192w8192_c &
6119         pid=$!
6120         sleep 2
6121         dd if=/dev/zero of=$DIR/$tfile bs=1k count=1 conv=notrunc
6122         sleep 2
6123         kill -USR1 $pid && wait $pid || error "multiop failure"
6124         check_mdt_xtimes $mdtdev
6125
6126         local xtimes
6127         local mdt_xtimes
6128
6129         # Verify mtime/ctime is NOT upated on MDS when there is no modification
6130         # on the client side
6131         xtimes=($(get_stat_xtimes))
6132         $MULTIOP $DIR/$tfile O_c &
6133         pid=$!
6134         sleep 2
6135         kill -USR1 $pid && wait $pid || error "multiop failure"
6136         mdt_xtimes=($(get_mdt_xtimes $mdtdev))
6137         [[ ${xtimes[1]} == ${mdt_xtimes[1]} ]] ||
6138                 error "$DIR/$tfile mtime (${xtimes[1]}:${mdt_xtimes[1]}) diff"
6139         [[ ${xtimes[2]} == ${mdt_xtimes[2]} ]] ||
6140                 error "$DIR/$tfile ctime (${xtimes[2]}:${mdt_xtimes[2]}) diff"
6141         check_mdt_xtimes $mdtdev
6142
6143         sleep 2
6144         # Change ctime via chmod
6145         $MULTIOP $DIR/$tfile o_tc &
6146         pid=$!
6147         sleep 2
6148         kill -USR1 $pid && wait $pid || error "multiop failure"
6149         check_mdt_xtimes $mdtdev
6150 }
6151 run_test 104 "Verify that MDS stores atime/mtime/ctime during close"
6152
6153 test_105() {
6154         test_mkdir -p $DIR/$tdir
6155         echo test > $DIR/$tdir/$tfile
6156         $LCTL set_param fail_loc=0x416
6157         cancel_lru_locks osc & sleep 1
6158         fsize1=$(stat -c %s $DIR2/$tdir/$tfile)
6159         wait
6160         [[ $fsize1 = 5 ]] ||  error "Glimpse returned wrong file size $fsize1"
6161 }
6162 run_test 105 "Glimpse and lock cancel race"
6163
6164 test_106a() {
6165         [ "$mds1_FSTYPE" == "ldiskfs" ] && statx_supported ||
6166                 skip_env "Test only for ldiskfs and statx() supported"
6167
6168         local btime
6169         local mdt_btime
6170         local output
6171         local mdtdev=$(mdsdevname ${SINGLEMDS//mds/})
6172
6173         dd if=/dev/zero of=$DIR/$tfile bs=1k count=1 conv=notrunc
6174         btime=$($STATX -c %W $DIR/$tfile)
6175         output=$(do_facet mds1 "$DEBUGFS -c -R 'stat ROOT/$tfile' $mdtdev")
6176         echo $output
6177         ((mdt_btime=$(awk -F ':' /crtime/'{ print $2 }' <<< "$output")))
6178         [[ $btime == $mdt_btime ]] ||
6179                 error "$DIR/$tfile btime ($btime:$mdt_btime) diff"
6180
6181 }
6182 run_test 106a "Verify the btime via statx()"
6183
6184 test_106b() {
6185         statx_supported || skip_env "statx() only test"
6186
6187         local rpcs_before
6188         local rpcs_after
6189
6190         $LFS setstripe -c 1 $DIR/$tfile || error "$DIR/$tfile setstripe failed"
6191         dd if=/dev/zero of=$DIR/$tfile bs=1k count=1 conv=notrunc
6192         cancel_lru_locks $OSC
6193         rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6194         $STATX $DIR/$tfile
6195         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6196         [ $rpcs_after -eq $((rpcs_before + 1)) ] ||
6197                 error "$STATX should send 1 glimpse RPC to $OSC"
6198
6199         cancel_lru_locks $OSC
6200         rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6201         # %n: FILENAME; %i: STATX_INO; %A STATX_MODE; %h STATX_NLINK;
6202         # %u: STATX_UID; %g: STATX_GID; %W STATX_BTIME; %X STATX_ATIME;
6203         # %Z: STATX_CTIME
6204         $STATX -c "%n %i %A %h %u %g %W %X %Z" $DIR/$tfile
6205         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6206         [ $rpcs_after -eq $rpcs_before ] ||
6207                 error "$STATX should not send glimpse RPCs to $OSC"
6208
6209         cancel_lru_locks $OSC
6210         rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6211         $STATX --cached=always $DIR/$tfile
6212         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6213         [ $rpcs_after -eq $rpcs_before ] ||
6214                 error "$STATX should not send glimpse RPCs to $OSC"
6215
6216         cancel_lru_locks $OSC
6217         rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6218         $STATX -c %Y $DIR/$tfile
6219         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6220         [ $rpcs_after -eq $((rpcs_before + 1)) ] ||
6221                 error "$STATX -c %Y should send 1 glimpse RPC to $OSC"
6222
6223         cancel_lru_locks $OSC
6224         rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6225         $STATX -c %s $DIR/$tfile
6226         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6227         [ $rpcs_after -eq $((rpcs_before + 1)) ] ||
6228                 error "$STATX -c %s should send 1 glimpse RPC to $OSC"
6229
6230         cancel_lru_locks $OSC
6231         rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6232         $STATX -c %b $DIR/$tfile
6233         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6234         [ $rpcs_after -eq $((rpcs_before + 1)) ] ||
6235                 error "$STATX -c %b should send 1 glimpse RPC to $OSC"
6236 }
6237 run_test 106b "Glimpse RPCs test for statx"
6238
6239 test_106c() {
6240         statx_supported || skip_env "statx() only test"
6241
6242         local mask
6243
6244         touch $DIR/$tfile
6245         # Mask supported in stx_attributes by Lustre is
6246         # STATX_ATTR_IMMUTABLE(0x10) | STATX_ATTR_APPEND(0x20) : (0x30).
6247         mask=$($STATX -c %p $DIR/$tfile)
6248         (( (0x$mask & 0x30) == 0x30 )) ||
6249                 error "supported stx_attributes: got '0x$mask', expected '0x30' at least"
6250         chattr +i $DIR/$tfile || error "chattr +i $DIR/$tfile failed"
6251         mask=$($STATX -c %r $DIR/$tfile)
6252         [[ $mask == "10" ]] ||
6253                 error "got immutable flags '$mask', expected '10'"
6254         chattr -i $DIR/$tfile || error "chattr -i $DIR/$tfile failed"
6255         mask=$($STATX -c %r $DIR/$tfile)
6256         [[ $mask == "0" ]] || error "got flags '$mask', expected '0'"
6257         chattr +a $DIR/$tfile || error "chattr +a $DIR/$tfile failed"
6258         mask=$($STATX -c %r $DIR/$tfile)
6259         [[ $mask == "20" ]] || error "got flags '$mask', expected '20'"
6260         chattr -a $DIR/$tfile || error "chattr -a $DIR/$tfile failed"
6261         mask=$($STATX -c %r $DIR/$tfile)
6262         [[ $mask == "0" ]] || error "got flags '$mask', expected '0'"
6263         chattr +ia $DIR/$tfile || error "chattr +ia $DIR/$tfile failed"
6264         mask=$($STATX -c %r $DIR/$tfile)
6265         [[ $mask == "30" ]] || error "got flags '$mask', expected '30'"
6266         chattr -ia $DIR/$tfile || error "chattr -ia $DIR/$tfile failed"
6267         mask=$($STATX -c %r $DIR/$tfile)
6268         [[ $mask == "0" ]] || error "got flags '$mask', expected '0'"
6269 }
6270 run_test 106c "Verify statx attributes mask"
6271
6272 test_107a() { # LU-1031
6273         dd if=/dev/zero of=$DIR1/$tfile bs=1M count=10
6274         local gid1=14091995
6275         local gid2=16022000
6276
6277         $LFS getstripe $DIR1/$tfile
6278
6279         multiop_bg_pause $DIR1/$tfile OG${gid1}_g${gid1}c || return 1
6280         local MULTIPID1=$!
6281         multiop_bg_pause $DIR2/$tfile O_G${gid2}r10g${gid2}c || return 2
6282         local MULTIPID2=$!
6283         kill -USR1 $MULTIPID2
6284         sleep 2
6285         if [[ $(ps h -o comm -p $MULTIPID2) == "" ]]; then
6286                 error "First grouplock does not block second one"
6287         else
6288                 echo "First grouplock blocks second one"
6289         fi
6290         kill -USR1 $MULTIPID1
6291         wait $MULTIPID1
6292         wait $MULTIPID2
6293 }
6294 run_test 107a "Basic grouplock conflict"
6295
6296 test_107b() {
6297         dd if=/dev/zero of=$DIR1/$tfile bs=1M count=10
6298         local gid1=14091995
6299         local gid2=16022000
6300
6301         $LFS getstripe $DIR1/$tfile
6302
6303         multiop_bg_pause $DIR1/$tfile OG${gid1}_g${gid1}c || return 1
6304         local MULTIPID1=$!
6305         multiop $DIR2/$tfile Or10c &
6306         local MULTIPID2=$!
6307         sleep 2
6308
6309         if [[ $(ps h -o comm -p $MULTIPID2) == "" ]]; then
6310                 error "Grouplock does not block IO"
6311         else
6312                 echo "Grouplock blocks IO"
6313         fi
6314
6315         multiop $DIR2/$tfile OG${gid2}_g${gid2}c &
6316         local MULTIPID3=$!
6317         sleep 2
6318         if [[ $(ps h -o comm -p $MULTIPID3) == "" ]]; then
6319                 error "First grouplock does not block second one"
6320         else
6321                 echo "First grouplock blocks second one"
6322         fi
6323
6324         kill -USR1 $MULTIPID1
6325         sleep 2
6326
6327         if [[ $(ps h -o comm -p $MULTIPID3) == "" ]]; then
6328                 error "Second grouplock thread disappeared"
6329         fi
6330
6331         if [[ $(ps h -o comm -p $MULTIPID2) == "" ]]; then
6332                 error "Second grouplock does not block IO"
6333         else
6334                 echo "Second grouplock blocks IO"
6335         fi
6336
6337         kill -USR1 $MULTIPID3
6338         wait $MULTIPID1
6339         wait $MULTIPID2
6340         wait $MULTIPID3
6341 }
6342 run_test 107b "Grouplock is added to the head of waiting list"
6343
6344 test_108a() {
6345         local offset
6346
6347         $LFS setstripe -E 1M -c 1 -E -1 $DIR1/$tfile ||
6348                 error "Create $DIR1/$tfile failed"
6349
6350         dd if=/dev/zero of=$DIR1/$tfile bs=10000 count=1 ||
6351                 error "dd $DIR1/$tfile failed"
6352         offset=$(lseek_test -d 5000 $DIR2/$tfile)
6353         [[ $offset == 5000 ]] || error "offset $offset != 5000"
6354
6355         $TRUNCATE $DIR1/$tfile 2000
6356         offset=$(lseek_test -l 1000 $DIR2/$tfile)
6357         [[ $offset == 2000 ]] || error "offset $offset != 2000"
6358
6359         #define OBD_FAIL_OSC_DELAY_IO 0x414
6360         $LCTL set_param fail_val=4 fail_loc=0x80000414
6361         dd if=/dev/zero of=$DIR1/$tfile count=1 bs=8M conv=notrunc oflag=dsync &
6362         local pid=$!
6363         sleep 2
6364
6365         offset=$(lseek_test -l 8000 $DIR2/$tfile)
6366         wait $pid
6367         [[ $offset == 8388608 ]] || error "offset $offset != 8388608"
6368 }
6369 run_test 108a "lseek: parallel updates"
6370
6371 # LU-14110
6372 test_109() {
6373         local i
6374         local pid1 pid2
6375
6376         ! local_mode ||
6377                 skip "Clients need to be on different nodes than the servers"
6378
6379         umount_client $MOUNT
6380         umount_client $MOUNT2
6381
6382         echo "Starting race between client mount instances (50 iterations):"
6383         for i in {1..50}; do
6384                 log "Iteration $i"
6385
6386 #define CFS_FAIL_ONCE|OBD_FAIL_LLITE_RACE_MOUNT        0x80001417
6387                 $LCTL set_param -n fail_loc=0x80001417
6388
6389                 mount_client $MOUNT  & pid1=$!
6390                 mount_client $MOUNT2 & pid2=$!
6391                 wait $pid1 || error "Mount $MOUNT fails with $?"
6392                 wait $pid2 || error "Mount $MOUNT2 fails with $?"
6393
6394                 umount_client $MOUNT  & pid1=$!
6395                 umount_client $MOUNT2 & pid2=$!
6396                 wait $pid1 || error "Umount $MOUNT fails with $?"
6397                 wait $pid2 || error "Umount $MOUNT2 fails with $?"
6398
6399                 $LUSTRE_RMMOD || error "Fail to remove lustre modules"
6400                 load_modules
6401                 echo
6402         done
6403
6404         mount_client $MOUNT
6405         mount_client $MOUNT2
6406 }
6407
6408 run_test 109 "Race with several mount instances on 1 node"
6409
6410 test_110() {
6411         local before=$(date +%s)
6412         local evict
6413
6414         mkdir -p $DIR/$tdir
6415         touch $DIR/$tdir/f1
6416         touch $DIR/$tfile
6417
6418         #define OBD_FAIL_PTLRPC_RESEND_RACE      0x525
6419         do_facet mds1 lctl set_param fail_loc=0x525 fail_val=3
6420
6421         # disable last_xid logic by dropping link reply
6422         ln $DIR/$tdir/f1 $DIR/$tdir/f2 &
6423         sleep 1
6424
6425         #define OBD_FAIL_PTLRPC_ENQ_RESEND      0x534
6426         do_facet mds1 lctl set_param fail_loc=0x534
6427
6428         # RPC will race with its Resend and the Resend will sleep to let
6429         # the original lock to get granted & cancelled.
6430         #
6431         # AST_SENT is set artificially, so an explicit conflict is not needed
6432         #
6433         # The woken up Resend gets a new lock, but client does not wait for it
6434         stat $DIR/$tfile
6435         sleep $TIMEOUT
6436         do_facet mds1 lctl set_param fail_loc=0 fail_val=0
6437
6438         # Take a conflict to wait long enough to see the eviction
6439         touch $DIR2/$tfile
6440
6441         # let the client reconnect
6442         client_reconnect
6443         evict=$(do_facet client $LCTL get_param mdc.$FSNAME-MDT*.state |
6444           awk -F"[ [,]" '/EVICTED ]$/ { if (mx<$5) {mx=$5;} } END { print mx }')
6445
6446         [ -z "$evict" ] || [[ $evict -le $before ]] ||
6447                 (do_facet client $LCTL get_param mdc.$FSNAME-MDT*.state;
6448                     error "eviction happened: $evict before:$before")
6449 }
6450 run_test 110 "do not grant another lock on resend"
6451
6452 test_111() {
6453         [ $MDSCOUNT -ge 2 ] || skip "needs >= 2 MDTs"
6454         [[ $(facet_active_host mds1) = $(facet_active_host mds2) ]] ||
6455                 skip "MDT0 and MDT1 should be on the same node"
6456
6457         mkdir $DIR1/$tdir
6458         $LFS mkdir -i 0 $DIR1/$tdir/mdt0dir
6459         $LFS mkdir -i 1 $DIR1/$tdir/mdt1dir
6460
6461         mkdir $DIR1/$tdir/mdt0dir/foodir
6462         touch $DIR1/$tdir/mdt0dir/foodir/{file1,file2}
6463
6464         $MULTIOP $DIR2/$tdir/mdt0dir/foodir/file2 Ow4096_c &
6465         MULTIOP_PID=$!
6466         ln $DIR1/$tdir/mdt0dir/foodir/file2 $DIR1/$tdir/mdt1dir/file2
6467
6468         #define OBD_FAIL_MDS_LINK_RENAME_RACE   0x18a
6469         do_facet mds1 $LCTL set_param fail_loc=0x8000018a
6470
6471         ln $DIR1/$tdir/mdt0dir/foodir/file2 $DIR1/$tdir/mdt1dir/file2x &
6472         sleep 1
6473
6474         rm $DIR2/$tdir/mdt1dir/file2
6475         sleep 1
6476
6477         mv $DIR2/$tdir/mdt0dir/foodir/file1 $DIR2/$tdir/mdt0dir/foodir/file2
6478         sleep 1
6479
6480         kill $MULTIOP_PID
6481         wait
6482         rm -r $DIR1/$tdir || error "Removing test dir failed"
6483 }
6484 run_test 111 "A racy rename/link an open file should not cause fs corruption"
6485
6486 test_112() {
6487         (( MDSCOUNT >= 2 )) ||
6488                 skip "We need at least 2 MDTs for this test"
6489
6490         (( MDS1_VERSION >= $(version_code 2.14.54) )) ||
6491                 skip "Need server version at least 2.14.54"
6492
6493         local rr
6494         local count
6495
6496         rr=$($LCTL get_param -n lmv.*.qos_threshold_rr | head -n1)
6497         rr=${rr%%%}
6498         stack_trap "$LCTL set_param lmv.*.qos_threshold_rr=$rr > /dev/null"
6499
6500         mkdir -p $DIR1/$tdir/s1/s2 || error "mkdir s2 failed"
6501         $LFS mkdir -i 0 $DIR1/$tdir/s1/s2/s3 || error "mkdir s3 failed"
6502         $LFS setdirstripe -D -i -1 --max-inherit-rr=0 $DIR1/$tdir/s1/s2/s3 ||
6503                 error "setdirstripe s3 failed"
6504         $LCTL set_param lmv.*.qos_threshold_rr=90
6505         mkdir $DIR2/$tdir/s1/s2/s3/d{1..64}
6506         count=$($LFS getstripe -m $DIR2/$tdir/s1/s2/s3/d* | grep ^0 | wc -l)
6507         (( count == 64 )) || error "only $count subdirs created on MDT0"
6508
6509         $LFS setdirstripe -D -i -1 --max-inherit-rr=3 $DIR1/$tdir/s1/s2/s3 ||
6510                 error "setdirstripe s3 failed"
6511         mkdir $DIR2/$tdir/s1/s2/s3/s{1..64}
6512         count=$($LFS getstripe -m $DIR2/$tdir/s1/s2/s3/s* | grep ^0 | wc -l)
6513         (( count == 64 / MDSCOUNT )) || error "$count subdirs created on MDT0"
6514 }
6515 run_test 112 "update max-inherit in default LMV"
6516
6517 test_113 () {
6518         (( MDS1_VERSION >= $(version_code 2.15.50) )) ||
6519                 skip "Need server version at least 2.15.50"
6520
6521         local instance
6522         local nid
6523
6524         instance=$($LFS getname -i $DIR1) ||
6525                 error "cannot get instance of $DIR1"
6526
6527         $LFS check osts $DIR1 | grep $instance ||
6528                 error "cannot find OSTs of instance $instance"
6529
6530         $LFS check osts $DIR1 | grep -v $instance
6531         if (( $? == 0 )); then
6532                 error "find OSTs other than instance $instance"
6533         fi
6534
6535         $LFS check osts | grep $instance ||
6536                 error "cannot find other OSTs"
6537
6538         nid=$(df $DIR2 | tail -1 | sed 's%:/.*%%') ||
6539                 error "cannot parse nid for $DIR2"
6540
6541         $LFS check mgts $DIR2 | grep MGC$nid ||
6542                 error "cannot find mgc of $nid"
6543
6544         $LFS check mgts $DIR2 | grep -v MGC$nid
6545         if (( $? == 0 )); then
6546                 error "find MGTs other than nid $nid"
6547         fi
6548 }
6549 run_test 113 "check servers of specified fs"
6550
6551 check_default_lmv() {
6552         local dir=$1
6553
6554         local enabled
6555         local dmv
6556         local index
6557         local count
6558         local inherit
6559         local inherit_rr
6560         local raw
6561
6562         enabled=$(do_facet mds1 \
6563                 $LCTL get_param -n mdt.*-MDT0000*.enable_dmv_implicit_inherit)
6564
6565         dmv=$($LFS getdirstripe -D $dir)
6566         echo $dir $dmv
6567         index=$(echo $dmv | awk '{ print $4 }')
6568         (( index == $2 )) || error "$dir default stripe index $index != $2"
6569
6570         count=$(echo $dmv | awk '{ print $2 }')
6571         (( count == $3 )) || error "$dir default stripe count $count != $3"
6572
6573         inherit=$(echo $dmv | awk '{ print $8 }')
6574         (( inherit == $4 )) || error "$dir default max-inherit $inherit != $4"
6575
6576         if [ $index -eq -1 ]; then
6577                 inherit_rr=$(echo $dmv | awk '{ print $10 }')
6578                 (( inherit_rr == $5 )) ||
6579                         error "$dir default max-inherit-rr $inherit_rr != $5"
6580         fi
6581
6582         # with --raw, print default LMV stored in inode, otherwise print nothing
6583         raw=$($LFS getdirstripe -D --raw $dir)
6584         if (( enabled == 1 )); then
6585                 [ -z $raw ] ||
6586                         error "implicit inherited DMV is printed with --raw"
6587         else
6588                 # if disabled, dmv is stored in inode, which will always
6589                 # print max-inherit-rr
6590                 echo $dir $raw
6591                 [[ $raw =~ $dmv.* ]] || error "$dir raw $raw != dmv $dmv"
6592         fi
6593 }
6594
6595 test_dmv_imp_inherit() {
6596         local dmv
6597         local raw
6598         local index
6599         local count
6600         local inherit
6601         local inherit_rr
6602
6603         rm -rf $DIR/$tdir || error "rm $tdir failed"
6604         mkdir -p $DIR/$tdir || error "mkdir $tdir failed"
6605
6606         # set dir default LMV
6607         $LFS setdirstripe -D -c1 -X4 --max-inherit-rr 2 $DIR/$tdir ||
6608                 error "setdirstripe -D $tdir failed"
6609         dmv=$($LFS getdirstripe -D $DIR/$tdir)
6610         raw=$($LFS getdirstripe -D --raw $DIR/$tdir)
6611         [ "$dmv" == "$raw" ] || error "$dmv != $raw"
6612
6613         mkdir -p $DIR/$tdir/l1/l2/l3 || error "mkdir $DIR/$tdir/l1/l2/l3 failed"
6614         check_default_lmv $DIR/$tdir/l1/l2/l3 -1 1 1 0
6615         check_default_lmv $DIR2/$tdir/l1/l2/l3 -1 1 1 0
6616
6617         # below tests are valid only when this feature is enabled
6618         local enabled=$(do_facet mds1 \
6619                 $LCTL get_param -n mdt.*-MDT0000*.enable_dmv_implicit_inherit)
6620
6621         (( enabled == 1 )) || return 0
6622
6623         # set l2 default LMV, dmv of l3 should change immediately
6624         $LFS setdirstripe -D -i1 -c2 -X4 $DIR/$tdir/l1/l2 ||
6625                 error "setdirstripe -D $tdir/l1/l2 failed"
6626
6627         check_default_lmv $DIR/$tdir/l1/l2/l3 1 2 3
6628         check_default_lmv $DIR2/$tdir/l1/l2/l3 1 2 3
6629
6630         # change tdir default LMV, dmv of l3 should be unchanged because dmv
6631         # of l2 is explicitly set
6632         $LFS setdirstripe -D -i2 -c2 -X3 $DIR/$tdir ||
6633                 error "setdirstripe -D $tdir failed"
6634
6635         check_default_lmv $DIR/$tdir/l1 2 2 2
6636         check_default_lmv $DIR2/$tdir/l1 2 2 2
6637         check_default_lmv $DIR/$tdir/l1/l2/l3 1 2 3
6638         check_default_lmv $DIR2/$tdir/l1/l2/l3 1 2 3
6639 }
6640
6641 test_114() {
6642         (( MDSCOUNT >= 2 )) ||
6643                 skip "We need at least 2 MDTs for this test"
6644
6645         (( MDS1_VERSION >= $(version_code 2.15.55.45) )) ||
6646                 skip "Need server version at least 2.15.54.45"
6647
6648         test_dmv_imp_inherit
6649
6650         # disable dmv_imp_inherit to simulate old client
6651         local mdts=$(comma_list $(mdts_nodes))
6652
6653         do_nodes $mdts $LCTL set_param -n \
6654                 mdt.*MDT*.enable_dmv_implicit_inherit=0
6655         test_dmv_imp_inherit
6656         do_nodes $mdts $LCTL set_param -n \
6657                 mdt.*MDT*.enable_dmv_implicit_inherit=1
6658 }
6659 run_test 114 "implicit default LMV inherit"
6660
6661 test_115() {
6662         local td=$DIR/$tdir
6663
6664         [ "$mds1_FSTYPE" == "ldiskfs" ] || skip_env "ldiskfs only test"
6665
6666         mkdir_on_mdt0 $td || error "can't mkdir"
6667         # turn it htree (don't really needed)
6668         createmany -m $td/f 3000 || error "can't createmany"
6669
6670         # here is an example of debugfs output for htree command:
6671         # Entry #0: Hash 0x00000000, block 27
6672         # Reading directory block 27, phys 16760
6673         # 938 0x0016fb58-7f3d21f5 (32) f775   834 0x001db8c8-d31a4e0e (32) f671
6674         # 1085 0x0040cb70-4498abd4 (32) f922   1850 0x0066a1e6-f6f0dc69 (32) f1687
6675         # 2005 0x006c1a46-ef466058 (32) f1842   2025 0x007e64d4-8b28b734 (32) f1862
6676         # 642 0x008b53a0-77adc601 (32) f479   447 0x009ec152-af54eea3 (32) f284
6677         # 1740 0x00c38f56-ed310e61 (32) f1577   2165 0x00cdfd66-f429a93f (32) f2002
6678         # 930 0x00d7ada4-b80421c9 (32) f767   1946 0x00da6a7a-e8080600 (32) f1783
6679         # 273 0x00f8ea00-760bf97c (32) f110   1589 0x0103c4ee-94fad5dd (32) f1426
6680         # 1383 0x01193516-83120b48 (32) f1220   2379 0x01431e3c-e85b5bd9 (32) f2216
6681         #
6682         # find couple names in a same htree block of the same size
6683         mdt_dev=$(facet_device $SINGLEMDS)
6684         de=( $(do_facet $SINGLEMDS "debugfs -c -R 'htree /ROOT/$tdir' $mdt_dev" |
6685                 awk '/Reading directory block/ { getline; print $4,$8; exit; }' ))
6686         local de1=${de[0]}
6687         local de2=${de[1]}
6688         [[ $de1 == "" || $de2 == "" ]] && error "de1=$de1 de2=$de2"
6689         echo "USE: $de1 $de2"
6690         # release one mkdir will lookup
6691         rm $DIR/$tdir/$de2
6692 #define OBD_FAIL_MDS_PAUSE_CREATE_AFTER_LOOKUP  0x2401
6693         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x80002401 fail_val=5
6694         mkdir $DIR/$tdir/$de2 &
6695         sleep 0.3
6696         local PID1=$!
6697         # recreate $de2
6698         mkdir $DIR2/$tdir/$de2
6699         # release space $de1 (should be enough to save $de2)
6700         rm $DIR2/$tdir/$de1
6701         # ready to create a dup of $de2
6702         wait $PID1
6703         local found=$(ls $DIR/$tdir/|grep "^$de2\$"|wc -l)
6704         (( $found == 1 )) || error "found $found"
6705 }
6706 run_test 115 "ldiskfs doesn't check direntry for uniqueness"
6707
6708 test_116() {
6709         (( $MDSCOUNT >= 2 )) || skip "needs >= 2 MDTs"
6710         (( $MDS1_VERSION >= $(version_code 2.15.61) )) ||
6711                 skip "Need MDS version at least 2.15.61 for intent mkdir"
6712
6713         local mdt_idx
6714         local save="$TMP/$TESTSUITE-$TESTNAME.parameters"
6715
6716         save_lustre_params client "llite.*.intent_mkdir" > $save
6717         stack_trap "restore_lustre_params < $save; rm -f $save" EXIT
6718         $LCTL set_param llite.*.intent_mkdir=1
6719
6720         $LFS mkdir -c$MDSCOUNT -i0 $DIR/$tdir ||
6721                 error "$LFS mkdir $DIR/$tdir failed"
6722         echo "MD layout $DIR/$tdir:"
6723         $LFS getdirstripe $DIR/$tdir
6724         echo "mkdir $DIR/$tdir/tdir0"
6725         mkdir $DIR/$tdir/tdir0 || error "mkdir tdir0 failed"
6726         echo "setdirstripe -D -i1 $DIR2/$tdir/tdir0"
6727         $LFS setdirstripe -D -i1 $DIR2/$tdir/tdir0 ||
6728                 error "$LFS setdirstripe $DIR2/$tdir/tdir0 failed"
6729         echo "mkdir $DIR/$tdir/tdir0/tdir11"
6730         mkdir $DIR/$tdir/tdir0/tdir11 || error "mkdir tdir0/tdir11 failed"
6731         $LFS getdirstripe $DIR/$tdir/tdir0
6732         $LFS getdirstripe $DIR/$tdir/tdir0/tdir11
6733
6734         mdt_idx=$($LFS getstripe -m $DIR/$tdir/tdir0/tdir11)
6735         [ $mdt_idx == 1 ] ||
6736                 error "$DIR/$tdir/tdir0/tdir11 on wrong MDT $mdt_idx"
6737 }
6738 run_test 116 "DNE: Set default LMV layout from a remote client"
6739
6740 log "cleanup: ======================================================"
6741
6742 # kill and wait in each test only guarentee script finish, but command in script
6743 # like 'rm' 'chmod' may still be running, wait for all commands to finish
6744 # otherwise umount below will fail
6745 [ "$(mount | grep $MOUNT2)" ] && wait_update $HOSTNAME "fuser -m $MOUNT2" "" ||
6746         true
6747
6748 complete_test $SECONDS
6749 rm -f $SAMPLE_FILE
6750 check_and_cleanup_lustre
6751 exit_status