lustre/tests/sanity.sh

   1 #!/bin/bash
   2 #
   3 # Run select tests by setting ONLY, or as arguments to the script.
   4 # Skip specific tests by setting EXCEPT.
   5 #
   6 # e.g. ONLY="22 23" or ONLY="`seq 32 39`" or EXCEPT="31"
   7 set -e
   8
   9 ONLY=${ONLY:-"$*"}
  10
  11 # Check Grants after these tests
  12 GRANT_CHECK_LIST="$GRANT_CHECK_LIST 42a 42b 42c 42d 42e 63a 63b 64a 64b 64c 64d"
  13
  14 OSC=${OSC:-"osc"}
  15
  16 CC=${CC:-cc}
  17 CREATETEST=${CREATETEST:-createtest}
  18 LVERIFY=${LVERIFY:-ll_dirstripe_verify}
  19 OPENFILE=${OPENFILE:-openfile}
  20 OPENUNLINK=${OPENUNLINK:-openunlink}
  21 READS=${READS:-"reads"}
  22 MUNLINK=${MUNLINK:-munlink}
  23 SOCKETSERVER=${SOCKETSERVER:-socketserver}
  24 SOCKETCLIENT=${SOCKETCLIENT:-socketclient}
  25 MEMHOG=${MEMHOG:-memhog}
  26 DIRECTIO=${DIRECTIO:-directio}
  27 ACCEPTOR_PORT=${ACCEPTOR_PORT:-988}
  28 DEF_STRIPE_COUNT=-1
  29 CHECK_GRANT=${CHECK_GRANT:-"yes"}
  30 GRANT_CHECK_LIST=${GRANT_CHECK_LIST:-""}
  31 export PARALLEL=${PARALLEL:-"no"}
  32
  33 TRACE=${TRACE:-""}
  34 LUSTRE_TESTS_API_DIR=${LUSTRE_TESTS_API_DIR:-${LUSTRE}/tests/clientapi}
  35 LUSTRE=${LUSTRE:-$(dirname $0)/..}
  36 . $LUSTRE/tests/test-framework.sh
  37 init_test_env $@
  38
  39 init_logging
  40
  41 ALWAYS_EXCEPT="$SANITY_EXCEPT "
  42 # bug number for skipped test: LU-9693 LU-6493 LU-9693
  43 ALWAYS_EXCEPT+="               42a     42b     42c "
  44 # bug number:    LU-8411 LU-9054
  45 ALWAYS_EXCEPT+=" 407     312 "
  46
  47 if $SHARED_KEY; then
  48         # bug number:    LU-9795 LU-9795 LU-9795 LU-9795
  49         ALWAYS_EXCEPT+=" 17n     60a     133g    300f "
  50 fi
  51
  52 # skip the grant tests for ARM until they are fixed
  53 if [[ $(uname -m) = aarch64 ]]; then
  54         # bug number:    LU-11596
  55         ALWAYS_EXCEPT+=" $GRANT_CHECK_LIST"
  56         # bug number:    LU-11671 LU-11667 LU-11729 LU-4398
  57         ALWAYS_EXCEPT+=" 45       317      810       817"
  58 fi
  59
  60 #                                  5          12          (min)"
  61 [ "$SLOW" = "no" ] && EXCEPT_SLOW="27m 64b 68 71 115 300o"
  62
  63 if [ "$mds1_FSTYPE" = "zfs" ]; then
  64         # bug number for skipped test: LU-1957
  65         ALWAYS_EXCEPT="$ALWAYS_EXCEPT  180"
  66         #                                               13    (min)"
  67         [ "$SLOW" = "no" ] && EXCEPT_SLOW="$EXCEPT_SLOW 51b"
  68 fi
  69
  70 # Get the SLES distro version
  71 #
  72 # Returns a version string that should only be used in comparing
  73 # strings returned by version_code()
  74 sles_version_code()
  75 {
  76         local version=$(grep VERSION_ID /etc/os-release | cut -d'"' -f2)
  77
  78         # All SuSE Linux versions have one decimal. version_code expects two
  79         local sles_version=$version.0
  80         version_code $sles_version
  81 }
  82
  83 # Check if we are running on Ubuntu or SLES so we can make decisions on
  84 # what tests to run
  85 if [ -r /etc/SuSE-release ]; then
  86         sles_version=$(sles_version_code)
  87         [ $sles_version -lt $(version_code 11.4.0) ] &&
  88                 # bug number for skipped test: LU-4341
  89                 ALWAYS_EXCEPT="$ALWAYS_EXCEPT  170"
  90         [ $sles_version -lt $(version_code 12.0.0) ] &&
  91                 # bug number for skipped test: LU-3703
  92                 ALWAYS_EXCEPT="$ALWAYS_EXCEPT  234"
  93 elif [ -r /etc/os-release ]; then
  94         if grep -qi ubuntu /etc/os-release; then
  95                 ubuntu_version=$(version_code $(sed -n -e 's/"//g' \
  96                                                 -e 's/^VERSION=//p' \
  97                                                 /etc/os-release |
  98                                                 awk '{ print $1 }'))
  99
 100                 if [[ $ubuntu_version -gt $(version_code 16.0.0) ]]; then
 101                         # bug number for skipped test:
 102                         #                LU-10334 LU-10366
 103                         ALWAYS_EXCEPT+=" 103a     410"
 104                 fi
 105         fi
 106 fi
 107
 108 build_test_filter
 109 FAIL_ON_ERROR=false
 110
 111 cleanup() {
 112         echo -n "cln.."
 113         pgrep ll_sa > /dev/null && { echo "There are ll_sa thread not exit!"; exit 20; }
 114         cleanupall ${FORCE} $* || { echo "FAILed to clean up"; exit 20; }
 115 }
 116 setup() {
 117         echo -n "mnt.."
 118         load_modules
 119         setupall || exit 10
 120         echo "done"
 121 }
 122
 123 check_swap_layouts_support()
 124 {
 125         $LCTL get_param -n llite.*.sbi_flags | grep -q layout ||
 126                 skip "Does not support layout lock."
 127 }
 128
 129 check_and_setup_lustre
 130 DIR=${DIR:-$MOUNT}
 131 assert_DIR
 132
 133 MAXFREE=${MAXFREE:-$((200000 * $OSTCOUNT))}
 134
 135 [ -f $DIR/d52a/foo ] && chattr -a $DIR/d52a/foo
 136 [ -f $DIR/d52b/foo ] && chattr -i $DIR/d52b/foo
 137 rm -rf $DIR/[Rdfs][0-9]*
 138
 139 # $RUNAS_ID may get set incorrectly somewhere else
 140 [ $UID -eq 0 -a $RUNAS_ID -eq 0 ] &&
 141         error "\$RUNAS_ID set to 0, but \$UID is also 0!"
 142
 143 check_runas_id $RUNAS_ID $RUNAS_GID $RUNAS
 144
 145 if [ "${ONLY}" = "MOUNT" ] ; then
 146         echo "Lustre is up, please go on"
 147         exit
 148 fi
 149
 150 echo "preparing for tests involving mounts"
 151 EXT2_DEV=${EXT2_DEV:-$TMP/SANITY.LOOP}
 152 touch $EXT2_DEV
 153 mke2fs -j -F $EXT2_DEV 8000 > /dev/null
 154 echo # add a newline after mke2fs.
 155
 156 umask 077
 157
 158 OLDDEBUG=$(lctl get_param -n debug 2> /dev/null)
 159 lctl set_param debug=-1 2> /dev/null || true
 160 test_0a() {
 161         touch $DIR/$tfile
 162         $CHECKSTAT -t file $DIR/$tfile || error "$tfile is not a file"
 163         rm $DIR/$tfile
 164         $CHECKSTAT -a $DIR/$tfile || error "$tfile was not removed"
 165 }
 166 run_test 0a "touch; rm ====================="
 167
 168 test_0b() {
 169         chmod 0755 $DIR || error "chmod 0755 $DIR failed"
 170         $CHECKSTAT -p 0755 $DIR || error "$DIR permission is not 0755"
 171 }
 172 run_test 0b "chmod 0755 $DIR ============================="
 173
 174 test_0c() {
 175         $LCTL get_param mdc.*.import | grep "state: FULL" ||
 176                 error "import not FULL"
 177         $LCTL get_param mdc.*.import | grep "target: $FSNAME-MDT" ||
 178                 error "bad target"
 179 }
 180 run_test 0c "check import proc"
 181
 182 test_0d() { # LU-3397
 183         [ $MGS_VERSION -lt $(version_code 2.10.57) ] &&
 184                 skip "proc exports not supported before 2.10.57"
 185
 186         local mgs_exp="mgs.MGS.exports"
 187         local client_uuid=$($LCTL get_param -n mgc.*.uuid)
 188         local exp_client_nid
 189         local exp_client_version
 190         local exp_val
 191         local imp_val
 192         local temp_imp=$DIR/$tfile.import
 193         local temp_exp=$DIR/$tfile.export
 194
 195         # save mgc import file to $temp_imp
 196         $LCTL get_param mgc.*.import | tee $temp_imp
 197         # Check if client uuid is found in MGS export
 198         for exp_client_nid in $(do_facet mgs $LCTL get_param -N $mgs_exp.*); do
 199                 [ $(do_facet mgs $LCTL get_param -n $exp_client_nid.uuid) == \
 200                         $client_uuid ] &&
 201                         break;
 202         done
 203         # save mgs export file to $temp_exp
 204         do_facet mgs $LCTL get_param $exp_client_nid.export | tee $temp_exp
 205
 206         # Compare the value of field "connect_flags"
 207         imp_val=$(grep "connect_flags" $temp_imp)
 208         exp_val=$(grep "connect_flags" $temp_exp)
 209         [ "$exp_val" == "$imp_val" ] ||
 210                 error "export flags '$exp_val' != import flags '$imp_val'"
 211
 212         # Compare the value of client version
 213         exp_client_version=$(awk '/target_version:/ { print $2 }' $temp_exp)
 214         exp_val=$(version_code $exp_client_version)
 215         imp_val=$CLIENT_VERSION
 216         [ "$exp_val" == "$imp_val" ] ||
 217                 error "export client version '$exp_val' != '$imp_val'"
 218 }
 219 run_test 0d "check export proc ============================="
 220
 221 test_1() {
 222         test_mkdir $DIR/$tdir
 223         test_mkdir $DIR/$tdir/d2
 224         mkdir $DIR/$tdir/d2 && error "we expect EEXIST, but not returned"
 225         $CHECKSTAT -t dir $DIR/$tdir/d2 || error "$tdir/d2 is not a dir"
 226         rmdir $DIR/$tdir/d2
 227         rmdir $DIR/$tdir
 228         $CHECKSTAT -a $DIR/$tdir || error "$tdir was not removed"
 229 }
 230 run_test 1 "mkdir; remkdir; rmdir"
 231
 232 test_2() {
 233         test_mkdir $DIR/$tdir
 234         touch $DIR/$tdir/$tfile || error "touch $tdir/$tfile failed"
 235         $CHECKSTAT -t file $DIR/$tdir/$tfile || error "$tdir/$tfile not a file"
 236         rm -r $DIR/$tdir
 237         $CHECKSTAT -a $DIR/$tdir/$tfile || error "$tdir/$file is not removed"
 238 }
 239 run_test 2 "mkdir; touch; rmdir; check file"
 240
 241 test_3() {
 242         test_mkdir $DIR/$tdir
 243         $CHECKSTAT -t dir $DIR/$tdir || error "$tdir is not a directory"
 244         touch $DIR/$tdir/$tfile
 245         $CHECKSTAT -t file $DIR/$tdir/$tfile || error "$tdir/$tfile not a file"
 246         rm -r $DIR/$tdir
 247         $CHECKSTAT -a $DIR/$tdir || error "$tdir is not removed"
 248 }
 249 run_test 3 "mkdir; touch; rmdir; check dir"
 250
 251 # LU-4471 - failed rmdir on remote directories still removes directory on MDT0
 252 test_4() {
 253         test_mkdir -i 1 $DIR/$tdir
 254
 255         touch $DIR/$tdir/$tfile ||
 256                 error "Create file under remote directory failed"
 257
 258         rmdir $DIR/$tdir &&
 259                 error "Expect error removing in-use dir $DIR/$tdir"
 260
 261         test -d $DIR/$tdir || error "Remote directory disappeared"
 262
 263         rm -rf $DIR/$tdir || error "remove remote dir error"
 264 }
 265 run_test 4 "mkdir; touch dir/file; rmdir; checkdir (expect error)"
 266
 267 test_5() {
 268         test_mkdir $DIR/$tdir
 269         test_mkdir $DIR/$tdir/d2
 270         chmod 0707 $DIR/$tdir/d2 || error "chmod 0707 $tdir/d2 failed"
 271         $CHECKSTAT -t dir -p 0707 $DIR/$tdir/d2 || error "$tdir/d2 not mode 707"
 272         $CHECKSTAT -t dir $DIR/$tdir/d2 || error "$tdir/d2 is not a directory"
 273 }
 274 run_test 5 "mkdir .../d5 .../d5/d2; chmod .../d5/d2"
 275
 276 test_6a() {
 277         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
 278         chmod 0666 $DIR/$tfile || error "chmod 0666 $tfile failed"
 279         $CHECKSTAT -t file -p 0666 -u \#$UID $DIR/$tfile ||
 280                 error "$tfile does not have perm 0666 or UID $UID"
 281         $RUNAS chmod 0444 $DIR/$tfile && error "chmod $tfile worked on UID $UID"
 282         $CHECKSTAT -t file -p 0666 -u \#$UID $DIR/$tfile ||
 283                 error "$tfile should be 0666 and owned by UID $UID"
 284 }
 285 run_test 6a "touch f6a; chmod f6a; $RUNAS chmod f6a (should return error) =="
 286
 287 test_6c() {
 288         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID"
 289
 290         touch $DIR/$tfile
 291         chown $RUNAS_ID $DIR/$tfile || error "chown $RUNAS_ID $file failed"
 292         $CHECKSTAT -t file -u \#$RUNAS_ID $DIR/$tfile ||
 293                 error "$tfile should be owned by UID $RUNAS_ID"
 294         $RUNAS chown $UID $DIR/$tfile && error "chown $UID $file succeeded"
 295         $CHECKSTAT -t file -u \#$RUNAS_ID $DIR/$tfile ||
 296                 error "$tfile should be owned by UID $RUNAS_ID"
 297 }
 298 run_test 6c "touch f6c; chown f6c; $RUNAS chown f6c (should return error) =="
 299
 300 test_6e() {
 301         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID"
 302
 303         touch $DIR/$tfile
 304         chgrp $RUNAS_ID $DIR/$tfile || error "chgrp $RUNAS_ID $file failed"
 305         $CHECKSTAT -t file -u \#$UID -g \#$RUNAS_ID $DIR/$tfile ||
 306                 error "$tfile should be owned by GID $UID"
 307         $RUNAS chgrp $UID $DIR/$tfile && error "chgrp $UID $file succeeded"
 308         $CHECKSTAT -t file -u \#$UID -g \#$RUNAS_ID $DIR/$tfile ||
 309                 error "$tfile should be owned by UID $UID and GID $RUNAS_ID"
 310 }
 311 run_test 6e "touch+chgrp $tfile; $RUNAS chgrp $tfile (should return error)"
 312
 313 test_6g() {
 314         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID"
 315
 316         test_mkdir $DIR/$tdir
 317         chmod 777 $DIR/$tdir || error "chmod 0777 $tdir failed"
 318         $RUNAS mkdir $DIR/$tdir/d || error "mkdir $tdir/d failed"
 319         chmod g+s $DIR/$tdir/d || error "chmod g+s $tdir/d failed"
 320         test_mkdir $DIR/$tdir/d/subdir
 321         $CHECKSTAT -g \#$RUNAS_GID $DIR/$tdir/d/subdir ||
 322                 error "$tdir/d/subdir should be GID $RUNAS_GID"
 323         if [[ $MDSCOUNT -gt 1 ]]; then
 324                 # check remote dir sgid inherite
 325                 $LFS mkdir -i 0 $DIR/$tdir.local ||
 326                         error "mkdir $tdir.local failed"
 327                 chmod g+s $DIR/$tdir.local ||
 328                         error "chmod $tdir.local failed"
 329                 chgrp $RUNAS_GID $DIR/$tdir.local ||
 330                         error "chgrp $tdir.local failed"
 331                 $LFS mkdir -i 1 $DIR/$tdir.local/$tdir.remote ||
 332                         error "mkdir $tdir.remote failed"
 333                 $CHECKSTAT -g \#$RUNAS_GID $DIR/$tdir.local/$tdir.remote ||
 334                         error "$tdir.remote should be owned by $UID.$RUNAS_ID"
 335                 $CHECKSTAT -p 02755 $DIR/$tdir.local/$tdir.remote ||
 336                         error "$tdir.remote should be mode 02755"
 337         fi
 338 }
 339 run_test 6g "verify new dir in sgid dir inherits group"
 340
 341 test_6h() { # bug 7331
 342         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID"
 343
 344         touch $DIR/$tfile || error "touch failed"
 345         chown $RUNAS_ID:$RUNAS_GID $DIR/$tfile || error "initial chown failed"
 346         $RUNAS -G$RUNAS_GID chown $RUNAS_ID:0 $DIR/$tfile &&
 347                 error "chown $RUNAS_ID:0 $tfile worked as GID $RUNAS_GID"
 348         $CHECKSTAT -t file -u \#$RUNAS_ID -g \#$RUNAS_GID $DIR/$tfile ||
 349                 error "$tdir/$tfile should be UID $RUNAS_UID GID $RUNAS_GID"
 350 }
 351 run_test 6h "$RUNAS chown RUNAS_ID.0 .../$tfile (should return error)"
 352
 353 test_7a() {
 354         test_mkdir $DIR/$tdir
 355         $MCREATE $DIR/$tdir/$tfile
 356         chmod 0666 $DIR/$tdir/$tfile
 357         $CHECKSTAT -t file -p 0666 $DIR/$tdir/$tfile ||
 358                 error "$tdir/$tfile should be mode 0666"
 359 }
 360 run_test 7a "mkdir .../d7; mcreate .../d7/f; chmod .../d7/f ===="
 361
 362 test_7b() {
 363         if [ ! -d $DIR/$tdir ]; then
 364                 test_mkdir $DIR/$tdir
 365         fi
 366         $MCREATE $DIR/$tdir/$tfile
 367         echo -n foo > $DIR/$tdir/$tfile
 368         [ "$(cat $DIR/$tdir/$tfile)" = "foo" ] || error "$tdir/$tfile not 'foo'"
 369         $CHECKSTAT -t file -s 3 $DIR/$tdir/$tfile || error "$tfile size not 3"
 370 }
 371 run_test 7b "mkdir .../d7; mcreate d7/f2; echo foo > d7/f2 ====="
 372
 373 test_8() {
 374         test_mkdir $DIR/$tdir
 375         touch $DIR/$tdir/$tfile
 376         chmod 0666 $DIR/$tdir/$tfile
 377         $CHECKSTAT -t file -p 0666 $DIR/$tdir/$tfile ||
 378                 error "$tfile mode not 0666"
 379 }
 380 run_test 8 "mkdir .../d8; touch .../d8/f; chmod .../d8/f ======="
 381
 382 test_9() {
 383         test_mkdir $DIR/$tdir
 384         test_mkdir $DIR/$tdir/d2
 385         test_mkdir $DIR/$tdir/d2/d3
 386         $CHECKSTAT -t dir $DIR/$tdir/d2/d3 || error "$tdir/d2/d3 not a dir"
 387 }
 388 run_test 9 "mkdir .../d9 .../d9/d2 .../d9/d2/d3 ================"
 389
 390 test_10() {
 391         test_mkdir $DIR/$tdir
 392         test_mkdir $DIR/$tdir/d2
 393         touch $DIR/$tdir/d2/$tfile
 394         $CHECKSTAT -t file $DIR/$tdir/d2/$tfile ||
 395                 error "$tdir/d2/$tfile not a file"
 396 }
 397 run_test 10 "mkdir .../d10 .../d10/d2; touch .../d10/d2/f ======"
 398
 399 test_11() {
 400         test_mkdir $DIR/$tdir
 401         test_mkdir $DIR/$tdir/d2
 402         chmod 0666 $DIR/$tdir/d2
 403         chmod 0705 $DIR/$tdir/d2
 404         $CHECKSTAT -t dir -p 0705 $DIR/$tdir/d2 ||
 405                 error "$tdir/d2 mode not 0705"
 406 }
 407 run_test 11 "mkdir .../d11 d11/d2; chmod .../d11/d2 ============"
 408
 409 test_12() {
 410         test_mkdir $DIR/$tdir
 411         touch $DIR/$tdir/$tfile
 412         chmod 0666 $DIR/$tdir/$tfile
 413         chmod 0654 $DIR/$tdir/$tfile
 414         $CHECKSTAT -t file -p 0654 $DIR/$tdir/$tfile ||
 415                 error "$tdir/d2 mode not 0654"
 416 }
 417 run_test 12 "touch .../d12/f; chmod .../d12/f .../d12/f ========"
 418
 419 test_13() {
 420         test_mkdir $DIR/$tdir
 421         dd if=/dev/zero of=$DIR/$tdir/$tfile count=10
 422         >  $DIR/$tdir/$tfile
 423         $CHECKSTAT -t file -s 0 $DIR/$tdir/$tfile ||
 424                 error "$tdir/$tfile size not 0 after truncate"
 425 }
 426 run_test 13 "creat .../d13/f; dd .../d13/f; > .../d13/f ========"
 427
 428 test_14() {
 429         test_mkdir $DIR/$tdir
 430         touch $DIR/$tdir/$tfile
 431         rm $DIR/$tdir/$tfile
 432         $CHECKSTAT -a $DIR/$tdir/$tfile || error "$tdir/$tfile not removed"
 433 }
 434 run_test 14 "touch .../d14/f; rm .../d14/f; rm .../d14/f ======="
 435
 436 test_15() {
 437         test_mkdir $DIR/$tdir
 438         touch $DIR/$tdir/$tfile
 439         mv $DIR/$tdir/$tfile $DIR/$tdir/${tfile}_2
 440         $CHECKSTAT -t file $DIR/$tdir/${tfile}_2 ||
 441                 error "$tdir/${tfile_2} not a file after rename"
 442         rm $DIR/$tdir/${tfile}_2 || error "unlink failed after rename"
 443 }
 444 run_test 15 "touch .../d15/f; mv .../d15/f .../d15/f2 =========="
 445
 446 test_16() {
 447         test_mkdir $DIR/$tdir
 448         touch $DIR/$tdir/$tfile
 449         rm -rf $DIR/$tdir/$tfile
 450         $CHECKSTAT -a $DIR/$tdir/$tfile || error "$tdir/$tfile not removed"
 451 }
 452 run_test 16 "touch .../d16/f; rm -rf .../d16/f"
 453
 454 test_17a() {
 455         test_mkdir $DIR/$tdir
 456         touch $DIR/$tdir/$tfile
 457         ln -s $DIR/$tdir/$tfile $DIR/$tdir/l-exist
 458         ls -l $DIR/$tdir
 459         $CHECKSTAT -l $DIR/$tdir/$tfile $DIR/$tdir/l-exist ||
 460                 error "$tdir/l-exist not a symlink"
 461         $CHECKSTAT -f -t f $DIR/$tdir/l-exist ||
 462                 error "$tdir/l-exist not referencing a file"
 463         rm -f $DIR/$tdir/l-exist
 464         $CHECKSTAT -a $DIR/$tdir/l-exist || error "$tdir/l-exist not removed"
 465 }
 466 run_test 17a "symlinks: create, remove (real)"
 467
 468 test_17b() {
 469         test_mkdir $DIR/$tdir
 470         ln -s no-such-file $DIR/$tdir/l-dangle
 471         ls -l $DIR/$tdir
 472         $CHECKSTAT -l no-such-file $DIR/$tdir/l-dangle ||
 473                 error "$tdir/l-dangle not referencing no-such-file"
 474         $CHECKSTAT -fa $DIR/$tdir/l-dangle ||
 475                 error "$tdir/l-dangle not referencing non-existent file"
 476         rm -f $DIR/$tdir/l-dangle
 477         $CHECKSTAT -a $DIR/$tdir/l-dangle || error "$tdir/l-dangle not removed"
 478 }
 479 run_test 17b "symlinks: create, remove (dangling)"
 480
 481 test_17c() { # bug 3440 - don't save failed open RPC for replay
 482         test_mkdir $DIR/$tdir
 483         ln -s foo $DIR/$tdir/$tfile
 484         cat $DIR/$tdir/$tfile && error "opened non-existent symlink" || true
 485 }
 486 run_test 17c "symlinks: open dangling (should return error)"
 487
 488 test_17d() {
 489         test_mkdir $DIR/$tdir
 490         ln -s foo $DIR/$tdir/$tfile
 491         touch $DIR/$tdir/$tfile || error "creating to new symlink"
 492 }
 493 run_test 17d "symlinks: create dangling"
 494
 495 test_17e() {
 496         test_mkdir $DIR/$tdir
 497         local foo=$DIR/$tdir/$tfile
 498         ln -s $foo $foo || error "create symlink failed"
 499         ls -l $foo || error "ls -l failed"
 500         ls $foo && error "ls not failed" || true
 501 }
 502 run_test 17e "symlinks: create recursive symlink (should return error)"
 503
 504 test_17f() {
 505         test_mkdir $DIR/$tdir
 506         ln -s 1234567890/2234567890/3234567890/4234567890 $DIR/$tdir/111
 507         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890 $DIR/$tdir/222
 508         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890 $DIR/$tdir/333
 509         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890 $DIR/$tdir/444
 510         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890/c234567890/d234567890/f234567890 $DIR/$tdir/555
 511         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890/c234567890/d234567890/f234567890/aaaaaaaaaa/bbbbbbbbbb/cccccccccc/dddddddddd/eeeeeeeeee/ffffffffff/ $DIR/$tdir/666
 512         ls -l  $DIR/$tdir
 513 }
 514 run_test 17f "symlinks: long and very long symlink name"
 515
 516 # str_repeat(S, N) generate a string that is string S repeated N times
 517 str_repeat() {
 518         local s=$1
 519         local n=$2
 520         local ret=''
 521         while [ $((n -= 1)) -ge 0 ]; do
 522                 ret=$ret$s
 523         done
 524         echo $ret
 525 }
 526
 527 # Long symlinks and LU-2241
 528 test_17g() {
 529         test_mkdir $DIR/$tdir
 530         local TESTS="59 60 61 4094 4095"
 531
 532         # Fix for inode size boundary in 2.1.4
 533         [ $MDS1_VERSION -lt $(version_code 2.1.4) ] &&
 534                 TESTS="4094 4095"
 535
 536         # Patch not applied to 2.2 or 2.3 branches
 537         [ $MDS1_VERSION -ge $(version_code 2.2.0) ] &&
 538         [ $MDS1_VERSION -le $(version_code 2.3.55) ] &&
 539                 TESTS="4094 4095"
 540
 541         # skip long symlink name for rhel6.5.
 542         # rhel6.5 has a limit (PATH_MAX - sizeof(struct filename))
 543         grep -q '6.5' /etc/redhat-release &>/dev/null &&
 544                 TESTS="59 60 61 4062 4063"
 545
 546         for i in $TESTS; do
 547                 local SYMNAME=$(str_repeat 'x' $i)
 548                 ln -s $SYMNAME $DIR/$tdir/f$i || error "failed $i-char symlink"
 549                 readlink $DIR/$tdir/f$i || error "failed $i-char readlink"
 550         done
 551 }
 552 run_test 17g "symlinks: really long symlink name and inode boundaries"
 553
 554 test_17h() { #bug 17378
 555         [ $PARALLEL == "yes" ] && skip "skip parallel run"
 556         remote_mds_nodsh && skip "remote MDS with nodsh"
 557
 558         local mdt_idx
 559
 560         test_mkdir $DIR/$tdir
 561         mdt_idx=$($LFS getdirstripe -i $DIR/$tdir)
 562         $LFS setstripe -c -1 $DIR/$tdir
 563         #define OBD_FAIL_MDS_LOV_PREP_CREATE 0x141
 564         do_facet mds$((mdt_idx + 1)) lctl set_param fail_loc=0x80000141
 565         touch $DIR/$tdir/$tfile || true
 566 }
 567 run_test 17h "create objects: lov_free_memmd() doesn't lbug"
 568
 569 test_17i() { #bug 20018
 570         [ $PARALLEL == "yes" ] && skip "skip parallel run"
 571         remote_mds_nodsh && skip "remote MDS with nodsh"
 572
 573         local foo=$DIR/$tdir/$tfile
 574         local mdt_idx
 575
 576         test_mkdir -c1 $DIR/$tdir
 577         mdt_idx=$($LFS getdirstripe -i $DIR/$tdir)
 578         ln -s $foo $foo || error "create symlink failed"
 579 #define OBD_FAIL_MDS_READLINK_EPROTO     0x143
 580         do_facet mds$((mdt_idx + 1)) lctl set_param fail_loc=0x80000143
 581         ls -l $foo && error "error not detected"
 582         return 0
 583 }
 584 run_test 17i "don't panic on short symlink (should return error)"
 585
 586 test_17k() { #bug 22301
 587         [ $PARALLEL == "yes" ] && skip "skip parallel run"
 588         [[ -z "$(which rsync 2>/dev/null)" ]] &&
 589                 skip "no rsync command"
 590         rsync --help | grep -q xattr ||
 591                 skip_env "$(rsync --version | head -n1) does not support xattrs"
 592         test_mkdir $DIR/$tdir
 593         test_mkdir $DIR/$tdir.new
 594         touch $DIR/$tdir/$tfile
 595         ln -s $DIR/$tdir/$tfile $DIR/$tdir/$tfile.lnk
 596         rsync -av -X $DIR/$tdir/ $DIR/$tdir.new ||
 597                 error "rsync failed with xattrs enabled"
 598 }
 599 run_test 17k "symlinks: rsync with xattrs enabled"
 600
 601 test_17l() { # LU-279
 602         [[ -z "$(which getfattr 2>/dev/null)" ]] &&
 603                 skip "no getfattr command"
 604
 605         test_mkdir $DIR/$tdir
 606         touch $DIR/$tdir/$tfile
 607         ln -s $DIR/$tdir/$tfile $DIR/$tdir/$tfile.lnk
 608         for path in "$DIR/$tdir" "$DIR/$tdir/$tfile" "$DIR/$tdir/$tfile.lnk"; do
 609                 # -h to not follow symlinks. -m '' to list all the xattrs.
 610                 # grep to remove first line: '# file: $path'.
 611                 for xattr in `getfattr -hm '' $path 2>/dev/null | grep -v '^#'`;
 612                 do
 613                         lgetxattr_size_check $path $xattr ||
 614                                 error "lgetxattr_size_check $path $xattr failed"
 615                 done
 616         done
 617 }
 618 run_test 17l "Ensure lgetxattr's returned xattr size is consistent"
 619
 620 # LU-1540
 621 test_17m() {
 622         [ $PARALLEL == "yes" ] && skip "skip parallel run"
 623         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip_env "ldiskfs only test"
 624         remote_mds_nodsh && skip "remote MDS with nodsh"
 625         [ $MDS1_VERSION -ge $(version_code 2.2.0) ] &&
 626         [ $MDS1_VERSION -le $(version_code 2.2.93) ] &&
 627                 skip "MDS 2.2.0-2.2.93 do not NUL-terminate symlinks"
 628
 629         local short_sym="0123456789"
 630         local wdir=$DIR/$tdir
 631         local i
 632
 633         test_mkdir $wdir
 634         long_sym=$short_sym
 635         # create a long symlink file
 636         for ((i = 0; i < 4; ++i)); do
 637                 long_sym=${long_sym}${long_sym}
 638         done
 639
 640         echo "create 512 short and long symlink files under $wdir"
 641         for ((i = 0; i < 256; ++i)); do
 642                 ln -sf ${long_sym}"a5a5" $wdir/long-$i
 643                 ln -sf ${short_sym}"a5a5" $wdir/short-$i
 644         done
 645
 646         echo "erase them"
 647         rm -f $wdir/*
 648         sync
 649         wait_delete_completed
 650
 651         echo "recreate the 512 symlink files with a shorter string"
 652         for ((i = 0; i < 512; ++i)); do
 653                 # rewrite the symlink file with a shorter string
 654                 ln -sf ${long_sym} $wdir/long-$i || error "long_sym failed"
 655                 ln -sf ${short_sym} $wdir/short-$i || error "short_sym failed"
 656         done
 657
 658         local mds_index=$(($($LFS getstripe -m $wdir) + 1))
 659         local devname=$(mdsdevname $mds_index)
 660
 661         echo "stop and checking mds${mds_index}:"
 662         # e2fsck should not return error
 663         stop mds${mds_index}
 664         run_e2fsck $(facet_active_host mds${mds_index}) $devname -n
 665         rc=$?
 666
 667         start mds${mds_index} $devname $MDS_MOUNT_OPTS ||
 668                 error "start mds${mds_index} failed"
 669         df $MOUNT > /dev/null 2>&1
 670         [ $rc -eq 0 ] ||
 671                 error "e2fsck detected error for short/long symlink: rc=$rc"
 672         rm -f $wdir/*
 673 }
 674 run_test 17m "run e2fsck against MDT which contains short/long symlink"
 675
 676 check_fs_consistency_17n() {
 677         local mdt_index
 678         local rc=0
 679
 680         # create/unlink in 17n only change 2 MDTs(MDT1/MDT2),
 681         # so it only check MDT1/MDT2 instead of all of MDTs.
 682         for mdt_index in 1 2; do
 683                 local devname=$(mdsdevname $mdt_index)
 684                 # e2fsck should not return error
 685                 stop mds${mdt_index}
 686                 run_e2fsck $(facet_active_host mds$mdt_index) $devname -n ||
 687                         rc=$((rc + $?))
 688
 689                 start mds${mdt_index} $devname $MDS_MOUNT_OPTS ||
 690                         error "mount mds$mdt_index failed"
 691                 df $MOUNT > /dev/null 2>&1
 692         done
 693         return $rc
 694 }
 695
 696 test_17n() {
 697         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
 698         [ $PARALLEL == "yes" ] && skip "skip parallel run"
 699         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip_env "ldiskfs only test"
 700         remote_mds_nodsh && skip "remote MDS with nodsh"
 701         [ $MDS1_VERSION -ge $(version_code 2.2.0) ] &&
 702         [ $MDS1_VERSION -le $(version_code 2.2.93) ] &&
 703                 skip "MDS 2.2.0-2.2.93 do not NUL-terminate symlinks"
 704
 705         local i
 706
 707         test_mkdir $DIR/$tdir
 708         for ((i=0; i<10; i++)); do
 709                 $LFS mkdir -i1 -c2 $DIR/$tdir/remote_dir_${i} ||
 710                         error "create remote dir error $i"
 711                 createmany -o $DIR/$tdir/remote_dir_${i}/f 10 ||
 712                         error "create files under remote dir failed $i"
 713         done
 714
 715         check_fs_consistency_17n ||
 716                 error "e2fsck report error after create files under remote dir"
 717
 718         for ((i = 0; i < 10; i++)); do
 719                 rm -rf $DIR/$tdir/remote_dir_${i} ||
 720                         error "destroy remote dir error $i"
 721         done
 722
 723         check_fs_consistency_17n ||
 724                 error "e2fsck report error after unlink files under remote dir"
 725
 726         [ $MDS1_VERSION -lt $(version_code 2.4.50) ] &&
 727                 skip "lustre < 2.4.50 does not support migrate mv"
 728
 729         for ((i = 0; i < 10; i++)); do
 730                 mkdir -p $DIR/$tdir/remote_dir_${i}
 731                 createmany -o $DIR/$tdir/remote_dir_${i}/f 10 ||
 732                         error "create files under remote dir failed $i"
 733                 $LFS migrate --mdt-index 1 $DIR/$tdir/remote_dir_${i} ||
 734                         error "migrate remote dir error $i"
 735         done
 736         check_fs_consistency_17n || error "e2fsck report error after migration"
 737
 738         for ((i = 0; i < 10; i++)); do
 739                 rm -rf $DIR/$tdir/remote_dir_${i} ||
 740                         error "destroy remote dir error $i"
 741         done
 742
 743         check_fs_consistency_17n || error "e2fsck report error after unlink"
 744 }
 745 run_test 17n "run e2fsck against master/slave MDT which contains remote dir"
 746
 747 test_17o() {
 748         remote_mds_nodsh && skip "remote MDS with nodsh"
 749         [ $MDS1_VERSION -lt $(version_code 2.3.64) ] &&
 750                 skip "Need MDS version at least 2.3.64"
 751
 752         local wdir=$DIR/${tdir}o
 753         local mdt_index
 754         local rc=0
 755
 756         test_mkdir $wdir
 757         touch $wdir/$tfile
 758         mdt_index=$($LFS getstripe -m $wdir/$tfile)
 759         mdt_index=$((mdt_index + 1))
 760
 761         cancel_lru_locks mdc
 762         #fail mds will wait the failover finish then set
 763         #following fail_loc to avoid interfer the recovery process.
 764         fail mds${mdt_index}
 765
 766         #define OBD_FAIL_OSD_LMA_INCOMPAT 0x194
 767         do_facet mds${mdt_index} lctl set_param fail_loc=0x194
 768         ls -l $wdir/$tfile && rc=1
 769         do_facet mds${mdt_index} lctl set_param fail_loc=0
 770         [[ $rc -eq 0 ]] || error "stat file should fail"
 771 }
 772 run_test 17o "stat file with incompat LMA feature"
 773
 774 test_18() {
 775         touch $DIR/$tfile || error "Failed to touch $DIR/$tfile: $?"
 776         ls $DIR || error "Failed to ls $DIR: $?"
 777 }
 778 run_test 18 "touch .../f ; ls ... =============================="
 779
 780 test_19a() {
 781         touch $DIR/$tfile
 782         ls -l $DIR
 783         rm $DIR/$tfile
 784         $CHECKSTAT -a $DIR/$tfile || error "$tfile was not removed"
 785 }
 786 run_test 19a "touch .../f19 ; ls -l ... ; rm .../f19 ==========="
 787
 788 test_19b() {
 789         ls -l $DIR/$tfile && error "ls -l $tfile failed"|| true
 790 }
 791 run_test 19b "ls -l .../f19 (should return error) =============="
 792
 793 test_19c() {
 794         [ $RUNAS_ID -eq $UID ] &&
 795                 skip_env "RUNAS_ID = UID = $UID -- skipping"
 796
 797         $RUNAS touch $DIR/$tfile && error "create non-root file failed" || true
 798 }
 799 run_test 19c "$RUNAS touch .../f19 (should return error) =="
 800
 801 test_19d() {
 802         cat $DIR/f19 && error || true
 803 }
 804 run_test 19d "cat .../f19 (should return error) =============="
 805
 806 test_20() {
 807         touch $DIR/$tfile
 808         rm $DIR/$tfile
 809         touch $DIR/$tfile
 810         rm $DIR/$tfile
 811         touch $DIR/$tfile
 812         rm $DIR/$tfile
 813         $CHECKSTAT -a $DIR/$tfile || error "$tfile was not removed"
 814 }
 815 run_test 20 "touch .../f ; ls -l ..."
 816
 817 test_21() {
 818         test_mkdir $DIR/$tdir
 819         [ -f $DIR/$tdir/dangle ] && rm -f $DIR/$tdir/dangle
 820         ln -s dangle $DIR/$tdir/link
 821         echo foo >> $DIR/$tdir/link
 822         cat $DIR/$tdir/dangle
 823         $CHECKSTAT -t link $DIR/$tdir/link || error "$tdir/link not a link"
 824         $CHECKSTAT -f -t file $DIR/$tdir/link ||
 825                 error "$tdir/link not linked to a file"
 826 }
 827 run_test 21 "write to dangling link"
 828
 829 test_22() {
 830         local wdir=$DIR/$tdir
 831         test_mkdir $wdir
 832         chown $RUNAS_ID:$RUNAS_GID $wdir
 833         (cd $wdir || error "cd $wdir failed";
 834                 $RUNAS tar cf - /etc/hosts /etc/sysconfig/network |
 835                 $RUNAS tar xf -)
 836         ls -lR $wdir/etc || error "ls -lR $wdir/etc failed"
 837         $CHECKSTAT -t dir $wdir/etc || error "checkstat -t dir failed"
 838         $CHECKSTAT -u \#$RUNAS_ID -g \#$RUNAS_GID $wdir/etc ||
 839                 error "checkstat -u failed"
 840 }
 841 run_test 22 "unpack tar archive as non-root user"
 842
 843 # was test_23
 844 test_23a() {
 845         test_mkdir $DIR/$tdir
 846         local file=$DIR/$tdir/$tfile
 847
 848         openfile -f O_CREAT:O_EXCL $file || error "$file create failed"
 849         openfile -f O_CREAT:O_EXCL $file &&
 850                 error "$file recreate succeeded" || true
 851 }
 852 run_test 23a "O_CREAT|O_EXCL in subdir"
 853
 854 test_23b() { # bug 18988
 855         test_mkdir $DIR/$tdir
 856         local file=$DIR/$tdir/$tfile
 857
 858         rm -f $file
 859         echo foo > $file || error "write filed"
 860         echo bar >> $file || error "append filed"
 861         $CHECKSTAT -s 8 $file || error "wrong size"
 862         rm $file
 863 }
 864 run_test 23b "O_APPEND check"
 865
 866 # LU-9409, size with O_APPEND and tiny writes
 867 test_23c() {
 868         local file=$DIR/$tfile
 869
 870         # single dd
 871         dd conv=notrunc oflag=append if=/dev/zero of=$file bs=8 count=800
 872         $CHECKSTAT -s 6400 $file || error "wrong size, expected 6400"
 873         rm -f $file
 874
 875         # racing tiny writes
 876         dd conv=notrunc oflag=append if=/dev/zero of=$file bs=8 count=800 &
 877         dd conv=notrunc oflag=append if=/dev/zero of=$file bs=8 count=800 &
 878         wait
 879         $CHECKSTAT -s 12800 $file || error "wrong size, expected 12800"
 880         rm -f $file
 881
 882         #racing tiny & normal writes
 883         dd conv=notrunc oflag=append if=/dev/zero of=$file bs=4096 count=4 &
 884         dd conv=notrunc oflag=append if=/dev/zero of=$file bs=8 count=100 &
 885         wait
 886         $CHECKSTAT -s 17184 $file || error "wrong size, expected 17184"
 887         rm -f $file
 888
 889         #racing tiny & normal writes 2, ugly numbers
 890         dd conv=notrunc oflag=append if=/dev/zero of=$file bs=4099 count=11 &
 891         dd conv=notrunc oflag=append if=/dev/zero of=$file bs=17 count=173 &
 892         wait
 893         $CHECKSTAT -s 48030 $file || error "wrong size, expected 48030"
 894         rm -f $file
 895 }
 896 run_test 23c "O_APPEND size checks for tiny writes"
 897
 898 # LU-11069 file offset is correct after appending writes
 899 test_23d() {
 900         local file=$DIR/$tfile
 901         local offset
 902
 903         echo CentaurHauls > $file
 904         offset=$($MULTIOP $file oO_WRONLY:O_APPEND:w13Zp)
 905         if ((offset != 26)); then
 906                 error "wrong offset, expected 26, got '$offset'"
 907         fi
 908 }
 909 run_test 23d "file offset is correct after appending writes"
 910
 911 # rename sanity
 912 test_24a() {
 913         echo '-- same directory rename'
 914         test_mkdir $DIR/$tdir
 915         touch $DIR/$tdir/$tfile.1
 916         mv $DIR/$tdir/$tfile.1 $DIR/$tdir/$tfile.2
 917         $CHECKSTAT -t file $DIR/$tdir/$tfile.2 || error "$tfile.2 not a file"
 918 }
 919 run_test 24a "rename file to non-existent target"
 920
 921 test_24b() {
 922         test_mkdir $DIR/$tdir
 923         touch $DIR/$tdir/$tfile.{1,2}
 924         mv $DIR/$tdir/$tfile.1 $DIR/$tdir/$tfile.2
 925         $CHECKSTAT -a $DIR/$tdir/$tfile.1 || error "$tfile.1 exists"
 926         $CHECKSTAT -t file $DIR/$tdir/$tfile.2 || error "$tfile.2 not a file"
 927 }
 928 run_test 24b "rename file to existing target"
 929
 930 test_24c() {
 931         test_mkdir $DIR/$tdir
 932         test_mkdir $DIR/$tdir/d$testnum.1
 933         mv $DIR/$tdir/d$testnum.1 $DIR/$tdir/d$testnum.2
 934         $CHECKSTAT -a $DIR/$tdir/d$testnum.1 || error "d$testnum.1 exists"
 935         $CHECKSTAT -t dir $DIR/$tdir/d$testnum.2 || error "d$testnum.2 not dir"
 936 }
 937 run_test 24c "rename directory to non-existent target"
 938
 939 test_24d() {
 940         test_mkdir -c1 $DIR/$tdir
 941         test_mkdir -c1 $DIR/$tdir/d$testnum.1
 942         test_mkdir -c1 $DIR/$tdir/d$testnum.2
 943         mrename $DIR/$tdir/d$testnum.1 $DIR/$tdir/d$testnum.2
 944         $CHECKSTAT -a $DIR/$tdir/d$testnum.1 || error "d$testnum.1 exists"
 945         $CHECKSTAT -t dir $DIR/$tdir/d$testnum.2 || error "d$testnum.2 not dir"
 946 }
 947 run_test 24d "rename directory to existing target"
 948
 949 test_24e() {
 950         echo '-- cross directory renames --'
 951         test_mkdir $DIR/R5a
 952         test_mkdir $DIR/R5b
 953         touch $DIR/R5a/f
 954         mv $DIR/R5a/f $DIR/R5b/g
 955         $CHECKSTAT -a $DIR/R5a/f || error "$DIR/R5a/f exists"
 956         $CHECKSTAT -t file $DIR/R5b/g || error "$DIR/R5b/g not file type"
 957 }
 958 run_test 24e "touch .../R5a/f; rename .../R5a/f .../R5b/g ======"
 959
 960 test_24f() {
 961         test_mkdir $DIR/R6a
 962         test_mkdir $DIR/R6b
 963         touch $DIR/R6a/f $DIR/R6b/g
 964         mv $DIR/R6a/f $DIR/R6b/g
 965         $CHECKSTAT -a $DIR/R6a/f || error "$DIR/R6a/f exists"
 966         $CHECKSTAT -t file $DIR/R6b/g || error "$DIR/R6b/g not file type"
 967 }
 968 run_test 24f "touch .../R6a/f R6b/g; mv .../R6a/f .../R6b/g ===="
 969
 970 test_24g() {
 971         test_mkdir $DIR/R7a
 972         test_mkdir $DIR/R7b
 973         test_mkdir $DIR/R7a/d
 974         mv $DIR/R7a/d $DIR/R7b/e
 975         $CHECKSTAT -a $DIR/R7a/d || error "$DIR/R7a/d exists"
 976         $CHECKSTAT -t dir $DIR/R7b/e || error "$DIR/R7b/e not dir type"
 977 }
 978 run_test 24g "mkdir .../R7{a,b}/d; mv .../R7a/d .../R7b/e ======"
 979
 980 test_24h() {
 981         test_mkdir -c1 $DIR/R8a
 982         test_mkdir -c1 $DIR/R8b
 983         test_mkdir -c1 $DIR/R8a/d
 984         test_mkdir -c1 $DIR/R8b/e
 985         mrename $DIR/R8a/d $DIR/R8b/e
 986         $CHECKSTAT -a $DIR/R8a/d || error "$DIR/R8a/d exists"
 987         $CHECKSTAT -t dir $DIR/R8b/e || error "$DIR/R8b/e not dir type"
 988 }
 989 run_test 24h "mkdir .../R8{a,b}/{d,e}; rename .../R8a/d .../R8b/e"
 990
 991 test_24i() {
 992         echo "-- rename error cases"
 993         test_mkdir $DIR/R9
 994         test_mkdir $DIR/R9/a
 995         touch $DIR/R9/f
 996         mrename $DIR/R9/f $DIR/R9/a
 997         $CHECKSTAT -t file $DIR/R9/f || error "$DIR/R9/f not file type"
 998         $CHECKSTAT -t dir  $DIR/R9/a || error "$DIR/R9/a not dir type"
 999         $CHECKSTAT -a $DIR/R9/a/f || error "$DIR/R9/a/f exists"
1000 }
1001 run_test 24i "rename file to dir error: touch f ; mkdir a ; rename f a"
1002
1003 test_24j() {
1004         test_mkdir $DIR/R10
1005         mrename $DIR/R10/f $DIR/R10/g
1006         $CHECKSTAT -t dir $DIR/R10 || error "$DIR/R10 not dir type"
1007         $CHECKSTAT -a $DIR/R10/f || error "$DIR/R10/f exists"
1008         $CHECKSTAT -a $DIR/R10/g || error "$DIR/R10/g exists"
1009 }
1010 run_test 24j "source does not exist ============================"
1011
1012 test_24k() {
1013         test_mkdir $DIR/R11a
1014         test_mkdir $DIR/R11a/d
1015         touch $DIR/R11a/f
1016         mv $DIR/R11a/f $DIR/R11a/d
1017         $CHECKSTAT -a $DIR/R11a/f || error "$DIR/R11a/f exists"
1018         $CHECKSTAT -t file $DIR/R11a/d/f || error "$DIR/R11a/d/f not file type"
1019 }
1020 run_test 24k "touch .../R11a/f; mv .../R11a/f .../R11a/d ======="
1021
1022 # bug 2429 - rename foo foo foo creates invalid file
1023 test_24l() {
1024         f="$DIR/f24l"
1025         $MULTIOP $f OcNs || error "rename of ${f} to itself failed"
1026 }
1027 run_test 24l "Renaming a file to itself ========================"
1028
1029 test_24m() {
1030         f="$DIR/f24m"
1031         $MULTIOP $f OcLN ${f}2 ${f}2 || error "link ${f}2 ${f}2 failed"
1032         # on ext3 this does not remove either the source or target files
1033         # though the "expected" operation would be to remove the source
1034         $CHECKSTAT -t file ${f} || error "${f} missing"
1035         $CHECKSTAT -t file ${f}2 || error "${f}2 missing"
1036 }
1037 run_test 24m "Renaming a file to a hard link to itself ========="
1038
1039 test_24n() {
1040     f="$DIR/f24n"
1041     # this stats the old file after it was renamed, so it should fail
1042     touch ${f}
1043     $CHECKSTAT ${f} || error "${f} missing"
1044     mv ${f} ${f}.rename
1045     $CHECKSTAT ${f}.rename || error "${f}.rename missing"
1046     $CHECKSTAT -a ${f} || error "${f} exists"
1047 }
1048 run_test 24n "Statting the old file after renaming (Posix rename 2)"
1049
1050 test_24o() {
1051         test_mkdir $DIR/$tdir
1052         rename_many -s random -v -n 10 $DIR/$tdir
1053 }
1054 run_test 24o "rename of files during htree split"
1055
1056 test_24p() {
1057         test_mkdir $DIR/R12a
1058         test_mkdir $DIR/R12b
1059         DIRINO=`ls -lid $DIR/R12a | awk '{ print $1 }'`
1060         mrename $DIR/R12a $DIR/R12b
1061         $CHECKSTAT -a $DIR/R12a || error "$DIR/R12a exists"
1062         $CHECKSTAT -t dir $DIR/R12b || error "$DIR/R12b not dir type"
1063         DIRINO2=`ls -lid $DIR/R12b | awk '{ print $1 }'`
1064         [ "$DIRINO" = "$DIRINO2" ] || error "R12a $DIRINO != R12b $DIRINO2"
1065 }
1066 run_test 24p "mkdir .../R12{a,b}; rename .../R12a .../R12b"
1067
1068 cleanup_multiop_pause() {
1069         trap 0
1070         kill -USR1 $MULTIPID
1071 }
1072
1073 test_24q() {
1074         [ $PARALLEL == "yes" ] && skip "skip parallel run"
1075
1076         test_mkdir $DIR/R13a
1077         test_mkdir $DIR/R13b
1078         local DIRINO=$(ls -lid $DIR/R13a | awk '{ print $1 }')
1079         multiop_bg_pause $DIR/R13b D_c || error "multiop failed to start"
1080         MULTIPID=$!
1081
1082         trap cleanup_multiop_pause EXIT
1083         mrename $DIR/R13a $DIR/R13b
1084         $CHECKSTAT -a $DIR/R13a || error "R13a still exists"
1085         $CHECKSTAT -t dir $DIR/R13b || error "R13b does not exist"
1086         local DIRINO2=$(ls -lid $DIR/R13b | awk '{ print $1 }')
1087         [ "$DIRINO" = "$DIRINO2" ] || error "R13a $DIRINO != R13b $DIRINO2"
1088         cleanup_multiop_pause
1089         wait $MULTIPID || error "multiop close failed"
1090 }
1091 run_test 24q "mkdir .../R13{a,b}; open R13b rename R13a R13b ==="
1092
1093 test_24r() { #bug 3789
1094         test_mkdir $DIR/R14a
1095         test_mkdir $DIR/R14a/b
1096         mrename $DIR/R14a $DIR/R14a/b && error "rename to subdir worked!"
1097         $CHECKSTAT -t dir $DIR/R14a || error "$DIR/R14a missing"
1098         $CHECKSTAT -t dir $DIR/R14a/b || error "$DIR/R14a/b missing"
1099 }
1100 run_test 24r "mkdir .../R14a/b; rename .../R14a .../R14a/b ====="
1101
1102 test_24s() {
1103         test_mkdir $DIR/R15a
1104         test_mkdir $DIR/R15a/b
1105         test_mkdir $DIR/R15a/b/c
1106         mrename $DIR/R15a $DIR/R15a/b/c && error "rename to sub-subdir worked!"
1107         $CHECKSTAT -t dir $DIR/R15a || error "$DIR/R15a missing"
1108         $CHECKSTAT -t dir $DIR/R15a/b/c || error "$DIR/R15a/b/c missing"
1109 }
1110 run_test 24s "mkdir .../R15a/b/c; rename .../R15a .../R15a/b/c ="
1111 test_24t() {
1112         test_mkdir $DIR/R16a
1113         test_mkdir $DIR/R16a/b
1114         test_mkdir $DIR/R16a/b/c
1115         mrename $DIR/R16a/b/c $DIR/R16a && error "rename to sub-subdir worked!"
1116         $CHECKSTAT -t dir $DIR/R16a || error "$DIR/R16a missing"
1117         $CHECKSTAT -t dir $DIR/R16a/b/c || error "$DIR/R16a/b/c missing"
1118 }
1119 run_test 24t "mkdir .../R16a/b/c; rename .../R16a/b/c .../R16a ="
1120
1121 test_24u() { # bug12192
1122         $MULTIOP $DIR/$tfile C2w$((2048 * 1024))c || error "multiop failed"
1123         $CHECKSTAT -s $((2048 * 1024)) $DIR/$tfile || error "wrong file size"
1124 }
1125 run_test 24u "create stripe file"
1126
1127 simple_cleanup_common() {
1128         local rc=0
1129         trap 0
1130         [ -z "$DIR" ] || [ -z "$tdir" ] && return 0
1131
1132         local start=$SECONDS
1133         rm -rf $DIR/$tdir
1134         rc=$?
1135         wait_delete_completed
1136         echo "cleanup time $((SECONDS - start))"
1137         return $rc
1138 }
1139
1140 max_pages_per_rpc() {
1141         local mdtname="$(printf "MDT%04x" ${1:-0})"
1142         $LCTL get_param -n mdc.*$mdtname*.max_pages_per_rpc
1143 }
1144
1145 test_24v() {
1146         [ $PARALLEL == "yes" ] && skip "skip parallel run"
1147
1148         local nrfiles=${COUNT:-100000}
1149         local fname="$DIR/$tdir/$tfile"
1150
1151         # Performance issue on ZFS see LU-4072 (c.f. LU-2887)
1152         [ "$mds1_FSTYPE" = "zfs" ] && nrfiles=${COUNT:-10000}
1153
1154         test_mkdir "$(dirname $fname)"
1155         # assume MDT0000 has the fewest inodes
1156         local stripes=$($LFS getdirstripe -c $(dirname $fname))
1157         local free_inodes=$(($(mdt_free_inodes 0) * stripes))
1158         [[ $free_inodes -lt $nrfiles ]] && nrfiles=$free_inodes
1159
1160         trap simple_cleanup_common EXIT
1161
1162         createmany -m "$fname" $nrfiles
1163
1164         cancel_lru_locks mdc
1165         lctl set_param mdc.*.stats clear
1166
1167         # was previously test_24D: LU-6101
1168         # readdir() returns correct number of entries after cursor reload
1169         local num_ls=$(ls $DIR/$tdir | wc -l)
1170         local num_uniq=$(ls $DIR/$tdir | sort -u | wc -l)
1171         local num_all=$(ls -a $DIR/$tdir | wc -l)
1172         if [ $num_ls -ne $nrfiles ] || [ $num_uniq -ne $nrfiles ] ||
1173                 [ $num_all -ne $((nrfiles + 2)) ]; then
1174                         error "Expected $nrfiles files, got $num_ls " \
1175                                 "($num_uniq unique $num_all .&..)"
1176         fi
1177         # LU-5 large readdir
1178         # dirent_size = 32 bytes for sizeof(struct lu_dirent) +
1179         #               N bytes for name (len($nrfiles) rounded to 8 bytes) +
1180         #               8 bytes for luda_type (4 bytes rounded to 8 bytes)
1181         # take into account of overhead in lu_dirpage header and end mark in
1182         # each page, plus one in rpc_num calculation.
1183         local dirent_size=$((32 + (${#tfile} | 7) + 1 + 8))
1184         local page_entries=$(((PAGE_SIZE - 24) / dirent_size))
1185         local mdt_idx=$($LFS getdirstripe -i $(dirname $fname))
1186         local rpc_pages=$(max_pages_per_rpc $mdt_idx)
1187         local rpc_max=$((nrfiles / (page_entries * rpc_pages) + stripes))
1188         local mds_readpage=$(calc_stats mdc.*.stats mds_readpage)
1189         echo "readpages: $mds_readpage rpc_max: $rpc_max"
1190         (( $mds_readpage < $rpc_max - 2 || $mds_readpage > $rpc_max + 1)) &&
1191                 error "large readdir doesn't take effect: " \
1192                       "$mds_readpage should be about $rpc_max"
1193
1194         simple_cleanup_common
1195 }
1196 run_test 24v "list large directory (test hash collision, b=17560)"
1197
1198 test_24w() { # bug21506
1199         SZ1=234852
1200         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=4096 || return 1
1201         dd if=/dev/zero bs=$SZ1 count=1 >> $DIR/$tfile || return 2
1202         dd if=$DIR/$tfile of=$DIR/${tfile}_left bs=1M skip=4097 || return 3
1203         SZ2=`ls -l $DIR/${tfile}_left | awk '{print $5}'`
1204         [[ "$SZ1" -eq "$SZ2" ]] ||
1205                 error "Error reading at the end of the file $tfile"
1206 }
1207 run_test 24w "Reading a file larger than 4Gb"
1208
1209 test_24x() {
1210         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
1211         [ $PARALLEL == "yes" ] && skip "skip parallel run"
1212         [[ $MDS1_VERSION -lt $(version_code 2.7.56) ]] &&
1213                 skip "Need MDS version at least 2.7.56"
1214
1215         local MDTIDX=1
1216         local remote_dir=$DIR/$tdir/remote_dir
1217
1218         test_mkdir $DIR/$tdir
1219         $LFS mkdir -i $MDTIDX $remote_dir ||
1220                 error "create remote directory failed"
1221
1222         test_mkdir $DIR/$tdir/src_dir
1223         touch $DIR/$tdir/src_file
1224         test_mkdir $remote_dir/tgt_dir
1225         touch $remote_dir/tgt_file
1226
1227         mrename $DIR/$tdir/src_dir $remote_dir/tgt_dir ||
1228                 error "rename dir cross MDT failed!"
1229
1230         mrename $DIR/$tdir/src_file $remote_dir/tgt_file ||
1231                 error "rename file cross MDT failed!"
1232
1233         touch $DIR/$tdir/ln_file
1234         ln $DIR/$tdir/ln_file $remote_dir/ln_name ||
1235                 error "ln file cross MDT failed"
1236
1237         rm -rf $DIR/$tdir || error "Can not delete directories"
1238 }
1239 run_test 24x "cross MDT rename/link"
1240
1241 test_24y() {
1242         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
1243         [ $PARALLEL == "yes" ] && skip "skip parallel run"
1244
1245         local remote_dir=$DIR/$tdir/remote_dir
1246         local mdtidx=1
1247
1248         test_mkdir $DIR/$tdir
1249         $LFS mkdir -i $mdtidx $remote_dir ||
1250                 error "create remote directory failed"
1251
1252         test_mkdir $remote_dir/src_dir
1253         touch $remote_dir/src_file
1254         test_mkdir $remote_dir/tgt_dir
1255         touch $remote_dir/tgt_file
1256
1257         mrename $remote_dir/src_dir $remote_dir/tgt_dir ||
1258                 error "rename subdir in the same remote dir failed!"
1259
1260         mrename $remote_dir/src_file $remote_dir/tgt_file ||
1261                 error "rename files in the same remote dir failed!"
1262
1263         ln $remote_dir/tgt_file $remote_dir/tgt_file1 ||
1264                 error "link files in the same remote dir failed!"
1265
1266         rm -rf $DIR/$tdir || error "Can not delete directories"
1267 }
1268 run_test 24y "rename/link on the same dir should succeed"
1269
1270 test_24z() {
1271         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
1272         [[ $MDS1_VERSION -lt $(version_code 2.12.51) ]] &&
1273                 skip "Need MDS version at least 2.12.51"
1274
1275         local index
1276
1277         for index in 0 1; do
1278                 $LFS mkdir -i $index $DIR/$tdir.$index || error "mkdir failed"
1279                 touch $DIR/$tdir.0/$tfile.$index || error "touch failed"
1280         done
1281
1282         mv $DIR/$tdir.0/$tfile.0 $DIR/$tdir.1 || error "mv $tfile.0 failed"
1283
1284         index=$($LFS getstripe -m $DIR/$tdir.1/$tfile.0)
1285         [ $index -eq 0 ] || error "$tfile.0 is on MDT$index"
1286
1287         local mdts=$(comma_list $(mdts_nodes))
1288
1289         do_nodes $mdts $LCTL set_param mdt.*.enable_remote_rename=0
1290         stack_trap "do_nodes $mdts $LCTL \
1291                 set_param mdt.*.enable_remote_rename=1" EXIT
1292
1293         mv $DIR/$tdir.0/$tfile.1 $DIR/$tdir.1 || error "mv $tfile.1 failed"
1294
1295         index=$($LFS getstripe -m $DIR/$tdir.1/$tfile.1)
1296         [ $index -eq 1 ] || error "$tfile.1 is on MDT$index"
1297 }
1298 run_test 24z "cross-MDT rename is done as cp"
1299
1300 test_24A() { # LU-3182
1301         local NFILES=5000
1302
1303         rm -rf $DIR/$tdir
1304         test_mkdir $DIR/$tdir
1305         trap simple_cleanup_common EXIT
1306         createmany -m $DIR/$tdir/$tfile $NFILES
1307         local t=$(ls $DIR/$tdir | wc -l)
1308         local u=$(ls $DIR/$tdir | sort -u | wc -l)
1309         local v=$(ls -ai $DIR/$tdir | sort -u | wc -l)
1310         if [ $t -ne $NFILES ] || [ $u -ne $NFILES ] ||
1311            [ $v -ne $((NFILES + 2)) ] ; then
1312                 error "Expected $NFILES files, got $t ($u unique $v .&..)"
1313         fi
1314
1315         simple_cleanup_common || error "Can not delete directories"
1316 }
1317 run_test 24A "readdir() returns correct number of entries."
1318
1319 test_24B() { # LU-4805
1320         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
1321
1322         local count
1323
1324         test_mkdir $DIR/$tdir
1325         $LFS setdirstripe -i0 -c$MDSCOUNT $DIR/$tdir/striped_dir ||
1326                 error "create striped dir failed"
1327
1328         count=$(ls -ai $DIR/$tdir/striped_dir | wc -l)
1329         [ $count -eq 2 ] || error "Expected 2, got $count"
1330
1331         touch $DIR/$tdir/striped_dir/a
1332
1333         count=$(ls -ai $DIR/$tdir/striped_dir | wc -l)
1334         [ $count -eq 3 ] || error "Expected 3, got $count"
1335
1336         touch $DIR/$tdir/striped_dir/.f
1337
1338         count=$(ls -ai $DIR/$tdir/striped_dir | wc -l)
1339         [ $count -eq 4 ] || error "Expected 4, got $count"
1340
1341         rm -rf $DIR/$tdir || error "Can not delete directories"
1342 }
1343 run_test 24B "readdir for striped dir return correct number of entries"
1344
1345 test_24C() {
1346         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
1347
1348         mkdir $DIR/$tdir
1349         mkdir $DIR/$tdir/d0
1350         mkdir $DIR/$tdir/d1
1351
1352         $LFS setdirstripe -i0 -c$MDSCOUNT $DIR/$tdir/d0/striped_dir ||
1353                 error "create striped dir failed"
1354
1355         cd $DIR/$tdir/d0/striped_dir
1356
1357         local d0_ino=$(ls -i -l -a $DIR/$tdir | grep "d0" | awk '{print $1}')
1358         local d1_ino=$(ls -i -l -a $DIR/$tdir | grep "d1" | awk '{print $1}')
1359         local parent_ino=$(ls -i -l -a | grep "\.\." | awk '{print $1}')
1360
1361         [ "$d0_ino" = "$parent_ino" ] ||
1362                 error ".. wrong, expect $d0_ino, get $parent_ino"
1363
1364         mv $DIR/$tdir/d0/striped_dir $DIR/$tdir/d1/ ||
1365                 error "mv striped dir failed"
1366
1367         parent_ino=$(ls -i -l -a | grep "\.\." | awk '{print $1}')
1368
1369         [ "$d1_ino" = "$parent_ino" ] ||
1370                 error ".. wrong after mv, expect $d1_ino, get $parent_ino"
1371 }
1372 run_test 24C "check .. in striped dir"
1373
1374 test_24E() {
1375         [[ $MDSCOUNT -lt 4 ]] && skip_env "needs >= 4 MDTs"
1376         [ $PARALLEL == "yes" ] && skip "skip parallel run"
1377
1378         mkdir -p $DIR/$tdir
1379         mkdir $DIR/$tdir/src_dir
1380         $LFS mkdir -i 1 $DIR/$tdir/src_dir/src_child ||
1381                 error "create remote source failed"
1382
1383         touch $DIR/$tdir/src_dir/src_child/a
1384
1385         $LFS mkdir -i 2 $DIR/$tdir/tgt_dir ||
1386                 error "create remote target dir failed"
1387
1388         $LFS mkdir -i 3 $DIR/$tdir/tgt_dir/tgt_child ||
1389                 error "create remote target child failed"
1390
1391         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
1392                 error "rename dir cross MDT failed!"
1393
1394         find $DIR/$tdir
1395
1396         $CHECKSTAT -t dir $DIR/$tdir/src_dir/src_child &&
1397                 error "src_child still exists after rename"
1398
1399         $CHECKSTAT -t file $DIR/$tdir/tgt_dir/tgt_child/a ||
1400                 error "missing file(a) after rename"
1401
1402         rm -rf $DIR/$tdir || error "Can not delete directories"
1403 }
1404 run_test 24E "cross MDT rename/link"
1405
1406 test_24F () {
1407         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1408
1409         local repeats=1000
1410         [ "$SLOW" = "no" ] && repeats=100
1411
1412         mkdir -p $DIR/$tdir
1413
1414         echo "$repeats repeats"
1415         for ((i = 0; i < repeats; i++)); do
1416                 $LFS mkdir -i0 -c2 $DIR/$tdir/test || error "mkdir fails"
1417                 touch $DIR/$tdir/test/a || error "touch fails"
1418                 mkdir $DIR/$tdir/test/b || error "mkdir fails"
1419                 rm -rf $DIR/$tdir/test || error "rmdir fails"
1420         done
1421
1422         true
1423 }
1424 run_test 24F "hash order vs readdir (LU-11330)"
1425
1426 test_25a() {
1427         echo '== symlink sanity ============================================='
1428
1429         test_mkdir $DIR/d25
1430         ln -s d25 $DIR/s25
1431         touch $DIR/s25/foo ||
1432                 error "File creation in symlinked directory failed"
1433 }
1434 run_test 25a "create file in symlinked directory ==============="
1435
1436 test_25b() {
1437         [ ! -d $DIR/d25 ] && test_25a
1438         $CHECKSTAT -t file $DIR/s25/foo || error "$DIR/s25/foo not file type"
1439 }
1440 run_test 25b "lookup file in symlinked directory ==============="
1441
1442 test_26a() {
1443         test_mkdir $DIR/d26
1444         test_mkdir $DIR/d26/d26-2
1445         ln -s d26/d26-2 $DIR/s26
1446         touch $DIR/s26/foo || error "File creation failed"
1447 }
1448 run_test 26a "multiple component symlink ======================="
1449
1450 test_26b() {
1451         test_mkdir -p $DIR/$tdir/d26-2
1452         ln -s $tdir/d26-2/foo $DIR/s26-2
1453         touch $DIR/s26-2 || error "File creation failed"
1454 }
1455 run_test 26b "multiple component symlink at end of lookup ======"
1456
1457 test_26c() {
1458         test_mkdir $DIR/d26.2
1459         touch $DIR/d26.2/foo
1460         ln -s d26.2 $DIR/s26.2-1
1461         ln -s s26.2-1 $DIR/s26.2-2
1462         ln -s s26.2-2 $DIR/s26.2-3
1463         chmod 0666 $DIR/s26.2-3/foo
1464 }
1465 run_test 26c "chain of symlinks"
1466
1467 # recursive symlinks (bug 439)
1468 test_26d() {
1469         ln -s d26-3/foo $DIR/d26-3
1470 }
1471 run_test 26d "create multiple component recursive symlink"
1472
1473 test_26e() {
1474         [ ! -h $DIR/d26-3 ] && test_26d
1475         rm $DIR/d26-3
1476 }
1477 run_test 26e "unlink multiple component recursive symlink"
1478
1479 # recursive symlinks (bug 7022)
1480 test_26f() {
1481         test_mkdir $DIR/$tdir
1482         test_mkdir $DIR/$tdir/$tfile
1483         cd $DIR/$tdir/$tfile           || error "cd $DIR/$tdir/$tfile failed"
1484         test_mkdir -p lndir/bar1
1485         test_mkdir $DIR/$tdir/$tfile/$tfile
1486         cd $tfile                || error "cd $tfile failed"
1487         ln -s .. dotdot          || error "ln dotdot failed"
1488         ln -s dotdot/lndir lndir || error "ln lndir failed"
1489         cd $DIR/$tdir                 || error "cd $DIR/$tdir failed"
1490         output=`ls $tfile/$tfile/lndir/bar1`
1491         [ "$output" = bar1 ] && error "unexpected output"
1492         rm -r $tfile             || error "rm $tfile failed"
1493         $CHECKSTAT -a $DIR/$tfile || error "$tfile not gone"
1494 }
1495 run_test 26f "rm -r of a directory which has recursive symlink"
1496
1497 test_27a() {
1498         test_mkdir $DIR/$tdir
1499         $LFS getstripe $DIR/$tdir
1500         $LFS setstripe -c 1 $DIR/$tdir/$tfile || error "setstripe failed"
1501         $CHECKSTAT -t file $DIR/$tdir/$tfile || error "checkstat failed"
1502         cp /etc/hosts $DIR/$tdir/$tfile || error "Can't copy to one stripe file"
1503 }
1504 run_test 27a "one stripe file"
1505
1506 test_27b() {
1507         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
1508
1509         test_mkdir $DIR/$tdir
1510         $LFS setstripe -c 2 $DIR/$tdir/$tfile || error "setstripe failed"
1511         $LFS getstripe -c $DIR/$tdir/$tfile
1512         [ $($LFS getstripe -c $DIR/$tdir/$tfile) -eq 2 ] ||
1513                 error "two-stripe file doesn't have two stripes"
1514
1515         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=4k count=4 || error "dd failed"
1516 }
1517 run_test 27b "create and write to two stripe file"
1518
1519 # 27c family tests specific striping, setstripe -o
1520 test_27ca() {
1521         [[ $OSTCOUNT -lt 2 ]] && skip_env "skipping 2-stripe test"
1522         test_mkdir -p $DIR/$tdir
1523         local osts="1"
1524
1525         $LFS setstripe -o $osts $DIR/$tdir/$tfile  || error "setstripe failed"
1526         $LFS getstripe -i $DIR/$tdir/$tfile
1527         [ $($LFS getstripe -i $DIR/$tdir/$tfile ) -eq $osts ] ||
1528                 error "stripe not on specified OST"
1529
1530         dd if=/dev/zero of=$DIR/$tdir/$tfile  bs=1M count=4 || error "dd failed"
1531 }
1532 run_test 27ca "one stripe on specified OST"
1533
1534 test_27cb() {
1535         [[ $OSTCOUNT -lt 2 ]] && skip_env "skipping 2-stripe test"
1536         test_mkdir -p $DIR/$tdir
1537         local osts="1,0"
1538         $LFS setstripe -o $osts $DIR/$tdir/$tfile || error "setstripe failed"
1539         local getstripe=$($LFS getstripe $DIR/$tdir/$tfile)
1540         echo "$getstripe"
1541
1542         # Strip getstripe output to a space separated list of OSTs
1543         local getstripe_osts=$(echo "$getstripe" | sed -e '1,/obdidx/d' |\
1544                 awk '{print $1}' | tr '\n' '\ ' | sed -e 's/[[:space:]]*$//')
1545         [ "$getstripe_osts" = "${osts//,/ }" ] ||
1546                 error "stripes not on specified OSTs"
1547
1548         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=4 || error "dd failed"
1549 }
1550 run_test 27cb "two stripes on specified OSTs"
1551
1552 test_27cc() {
1553         [[ $OSTCOUNT -lt 2 ]] && skip_env "skipping 2-stripe test"
1554         [[ $($LCTL get_param mdc.*.import) =~ connect_flags.*overstriping ]] ||
1555                 skip "server does not support overstriping"
1556
1557         test_mkdir -p $DIR/$tdir
1558         local osts="0,0"
1559         $LFS setstripe -o $osts $DIR/$tdir/$tfile || error "setstripe failed"
1560         local getstripe=$($LFS getstripe $DIR/$tdir/$tfile)
1561         echo "$getstripe"
1562
1563         # Strip getstripe output to a space separated list of OSTs
1564         local getstripe_osts=$(echo "$getstripe" | sed -e '1,/obdidx/d' |\
1565                 awk '{print $1}' | tr '\n' '\ ' | sed -e 's/[[:space:]]*$//')
1566         [ "$getstripe_osts" = "${osts//,/ }" ] ||
1567                 error "stripes not on specified OSTs"
1568
1569         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=4 || error "dd failed"
1570 }
1571 run_test 27cc "two stripes on the same OST"
1572
1573 test_27cd() {
1574         [[ $OSTCOUNT -lt 2 ]] && skip_env "skipping 2-stripe test"
1575         [[ $($LCTL get_param mdc.*.import) =~ connect_flags.*overstriping ]] ||
1576                 skip "server does not support overstriping"
1577         test_mkdir -p $DIR/$tdir
1578         local osts="0,1,1,0"
1579         $LFS setstripe -o $osts $DIR/$tdir/$tfile || error "setstripe failed"
1580         local getstripe=$($LFS getstripe $DIR/$tdir/$tfile)
1581         echo "$getstripe"
1582
1583         # Strip getstripe output to a space separated list of OSTs
1584         local getstripe_osts=$(echo "$getstripe" | sed -e '1,/obdidx/d' |\
1585                 awk '{print $1}' | tr '\n' '\ ' | sed -e 's/[[:space:]]*$//')
1586         [ "$getstripe_osts" = "${osts//,/ }" ] ||
1587                 error "stripes not on specified OSTs"
1588
1589         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=4 || error "dd failed"
1590 }
1591 run_test 27cd "four stripes on two OSTs"
1592
1593 test_27ce() {
1594         [[ $OSTCOUNT -ge $(($LOV_MAX_STRIPE_COUNT / 2)) ]] &&
1595                 skip_env "too many osts, skipping"
1596         [[ $($LCTL get_param mdc.*.import) =~ connect_flags.*overstriping ]] ||
1597                 skip "server does not support overstriping"
1598         # We do one more stripe than we have OSTs
1599         [ $OSTCOUNT -ge 159 ] || large_xattr_enabled ||
1600                 skip_env "ea_inode feature disabled"
1601
1602         test_mkdir -p $DIR/$tdir
1603         local osts=""
1604         for i in $(seq 0 $OSTCOUNT);
1605         do
1606                 osts=$osts"0"
1607                 if [ $i -ne $OSTCOUNT ]; then
1608                         osts=$osts","
1609                 fi
1610         done
1611         $LFS setstripe -o $osts $DIR/$tdir/$tfile || error "setstripe failed"
1612         local getstripe=$($LFS getstripe $DIR/$tdir/$tfile)
1613         echo "$getstripe"
1614
1615         # Strip getstripe output to a space separated list of OSTs
1616         local getstripe_osts=$(echo "$getstripe" | sed -e '1,/obdidx/d' |\
1617                 awk '{print $1}' | tr '\n' '\ ' | sed -e 's/[[:space:]]*$//')
1618         [ "$getstripe_osts" = "${osts//,/ }" ] ||
1619                 error "stripes not on specified OSTs"
1620
1621         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=4 || error "dd failed"
1622 }
1623 run_test 27ce "more stripes than OSTs with -o"
1624
1625 test_27d() {
1626         test_mkdir $DIR/$tdir
1627         $LFS setstripe -c 0 -i -1 -S 0 $DIR/$tdir/$tfile ||
1628                 error "setstripe failed"
1629         $CHECKSTAT -t file $DIR/$tdir/$tfile || error "checkstat failed"
1630         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=4k count=4 || error "dd failed"
1631 }
1632 run_test 27d "create file with default settings"
1633
1634 test_27e() {
1635         # LU-5839 adds check for existed layout before setting it
1636         [[ $MDS1_VERSION -lt $(version_code 2.7.56) ]] &&
1637                 skip "Need MDS version at least 2.7.56"
1638
1639         test_mkdir $DIR/$tdir
1640         $LFS setstripe -c 2 $DIR/$tdir/$tfile || error "setstripe failed"
1641         $LFS setstripe -c 2 $DIR/$tdir/$tfile && error "setstripe worked twice"
1642         $CHECKSTAT -t file $DIR/$tdir/$tfile || error "checkstat failed"
1643 }
1644 run_test 27e "setstripe existing file (should return error)"
1645
1646 test_27f() {
1647         test_mkdir $DIR/$tdir
1648         $LFS setstripe -S 100 -i 0 -c 1 $DIR/$tdir/$tfile &&
1649                 error "$LFS setstripe $DIR/$tdir/$tfile failed"
1650         $CHECKSTAT -t file $DIR/$tdir/$tfile &&
1651                 error "$CHECKSTAT -t file $DIR/$tdir/$tfile should fail"
1652         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=4k count=4 || error "dd failed"
1653         $LFS getstripe $DIR/$tdir/$tfile || error "$LFS getstripe failed"
1654 }
1655 run_test 27f "setstripe with bad stripe size (should return error)"
1656
1657 test_27g() {
1658         test_mkdir $DIR/$tdir
1659         $MCREATE $DIR/$tdir/$tfile || error "mcreate failed"
1660         $LFS getstripe $DIR/$tdir/$tfile 2>&1 | grep "no stripe info" ||
1661                 error "$DIR/$tdir/$tfile has object"
1662 }
1663 run_test 27g "$LFS getstripe with no objects"
1664
1665 test_27ga() {
1666         test_mkdir $DIR/$tdir
1667         touch $DIR/$tdir/$tfile || error "touch failed"
1668         ln -s bogus $DIR/$tdir/$tfile.2 || error "ln failed"
1669         $LFS getstripe -m $DIR/$tdir/$tfile $DIR/$tdir/$tfile.2
1670         local rc=$?
1671         (( rc == 2 )) || error "getstripe did not return ENOENT"
1672 }
1673 run_test 27ga "$LFS getstripe with missing file (should return error)"
1674
1675 test_27i() {
1676         test_mkdir $DIR/$tdir
1677         touch $DIR/$tdir/$tfile || error "touch failed"
1678         [[ $($LFS getstripe -c $DIR/$tdir/$tfile) -gt 0 ]] ||
1679                 error "missing objects"
1680 }
1681 run_test 27i "$LFS getstripe with some objects"
1682
1683 test_27j() {
1684         test_mkdir $DIR/$tdir
1685         $LFS setstripe -i $OSTCOUNT $DIR/$tdir/$tfile &&
1686                 error "setstripe failed" || true
1687 }
1688 run_test 27j "setstripe with bad stripe offset (should return error)"
1689
1690 test_27k() { # bug 2844
1691         test_mkdir $DIR/$tdir
1692         local file=$DIR/$tdir/$tfile
1693         local ll_max_blksize=$((4 * 1024 * 1024))
1694         $LFS setstripe -S 67108864 $file || error "setstripe failed"
1695         local blksize=$(stat $file | awk '/IO Block:/ { print $7 }')
1696         [ $blksize -le $ll_max_blksize ] || error "1:$blksize > $ll_max_blksize"
1697         dd if=/dev/zero of=$file bs=4k count=1
1698         blksize=$(stat $file | awk '/IO Block:/ { print $7 }')
1699         [ $blksize -le $ll_max_blksize ] || error "2:$blksize > $ll_max_blksize"
1700 }
1701 run_test 27k "limit i_blksize for broken user apps"
1702
1703 test_27l() {
1704         mcreate $DIR/$tfile || error "creating file"
1705         $RUNAS $LFS setstripe -c 1 $DIR/$tfile &&
1706                 error "setstripe should have failed" || true
1707 }
1708 run_test 27l "check setstripe permissions (should return error)"
1709
1710 test_27m() {
1711         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
1712
1713         [ -n "$RCLIENTS" -o -n "$MOUNT_2" ] &&
1714                 skip_env "multiple clients -- skipping"
1715
1716         ORIGFREE=$($LCTL get_param -n lov.$FSNAME-clilov-*.kbytesavail |
1717                    head -n1)
1718         if [[ $ORIGFREE -gt $MAXFREE ]]; then
1719                 skip "$ORIGFREE > $MAXFREE skipping out-of-space test on OST0"
1720         fi
1721         trap simple_cleanup_common EXIT
1722         test_mkdir $DIR/$tdir
1723         $LFS setstripe -i 0 -c 1 $DIR/$tdir/$tfile.1
1724         dd if=/dev/zero of=$DIR/$tdir/$tfile.1 bs=1024 count=$MAXFREE &&
1725                 error "dd should fill OST0"
1726         i=2
1727         while $LFS setstripe -i 0 -c 1 $DIR/$tdir/$tfile.$i; do
1728                 i=$((i + 1))
1729                 [ $i -gt 256 ] && break
1730         done
1731         i=$((i + 1))
1732         touch $DIR/$tdir/$tfile.$i
1733         [ $($LFS getstripe $DIR/$tdir/$tfile.$i | grep -A 10 obdidx |
1734             awk '{print $1}'| grep -w "0") ] &&
1735                 error "OST0 was full but new created file still use it"
1736         i=$((i + 1))
1737         touch $DIR/$tdir/$tfile.$i
1738         [ $($LFS getstripe $DIR/$tdir/$tfile.$i | grep -A 10 obdidx |
1739             awk '{print $1}'| grep -w "0") ] &&
1740                 error "OST0 was full but new created file still use it"
1741         simple_cleanup_common
1742 }
1743 run_test 27m "create file while OST0 was full"
1744
1745 # OSCs keep a NOSPC flag that will be reset after ~5s (qos_maxage)
1746 # if the OST isn't full anymore.
1747 reset_enospc() {
1748         local OSTIDX=${1:-""}
1749
1750         local list=$(comma_list $(osts_nodes))
1751         [ "$OSTIDX" ] && list=$(facet_host ost$((OSTIDX + 1)))
1752
1753         do_nodes $list lctl set_param fail_loc=0
1754         sync    # initiate all OST_DESTROYs from MDS to OST
1755         sleep_maxage
1756 }
1757
1758 exhaust_precreations() {
1759         local OSTIDX=$1
1760         local FAILLOC=$2
1761         local FAILIDX=${3:-$OSTIDX}
1762         local ofacet=ost$((OSTIDX + 1))
1763
1764         test_mkdir -p -c1 $DIR/$tdir
1765         local mdtidx=$($LFS getstripe -m $DIR/$tdir)
1766         local mfacet=mds$((mdtidx + 1))
1767         echo OSTIDX=$OSTIDX MDTIDX=$mdtidx
1768
1769         local OST=$(ostname_from_index $OSTIDX)
1770
1771         # on the mdt's osc
1772         local mdtosc_proc1=$(get_mdtosc_proc_path $mfacet $OST)
1773         local last_id=$(do_facet $mfacet lctl get_param -n \
1774                         osp.$mdtosc_proc1.prealloc_last_id)
1775         local next_id=$(do_facet $mfacet lctl get_param -n \
1776                         osp.$mdtosc_proc1.prealloc_next_id)
1777
1778         local mdtosc_proc2=$(get_mdtosc_proc_path $mfacet)
1779         do_facet $mfacet lctl get_param osp.$mdtosc_proc2.prealloc*
1780
1781         test_mkdir -p $DIR/$tdir/${OST}
1782         $LFS setstripe -i $OSTIDX -c 1 $DIR/$tdir/${OST}
1783 #define OBD_FAIL_OST_ENOSPC              0x215
1784         do_facet $ofacet lctl set_param fail_val=$FAILIDX fail_loc=0x215
1785         echo "Creating to objid $last_id on ost $OST..."
1786         createmany -o $DIR/$tdir/${OST}/f $next_id $((last_id - next_id + 2))
1787         do_facet $mfacet lctl get_param osp.$mdtosc_proc2.prealloc*
1788         do_facet $ofacet lctl set_param fail_loc=$FAILLOC
1789         sleep_maxage
1790 }
1791
1792 exhaust_all_precreations() {
1793         local i
1794         for (( i=0; i < OSTCOUNT; i++ )) ; do
1795                 exhaust_precreations $i $1 -1
1796         done
1797 }
1798
1799 test_27n() {
1800         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
1801         [ $PARALLEL == "yes" ] && skip "skip parallel run"
1802         remote_mds_nodsh && skip "remote MDS with nodsh"
1803         remote_ost_nodsh && skip "remote OST with nodsh"
1804
1805         reset_enospc
1806         rm -f $DIR/$tdir/$tfile
1807         exhaust_precreations 0 0x80000215
1808         $LFS setstripe -c -1 $DIR/$tdir || error "setstripe failed"
1809         touch $DIR/$tdir/$tfile || error "touch failed"
1810         $LFS getstripe $DIR/$tdir/$tfile
1811         reset_enospc
1812 }
1813 run_test 27n "create file with some full OSTs"
1814
1815 test_27o() {
1816         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
1817         [ $PARALLEL == "yes" ] && skip "skip parallel run"
1818         remote_mds_nodsh && skip "remote MDS with nodsh"
1819         remote_ost_nodsh && skip "remote OST with nodsh"
1820
1821         reset_enospc
1822         rm -f $DIR/$tdir/$tfile
1823         exhaust_all_precreations 0x215
1824
1825         touch $DIR/$tdir/$tfile && error "able to create $DIR/$tdir/$tfile"
1826
1827         reset_enospc
1828         rm -rf $DIR/$tdir/*
1829 }
1830 run_test 27o "create file with all full OSTs (should error)"
1831
1832 test_27p() {
1833         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
1834         [ $PARALLEL == "yes" ] && skip "skip parallel run"
1835         remote_mds_nodsh && skip "remote MDS with nodsh"
1836         remote_ost_nodsh && skip "remote OST with nodsh"
1837
1838         reset_enospc
1839         rm -f $DIR/$tdir/$tfile
1840         test_mkdir $DIR/$tdir
1841
1842         $MCREATE $DIR/$tdir/$tfile || error "mcreate failed"
1843         $TRUNCATE $DIR/$tdir/$tfile 80000000 || error "truncate failed"
1844         $CHECKSTAT -s 80000000 $DIR/$tdir/$tfile || error "checkstat failed"
1845
1846         exhaust_precreations 0 0x80000215
1847         echo foo >> $DIR/$tdir/$tfile || error "append failed"
1848         $CHECKSTAT -s 80000004 $DIR/$tdir/$tfile || error "checkstat failed"
1849         $LFS getstripe $DIR/$tdir/$tfile
1850
1851         reset_enospc
1852 }
1853 run_test 27p "append to a truncated file with some full OSTs"
1854
1855 test_27q() {
1856         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
1857         [ $PARALLEL == "yes" ] && skip "skip parallel run"
1858         remote_mds_nodsh && skip "remote MDS with nodsh"
1859         remote_ost_nodsh && skip "remote OST with nodsh"
1860
1861         reset_enospc
1862         rm -f $DIR/$tdir/$tfile
1863
1864         test_mkdir $DIR/$tdir
1865         $MCREATE $DIR/$tdir/$tfile || error "mcreate $DIR/$tdir/$tfile failed"
1866         $TRUNCATE $DIR/$tdir/$tfile 80000000 ||
1867                 error "truncate $DIR/$tdir/$tfile failed"
1868         $CHECKSTAT -s 80000000 $DIR/$tdir/$tfile || error "checkstat failed"
1869
1870         exhaust_all_precreations 0x215
1871
1872         echo foo >> $DIR/$tdir/$tfile && error "append succeeded"
1873         $CHECKSTAT -s 80000000 $DIR/$tdir/$tfile || error "checkstat 2 failed"
1874
1875         reset_enospc
1876 }
1877 run_test 27q "append to truncated file with all OSTs full (should error)"
1878
1879 test_27r() {
1880         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
1881         [ $PARALLEL == "yes" ] && skip "skip parallel run"
1882         remote_mds_nodsh && skip "remote MDS with nodsh"
1883         remote_ost_nodsh && skip "remote OST with nodsh"
1884
1885         reset_enospc
1886         rm -f $DIR/$tdir/$tfile
1887         exhaust_precreations 0 0x80000215
1888
1889         $LFS setstripe -i 0 -c 2 $DIR/$tdir/$tfile || error "setstripe failed"
1890
1891         reset_enospc
1892 }
1893 run_test 27r "stripe file with some full OSTs (shouldn't LBUG) ="
1894
1895 test_27s() { # bug 10725
1896         test_mkdir $DIR/$tdir
1897         local stripe_size=$((4096 * 1024 * 1024))       # 2^32
1898         local stripe_count=0
1899         [ $OSTCOUNT -eq 1 ] || stripe_count=2
1900         $LFS setstripe -S $stripe_size -c $stripe_count $DIR/$tdir &&
1901                 error "stripe width >= 2^32 succeeded" || true
1902
1903 }
1904 run_test 27s "lsm_xfersize overflow (should error) (bug 10725)"
1905
1906 test_27t() { # bug 10864
1907         WDIR=$(pwd)
1908         WLFS=$(which lfs)
1909         cd $DIR
1910         touch $tfile
1911         $WLFS getstripe $tfile
1912         cd $WDIR
1913 }
1914 run_test 27t "check that utils parse path correctly"
1915
1916 test_27u() { # bug 4900
1917         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
1918         remote_mds_nodsh && skip "remote MDS with nodsh"
1919
1920         local index
1921         local list=$(comma_list $(mdts_nodes))
1922
1923 #define OBD_FAIL_MDS_OSC_PRECREATE      0x139
1924         do_nodes $list $LCTL set_param fail_loc=0x139
1925         test_mkdir -p $DIR/$tdir
1926         trap simple_cleanup_common EXIT
1927         createmany -o $DIR/$tdir/t- 1000
1928         do_nodes $list $LCTL set_param fail_loc=0
1929
1930         TLOG=$TMP/$tfile.getstripe
1931         $LFS getstripe $DIR/$tdir > $TLOG
1932         OBJS=$(awk -vobj=0 '($1 == 0) { obj += 1 } END { print obj; }' $TLOG)
1933         unlinkmany $DIR/$tdir/t- 1000
1934         trap 0
1935         [[ $OBJS -gt 0 ]] &&
1936                 error "$OBJS objects created on OST-0. See $TLOG" ||
1937                 rm -f $TLOG
1938 }
1939 run_test 27u "skip object creation on OSC w/o objects"
1940
1941 test_27v() { # bug 4900
1942         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
1943         [ $PARALLEL == "yes" ] && skip "skip parallel run"
1944         remote_mds_nodsh && skip "remote MDS with nodsh"
1945         remote_ost_nodsh && skip "remote OST with nodsh"
1946
1947         exhaust_all_precreations 0x215
1948         reset_enospc
1949
1950         $LFS setstripe -c 1 $DIR/$tdir         # 1 stripe / file
1951
1952         touch $DIR/$tdir/$tfile
1953         #define OBD_FAIL_TGT_DELAY_PRECREATE     0x705
1954         # all except ost1
1955         for (( i=1; i < OSTCOUNT; i++ )); do
1956                 do_facet ost$i lctl set_param fail_loc=0x705
1957         done
1958         local START=`date +%s`
1959         createmany -o $DIR/$tdir/$tfile 32
1960
1961         local FINISH=`date +%s`
1962         local TIMEOUT=`lctl get_param -n timeout`
1963         local PROCESS=$((FINISH - START))
1964         [ $PROCESS -ge $((TIMEOUT / 2)) ] && \
1965                error "$FINISH - $START >= $TIMEOUT / 2"
1966         sleep $((TIMEOUT / 2 - PROCESS))
1967         reset_enospc
1968 }
1969 run_test 27v "skip object creation on slow OST"
1970
1971 test_27w() { # bug 10997
1972         test_mkdir $DIR/$tdir
1973         $LFS setstripe -S 65536 $DIR/$tdir/f0 || error "setstripe failed"
1974         [ $($LFS getstripe -S $DIR/$tdir/f0) -ne 65536 ] &&
1975                 error "stripe size $size != 65536" || true
1976         [ $($LFS getstripe -d $DIR/$tdir | grep -c "stripe_count") -eq 0 ] &&
1977                 error "$LFS getstripe -d $DIR/$tdir no 'stripe_count'" || true
1978 }
1979 run_test 27w "check $LFS setstripe -S and getstrip -d options"
1980
1981 test_27wa() {
1982         [[ $OSTCOUNT -lt 2 ]] &&
1983                 skip_env "skipping multiple stripe count/offset test"
1984
1985         test_mkdir $DIR/$tdir
1986         for i in $(seq 1 $OSTCOUNT); do
1987                 offset=$((i - 1))
1988                 $LFS setstripe -c $i -i $offset $DIR/$tdir/f$i ||
1989                         error "setstripe -c $i -i $offset failed"
1990                 count=$($LFS getstripe -c $DIR/$tdir/f$i)
1991                 index=$($LFS getstripe -i $DIR/$tdir/f$i)
1992                 [ $count -ne $i ] && error "stripe count $count != $i" || true
1993                 [ $index -ne $offset ] &&
1994                         error "stripe offset $index != $offset" || true
1995         done
1996 }
1997 run_test 27wa "check $LFS setstripe -c -i options"
1998
1999 test_27x() {
2000         remote_ost_nodsh && skip "remote OST with nodsh"
2001         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
2002         [ $PARALLEL == "yes" ] && skip "skip parallel run"
2003
2004         OFFSET=$(($OSTCOUNT - 1))
2005         OSTIDX=0
2006         local OST=$(ostname_from_index $OSTIDX)
2007
2008         test_mkdir $DIR/$tdir
2009         $LFS setstripe -c 1 $DIR/$tdir  # 1 stripe per file
2010         do_facet ost$((OSTIDX + 1)) lctl set_param -n obdfilter.$OST.degraded 1
2011         sleep_maxage
2012         createmany -o $DIR/$tdir/$tfile $OSTCOUNT
2013         for i in $(seq 0 $OFFSET); do
2014                 [ $($LFS getstripe $DIR/$tdir/$tfile$i | grep -A 10 obdidx |
2015                         awk '{print $1}' | grep -w "$OSTIDX") ] &&
2016                 error "OST0 was degraded but new created file still use it"
2017         done
2018         do_facet ost$((OSTIDX + 1)) lctl set_param -n obdfilter.$OST.degraded 0
2019 }
2020 run_test 27x "create files while OST0 is degraded"
2021
2022 test_27y() {
2023         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
2024         remote_mds_nodsh && skip "remote MDS with nodsh"
2025         remote_ost_nodsh && skip "remote OST with nodsh"
2026         [ $PARALLEL == "yes" ] && skip "skip parallel run"
2027
2028         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS $FSNAME-OST0000)
2029         local last_id=$(do_facet $SINGLEMDS lctl get_param -n \
2030                 osp.$mdtosc.prealloc_last_id)
2031         local next_id=$(do_facet $SINGLEMDS lctl get_param -n \
2032                 osp.$mdtosc.prealloc_next_id)
2033         local fcount=$((last_id - next_id))
2034         [[ $fcount -eq 0 ]] && skip "not enough space on OST0"
2035         [[ $fcount -gt $OSTCOUNT ]] && fcount=$OSTCOUNT
2036
2037         local MDS_OSCS=$(do_facet $SINGLEMDS lctl dl |
2038                          awk '/[oO][sS][cC].*md[ts]/ { print $4 }')
2039         local OST_DEACTIVE_IDX=-1
2040         local OSC
2041         local OSTIDX
2042         local OST
2043
2044         for OSC in $MDS_OSCS; do
2045                 OST=$(osc_to_ost $OSC)
2046                 OSTIDX=$(index_from_ostuuid $OST)
2047                 if [ $OST_DEACTIVE_IDX == -1 ]; then
2048                         OST_DEACTIVE_IDX=$OSTIDX
2049                 fi
2050                 if [ $OSTIDX != $OST_DEACTIVE_IDX ]; then
2051                         echo $OSC "is Deactivated:"
2052                         do_facet $SINGLEMDS lctl --device  %$OSC deactivate
2053                 fi
2054         done
2055
2056         OSTIDX=$(index_from_ostuuid $OST)
2057         test_mkdir $DIR/$tdir
2058         $LFS setstripe -c 1 $DIR/$tdir      # 1 stripe / file
2059
2060         for OSC in $MDS_OSCS; do
2061                 OST=$(osc_to_ost $OSC)
2062                 OSTIDX=$(index_from_ostuuid $OST)
2063                 if [ $OSTIDX == $OST_DEACTIVE_IDX ]; then
2064                         echo $OST "is degraded:"
2065                         do_facet ost$((OSTIDX+1)) lctl set_param -n \
2066                                                 obdfilter.$OST.degraded=1
2067                 fi
2068         done
2069
2070         sleep_maxage
2071         createmany -o $DIR/$tdir/$tfile $fcount
2072
2073         for OSC in $MDS_OSCS; do
2074                 OST=$(osc_to_ost $OSC)
2075                 OSTIDX=$(index_from_ostuuid $OST)
2076                 if [ $OSTIDX == $OST_DEACTIVE_IDX ]; then
2077                         echo $OST "is recovered from degraded:"
2078                         do_facet ost$((OSTIDX+1)) lctl set_param -n \
2079                                                 obdfilter.$OST.degraded=0
2080                 else
2081                         do_facet $SINGLEMDS lctl --device %$OSC activate
2082                 fi
2083         done
2084
2085         # all osp devices get activated, hence -1 stripe count restored
2086         local stripe_count=0
2087
2088         # sleep 2*lod_qos_maxage seconds waiting for lod qos to notice osp
2089         # devices get activated.
2090         sleep_maxage
2091         $LFS setstripe -c -1 $DIR/$tfile
2092         stripe_count=$($LFS getstripe -c $DIR/$tfile)
2093         rm -f $DIR/$tfile
2094         [ $stripe_count -ne $OSTCOUNT ] &&
2095                 error "Of $OSTCOUNT OSTs, only $stripe_count is available"
2096         return 0
2097 }
2098 run_test 27y "create files while OST0 is degraded and the rest inactive"
2099
2100 check_seq_oid()
2101 {
2102         log "check file $1"
2103
2104         lmm_count=$($LFS getstripe -c $1)
2105         lmm_seq=$($LFS getstripe -v $1 | awk '/lmm_seq/ { print $2 }')
2106         lmm_oid=$($LFS getstripe -v $1 | awk '/lmm_object_id/ { print $2 }')
2107
2108         local old_ifs="$IFS"
2109         IFS=$'[:]'
2110         fid=($($LFS path2fid $1))
2111         IFS="$old_ifs"
2112
2113         log "FID seq ${fid[1]}, oid ${fid[2]} ver ${fid[3]}"
2114         log "LOV seq $lmm_seq, oid $lmm_oid, count: $lmm_count"
2115
2116         # compare lmm_seq and lu_fid->f_seq
2117         [ $lmm_seq = ${fid[1]} ] || { error "SEQ mismatch"; return 1; }
2118         # compare lmm_object_id and lu_fid->oid
2119         [ $lmm_oid = ${fid[2]} ] || { error "OID mismatch"; return 2; }
2120
2121         # check the trusted.fid attribute of the OST objects of the file
2122         local have_obdidx=false
2123         local stripe_nr=0
2124         $LFS getstripe $1 | while read obdidx oid hex seq; do
2125                 # skip lines up to and including "obdidx"
2126                 [ -z "$obdidx" ] && break
2127                 [ "$obdidx" = "obdidx" ] && have_obdidx=true && continue
2128                 $have_obdidx || continue
2129
2130                 local ost=$((obdidx + 1))
2131                 local dev=$(ostdevname $ost)
2132                 local oid_hex
2133
2134                 log "want: stripe:$stripe_nr ost:$obdidx oid:$oid/$hex seq:$seq"
2135
2136                 seq=$(echo $seq | sed -e "s/^0x//g")
2137                 if [ $seq == 0 ] || [ $(facet_fstype ost$ost) == zfs ]; then
2138                         oid_hex=$(echo $oid)
2139                 else
2140                         oid_hex=$(echo $hex | sed -e "s/^0x//g")
2141                 fi
2142                 local obj_file="O/$seq/d$((oid %32))/$oid_hex"
2143
2144                 local ff=""
2145                 #
2146                 # Don't unmount/remount the OSTs if we don't need to do that.
2147                 # LU-2577 changes filter_fid to be smaller, so debugfs needs
2148                 # update too, until that use mount/ll_decode_filter_fid/mount.
2149                 # Re-enable when debugfs will understand new filter_fid.
2150                 #
2151                 if [ $(facet_fstype ost$ost) == ldiskfs ]; then
2152                         ff=$(do_facet ost$ost "$DEBUGFS -c -R 'stat $obj_file' \
2153                                 $dev 2>/dev/null" | grep "parent=")
2154                 fi
2155                 if [ -z "$ff" ]; then
2156                         stop ost$ost
2157                         mount_fstype ost$ost
2158                         ff=$(do_facet ost$ost $LL_DECODE_FILTER_FID \
2159                                 $(facet_mntpt ost$ost)/$obj_file)
2160                         unmount_fstype ost$ost
2161                         start ost$ost $dev $OST_MOUNT_OPTS
2162                         clients_up
2163                 fi
2164
2165                 [ -z "$ff" ] && error "$obj_file: no filter_fid info"
2166
2167                 echo "$ff" | sed -e 's#.*objid=#got: objid=#'
2168
2169                 # /mnt/O/0/d23/23: objid=23 seq=0 parent=[0x200000400:0x1e:0x1]
2170                 # fid: objid=23 seq=0 parent=[0x200000400:0x1e:0x0] stripe=1
2171                 #
2172                 # fid: parent=[0x200000400:0x1e:0x0] stripe=1 stripe_count=2 \
2173                 #       stripe_size=1048576 component_id=1 component_start=0 \
2174                 #       component_end=33554432
2175                 local ff_parent=$(sed -e 's/.*parent=.//' <<<$ff)
2176                 local ff_pseq=$(cut -d: -f1 <<<$ff_parent)
2177                 local ff_poid=$(cut -d: -f2 <<<$ff_parent)
2178                 local ff_pstripe
2179                 if grep -q 'stripe=' <<<$ff; then
2180                         ff_pstripe=$(sed -e 's/.*stripe=//' -e 's/ .*//' <<<$ff)
2181                 else
2182                         # $LL_DECODE_FILTER_FID does not print "stripe="; look
2183                         # into f_ver in this case.  See comment on ff_parent.
2184                         ff_pstripe=$(cut -d: -f3 <<<$ff_parent | sed -e 's/]//')
2185                 fi
2186
2187                 # compare lmm_seq and filter_fid->ff_parent.f_seq
2188                 [ $ff_pseq = $lmm_seq ] ||
2189                         error "FF parent SEQ $ff_pseq != $lmm_seq"
2190                 # compare lmm_object_id and filter_fid->ff_parent.f_oid
2191                 [ $ff_poid = $lmm_oid ] ||
2192                         error "FF parent OID $ff_poid != $lmm_oid"
2193                 (($ff_pstripe == $stripe_nr)) ||
2194                         error "FF stripe $ff_pstripe != $stripe_nr"
2195
2196                 stripe_nr=$((stripe_nr + 1))
2197                 [ $CLIENT_VERSION -lt $(version_code 2.9.55) ] &&
2198                         continue
2199                 if grep -q 'stripe_count=' <<<$ff; then
2200                         local ff_scnt=$(sed -e 's/.*stripe_count=//' \
2201                                             -e 's/ .*//' <<<$ff)
2202                         [ $lmm_count = $ff_scnt ] ||
2203                                 error "FF stripe count $lmm_count != $ff_scnt"
2204                 fi
2205         done
2206 }
2207
2208 test_27z() {
2209         [ $PARALLEL == "yes" ] && skip "skip parallel run"
2210         remote_ost_nodsh && skip "remote OST with nodsh"
2211
2212         test_mkdir $DIR/$tdir
2213         $LFS setstripe -c 1 -i 0 -S 64k $DIR/$tdir/$tfile-1 ||
2214                 { error "setstripe -c -1 failed"; return 1; }
2215         # We need to send a write to every object to get parent FID info set.
2216         # This _should_ also work for setattr, but does not currently.
2217         # touch $DIR/$tdir/$tfile-1 ||
2218         dd if=/dev/zero of=$DIR/$tdir/$tfile-1 bs=1M count=1 ||
2219                 { error "dd $tfile-1 failed"; return 2; }
2220         $LFS setstripe -c -1 -i $((OSTCOUNT - 1)) -S 1M $DIR/$tdir/$tfile-2 ||
2221                 { error "setstripe -c -1 failed"; return 3; }
2222         dd if=/dev/zero of=$DIR/$tdir/$tfile-2 bs=1M count=$OSTCOUNT ||
2223                 { error "dd $tfile-2 failed"; return 4; }
2224
2225         # make sure write RPCs have been sent to OSTs
2226         sync; sleep 5; sync
2227
2228         check_seq_oid $DIR/$tdir/$tfile-1 || return 5
2229         check_seq_oid $DIR/$tdir/$tfile-2 || return 6
2230 }
2231 run_test 27z "check SEQ/OID on the MDT and OST filesystems"
2232
2233 test_27A() { # b=19102
2234         [ $PARALLEL == "yes" ] && skip "skip parallel run"
2235
2236         save_layout_restore_at_exit $MOUNT
2237         $LFS setstripe -c 0 -i -1 -S 0 $MOUNT
2238         wait_update $HOSTNAME "$LFS getstripe -c $MOUNT | sed 's/  *//g'" "1" 20 ||
2239                 error "stripe count $($LFS getstripe -c $MOUNT) != 1"
2240         local default_size=$($LFS getstripe -S $MOUNT)
2241         local default_offset=$($LFS getstripe -i $MOUNT)
2242         local dsize=$(do_facet $SINGLEMDS \
2243                 "$LCTL get_param -n lod.$(facet_svc $SINGLEMDS)*.stripesize")
2244         [ $default_size -eq $dsize ] ||
2245                 error "stripe size $default_size != $dsize"
2246         [ $default_offset -eq -1 ] ||
2247                 error "stripe offset $default_offset != -1"
2248 }
2249 run_test 27A "check filesystem-wide default LOV EA values"
2250
2251 test_27B() { # LU-2523
2252         test_mkdir $DIR/$tdir
2253         rm -f $DIR/$tdir/f0 $DIR/$tdir/f1
2254         touch $DIR/$tdir/f0
2255         # open f1 with O_LOV_DELAY_CREATE
2256         # rename f0 onto f1
2257         # call setstripe ioctl on open file descriptor for f1
2258         # close
2259         multiop $DIR/$tdir/f1 oO_RDWR:O_CREAT:O_LOV_DELAY_CREATE:nB1c \
2260                 $DIR/$tdir/f0
2261
2262         rm -f $DIR/$tdir/f1
2263         # open f1 with O_LOV_DELAY_CREATE
2264         # unlink f1
2265         # call setstripe ioctl on open file descriptor for f1
2266         # close
2267         multiop $DIR/$tdir/f1 oO_RDWR:O_CREAT:O_LOV_DELAY_CREATE:uB1c
2268
2269         # Allow multiop to fail in imitation of NFS's busted semantics.
2270         true
2271 }
2272 run_test 27B "call setstripe on open unlinked file/rename victim"
2273
2274 # 27C family tests full striping and overstriping
2275 test_27Ca() { #LU-2871
2276         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
2277
2278         declare -a ost_idx
2279         local index
2280         local found
2281         local i
2282         local j
2283
2284         test_mkdir $DIR/$tdir
2285         cd $DIR/$tdir
2286         for i in $(seq 0 $((OSTCOUNT - 1))); do
2287                 # set stripe across all OSTs starting from OST$i
2288                 $LFS setstripe -i $i -c -1 $tfile$i
2289                 # get striping information
2290                 ost_idx=($($LFS getstripe $tfile$i |
2291                          tail -n $((OSTCOUNT + 1)) | awk '{print $1}'))
2292                 echo ${ost_idx[@]}
2293
2294                 # check the layout
2295                 [ ${#ost_idx[@]} -eq $OSTCOUNT ] ||
2296                         error "${#ost_idx[@]} != $OSTCOUNT"
2297
2298                 for index in $(seq 0 $((OSTCOUNT - 1))); do
2299                         found=0
2300                         for j in $(echo ${ost_idx[@]}); do
2301                                 if [ $index -eq $j ]; then
2302                                         found=1
2303                                         break
2304                                 fi
2305                         done
2306                         [ $found = 1 ] ||
2307                                 error "Can not find $index in ${ost_idx[@]}"
2308                 done
2309         done
2310 }
2311 run_test 27Ca "check full striping across all OSTs"
2312
2313 test_27Cb() {
2314         [[ $($LCTL get_param mdc.*.import) =~ connect_flags.*overstriping ]] ||
2315                 skip "server does not support overstriping"
2316         [[ $OSTCOUNT -ge $(($LOV_MAX_STRIPE_COUNT / 2)) ]] &&
2317                 skip_env "too many osts, skipping"
2318
2319         test_mkdir -p $DIR/$tdir
2320         local setcount=$(($OSTCOUNT * 2))
2321         [ $setcount -ge 160 ] || large_xattr_enabled ||
2322                 skip_env "ea_inode feature disabled"
2323
2324         $LFS setstripe -C $setcount $DIR/$tdir/$tfile ||
2325                 error "setstripe failed"
2326
2327         local count=$($LFS getstripe -c $DIR/$tdir/$tfile)
2328         [ $count -eq $setcount ] ||
2329                 error "stripe count $count, should be $setcount"
2330
2331         $LFS getstripe $DIR/$tdir/$tfile 2>&1 | grep "overstriped" ||
2332                 error "overstriped should be set in pattern"
2333
2334         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=4 conv=notrunc ||
2335                 error "dd failed"
2336 }
2337 run_test 27Cb "more stripes than OSTs with -C"
2338
2339 test_27Cc() {
2340         [[ $($LCTL get_param mdc.*.import) =~ connect_flags.*overstriping ]] ||
2341                 skip "server does not support overstriping"
2342         [[ $OSTCOUNT -lt 2 ]] && skip_env "need > 1 OST"
2343
2344         test_mkdir -p $DIR/$tdir
2345         local setcount=$(($OSTCOUNT - 1))
2346
2347         [ $setcount -ge 160 ] || large_xattr_enabled ||
2348                 skip_env "ea_inode feature disabled"
2349
2350         $LFS setstripe -C $setcount $DIR/$tdir/$tfile ||
2351                 error "setstripe failed"
2352
2353         local count=$($LFS getstripe -c $DIR/$tdir/$tfile)
2354         [ $count -eq $setcount ] ||
2355                 error "stripe count $count, should be $setcount"
2356
2357         $LFS getstripe $DIR/$tdir/$tfile 2>&1 | grep "overstriped" &&
2358                 error "overstriped should not be set in pattern"
2359
2360         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=4 conv=notrunc ||
2361                 error "dd failed"
2362 }
2363 run_test 27Cc "fewer stripes than OSTs does not set overstriping"
2364
2365 test_27Cd() {
2366         [[ $($LCTL get_param mdc.*.import) =~ connect_flags.*overstriping ]] ||
2367                 skip "server does not support overstriping"
2368         [[ $OSTCOUNT -lt 2 ]] && skip_env "need > 1 OST"
2369         large_xattr_enabled || skip_env "ea_inode feature disabled"
2370
2371         test_mkdir -p $DIR/$tdir
2372         local setcount=$LOV_MAX_STRIPE_COUNT
2373
2374         $LFS setstripe -C $setcount $DIR/$tdir/$tfile ||
2375                 error "setstripe failed"
2376
2377         local count=$($LFS getstripe -c $DIR/$tdir/$tfile)
2378         [ $count -eq $setcount ] ||
2379                 error "stripe count $count, should be $setcount"
2380
2381         $LFS getstripe $DIR/$tdir/$tfile 2>&1 | grep "overstriped" ||
2382                 error "overstriped should be set in pattern"
2383
2384         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=4 conv=notrunc ||
2385                 error "dd failed"
2386
2387         rm -f $DIR/$tdir/$tfile || error "Delete $tfile failed"
2388 }
2389 run_test 27Cd "test maximum stripe count"
2390
2391 test_27Ce() {
2392         [[ $($LCTL get_param mdc.*.import) =~ connect_flags.*overstriping ]] ||
2393                 skip "server does not support overstriping"
2394         test_mkdir -p $DIR/$tdir
2395
2396         pool_add $TESTNAME || error "Pool creation failed"
2397         pool_add_targets $TESTNAME 0 || error "pool_add_targets failed"
2398
2399         local setcount=8
2400
2401         $LFS setstripe  -C $setcount -p "$TESTNAME" $DIR/$tdir/$tfile ||
2402                 error "setstripe failed"
2403
2404         local count=$($LFS getstripe -c $DIR/$tdir/$tfile)
2405         [ $count -eq $setcount ] ||
2406                 error "stripe count $count, should be $setcount"
2407
2408         $LFS getstripe $DIR/$tdir/$tfile 2>&1 | grep "overstriped" ||
2409                 error "overstriped should be set in pattern"
2410
2411         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=4 conv=notrunc ||
2412                 error "dd failed"
2413
2414         rm -f $DIR/$tdir/$tfile || error "Delete $tfile failed"
2415 }
2416 run_test 27Ce "test pool with overstriping"
2417
2418 test_27Cf() {
2419         [[ $($LCTL get_param mdc.*.import) =~ connect_flags.*overstriping ]] ||
2420                 skip "server does not support overstriping"
2421         [[ $OSTCOUNT -ge $(($LOV_MAX_STRIPE_COUNT / 2)) ]] &&
2422                 skip_env "too many osts, skipping"
2423
2424         test_mkdir -p $DIR/$tdir
2425
2426         local setcount=$(($OSTCOUNT * 2))
2427         [ $setcount -ge 160 ] || large_xattr_enabled ||
2428                 skip_env "ea_inode feature disabled"
2429
2430         $LFS setstripe  -C $setcount $DIR/$tdir/ ||
2431                 error "setstripe failed"
2432
2433         echo 1 > $DIR/$tdir/$tfile
2434
2435         local count=$($LFS getstripe -c $DIR/$tdir/$tfile)
2436         [ $count -eq $setcount ] ||
2437                 error "stripe count $count, should be $setcount"
2438
2439         $LFS getstripe $DIR/$tdir/$tfile 2>&1 | grep "overstriped" ||
2440                 error "overstriped should be set in pattern"
2441
2442         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=4 conv=notrunc ||
2443                 error "dd failed"
2444
2445         rm -f $DIR/$tdir/$tfile || error "Delete $tfile failed"
2446 }
2447 run_test 27Cf "test default inheritance with overstriping"
2448
2449 test_27D() {
2450         [ $OSTCOUNT -lt 2 ] && skip_env "needs >= 2 OSTs"
2451         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
2452         remote_mds_nodsh && skip "remote MDS with nodsh"
2453
2454         local POOL=${POOL:-testpool}
2455         local first_ost=0
2456         local last_ost=$(($OSTCOUNT - 1))
2457         local ost_step=1
2458         local ost_list=$(seq $first_ost $ost_step $last_ost)
2459         local ost_range="$first_ost $last_ost $ost_step"
2460
2461         if ! combined_mgs_mds ; then
2462                 mount_mgs_client
2463         fi
2464
2465         test_mkdir $DIR/$tdir
2466         pool_add $POOL || error "pool_add failed"
2467         pool_add_targets $POOL $ost_range || error "pool_add_targets failed"
2468
2469         local skip27D
2470         [ $MDS1_VERSION -lt $(version_code 2.8.55) ] &&
2471                 skip27D+="-s 29"
2472         [ $MDS1_VERSION -lt $(version_code 2.9.55) ] ||
2473                 [ $CLIENT_VERSION -lt $(version_code 2.9.55) ] &&
2474                         skip27D+=" -s 30,31"
2475         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code $SEL_VER) ] &&
2476                 skip27D+="-s 32"
2477         [[ ! $($LCTL get_param mdc.*.import) =~ connect_flags.*overstriping ||
2478           $OSTCOUNT -ge $(($LOV_MAX_STRIPE_COUNT / 2)) ]] &&
2479                 skip27D+=" -s 32,33"
2480         llapi_layout_test -d$DIR/$tdir -p$POOL -o$OSTCOUNT $skip27D ||
2481                 error "llapi_layout_test failed"
2482
2483         destroy_test_pools || error "destroy test pools failed"
2484
2485         if ! combined_mgs_mds ; then
2486                 umount_mgs_client
2487         fi
2488 }
2489 run_test 27D "validate llapi_layout API"
2490
2491 # Verify that default_easize is increased from its initial value after
2492 # accessing a widely striped file.
2493 test_27E() {
2494         [ $OSTCOUNT -lt 2 ] && skip_env "needs >= 2 OSTs"
2495         [ $CLIENT_VERSION -lt $(version_code 2.5.57) ] &&
2496                 skip "client does not have LU-3338 fix"
2497
2498         # 72 bytes is the minimum space required to store striping
2499         # information for a file striped across one OST:
2500         # (sizeof(struct lov_user_md_v3) +
2501         #  sizeof(struct lov_user_ost_data_v1))
2502         local min_easize=72
2503         $LCTL set_param -n llite.*.default_easize $min_easize ||
2504                 error "lctl set_param failed"
2505         local easize=$($LCTL get_param -n llite.*.default_easize)
2506
2507         [ $easize -eq $min_easize ] ||
2508                 error "failed to set default_easize"
2509
2510         $LFS setstripe -c $OSTCOUNT $DIR/$tfile ||
2511                 error "setstripe failed"
2512         # In order to ensure stat() call actually talks to MDS we need to
2513         # do something drastic to this file to shake off all lock, e.g.
2514         # rename it (kills lookup lock forcing cache cleaning)
2515         mv $DIR/$tfile $DIR/${tfile}-1
2516         ls -l $DIR/${tfile}-1
2517         rm $DIR/${tfile}-1
2518
2519         easize=$($LCTL get_param -n llite.*.default_easize)
2520
2521         [ $easize -gt $min_easize ] ||
2522                 error "default_easize not updated"
2523 }
2524 run_test 27E "check that default extended attribute size properly increases"
2525
2526 test_27F() { # LU-5346/LU-7975
2527         [ $PARALLEL == "yes" ] && skip "skip parallel run"
2528         [[ $OSTCOUNT -lt 2 ]] && skip "needs >= 2 OSTs"
2529         [[ $MDS1_VERSION -lt $(version_code 2.8.51) ]] &&
2530                 skip "Need MDS version at least 2.8.51"
2531         remote_ost_nodsh && skip "remote OST with nodsh"
2532
2533         test_mkdir $DIR/$tdir
2534         rm -f $DIR/$tdir/f0
2535         $LFS setstripe -c 2 $DIR/$tdir
2536
2537         # stop all OSTs to reproduce situation for LU-7975 ticket
2538         for num in $(seq $OSTCOUNT); do
2539                 stop ost$num
2540         done
2541
2542         # open/create f0 with O_LOV_DELAY_CREATE
2543         # truncate f0 to a non-0 size
2544         # close
2545         multiop $DIR/$tdir/f0 oO_RDWR:O_CREAT:O_LOV_DELAY_CREATE:T1050000c
2546
2547         $CHECKSTAT -s 1050000 $DIR/$tdir/f0 || error "checkstat failed"
2548         # open/write it again to force delayed layout creation
2549         cat /etc/hosts > $DIR/$tdir/f0 &
2550         catpid=$!
2551
2552         # restart OSTs
2553         for num in $(seq $OSTCOUNT); do
2554                 start ost$num $(ostdevname $num) $OST_MOUNT_OPTS ||
2555                         error "ost$num failed to start"
2556         done
2557
2558         wait $catpid || error "cat failed"
2559
2560         cmp /etc/hosts $DIR/$tdir/f0 || error "cmp failed"
2561         [[ $($LFS getstripe -c $DIR/$tdir/f0) == 2 ]] ||
2562                 error "wrong stripecount"
2563
2564 }
2565 run_test 27F "Client resend delayed layout creation with non-zero size"
2566
2567 test_27G() { #LU-10629
2568         [ $MDS1_VERSION -lt $(version_code 2.11.51) ] &&
2569                 skip "Need MDS version at least 2.11.51"
2570         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
2571         remote_mds_nodsh && skip "remote MDS with nodsh"
2572         local POOL=${POOL:-testpool}
2573         local ostrange="0 0 1"
2574
2575         test_mkdir $DIR/$tdir
2576         pool_add $POOL || error "pool_add failed"
2577         pool_add_targets $POOL $ostrange || error "pool_add_targets failed"
2578         $LFS setstripe -p $POOL $DIR/$tdir
2579
2580         local pool=$($LFS getstripe -p $DIR/$tdir)
2581
2582         [ "$pool" = "$POOL" ] || error "Striping failed got '$pool' not '$POOL'"
2583
2584         $LFS setstripe -d $DIR/$tdir
2585
2586         pool=$($LFS getstripe -p $DIR/$tdir)
2587
2588         rmdir $DIR/$tdir
2589
2590         [ -z "$pool" ] || error "'$pool' is not empty"
2591 }
2592 run_test 27G "Clear OST pool from stripe"
2593
2594 test_27H() {
2595         [[ $MDS1_VERSION -le $(version_code 2.11.54) ]] &&
2596                 skip "Need MDS version newer than 2.11.54"
2597         [[ $OSTCOUNT -lt 3 ]] && skip_env "needs >= 3 OSTs"
2598         test_mkdir $DIR/$tdir
2599         $LFS setstripe -o 0 -o 2 $DIR/$tdir || error "setstripe failed"
2600         touch $DIR/$tdir/$tfile
2601         $LFS getstripe -c $DIR/$tdir/$tfile
2602         [ $($LFS getstripe -c $DIR/$tdir/$tfile) -eq 2 ] ||
2603                 error "two-stripe file doesn't have two stripes"
2604
2605         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=4k count=4 || error "dd failed"
2606         $LFS getstripe -y $DIR/$tdir/$tfile
2607         (( $($LFS getstripe -y $DIR/$tdir/$tfile |
2608              egrep -c "l_ost_idx: [02]$") == "2" )) ||
2609                 error "expected l_ost_idx: [02]$ not matched"
2610
2611         # make sure ost list has been cleared
2612         local stripesize=$($LFS getstripe -S $DIR/$tdir)
2613         $LFS setstripe -S $((stripesize * 4)) -i 1 \
2614                 -c $((OSTCOUNT - 1)) $DIR/$tdir || error "setstripe"
2615         touch $DIR/$tdir/f3
2616         $LVERIFY $DIR/$tdir $DIR/$tdir/f3 || error "lverify failed"
2617 }
2618 run_test 27H "Set specific OSTs stripe"
2619
2620 test_27I() {
2621         [ $PARALLEL == "yes" ] && skip "skip parallel run"
2622         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
2623         local pool=$TESTNAME
2624         local ostrange="1 1 1"
2625
2626         save_layout_restore_at_exit $MOUNT
2627         $LFS setstripe -c 2 -i 0 $MOUNT
2628         pool_add $pool || error "pool_add failed"
2629         pool_add_targets $pool $ostrange || "pool_add_targets failed"
2630         test_mkdir $DIR/$tdir
2631         $LFS setstripe -p $pool $DIR/$tdir
2632         $MULTIOP $DIR/$tdir/$tfile Oc || error "multiop failed"
2633         $LFS getstripe $DIR/$tdir/$tfile
2634 }
2635 run_test 27I "check that root dir striping does not break parent dir one"
2636
2637 test_27J() {
2638         [[ $(lustre_version_code $SINGLEMDS) -le $(version_code 2.12.51) ]] &&
2639                 skip "Need MDS version newer than 2.12.51"
2640
2641         test_mkdir $DIR/$tdir
2642         local uuid1=$(cat /proc/sys/kernel/random/uuid)
2643         local uuid2=$(cat /proc/sys/kernel/random/uuid)
2644
2645         # create foreign file (raw way)
2646         create_foreign_file -f $DIR/$tdir/$tfile -x "${uuid1}@${uuid2}" \
2647                 -t 1 -F 0xda08 || error "create_foreign_file failed"
2648
2649         # verify foreign file (raw way)
2650         parse_foreign_file -f $DIR/$tdir/$tfile |
2651                 grep "lov_foreign_magic: 0x0BD70BD0" ||
2652                 error "$DIR/$tdir/$tfile: invalid LOV EA foreign magic"
2653         parse_foreign_file -f $DIR/$tdir/$tfile | grep "lov_xattr_size: 89" ||
2654                 error "$DIR/$tdir/$tfile: invalid LOV EA foreign size"
2655         parse_foreign_file -f $DIR/$tdir/$tfile |
2656                 grep "lov_foreign_size: 73" ||
2657                 error "$DIR/$tdir/$tfile: invalid LOV EA foreign size"
2658         parse_foreign_file -f $DIR/$tdir/$tfile |
2659                 grep "lov_foreign_type: 1" ||
2660                 error "$DIR/$tdir/$tfile: invalid LOV EA foreign type"
2661         parse_foreign_file -f $DIR/$tdir/$tfile |
2662                 grep "lov_foreign_flags: 0x0000DA08" ||
2663                 error "$DIR/$tdir/$tfile: invalid LOV EA foreign flags"
2664         local lov=$(parse_foreign_file -f $DIR/$tdir/$tfile |
2665                 grep "lov_foreign_value: 0x" |
2666                 sed -e 's/lov_foreign_value: 0x//')
2667         local lov2=$(echo -n "${uuid1}@${uuid2}" | od -A n -t x1 -w160)
2668         [[ $lov = ${lov2// /} ]] ||
2669                 error "$DIR/$tdir/$tfile: invalid LOV EA foreign value"
2670
2671         # create foreign file (lfs + API)
2672         $LFS setstripe --foreign=daos --flags 0xda08 \
2673                 -x "${uuid1}@${uuid2}" $DIR/$tdir/${tfile}2 ||
2674                 error "$DIR/$tdir/${tfile}2: create failed"
2675
2676         $LFS getstripe -v $DIR/$tdir/${tfile}2 |
2677                 grep "lfm_magic:.*0x0BD70BD0" ||
2678                 error "$DIR/$tdir/${tfile}2: invalid LOV EA foreign magic"
2679         # lfm_length is LOV EA size - sizeof(lfm_magic) - sizeof(lfm_length)
2680         $LFS getstripe -v $DIR/$tdir/${tfile}2 | grep "lfm_length:.*73" ||
2681                 error "$DIR/$tdir/${tfile}2: invalid LOV EA foreign size"
2682         $LFS getstripe -v $DIR/$tdir/${tfile}2 | grep "lfm_type:.*daos" ||
2683                 error "$DIR/$tdir/${tfile}2: invalid LOV EA foreign type"
2684         $LFS getstripe -v $DIR/$tdir/${tfile}2 |
2685                 grep "lfm_flags:.*0x0000DA08" ||
2686                 error "$DIR/$tdir/${tfile}2: invalid LOV EA foreign flags"
2687         $LFS getstripe $DIR/$tdir/${tfile}2 |
2688                 grep "lfm_value:.*${uuid1}@${uuid2}" ||
2689                 error "$DIR/$tdir/${tfile}2: invalid LOV EA foreign value"
2690
2691         # modify striping should fail
2692         $LFS setstripe -c 2 $DIR/$tdir/$tfile &&
2693                 error "$DIR/$tdir/$tfile: setstripe should fail"
2694         $LFS setstripe -c 2 $DIR/$tdir/${tfile}2 &&
2695                 error "$DIR/$tdir/${tfile}2: setstripe should fail"
2696
2697         # R/W should fail
2698         cat $DIR/$tdir/$tfile && error "$DIR/$tdir/$tfile: read should fail"
2699         cat $DIR/$tdir/${tfile}2 &&
2700                 error "$DIR/$tdir/${tfile}2: read should fail"
2701         cat /etc/passwd > $DIR/$tdir/$tfile &&
2702                 error "$DIR/$tdir/$tfile: write should fail"
2703         cat /etc/passwd > $DIR/$tdir/${tfile}2 &&
2704                 error "$DIR/$tdir/${tfile}2: write should fail"
2705
2706         # chmod should work
2707         chmod 222 $DIR/$tdir/$tfile ||
2708                 error "$DIR/$tdir/$tfile: chmod failed"
2709         chmod 222 $DIR/$tdir/${tfile}2 ||
2710                 error "$DIR/$tdir/${tfile}2: chmod failed"
2711
2712         # chown should work
2713         chown $RUNAS_ID:$RUNAS_GID $DIR/$tdir/$tfile ||
2714                 error "$DIR/$tdir/$tfile: chown failed"
2715         chown $RUNAS_ID:$RUNAS_GID $DIR/$tdir/${tfile}2 ||
2716                 error "$DIR/$tdir/${tfile}2: chown failed"
2717
2718         # rename should work
2719         mv $DIR/$tdir/$tfile $DIR/$tdir/${tfile}.new ||
2720                 error "$DIR/$tdir/$tfile: rename of foreign file has failed"
2721         mv $DIR/$tdir/${tfile}2 $DIR/$tdir/${tfile}2.new ||
2722                 error "$DIR/$tdir/${tfile}2: rename of foreign file has failed"
2723
2724         #remove foreign file
2725         rm $DIR/$tdir/${tfile}.new ||
2726                 error "$DIR/$tdir/${tfile}.new: remove of foreign file has failed"
2727         rm $DIR/$tdir/${tfile}2.new ||
2728                 error "$DIR/$tdir/${tfile}2.new: remove of foreign file has failed"
2729 }
2730 run_test 27J "basic ops on file with foreign LOV"
2731
2732 test_27K() {
2733         [[ $(lustre_version_code $SINGLEMDS) -le $(version_code 2.12.49) ]] &&
2734                 skip "Need MDS version newer than 2.12.49"
2735
2736         test_mkdir $DIR/$tdir
2737         local uuid1=$(cat /proc/sys/kernel/random/uuid)
2738         local uuid2=$(cat /proc/sys/kernel/random/uuid)
2739
2740         # create foreign dir (raw way)
2741         create_foreign_dir -d $DIR/$tdir/$tdir -x "${uuid1}@${uuid2}" -t 1 ||
2742                 error "create_foreign_dir FAILED"
2743
2744         # verify foreign dir (raw way)
2745         parse_foreign_dir -d $DIR/$tdir/$tdir |
2746                 grep "lmv_foreign_magic:.*0xcd50cd0" ||
2747                 error "$DIR/$tdir/$tfile: invalid LMV EA magic"
2748         parse_foreign_dir -d $DIR/$tdir/$tdir | grep "lmv_xattr_size:.*89$" ||
2749                 error "$DIR/$tdir/$tdir: invalid LMV EA size"
2750         parse_foreign_dir -d $DIR/$tdir/$tdir | grep "lmv_foreign_type: 1$" ||
2751                 error "$DIR/$tdir/$tdir: invalid LMV EA type"
2752         parse_foreign_dir -d $DIR/$tdir/$tdir | grep "lmv_foreign_flags: 0$" ||
2753                 error "$DIR/$tdir/$tdir: invalid LMV EA flags"
2754         local lmv=$(parse_foreign_dir -d $DIR/$tdir/$tdir |
2755                 grep "lmv_foreign_value: 0x" |
2756                 sed 's/lmv_foreign_value: 0x//')
2757         local lmv2=$(echo -n "${uuid1}@${uuid2}" | od -A n -t x1 -w160 |
2758                 sed 's/ //g')
2759         [[ $lmv == $lmv2 ]] || error "$DIR/$tdir/$tdir: invalid LMV EA value"
2760
2761         # create foreign dir (lfs + API)
2762         $LFS mkdir --foreign=daos --xattr="${uuid1}@${uuid2}" --flags=0xda05 \
2763                 $DIR/$tdir/${tdir}2 ||
2764                 error "$DIR/$tdir/${tdir}2: create failed"
2765
2766         $LFS getdirstripe -v $DIR/$tdir/${tdir}2 |
2767                 grep "lfm_magic:.*0x0CD50CD0" ||
2768                 error "$DIR/$tdir/${tdir}2: invalid LMV EA magic"
2769         # lfm_length is LMV EA size - sizeof(lfm_magic) - sizeof(lfm_length)
2770         # - sizeof(lfm_type) - sizeof(lfm_flags)
2771         $LFS getdirstripe -v $DIR/$tdir/${tdir}2 | grep "lfm_length:.*73" ||
2772                 error "$DIR/$tdir/${tdir}2: invalid LMV EA size"
2773         $LFS getdirstripe -v $DIR/$tdir/${tdir}2 | grep "lfm_type:.*daos" ||
2774                 error "$DIR/$tdir/${tdir}2: invalid LMV EA type"
2775         $LFS getdirstripe -v $DIR/$tdir/${tdir}2 |
2776                 grep "lfm_flags:.*0x0000DA05" ||
2777                 error "$DIR/$tdir/${tdir}2: invalid LMV EA flags"
2778         $LFS getdirstripe $DIR/$tdir/${tdir}2 |
2779                 grep "lfm_value.*${uuid1}@${uuid2}" ||
2780                 error "$DIR/$tdir/${tdir}2: invalid LMV EA value"
2781
2782         # file create in dir should fail
2783         touch $DIR/$tdir/$tdir/$tfile && "$DIR/$tdir: file create should fail"
2784         touch $DIR/$tdir/${tdir}2/$tfile &&
2785                 "$DIR/${tdir}2: file create should fail"
2786
2787         # chmod should work
2788         chmod 777 $DIR/$tdir/$tdir ||
2789                 error "$DIR/$tdir: chmod failed"
2790         chmod 777 $DIR/$tdir/${tdir}2 ||
2791                 error "$DIR/${tdir}2: chmod failed"
2792
2793         # chown should work
2794         chown $RUNAS_ID:$RUNAS_GID $DIR/$tdir/$tdir ||
2795                 error "$DIR/$tdir: chown failed"
2796         chown $RUNAS_ID:$RUNAS_GID $DIR/$tdir/${tdir}2 ||
2797                 error "$DIR/${tdir}2: chown failed"
2798
2799         # rename should work
2800         mv $DIR/$tdir/$tdir $DIR/$tdir/${tdir}.new ||
2801                 error "$DIR/$tdir/$tdir: rename of foreign dir has failed"
2802         mv $DIR/$tdir/${tdir}2 $DIR/$tdir/${tdir}2.new ||
2803                 error "$DIR/$tdir/${tdir}2: rename of foreign dir has failed"
2804
2805         #remove foreign dir
2806         rmdir $DIR/$tdir/${tdir}.new ||
2807                 error "$DIR/$tdir/${tdir}.new: remove of foreign dir has failed"
2808         rmdir $DIR/$tdir/${tdir}2.new ||
2809                 error "$DIR/$tdir/${tdir}2.new: remove of foreign dir has failed"
2810 }
2811 run_test 27K "basic ops on dir with foreign LMV"
2812
2813 test_27L() {
2814         remote_mds_nodsh && skip "remote MDS with nodsh"
2815
2816         local POOL=${POOL:-$TESTNAME}
2817
2818         if ! combined_mgs_mds ; then
2819                 mount_mgs_client
2820                 trap umount_mgs_client EXIT
2821         fi
2822
2823         pool_add $POOL || error "pool_add failed"
2824
2825         lfs pool_list $MOUNT | grep -Fx "${FSNAME}.${POOL}" ||
2826                  error "pool_list does not contain ${FSNAME}.${POOL}:" \
2827                        "$(lfs pool_list $MOUNT | grep -F "${POOL}")"
2828 }
2829 run_test 27L "lfs pool_list gives correct pool name"
2830
2831 # createtest also checks that device nodes are created and
2832 # then visible correctly (#2091)
2833 test_28() { # bug 2091
2834         test_mkdir $DIR/d28
2835         $CREATETEST $DIR/d28/ct || error "createtest failed"
2836 }
2837 run_test 28 "create/mknod/mkdir with bad file types ============"
2838
2839 test_29() {
2840         [ $PARALLEL == "yes" ] && skip "skip parallel run"
2841
2842         sync; sleep 1; sync # flush out any dirty pages from previous tests
2843         cancel_lru_locks
2844         test_mkdir $DIR/d29
2845         touch $DIR/d29/foo
2846         log 'first d29'
2847         ls -l $DIR/d29
2848
2849         declare -i LOCKCOUNTORIG=0
2850         for lock_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_count); do
2851                 let LOCKCOUNTORIG=$LOCKCOUNTORIG+$lock_count
2852         done
2853         [ $LOCKCOUNTORIG -eq 0 ] && error "No mdc lock count" && return 1
2854
2855         declare -i LOCKUNUSEDCOUNTORIG=0
2856         for unused_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_unused_count); do
2857                 let LOCKUNUSEDCOUNTORIG=$LOCKUNUSEDCOUNTORIG+$unused_count
2858         done
2859
2860         log 'second d29'
2861         ls -l $DIR/d29
2862         log 'done'
2863
2864         declare -i LOCKCOUNTCURRENT=0
2865         for lock_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_count); do
2866                 let LOCKCOUNTCURRENT=$LOCKCOUNTCURRENT+$lock_count
2867         done
2868
2869         declare -i LOCKUNUSEDCOUNTCURRENT=0
2870         for unused_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_unused_count); do
2871                 let LOCKUNUSEDCOUNTCURRENT=$LOCKUNUSEDCOUNTCURRENT+$unused_count
2872         done
2873
2874         if [[ $LOCKCOUNTCURRENT -gt $LOCKCOUNTORIG ]]; then
2875                 $LCTL set_param -n ldlm.dump_namespaces ""
2876                 error "CURRENT: $LOCKCOUNTCURRENT > $LOCKCOUNTORIG"
2877                 $LCTL dk | sort -k4 -t: > $TMP/test_29.dk
2878                 log "dumped log to $TMP/test_29.dk (bug 5793)"
2879                 return 2
2880         fi
2881         if [[ $LOCKUNUSEDCOUNTCURRENT -gt $LOCKUNUSEDCOUNTORIG ]]; then
2882                 error "UNUSED: $LOCKUNUSEDCOUNTCURRENT > $LOCKUNUSEDCOUNTORIG"
2883                 $LCTL dk | sort -k4 -t: > $TMP/test_29.dk
2884                 log "dumped log to $TMP/test_29.dk (bug 5793)"
2885                 return 3
2886         fi
2887 }
2888 run_test 29 "IT_GETATTR regression  ============================"
2889
2890 test_30a() { # was test_30
2891         cp $(which ls) $DIR || cp /bin/ls $DIR
2892         $DIR/ls / || error "Can't execute binary from lustre"
2893         rm $DIR/ls
2894 }
2895 run_test 30a "execute binary from Lustre (execve) =============="
2896
2897 test_30b() {
2898         cp `which ls` $DIR || cp /bin/ls $DIR
2899         chmod go+rx $DIR/ls
2900         $RUNAS $DIR/ls / || error "Can't execute binary from lustre as non-root"
2901         rm $DIR/ls
2902 }
2903 run_test 30b "execute binary from Lustre as non-root ==========="
2904
2905 test_30c() { # b=22376
2906         [ $PARALLEL == "yes" ] && skip "skip parallel run"
2907
2908         cp `which ls` $DIR || cp /bin/ls $DIR
2909         chmod a-rw $DIR/ls
2910         cancel_lru_locks mdc
2911         cancel_lru_locks osc
2912         $RUNAS $DIR/ls / || error "Can't execute binary from lustre"
2913         rm -f $DIR/ls
2914 }
2915 run_test 30c "execute binary from Lustre without read perms ===="
2916
2917 test_31a() {
2918         $OPENUNLINK $DIR/f31 $DIR/f31 || error "openunlink failed"
2919         $CHECKSTAT -a $DIR/f31 || error "$DIR/f31 exists"
2920 }
2921 run_test 31a "open-unlink file =================================="
2922
2923 test_31b() {
2924         touch $DIR/f31 || error "touch $DIR/f31 failed"
2925         ln $DIR/f31 $DIR/f31b || error "ln failed"
2926         $MULTIOP $DIR/f31b Ouc || error "multiop failed"
2927         $CHECKSTAT -t file $DIR/f31 || error "$DIR/f31 not file type"
2928 }
2929 run_test 31b "unlink file with multiple links while open ======="
2930
2931 test_31c() {
2932         touch $DIR/f31 || error "touch $DIR/f31 failed"
2933         ln $DIR/f31 $DIR/f31c || error "ln failed"
2934         multiop_bg_pause $DIR/f31 O_uc ||
2935                 error "multiop_bg_pause for $DIR/f31 failed"
2936         MULTIPID=$!
2937         $MULTIOP $DIR/f31c Ouc
2938         kill -USR1 $MULTIPID
2939         wait $MULTIPID
2940 }
2941 run_test 31c "open-unlink file with multiple links ============="
2942
2943 test_31d() {
2944         opendirunlink $DIR/d31d $DIR/d31d || error "opendirunlink failed"
2945         $CHECKSTAT -a $DIR/d31d || error "$DIR/d31d exists"
2946 }
2947 run_test 31d "remove of open directory ========================="
2948
2949 test_31e() { # bug 2904
2950         openfilleddirunlink $DIR/d31e || error "openfilleddirunlink failed"
2951 }
2952 run_test 31e "remove of open non-empty directory ==============="
2953
2954 test_31f() { # bug 4554
2955         [ $PARALLEL == "yes" ] && skip "skip parallel run"
2956
2957         set -vx
2958         test_mkdir $DIR/d31f
2959         $LFS setstripe -S 1048576 -c 1 $DIR/d31f
2960         cp /etc/hosts $DIR/d31f
2961         ls -l $DIR/d31f
2962         $LFS getstripe $DIR/d31f/hosts
2963         multiop_bg_pause $DIR/d31f D_c || return 1
2964         MULTIPID=$!
2965
2966         rm -rv $DIR/d31f || error "first of $DIR/d31f"
2967         test_mkdir $DIR/d31f
2968         $LFS setstripe -S 1048576 -c 1 $DIR/d31f
2969         cp /etc/hosts $DIR/d31f
2970         ls -l $DIR/d31f
2971         $LFS getstripe $DIR/d31f/hosts
2972         multiop_bg_pause $DIR/d31f D_c || return 1
2973         MULTIPID2=$!
2974
2975         kill -USR1 $MULTIPID || error "first opendir $MULTIPID not running"
2976         wait $MULTIPID || error "first opendir $MULTIPID failed"
2977
2978         sleep 6
2979
2980         kill -USR1 $MULTIPID2 || error "second opendir $MULTIPID not running"
2981         wait $MULTIPID2 || error "second opendir $MULTIPID2 failed"
2982         set +vx
2983 }
2984 run_test 31f "remove of open directory with open-unlink file ==="
2985
2986 test_31g() {
2987         echo "-- cross directory link --"
2988         test_mkdir -c1 $DIR/${tdir}ga
2989         test_mkdir -c1 $DIR/${tdir}gb
2990         touch $DIR/${tdir}ga/f
2991         ln $DIR/${tdir}ga/f $DIR/${tdir}gb/g
2992         $CHECKSTAT -t file $DIR/${tdir}ga/f || error "source"
2993         [ `stat -c%h $DIR/${tdir}ga/f` == '2' ] || error "source nlink"
2994         $CHECKSTAT -t file $DIR/${tdir}gb/g || error "target"
2995         [ `stat -c%h $DIR/${tdir}gb/g` == '2' ] || error "target nlink"
2996 }
2997 run_test 31g "cross directory link==============="
2998
2999 test_31h() {
3000         echo "-- cross directory link --"
3001         test_mkdir -c1 $DIR/${tdir}
3002         test_mkdir -c1 $DIR/${tdir}/dir
3003         touch $DIR/${tdir}/f
3004         ln $DIR/${tdir}/f $DIR/${tdir}/dir/g
3005         $CHECKSTAT -t file $DIR/${tdir}/f || error "source"
3006         [ `stat -c%h $DIR/${tdir}/f` == '2' ] || error "source nlink"
3007         $CHECKSTAT -t file $DIR/${tdir}/dir/g || error "target"
3008         [ `stat -c%h $DIR/${tdir}/dir/g` == '2' ] || error "target nlink"
3009 }
3010 run_test 31h "cross directory link under child==============="
3011
3012 test_31i() {
3013         echo "-- cross directory link --"
3014         test_mkdir -c1 $DIR/$tdir
3015         test_mkdir -c1 $DIR/$tdir/dir
3016         touch $DIR/$tdir/dir/f
3017         ln $DIR/$tdir/dir/f $DIR/$tdir/g
3018         $CHECKSTAT -t file $DIR/$tdir/dir/f || error "source"
3019         [ `stat -c%h $DIR/$tdir/dir/f` == '2' ] || error "source nlink"
3020         $CHECKSTAT -t file $DIR/$tdir/g || error "target"
3021         [ `stat -c%h $DIR/$tdir/g` == '2' ] || error "target nlink"
3022 }
3023 run_test 31i "cross directory link under parent==============="
3024
3025 test_31j() {
3026         test_mkdir -c1 -p $DIR/$tdir
3027         test_mkdir -c1 -p $DIR/$tdir/dir1
3028         ln $DIR/$tdir/dir1 $DIR/$tdir/dir2 && error "ln for dir"
3029         link $DIR/$tdir/dir1 $DIR/$tdir/dir3 && error "link for dir"
3030         mlink $DIR/$tdir/dir1 $DIR/$tdir/dir4 && error "mlink for dir"
3031         mlink $DIR/$tdir/dir1 $DIR/$tdir/dir1 && error "mlink to the same dir"
3032         return 0
3033 }
3034 run_test 31j "link for directory==============="
3035
3036 test_31k() {
3037         test_mkdir -c1 -p $DIR/$tdir
3038         touch $DIR/$tdir/s
3039         touch $DIR/$tdir/exist
3040         mlink $DIR/$tdir/s $DIR/$tdir/t || error "mlink"
3041         mlink $DIR/$tdir/s $DIR/$tdir/exist && error "mlink to exist file"
3042         mlink $DIR/$tdir/s $DIR/$tdir/s && error "mlink to the same file"
3043         mlink $DIR/$tdir/s $DIR/$tdir && error "mlink to parent dir"
3044         mlink $DIR/$tdir $DIR/$tdir/s && error "mlink parent dir to target"
3045         mlink $DIR/$tdir/not-exist $DIR/$tdir/foo && error "mlink non-existing to new"
3046         mlink $DIR/$tdir/not-exist $DIR/$tdir/s && error "mlink non-existing to exist"
3047         return 0
3048 }
3049 run_test 31k "link to file: the same, non-existing, dir==============="
3050
3051 test_31m() {
3052         mkdir $DIR/d31m
3053         touch $DIR/d31m/s
3054         mkdir $DIR/d31m2
3055         touch $DIR/d31m2/exist
3056         mlink $DIR/d31m/s $DIR/d31m2/t || error "mlink"
3057         mlink $DIR/d31m/s $DIR/d31m2/exist && error "mlink to exist file"
3058         mlink $DIR/d31m/s $DIR/d31m2 && error "mlink to parent dir"
3059         mlink $DIR/d31m2 $DIR/d31m/s && error "mlink parent dir to target"
3060         mlink $DIR/d31m/not-exist $DIR/d31m2/foo && error "mlink non-existing to new"
3061         mlink $DIR/d31m/not-exist $DIR/d31m2/s && error "mlink non-existing to exist"
3062         return 0
3063 }
3064 run_test 31m "link to file: the same, non-existing, dir==============="
3065
3066 test_31n() {
3067         touch $DIR/$tfile || error "cannot create '$DIR/$tfile'"
3068         nlink=$(stat --format=%h $DIR/$tfile)
3069         [ ${nlink:--1} -eq 1 ] || error "nlink is $nlink, expected 1"
3070         local fd=$(free_fd)
3071         local cmd="exec $fd<$DIR/$tfile"
3072         eval $cmd
3073         cmd="exec $fd<&-"
3074         trap "eval $cmd" EXIT
3075         nlink=$(stat --dereference --format=%h /proc/self/fd/$fd)
3076         [ ${nlink:--1} -eq 1 ] || error "nlink is $nlink, expected 1"
3077         rm $DIR/$tfile || error "cannot remove '$DIR/$tfile'"
3078         nlink=$(stat --dereference --format=%h /proc/self/fd/$fd)
3079         [ ${nlink:--1} -eq 0 ] || error "nlink is $nlink, expected 0"
3080         eval $cmd
3081 }
3082 run_test 31n "check link count of unlinked file"
3083
3084 link_one() {
3085         local tempfile=$(mktemp $1_XXXXXX)
3086         mlink $tempfile $1 2> /dev/null &&
3087                 echo "$BASHPID: link $tempfile to $1 succeeded"
3088         munlink $tempfile
3089 }
3090
3091 test_31o() { # LU-2901
3092         test_mkdir $DIR/$tdir
3093         for LOOP in $(seq 100); do
3094                 rm -f $DIR/$tdir/$tfile*
3095                 for THREAD in $(seq 8); do
3096                         link_one $DIR/$tdir/$tfile.$LOOP &
3097                 done
3098                 wait
3099                 local LINKS=$(ls -1 $DIR/$tdir | grep -c $tfile.$LOOP)
3100                 [[ $LINKS -gt 1 ]] && ls $DIR/$tdir &&
3101                         error "$LINKS duplicate links to $tfile.$LOOP" &&
3102                         break || true
3103         done
3104 }
3105 run_test 31o "duplicate hard links with same filename"
3106
3107 test_31p() {
3108         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
3109
3110         test_mkdir $DIR/$tdir
3111         $LFS setdirstripe -i0 -c2 $DIR/$tdir/striped_dir
3112         $LFS setdirstripe -D -c2 -H all_char $DIR/$tdir/striped_dir
3113
3114         opendirunlink $DIR/$tdir/striped_dir/test1 ||
3115                 error "open unlink test1 failed"
3116         opendirunlink $DIR/$tdir/striped_dir/test2 ||
3117                 error "open unlink test2 failed"
3118
3119         $CHECKSTAT -a $DIR/$tdir/striped_dir/test1 ||
3120                 error "test1 still exists"
3121         $CHECKSTAT -a $DIR/$tdir/striped_dir/test2 ||
3122                 error "test2 still exists"
3123 }
3124 run_test 31p "remove of open striped directory"
3125
3126 cleanup_test32_mount() {
3127         local rc=0
3128         trap 0
3129         local loopdev=$(losetup -a | grep $EXT2_DEV | sed -ne 's/:.*$//p')
3130         $UMOUNT $DIR/$tdir/ext2-mountpoint || rc=$?
3131         losetup -d $loopdev || true
3132         rm -rf $DIR/$tdir
3133         return $rc
3134 }
3135
3136 test_32a() {
3137         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3138
3139         echo "== more mountpoints and symlinks ================="
3140         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3141         trap cleanup_test32_mount EXIT
3142         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3143         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3144                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3145         $CHECKSTAT -t dir $DIR/$tdir/ext2-mountpoint/.. ||
3146                 error "$DIR/$tdir/ext2-mountpoint/.. not dir type"
3147         cleanup_test32_mount
3148 }
3149 run_test 32a "stat d32a/ext2-mountpoint/.. ====================="
3150
3151 test_32b() {
3152         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3153
3154         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3155         trap cleanup_test32_mount EXIT
3156         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3157         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3158                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3159         ls -al $DIR/$tdir/ext2-mountpoint/.. ||
3160                 error "Can't list $DIR/$tdir/ext2-mountpoint/.."
3161         cleanup_test32_mount
3162 }
3163 run_test 32b "open d32b/ext2-mountpoint/.. ====================="
3164
3165 test_32c() {
3166         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3167
3168         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3169         trap cleanup_test32_mount EXIT
3170         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3171         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3172                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3173         test_mkdir -p $DIR/$tdir/d2/test_dir
3174         $CHECKSTAT -t dir $DIR/$tdir/ext2-mountpoint/../d2/test_dir ||
3175                 error "$DIR/$tdir/ext2-mountpoint/../d2/test_dir not dir type"
3176         cleanup_test32_mount
3177 }
3178 run_test 32c "stat d32c/ext2-mountpoint/../d2/test_dir ========="
3179
3180 test_32d() {
3181         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3182
3183         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3184         trap cleanup_test32_mount EXIT
3185         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3186         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3187                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3188         test_mkdir -p $DIR/$tdir/d2/test_dir
3189         ls -al $DIR/$tdir/ext2-mountpoint/../d2/test_dir ||
3190                 error "Can't list $DIR/$tdir/ext2-mountpoint/../d2/test_dir"
3191         cleanup_test32_mount
3192 }
3193 run_test 32d "open d32d/ext2-mountpoint/../d2/test_dir"
3194
3195 test_32e() {
3196         rm -fr $DIR/$tdir
3197         test_mkdir -p $DIR/$tdir/tmp
3198         local tmp_dir=$DIR/$tdir/tmp
3199         ln -s $DIR/$tdir $tmp_dir/symlink11
3200         ln -s $tmp_dir/symlink11 $tmp_dir/../symlink01
3201         $CHECKSTAT -t link $DIR/$tdir/tmp/symlink11 || error "symlink11 bad"
3202         $CHECKSTAT -t link $DIR/$tdir/symlink01 || error "symlink01 bad"
3203 }
3204 run_test 32e "stat d32e/symlink->tmp/symlink->lustre-subdir"
3205
3206 test_32f() {
3207         rm -fr $DIR/$tdir
3208         test_mkdir -p $DIR/$tdir/tmp
3209         local tmp_dir=$DIR/$tdir/tmp
3210         ln -s $DIR/$tdir $tmp_dir/symlink11
3211         ln -s $tmp_dir/symlink11 $tmp_dir/../symlink01
3212         ls $DIR/$tdir/tmp/symlink11  || error "symlink11 bad"
3213         ls $DIR/$tdir/symlink01 || error "symlink01 bad"
3214 }
3215 run_test 32f "open d32f/symlink->tmp/symlink->lustre-subdir"
3216
3217 test_32g() {
3218         local tmp_dir=$DIR/$tdir/tmp
3219         test_mkdir -p $tmp_dir
3220         test_mkdir $DIR/${tdir}2
3221         ln -s $DIR/${tdir}2 $tmp_dir/symlink12
3222         ln -s $tmp_dir/symlink12 $tmp_dir/../symlink02
3223         $CHECKSTAT -t link $tmp_dir/symlink12 || error "symlink12 not a link"
3224         $CHECKSTAT -t link $DIR/$tdir/symlink02 || error "symlink02 not a link"
3225         $CHECKSTAT -t dir -f $tmp_dir/symlink12 || error "symlink12 not a dir"
3226         $CHECKSTAT -t dir -f $DIR/$tdir/symlink02 || error "symlink12 not a dir"
3227 }
3228 run_test 32g "stat d32g/symlink->tmp/symlink->lustre-subdir/${tdir}2"
3229
3230 test_32h() {
3231         rm -fr $DIR/$tdir $DIR/${tdir}2
3232         tmp_dir=$DIR/$tdir/tmp
3233         test_mkdir -p $tmp_dir
3234         test_mkdir $DIR/${tdir}2
3235         ln -s $DIR/${tdir}2 $tmp_dir/symlink12
3236         ln -s $tmp_dir/symlink12 $tmp_dir/../symlink02
3237         ls $tmp_dir/symlink12 || error "listing symlink12"
3238         ls $DIR/$tdir/symlink02  || error "listing symlink02"
3239 }
3240 run_test 32h "open d32h/symlink->tmp/symlink->lustre-subdir/${tdir}2"
3241
3242 test_32i() {
3243         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3244
3245         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3246         trap cleanup_test32_mount EXIT
3247         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3248         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3249                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3250         touch $DIR/$tdir/test_file
3251         $CHECKSTAT -t file $DIR/$tdir/ext2-mountpoint/../test_file ||
3252                 error "$DIR/$tdir/ext2-mountpoint/../test_file not file type"
3253         cleanup_test32_mount
3254 }
3255 run_test 32i "stat d32i/ext2-mountpoint/../test_file ==========="
3256
3257 test_32j() {
3258         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3259
3260         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3261         trap cleanup_test32_mount EXIT
3262         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3263         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3264                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3265         touch $DIR/$tdir/test_file
3266         cat $DIR/$tdir/ext2-mountpoint/../test_file ||
3267                 error "Can't open $DIR/$tdir/ext2-mountpoint/../test_file"
3268         cleanup_test32_mount
3269 }
3270 run_test 32j "open d32j/ext2-mountpoint/../test_file ==========="
3271
3272 test_32k() {
3273         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3274
3275         rm -fr $DIR/$tdir
3276         trap cleanup_test32_mount EXIT
3277         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3278         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3279                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3280         test_mkdir -p $DIR/$tdir/d2
3281         touch $DIR/$tdir/d2/test_file || error "touch failed"
3282         $CHECKSTAT -t file $DIR/$tdir/ext2-mountpoint/../d2/test_file ||
3283                 error "$DIR/$tdir/ext2-mountpoint/../d2/test_file not file type"
3284         cleanup_test32_mount
3285 }
3286 run_test 32k "stat d32k/ext2-mountpoint/../d2/test_file ========"
3287
3288 test_32l() {
3289         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3290
3291         rm -fr $DIR/$tdir
3292         trap cleanup_test32_mount EXIT
3293         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3294         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3295                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3296         test_mkdir -p $DIR/$tdir/d2
3297         touch $DIR/$tdir/d2/test_file || error "touch failed"
3298         cat  $DIR/$tdir/ext2-mountpoint/../d2/test_file ||
3299                 error "Can't open $DIR/$tdir/ext2-mountpoint/../d2/test_file"
3300         cleanup_test32_mount
3301 }
3302 run_test 32l "open d32l/ext2-mountpoint/../d2/test_file ========"
3303
3304 test_32m() {
3305         rm -fr $DIR/d32m
3306         test_mkdir -p $DIR/d32m/tmp
3307         TMP_DIR=$DIR/d32m/tmp
3308         ln -s $DIR $TMP_DIR/symlink11
3309         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
3310         $CHECKSTAT -t link $DIR/d32m/tmp/symlink11 ||
3311                 error "symlink11 not a link"
3312         $CHECKSTAT -t link $DIR/d32m/symlink01 ||
3313                 error "symlink01 not a link"
3314 }
3315 run_test 32m "stat d32m/symlink->tmp/symlink->lustre-root ======"
3316
3317 test_32n() {
3318         rm -fr $DIR/d32n
3319         test_mkdir -p $DIR/d32n/tmp
3320         TMP_DIR=$DIR/d32n/tmp
3321         ln -s $DIR $TMP_DIR/symlink11
3322         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
3323         ls -l $DIR/d32n/tmp/symlink11  || error "listing symlink11"
3324         ls -l $DIR/d32n/symlink01 || error "listing symlink01"
3325 }
3326 run_test 32n "open d32n/symlink->tmp/symlink->lustre-root ======"
3327
3328 test_32o() {
3329         touch $DIR/$tfile
3330         test_mkdir -p $DIR/d32o/tmp
3331         TMP_DIR=$DIR/d32o/tmp
3332         ln -s $DIR/$tfile $TMP_DIR/symlink12
3333         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
3334         $CHECKSTAT -t link $DIR/d32o/tmp/symlink12 ||
3335                 error "symlink12 not a link"
3336         $CHECKSTAT -t link $DIR/d32o/symlink02 || error "symlink02 not a link"
3337         $CHECKSTAT -t file -f $DIR/d32o/tmp/symlink12 ||
3338                 error "$DIR/d32o/tmp/symlink12 not file type"
3339         $CHECKSTAT -t file -f $DIR/d32o/symlink02 ||
3340                 error "$DIR/d32o/symlink02 not file type"
3341 }
3342 run_test 32o "stat d32o/symlink->tmp/symlink->lustre-root/$tfile"
3343
3344 test_32p() {
3345         log 32p_1
3346         rm -fr $DIR/d32p
3347         log 32p_2
3348         rm -f $DIR/$tfile
3349         log 32p_3
3350         touch $DIR/$tfile
3351         log 32p_4
3352         test_mkdir -p $DIR/d32p/tmp
3353         log 32p_5
3354         TMP_DIR=$DIR/d32p/tmp
3355         log 32p_6
3356         ln -s $DIR/$tfile $TMP_DIR/symlink12
3357         log 32p_7
3358         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
3359         log 32p_8
3360         cat $DIR/d32p/tmp/symlink12 ||
3361                 error "Can't open $DIR/d32p/tmp/symlink12"
3362         log 32p_9
3363         cat $DIR/d32p/symlink02 || error "Can't open $DIR/d32p/symlink02"
3364         log 32p_10
3365 }
3366 run_test 32p "open d32p/symlink->tmp/symlink->lustre-root/$tfile"
3367
3368 test_32q() {
3369         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3370
3371         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3372         trap cleanup_test32_mount EXIT
3373         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3374         touch $DIR/$tdir/ext2-mountpoint/under_the_mount || error "touch failed"
3375         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3376                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3377         ls $DIR/$tdir/ext2-mountpoint | grep "\<under_the_mount\>" && error
3378         cleanup_test32_mount
3379 }
3380 run_test 32q "stat follows mountpoints in Lustre (should return error)"
3381
3382 test_32r() {
3383         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3384
3385         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3386         trap cleanup_test32_mount EXIT
3387         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3388         touch $DIR/$tdir/ext2-mountpoint/under_the_mount || error "touch failed"
3389         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3390                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3391         ls $DIR/$tdir/ext2-mountpoint | grep -q under_the_mount && error || true
3392         cleanup_test32_mount
3393 }
3394 run_test 32r "opendir follows mountpoints in Lustre (should return error)"
3395
3396 test_33aa() {
3397         rm -f $DIR/$tfile
3398         touch $DIR/$tfile
3399         chmod 444 $DIR/$tfile
3400         chown $RUNAS_ID $DIR/$tfile
3401         log 33_1
3402         $RUNAS $OPENFILE -f O_RDWR $DIR/$tfile && error || true
3403         log 33_2
3404 }
3405 run_test 33aa "write file with mode 444 (should return error)"
3406
3407 test_33a() {
3408         rm -fr $DIR/$tdir
3409         test_mkdir $DIR/$tdir
3410         chown $RUNAS_ID $DIR/$tdir
3411         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/$tdir/$tfile ||
3412                 error "$RUNAS create $tdir/$tfile failed"
3413         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/$tdir/$tfile &&
3414                 error "open RDWR" || true
3415 }
3416 run_test 33a "test open file(mode=0444) with O_RDWR (should return error)"
3417
3418 test_33b() {
3419         rm -fr $DIR/$tdir
3420         test_mkdir $DIR/$tdir
3421         chown $RUNAS_ID $DIR/$tdir
3422         $RUNAS $OPENFILE -f 1286739555 $DIR/$tdir/$tfile || true
3423 }
3424 run_test 33b "test open file with malformed flags (No panic)"
3425
3426 test_33c() {
3427         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3428         remote_ost_nodsh && skip "remote OST with nodsh"
3429
3430         local ostnum
3431         local ostname
3432         local write_bytes
3433         local all_zeros
3434
3435         all_zeros=:
3436         rm -fr $DIR/$tdir
3437         test_mkdir $DIR/$tdir
3438         # Read: 0, Write: 4, create/destroy: 2/0, stat: 1, punch: 0
3439
3440         sync
3441         for ostnum in $(seq $OSTCOUNT); do
3442                 # test-framework's OST numbering is one-based, while Lustre's
3443                 # is zero-based
3444                 ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
3445                 # Parsing llobdstat's output sucks; we could grep the /proc
3446                 # path, but that's likely to not be as portable as using the
3447                 # llobdstat utility.  So we parse lctl output instead.
3448                 write_bytes=$(do_facet ost$ostnum lctl get_param -n \
3449                         obdfilter/$ostname/stats |
3450                         awk '/^write_bytes/ {print $7}' )
3451                 echo "baseline_write_bytes@$OSTnum/$ostname=$write_bytes"
3452                 if (( ${write_bytes:-0} > 0 ))
3453                 then
3454                         all_zeros=false
3455                         break;
3456                 fi
3457         done
3458
3459         $all_zeros || return 0
3460
3461         # Write four bytes
3462         echo foo > $DIR/$tdir/bar
3463         # Really write them
3464         sync
3465
3466         # Total up write_bytes after writing.  We'd better find non-zeros.
3467         for ostnum in $(seq $OSTCOUNT); do
3468                 ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
3469                 write_bytes=$(do_facet ost$ostnum lctl get_param -n \
3470                         obdfilter/$ostname/stats |
3471                         awk '/^write_bytes/ {print $7}' )
3472                 echo "write_bytes@$OSTnum/$ostname=$write_bytes"
3473                 if (( ${write_bytes:-0} > 0 ))
3474                 then
3475                         all_zeros=false
3476                         break;
3477                 fi
3478         done
3479
3480         if $all_zeros
3481         then
3482                 for ostnum in $(seq $OSTCOUNT); do
3483                         ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
3484                         echo "Check that write_bytes is present in obdfilter/*/stats:"
3485                         do_facet ost$ostnum lctl get_param -n \
3486                                 obdfilter/$ostname/stats
3487                 done
3488                 error "OST not keeping write_bytes stats (b22312)"
3489         fi
3490 }
3491 run_test 33c "test llobdstat and write_bytes"
3492
3493 test_33d() {
3494         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
3495         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3496
3497         local MDTIDX=1
3498         local remote_dir=$DIR/$tdir/remote_dir
3499
3500         test_mkdir $DIR/$tdir
3501         $LFS mkdir -i $MDTIDX $remote_dir ||
3502                 error "create remote directory failed"
3503
3504         touch $remote_dir/$tfile
3505         chmod 444 $remote_dir/$tfile
3506         chown $RUNAS_ID $remote_dir/$tfile
3507
3508         $RUNAS $OPENFILE -f O_RDWR $DIR/$tfile && error || true
3509
3510         chown $RUNAS_ID $remote_dir
3511         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $remote_dir/f33 ||
3512                                         error "create" || true
3513         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $remote_dir/f33 &&
3514                                     error "open RDWR" || true
3515         $RUNAS $OPENFILE -f 1286739555 $remote_dir/f33 || true
3516 }
3517 run_test 33d "openfile with 444 modes and malformed flags under remote dir"
3518
3519 test_33e() {
3520         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
3521
3522         mkdir $DIR/$tdir
3523
3524         $LFS setdirstripe -i0 -c2 $DIR/$tdir/striped_dir
3525         $LFS setdirstripe -i1 -c2 $DIR/$tdir/striped_dir1
3526         mkdir $DIR/$tdir/local_dir
3527
3528         local s0_mode=$(stat -c%f $DIR/$tdir/striped_dir)
3529         local s1_mode=$(stat -c%f $DIR/$tdir/striped_dir1)
3530         local l_mode=$(stat -c%f $DIR/$tdir/local_dir)
3531
3532         [ "$l_mode" = "$s0_mode" -a "$l_mode" = "$s1_mode" ] ||
3533                 error "mkdir $l_mode striped0 $s0_mode striped1 $s1_mode"
3534
3535         rmdir $DIR/$tdir/* || error "rmdir failed"
3536
3537         umask 777
3538         $LFS setdirstripe -i0 -c2 $DIR/$tdir/striped_dir
3539         $LFS setdirstripe -i1 -c2 $DIR/$tdir/striped_dir1
3540         mkdir $DIR/$tdir/local_dir
3541
3542         s0_mode=$(stat -c%f $DIR/$tdir/striped_dir)
3543         s1_mode=$(stat -c%f $DIR/$tdir/striped_dir1)
3544         l_mode=$(stat -c%f $DIR/$tdir/local_dir)
3545
3546         [ "$l_mode" = "$s0_mode" -a "$l_mode" = "$s1_mode" ] ||
3547                 error "mkdir $l_mode striped0 $s0_mode striped1 $s1_mode 777"
3548
3549         rmdir $DIR/$tdir/* || error "rmdir(umask 777) failed"
3550
3551         umask 000
3552         $LFS setdirstripe -i0 -c2 $DIR/$tdir/striped_dir
3553         $LFS setdirstripe -i1 -c2 $DIR/$tdir/striped_dir1
3554         mkdir $DIR/$tdir/local_dir
3555
3556         s0_mode=$(stat -c%f $DIR/$tdir/striped_dir)
3557         s1_mode=$(stat -c%f $DIR/$tdir/striped_dir1)
3558         l_mode=$(stat -c%f $DIR/$tdir/local_dir)
3559
3560         [ "$l_mode" = "$s0_mode" -a "$l_mode" = "$s1_mode" ] ||
3561                 error "mkdir $l_mode striped0 $s0_mode striped1 $s1_mode 0"
3562 }
3563 run_test 33e "mkdir and striped directory should have same mode"
3564
3565 cleanup_33f() {
3566         trap 0
3567         do_facet $SINGLEMDS $LCTL set_param mdt.*.enable_remote_dir_gid=0
3568 }
3569
3570 test_33f() {
3571         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
3572         remote_mds_nodsh && skip "remote MDS with nodsh"
3573
3574         mkdir $DIR/$tdir
3575         chmod go+rwx $DIR/$tdir
3576         do_facet $SINGLEMDS $LCTL set_param mdt.*.enable_remote_dir_gid=-1
3577         trap cleanup_33f EXIT
3578
3579         $RUNAS lfs mkdir -i 0 -c$MDSCOUNT $DIR/$tdir/striped_dir ||
3580                 error "cannot create striped directory"
3581
3582         $RUNAS touch $DIR/$tdir/striped_dir/{0..16} ||
3583                 error "cannot create files in striped directory"
3584
3585         $RUNAS rm $DIR/$tdir/striped_dir/{0..16} ||
3586                 error "cannot remove files in striped directory"
3587
3588         $RUNAS rmdir $DIR/$tdir/striped_dir ||
3589                 error "cannot remove striped directory"
3590
3591         cleanup_33f
3592 }
3593 run_test 33f "nonroot user can create, access, and remove a striped directory"
3594
3595 test_33g() {
3596         mkdir -p $DIR/$tdir/dir2
3597
3598         local err=$($RUNAS mkdir $DIR/$tdir/dir2 2>&1)
3599         echo $err
3600         [[ $err =~ "exists" ]] || error "Not exists error"
3601 }
3602 run_test 33g "nonroot user create already existing root created file"
3603
3604 TEST_34_SIZE=${TEST_34_SIZE:-2000000000000}
3605 test_34a() {
3606         rm -f $DIR/f34
3607         $MCREATE $DIR/f34 || error "mcreate failed"
3608         $LFS getstripe $DIR/f34 2>&1 | grep -q "no stripe info" ||
3609                 error "getstripe failed"
3610         $TRUNCATE $DIR/f34 $TEST_34_SIZE || error "truncate failed"
3611         $LFS getstripe $DIR/f34 2>&1 | grep -q "no stripe info" ||
3612                 error "getstripe failed"
3613         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 ||
3614                 error "Size of $DIR/f34 not equal to $TEST_34_SIZE bytes"
3615 }
3616 run_test 34a "truncate file that has not been opened ==========="
3617
3618 test_34b() {
3619         [ ! -f $DIR/f34 ] && test_34a
3620         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 ||
3621                 error "Size of $DIR/f34 not equal to $TEST_34_SIZE bytes"
3622         $OPENFILE -f O_RDONLY $DIR/f34
3623         $LFS getstripe $DIR/f34 2>&1 | grep -q "no stripe info" ||
3624                 error "getstripe failed"
3625         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 ||
3626                 error "Size of $DIR/f34 not equal to $TEST_34_SIZE bytes"
3627 }
3628 run_test 34b "O_RDONLY opening file doesn't create objects ====="
3629
3630 test_34c() {
3631         [ ! -f $DIR/f34 ] && test_34a
3632         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 ||
3633                 error "Size of $DIR/f34 not equal to $TEST_34_SIZE bytes"
3634         $OPENFILE -f O_RDWR $DIR/f34
3635         $LFS getstripe $DIR/f34 2>&1 | grep -q "no stripe info" &&
3636                 error "$LFS getstripe failed"
3637         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 ||
3638                 error "Size of $DIR/f34 not equal to $TEST_34_SIZE bytes"
3639 }
3640 run_test 34c "O_RDWR opening file-with-size works =============="
3641
3642 test_34d() {
3643         [ ! -f $DIR/f34 ] && test_34a
3644         dd if=/dev/zero of=$DIR/f34 conv=notrunc bs=4k count=1 ||
3645                 error "dd failed"
3646         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 ||
3647                 error "Size of $DIR/f34 not equal to $TEST_34_SIZE bytes"
3648         rm $DIR/f34
3649 }
3650 run_test 34d "write to sparse file ============================="
3651
3652 test_34e() {
3653         rm -f $DIR/f34e
3654         $MCREATE $DIR/f34e || error "mcreate failed"
3655         $TRUNCATE $DIR/f34e 1000 || error "truncate failed"
3656         $CHECKSTAT -s 1000 $DIR/f34e ||
3657                 error "Size of $DIR/f34e not equal to 1000 bytes"
3658         $OPENFILE -f O_RDWR $DIR/f34e
3659         $CHECKSTAT -s 1000 $DIR/f34e ||
3660                 error "Size of $DIR/f34e not equal to 1000 bytes"
3661 }
3662 run_test 34e "create objects, some with size and some without =="
3663
3664 test_34f() { # bug 6242, 6243
3665         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3666
3667         SIZE34F=48000
3668         rm -f $DIR/f34f
3669         $MCREATE $DIR/f34f || error "mcreate failed"
3670         $TRUNCATE $DIR/f34f $SIZE34F || error "truncating $DIR/f3f to $SIZE34F"
3671         dd if=$DIR/f34f of=$TMP/f34f
3672         $CHECKSTAT -s $SIZE34F $TMP/f34f || error "$TMP/f34f not $SIZE34F bytes"
3673         dd if=/dev/zero of=$TMP/f34fzero bs=$SIZE34F count=1
3674         cmp $DIR/f34f $TMP/f34fzero || error "$DIR/f34f not all zero"
3675         cmp $TMP/f34f $TMP/f34fzero || error "$TMP/f34f not all zero"
3676         rm $TMP/f34f $TMP/f34fzero $DIR/f34f
3677 }
3678 run_test 34f "read from a file with no objects until EOF ======="
3679
3680 test_34g() {
3681         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3682
3683         dd if=/dev/zero of=$DIR/$tfile bs=1 count=100 seek=$TEST_34_SIZE ||
3684                 error "dd failed"
3685         $TRUNCATE $DIR/$tfile $((TEST_34_SIZE / 2))|| error "truncate failed"
3686         $CHECKSTAT -s $((TEST_34_SIZE / 2)) $DIR/$tfile ||
3687                 error "Size of $DIR/$tfile not equal to $((TEST_34_SIZE / 2))"
3688         cancel_lru_locks osc
3689         $CHECKSTAT -s $((TEST_34_SIZE / 2)) $DIR/$tfile ||
3690                 error "wrong size after lock cancel"
3691
3692         $TRUNCATE $DIR/$tfile $TEST_34_SIZE || error "truncate failed"
3693         $CHECKSTAT -s $TEST_34_SIZE $DIR/$tfile ||
3694                 error "expanding truncate failed"
3695         cancel_lru_locks osc
3696         $CHECKSTAT -s $TEST_34_SIZE $DIR/$tfile ||
3697                 error "wrong expanded size after lock cancel"
3698 }
3699 run_test 34g "truncate long file ==============================="
3700
3701 test_34h() {
3702         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3703
3704         local gid=10
3705         local sz=1000
3706
3707         dd if=/dev/zero of=$DIR/$tfile bs=1M count=10 || error "dd failed"
3708         sync # Flush the cache so that multiop below does not block on cache
3709              # flush when getting the group lock
3710         $MULTIOP $DIR/$tfile OG${gid}T${sz}g${gid}c &
3711         MULTIPID=$!
3712
3713         # Since just timed wait is not good enough, let's do a sync write
3714         # that way we are sure enough time for a roundtrip + processing
3715         # passed + 2 seconds of extra margin.
3716         dd if=/dev/zero of=$DIR/${tfile}-1 bs=$PAGE_SIZE oflag=direct count=1
3717         rm $DIR/${tfile}-1
3718         sleep 2
3719
3720         if [[ `ps h -o comm -p $MULTIPID` == "multiop" ]]; then
3721                 error "Multiop blocked on ftruncate, pid=$MULTIPID"
3722                 kill -9 $MULTIPID
3723         fi
3724         wait $MULTIPID
3725         local nsz=`stat -c %s $DIR/$tfile`
3726         [[ $nsz == $sz ]] || error "New size wrong $nsz != $sz"
3727 }
3728 run_test 34h "ftruncate file under grouplock should not block"
3729
3730 test_35a() {
3731         cp /bin/sh $DIR/f35a
3732         chmod 444 $DIR/f35a
3733         chown $RUNAS_ID $DIR/f35a
3734         $RUNAS $DIR/f35a && error || true
3735         rm $DIR/f35a
3736 }
3737 run_test 35a "exec file with mode 444 (should return and not leak)"
3738
3739 test_36a() {
3740         rm -f $DIR/f36
3741         utime $DIR/f36 || error "utime failed for MDS"
3742 }
3743 run_test 36a "MDS utime check (mknod, utime)"
3744
3745 test_36b() {
3746         echo "" > $DIR/f36
3747         utime $DIR/f36 || error "utime failed for OST"
3748 }
3749 run_test 36b "OST utime check (open, utime)"
3750
3751 test_36c() {
3752         rm -f $DIR/d36/f36
3753         test_mkdir $DIR/d36
3754         chown $RUNAS_ID $DIR/d36
3755         $RUNAS utime $DIR/d36/f36 || error "utime failed for MDS as non-root"
3756 }
3757 run_test 36c "non-root MDS utime check (mknod, utime)"
3758
3759 test_36d() {
3760         [ ! -d $DIR/d36 ] && test_36c
3761         echo "" > $DIR/d36/f36
3762         $RUNAS utime $DIR/d36/f36 || error "utime failed for OST as non-root"
3763 }
3764 run_test 36d "non-root OST utime check (open, utime)"
3765
3766 test_36e() {
3767         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping"
3768
3769         test_mkdir $DIR/$tdir
3770         touch $DIR/$tdir/$tfile
3771         $RUNAS utime $DIR/$tdir/$tfile &&
3772                 error "utime worked, expected failure" || true
3773 }
3774 run_test 36e "utime on non-owned file (should return error)"
3775
3776 subr_36fh() {
3777         local fl="$1"
3778         local LANG_SAVE=$LANG
3779         local LC_LANG_SAVE=$LC_LANG
3780         export LANG=C LC_LANG=C # for date language
3781
3782         DATESTR="Dec 20  2000"
3783         test_mkdir $DIR/$tdir
3784         lctl set_param fail_loc=$fl
3785         date; date +%s
3786         cp /etc/hosts $DIR/$tdir/$tfile
3787         sync & # write RPC generated with "current" inode timestamp, but delayed
3788         sleep 1
3789         touch --date="$DATESTR" $DIR/$tdir/$tfile # setattr timestamp in past
3790         LS_BEFORE="`ls -l $DIR/$tdir/$tfile`" # old timestamp from client cache
3791         cancel_lru_locks $OSC
3792         LS_AFTER="`ls -l $DIR/$tdir/$tfile`"  # timestamp from OST object
3793         date; date +%s
3794         [ "$LS_BEFORE" != "$LS_AFTER" ] && \
3795                 echo "BEFORE: $LS_BEFORE" && \
3796                 echo "AFTER : $LS_AFTER" && \
3797                 echo "WANT  : $DATESTR" && \
3798                 error "$DIR/$tdir/$tfile timestamps changed" || true
3799
3800         export LANG=$LANG_SAVE LC_LANG=$LC_LANG_SAVE
3801 }
3802
3803 test_36f() {
3804         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3805
3806         #define OBD_FAIL_OST_BRW_PAUSE_BULK 0x214
3807         subr_36fh "0x80000214"
3808 }
3809 run_test 36f "utime on file racing with OST BRW write =========="
3810
3811 test_36g() {
3812         remote_ost_nodsh && skip "remote OST with nodsh"
3813         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3814         [ $MDS1_VERSION -lt $(version_code 2.12.51) ] &&
3815                 skip "Need MDS version at least 2.12.51"
3816
3817         local fmd_max_age
3818         local fmd
3819         local facet="ost1"
3820         local tgt="obdfilter"
3821
3822         [[ $OSC == "mdc" ]] && tgt="mdt" && facet="mds1"
3823
3824         test_mkdir $DIR/$tdir
3825         fmd_max_age=$(do_facet $facet \
3826                 "lctl get_param -n $tgt.*.tgt_fmd_seconds 2> /dev/null | \
3827                 head -n 1")
3828
3829         echo "FMD max age: ${fmd_max_age}s"
3830         touch $DIR/$tdir/$tfile
3831         fmd=$(do_facet $facet "lctl get_param -n $tgt.*.exports.*.fmd_count" |
3832                 gawk '{cnt=cnt+$1}  END{print cnt}')
3833         echo "FMD before: $fmd"
3834         [[ $fmd == 0 ]] &&
3835                 error "FMD wasn't create by touch"
3836         sleep $((fmd_max_age + 12))
3837         fmd=$(do_facet $facet "lctl get_param -n $tgt.*.exports.*.fmd_count" |
3838                 gawk '{cnt=cnt+$1}  END{print cnt}')
3839         echo "FMD after: $fmd"
3840         [[ $fmd == 0 ]] ||
3841                 error "FMD wasn't expired by ping"
3842 }
3843 run_test 36g "FMD cache expiry ====================="
3844
3845 test_36h() {
3846         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3847
3848         #define OBD_FAIL_OST_BRW_PAUSE_BULK2 0x227
3849         subr_36fh "0x80000227"
3850 }
3851 run_test 36h "utime on file racing with OST BRW write =========="
3852
3853 test_36i() {
3854         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
3855
3856         test_mkdir $DIR/$tdir
3857         $LFS setdirstripe -i0 -c$MDSCOUNT $DIR/$tdir/striped_dir
3858
3859         local mtime=$(stat -c%Y $DIR/$tdir/striped_dir)
3860         local new_mtime=$((mtime + 200))
3861
3862         #change Modify time of striped dir
3863         touch -m -d @$new_mtime $DIR/$tdir/striped_dir ||
3864                         error "change mtime failed"
3865
3866         local got=$(stat -c%Y $DIR/$tdir/striped_dir)
3867
3868         [ "$new_mtime" = "$got" ] || error "expect $new_mtime got $got"
3869 }
3870 run_test 36i "change mtime on striped directory"
3871
3872 # test_37 - duplicate with tests 32q 32r
3873
3874 test_38() {
3875         local file=$DIR/$tfile
3876         touch $file
3877         openfile -f O_DIRECTORY $file
3878         local RC=$?
3879         local ENOTDIR=20
3880         [ $RC -eq 0 ] && error "opened file $file with O_DIRECTORY" || true
3881         [ $RC -eq $ENOTDIR ] || error "error $RC should be ENOTDIR ($ENOTDIR)"
3882 }
3883 run_test 38 "open a regular file with O_DIRECTORY should return -ENOTDIR ==="
3884
3885 test_39a() { # was test_39
3886         touch $DIR/$tfile
3887         touch $DIR/${tfile}2
3888 #       ls -l  $DIR/$tfile $DIR/${tfile}2
3889 #       ls -lu  $DIR/$tfile $DIR/${tfile}2
3890 #       ls -lc  $DIR/$tfile $DIR/${tfile}2
3891         sleep 2
3892         $OPENFILE -f O_CREAT:O_TRUNC:O_WRONLY $DIR/${tfile}2
3893         if [ ! $DIR/${tfile}2 -nt $DIR/$tfile ]; then
3894                 echo "mtime"
3895                 ls -l --full-time $DIR/$tfile $DIR/${tfile}2
3896                 echo "atime"
3897                 ls -lu --full-time $DIR/$tfile $DIR/${tfile}2
3898                 echo "ctime"
3899                 ls -lc --full-time $DIR/$tfile $DIR/${tfile}2
3900                 error "O_TRUNC didn't change timestamps"
3901         fi
3902 }
3903 run_test 39a "mtime changed on create"
3904
3905 test_39b() {
3906         test_mkdir -c1 $DIR/$tdir
3907         cp -p /etc/passwd $DIR/$tdir/fopen
3908         cp -p /etc/passwd $DIR/$tdir/flink
3909         cp -p /etc/passwd $DIR/$tdir/funlink
3910         cp -p /etc/passwd $DIR/$tdir/frename
3911         ln $DIR/$tdir/funlink $DIR/$tdir/funlink2
3912
3913         sleep 1
3914         echo "aaaaaa" >> $DIR/$tdir/fopen
3915         echo "aaaaaa" >> $DIR/$tdir/flink
3916         echo "aaaaaa" >> $DIR/$tdir/funlink
3917         echo "aaaaaa" >> $DIR/$tdir/frename
3918
3919         local open_new=`stat -c %Y $DIR/$tdir/fopen`
3920         local link_new=`stat -c %Y $DIR/$tdir/flink`
3921         local unlink_new=`stat -c %Y $DIR/$tdir/funlink`
3922         local rename_new=`stat -c %Y $DIR/$tdir/frename`
3923
3924         cat $DIR/$tdir/fopen > /dev/null
3925         ln $DIR/$tdir/flink $DIR/$tdir/flink2
3926         rm -f $DIR/$tdir/funlink2
3927         mv -f $DIR/$tdir/frename $DIR/$tdir/frename2
3928
3929         for (( i=0; i < 2; i++ )) ; do
3930                 local open_new2=`stat -c %Y $DIR/$tdir/fopen`
3931                 local link_new2=`stat -c %Y $DIR/$tdir/flink`
3932                 local unlink_new2=`stat -c %Y $DIR/$tdir/funlink`
3933                 local rename_new2=`stat -c %Y $DIR/$tdir/frename2`
3934
3935                 [ $open_new2 -eq $open_new ] || error "open file reverses mtime"
3936                 [ $link_new2 -eq $link_new ] || error "link file reverses mtime"
3937                 [ $unlink_new2 -eq $unlink_new ] || error "unlink file reverses mtime"
3938                 [ $rename_new2 -eq $rename_new ] || error "rename file reverses mtime"
3939
3940                 cancel_lru_locks $OSC
3941                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
3942         done
3943 }
3944 run_test 39b "mtime change on open, link, unlink, rename  ======"
3945
3946 # this should be set to past
3947 TEST_39_MTIME=`date -d "1 year ago" +%s`
3948
3949 # bug 11063
3950 test_39c() {
3951         touch $DIR1/$tfile
3952         sleep 2
3953         local mtime0=`stat -c %Y $DIR1/$tfile`
3954
3955         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
3956         local mtime1=`stat -c %Y $DIR1/$tfile`
3957         [ "$mtime1" = $TEST_39_MTIME ] || \
3958                 error "mtime is not set to past: $mtime1, should be $TEST_39_MTIME"
3959
3960         local d1=`date +%s`
3961         echo hello >> $DIR1/$tfile
3962         local d2=`date +%s`
3963         local mtime2=`stat -c %Y $DIR1/$tfile`
3964         [ "$mtime2" -ge "$d1" ] && [ "$mtime2" -le "$d2" ] || \
3965                 error "mtime is not updated on write: $d1 <= $mtime2 <= $d2"
3966
3967         mv $DIR1/$tfile $DIR1/$tfile-1
3968
3969         for (( i=0; i < 2; i++ )) ; do
3970                 local mtime3=`stat -c %Y $DIR1/$tfile-1`
3971                 [ "$mtime2" = "$mtime3" ] || \
3972                         error "mtime ($mtime2) changed (to $mtime3) on rename"
3973
3974                 cancel_lru_locks $OSC
3975                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
3976         done
3977 }
3978 run_test 39c "mtime change on rename ==========================="
3979
3980 # bug 21114
3981 test_39d() {
3982         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3983
3984         touch $DIR1/$tfile
3985         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
3986
3987         for (( i=0; i < 2; i++ )) ; do
3988                 local mtime=`stat -c %Y $DIR1/$tfile`
3989                 [ $mtime = $TEST_39_MTIME ] || \
3990                         error "mtime($mtime) is not set to $TEST_39_MTIME"
3991
3992                 cancel_lru_locks $OSC
3993                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
3994         done
3995 }
3996 run_test 39d "create, utime, stat =============================="
3997
3998 # bug 21114
3999 test_39e() {
4000         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4001
4002         touch $DIR1/$tfile
4003         local mtime1=`stat -c %Y $DIR1/$tfile`
4004
4005         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
4006
4007         for (( i=0; i < 2; i++ )) ; do
4008                 local mtime2=`stat -c %Y $DIR1/$tfile`
4009                 [ $mtime2 = $TEST_39_MTIME ] || \
4010                         error "mtime($mtime2) is not set to $TEST_39_MTIME"
4011
4012                 cancel_lru_locks $OSC
4013                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4014         done
4015 }
4016 run_test 39e "create, stat, utime, stat ========================"
4017
4018 # bug 21114
4019 test_39f() {
4020         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4021
4022         touch $DIR1/$tfile
4023         mtime1=`stat -c %Y $DIR1/$tfile`
4024
4025         sleep 2
4026         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
4027
4028         for (( i=0; i < 2; i++ )) ; do
4029                 local mtime2=`stat -c %Y $DIR1/$tfile`
4030                 [ $mtime2 = $TEST_39_MTIME ] || \
4031                         error "mtime($mtime2) is not set to $TEST_39_MTIME"
4032
4033                 cancel_lru_locks $OSC
4034                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4035         done
4036 }
4037 run_test 39f "create, stat, sleep, utime, stat ================="
4038
4039 # bug 11063
4040 test_39g() {
4041         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4042
4043         echo hello >> $DIR1/$tfile
4044         local mtime1=`stat -c %Y $DIR1/$tfile`
4045
4046         sleep 2
4047         chmod o+r $DIR1/$tfile
4048
4049         for (( i=0; i < 2; i++ )) ; do
4050                 local mtime2=`stat -c %Y $DIR1/$tfile`
4051                 [ "$mtime1" = "$mtime2" ] || \
4052                         error "lost mtime: $mtime2, should be $mtime1"
4053
4054                 cancel_lru_locks $OSC
4055                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4056         done
4057 }
4058 run_test 39g "write, chmod, stat ==============================="
4059
4060 # bug 11063
4061 test_39h() {
4062         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4063
4064         touch $DIR1/$tfile
4065         sleep 1
4066
4067         local d1=`date`
4068         echo hello >> $DIR1/$tfile
4069         local mtime1=`stat -c %Y $DIR1/$tfile`
4070
4071         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
4072         local d2=`date`
4073         if [ "$d1" != "$d2" ]; then
4074                 echo "write and touch not within one second"
4075         else
4076                 for (( i=0; i < 2; i++ )) ; do
4077                         local mtime2=`stat -c %Y $DIR1/$tfile`
4078                         [ "$mtime2" = $TEST_39_MTIME ] || \
4079                                 error "lost mtime: $mtime2, should be $TEST_39_MTIME"
4080
4081                         cancel_lru_locks $OSC
4082                         if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4083                 done
4084         fi
4085 }
4086 run_test 39h "write, utime within one second, stat ============="
4087
4088 test_39i() {
4089         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4090
4091         touch $DIR1/$tfile
4092         sleep 1
4093
4094         echo hello >> $DIR1/$tfile
4095         local mtime1=`stat -c %Y $DIR1/$tfile`
4096
4097         mv $DIR1/$tfile $DIR1/$tfile-1
4098
4099         for (( i=0; i < 2; i++ )) ; do
4100                 local mtime2=`stat -c %Y $DIR1/$tfile-1`
4101
4102                 [ "$mtime1" = "$mtime2" ] || \
4103                         error "lost mtime: $mtime2, should be $mtime1"
4104
4105                 cancel_lru_locks $OSC
4106                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4107         done
4108 }
4109 run_test 39i "write, rename, stat =============================="
4110
4111 test_39j() {
4112         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4113
4114         start_full_debug_logging
4115         touch $DIR1/$tfile
4116         sleep 1
4117
4118         #define OBD_FAIL_OSC_DELAY_SETTIME       0x412
4119         lctl set_param fail_loc=0x80000412
4120         multiop_bg_pause $DIR1/$tfile oO_RDWR:w2097152_c ||
4121                 error "multiop failed"
4122         local multipid=$!
4123         local mtime1=`stat -c %Y $DIR1/$tfile`
4124
4125         mv $DIR1/$tfile $DIR1/$tfile-1
4126
4127         kill -USR1 $multipid
4128         wait $multipid || error "multiop close failed"
4129
4130         for (( i=0; i < 2; i++ )) ; do
4131                 local mtime2=`stat -c %Y $DIR1/$tfile-1`
4132                 [ "$mtime1" = "$mtime2" ] ||
4133                         error "mtime is lost on close: $mtime2, " \
4134                               "should be $mtime1"
4135
4136                 cancel_lru_locks $OSC
4137                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4138         done
4139         lctl set_param fail_loc=0
4140         stop_full_debug_logging
4141 }
4142 run_test 39j "write, rename, close, stat ======================="
4143
4144 test_39k() {
4145         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4146
4147         touch $DIR1/$tfile
4148         sleep 1
4149
4150         multiop_bg_pause $DIR1/$tfile oO_RDWR:w2097152_c || error "multiop failed"
4151         local multipid=$!
4152         local mtime1=`stat -c %Y $DIR1/$tfile`
4153
4154         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
4155
4156         kill -USR1 $multipid
4157         wait $multipid || error "multiop close failed"
4158
4159         for (( i=0; i < 2; i++ )) ; do
4160                 local mtime2=`stat -c %Y $DIR1/$tfile`
4161
4162                 [ "$mtime2" = $TEST_39_MTIME ] || \
4163                         error "mtime is lost on close: $mtime2, should be $TEST_39_MTIME"
4164
4165                 cancel_lru_locks osc
4166                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4167         done
4168 }
4169 run_test 39k "write, utime, close, stat ========================"
4170
4171 # this should be set to future
4172 TEST_39_ATIME=`date -d "1 year" +%s`
4173
4174 test_39l() {
4175         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4176         remote_mds_nodsh && skip "remote MDS with nodsh"
4177
4178         local atime_diff=$(do_facet $SINGLEMDS \
4179                                 lctl get_param -n mdd.*MDT0000*.atime_diff)
4180         rm -rf $DIR/$tdir
4181         mkdir -p $DIR/$tdir
4182
4183         # test setting directory atime to future
4184         touch -a -d @$TEST_39_ATIME $DIR/$tdir
4185         local atime=$(stat -c %X $DIR/$tdir)
4186         [ "$atime" = $TEST_39_ATIME ] ||
4187                 error "atime is not set to future: $atime, $TEST_39_ATIME"
4188
4189         # test setting directory atime from future to now
4190         local now=$(date +%s)
4191         touch -a -d @$now $DIR/$tdir
4192
4193         atime=$(stat -c %X $DIR/$tdir)
4194         [ "$atime" -eq "$now"  ] ||
4195                 error "atime is not updated from future: $atime, $now"
4196
4197         do_facet $SINGLEMDS lctl set_param -n mdd.*MDT0000*.atime_diff=2
4198         sleep 3
4199
4200         # test setting directory atime when now > dir atime + atime_diff
4201         local d1=$(date +%s)
4202         ls $DIR/$tdir
4203         local d2=$(date +%s)
4204         cancel_lru_locks mdc
4205         atime=$(stat -c %X $DIR/$tdir)
4206         [ "$atime" -ge "$d1" -a "$atime" -le "$d2" ] ||
4207                 error "atime is not updated  : $atime, should be $d2"
4208
4209         do_facet $SINGLEMDS lctl set_param -n mdd.*MDT0000*.atime_diff=60
4210         sleep 3
4211
4212         # test not setting directory atime when now < dir atime + atime_diff
4213         ls $DIR/$tdir
4214         cancel_lru_locks mdc
4215         atime=$(stat -c %X $DIR/$tdir)
4216         [ "$atime" -ge "$d1" -a "$atime" -le "$d2" ] ||
4217                 error "atime is updated to $atime, should remain $d1<atime<$d2"
4218
4219         do_facet $SINGLEMDS \
4220                 lctl set_param -n mdd.*MDT0000*.atime_diff=$atime_diff
4221 }
4222 run_test 39l "directory atime update ==========================="
4223
4224 test_39m() {
4225         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4226
4227         touch $DIR1/$tfile
4228         sleep 2
4229         local far_past_mtime=$(date -d "May 29 1953" +%s)
4230         local far_past_atime=$(date -d "Dec 17 1903" +%s)
4231
4232         touch -m -d @$far_past_mtime $DIR1/$tfile
4233         touch -a -d @$far_past_atime $DIR1/$tfile
4234
4235         for (( i=0; i < 2; i++ )) ; do
4236                 local timestamps=$(stat -c "%X %Y" $DIR1/$tfile)
4237                 [ "$timestamps" = "$far_past_atime $far_past_mtime" ] || \
4238                         error "atime or mtime set incorrectly"
4239
4240                 cancel_lru_locks $OSC
4241                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4242         done
4243 }
4244 run_test 39m "test atime and mtime before 1970"
4245
4246 test_39n() { # LU-3832
4247         remote_mds_nodsh && skip "remote MDS with nodsh"
4248
4249         local atime_diff=$(do_facet $SINGLEMDS \
4250                 lctl get_param -n mdd.*MDT0000*.atime_diff)
4251         local atime0
4252         local atime1
4253         local atime2
4254
4255         do_facet $SINGLEMDS lctl set_param -n mdd.*MDT0000*.atime_diff=1
4256
4257         rm -rf $DIR/$tfile
4258         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 status=noxfer
4259         atime0=$(stat -c %X $DIR/$tfile)
4260
4261         sleep 5
4262         $MULTIOP $DIR/$tfile oO_RDONLY:O_NOATIME:r4096c
4263         atime1=$(stat -c %X $DIR/$tfile)
4264
4265         sleep 5
4266         cancel_lru_locks mdc
4267         cancel_lru_locks osc
4268         $MULTIOP $DIR/$tfile oO_RDONLY:O_NOATIME:r4096c
4269         atime2=$(stat -c %X $DIR/$tfile)
4270
4271         do_facet $SINGLEMDS \
4272                 lctl set_param -n mdd.*MDT0000*.atime_diff=$atime_diff
4273
4274         [ "$atime0" -eq "$atime1" ] || error "atime0 $atime0 != atime1 $atime1"
4275         [ "$atime1" -eq "$atime2" ] || error "atime0 $atime0 != atime1 $atime1"
4276 }
4277 run_test 39n "check that O_NOATIME is honored"
4278
4279 test_39o() {
4280         TESTDIR=$DIR/$tdir/$tfile
4281         [ -e $TESTDIR ] && rm -rf $TESTDIR
4282         mkdir -p $TESTDIR
4283         cd $TESTDIR
4284         links1=2
4285         ls
4286         mkdir a b
4287         ls
4288         links2=$(stat -c %h .)
4289         [ $(($links1 + 2)) != $links2 ] &&
4290                 error "wrong links count $(($links1 + 2)) != $links2"
4291         rmdir b
4292         links3=$(stat -c %h .)
4293         [ $(($links1 + 1)) != $links3 ] &&
4294                 error "wrong links count $links1 != $links3"
4295         return 0
4296 }
4297 run_test 39o "directory cached attributes updated after create"
4298
4299 test_39p() {
4300         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
4301
4302         local MDTIDX=1
4303         TESTDIR=$DIR/$tdir/$tdir
4304         [ -e $TESTDIR ] && rm -rf $TESTDIR
4305         test_mkdir -p $TESTDIR
4306         cd $TESTDIR
4307         links1=2
4308         ls
4309         test_mkdir -i $MDTIDX $TESTDIR/remote_dir1
4310         test_mkdir -i $MDTIDX $TESTDIR/remote_dir2
4311         ls
4312         links2=$(stat -c %h .)
4313         [ $(($links1 + 2)) != $links2 ] &&
4314                 error "wrong links count $(($links1 + 2)) != $links2"
4315         rmdir remote_dir2
4316         links3=$(stat -c %h .)
4317         [ $(($links1 + 1)) != $links3 ] &&
4318                 error "wrong links count $links1 != $links3"
4319         return 0
4320 }
4321 run_test 39p "remote directory cached attributes updated after create ========"
4322
4323
4324 test_39q() { # LU-8041
4325         local testdir=$DIR/$tdir
4326         mkdir -p $testdir
4327         multiop_bg_pause $testdir D_c || error "multiop failed"
4328         local multipid=$!
4329         cancel_lru_locks mdc
4330         kill -USR1 $multipid
4331         local atime=$(stat -c %X $testdir)
4332         [ "$atime" -ne 0 ] || error "atime is zero"
4333 }
4334 run_test 39q "close won't zero out atime"
4335
4336 test_40() {
4337         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1
4338         $RUNAS $OPENFILE -f O_WRONLY:O_TRUNC $DIR/$tfile &&
4339                 error "openfile O_WRONLY:O_TRUNC $tfile failed"
4340         $CHECKSTAT -t file -s 4096 $DIR/$tfile ||
4341                 error "$tfile is not 4096 bytes in size"
4342 }
4343 run_test 40 "failed open(O_TRUNC) doesn't truncate ============="
4344
4345 test_41() {
4346         # bug 1553
4347         small_write $DIR/f41 18
4348 }
4349 run_test 41 "test small file write + fstat ====================="
4350
4351 count_ost_writes() {
4352         lctl get_param -n ${OSC}.*.stats |
4353                 awk -vwrites=0 '/ost_write/ { writes += $2 } \
4354                         END { printf("%0.0f", writes) }'
4355 }
4356
4357 # decent default
4358 WRITEBACK_SAVE=500
4359 DIRTY_RATIO_SAVE=40
4360 MAX_DIRTY_RATIO=50
4361 BG_DIRTY_RATIO_SAVE=10
4362 MAX_BG_DIRTY_RATIO=25
4363
4364 start_writeback() {
4365         trap 0
4366         # in 2.6, restore /proc/sys/vm/dirty_writeback_centisecs,
4367         # dirty_ratio, dirty_background_ratio
4368         if [ -f /proc/sys/vm/dirty_writeback_centisecs ]; then
4369                 sysctl -w vm.dirty_writeback_centisecs=$WRITEBACK_SAVE
4370                 sysctl -w vm.dirty_background_ratio=$BG_DIRTY_RATIO_SAVE
4371                 sysctl -w vm.dirty_ratio=$DIRTY_RATIO_SAVE
4372         else
4373                 # if file not here, we are a 2.4 kernel
4374                 kill -CONT `pidof kupdated`
4375         fi
4376 }
4377
4378 stop_writeback() {
4379         # setup the trap first, so someone cannot exit the test at the
4380         # exact wrong time and mess up a machine
4381         trap start_writeback EXIT
4382         # in 2.6, save and 0 /proc/sys/vm/dirty_writeback_centisecs
4383         if [ -f /proc/sys/vm/dirty_writeback_centisecs ]; then
4384                 WRITEBACK_SAVE=`sysctl -n vm.dirty_writeback_centisecs`
4385                 sysctl -w vm.dirty_writeback_centisecs=0
4386                 sysctl -w vm.dirty_writeback_centisecs=0
4387                 # save and increase /proc/sys/vm/dirty_ratio
4388                 DIRTY_RATIO_SAVE=`sysctl -n vm.dirty_ratio`
4389                 sysctl -w vm.dirty_ratio=$MAX_DIRTY_RATIO
4390                 # save and increase /proc/sys/vm/dirty_background_ratio
4391                 BG_DIRTY_RATIO_SAVE=`sysctl -n vm.dirty_background_ratio`
4392                 sysctl -w vm.dirty_background_ratio=$MAX_BG_DIRTY_RATIO
4393         else
4394                 # if file not here, we are a 2.4 kernel
4395                 kill -STOP `pidof kupdated`
4396         fi
4397 }
4398
4399 # ensure that all stripes have some grant before we test client-side cache
4400 setup_test42() {
4401         for i in `seq -f $DIR/f42-%g 1 $OSTCOUNT`; do
4402                 dd if=/dev/zero of=$i bs=4k count=1
4403                 rm $i
4404         done
4405 }
4406
4407 # Tests 42* verify that our behaviour is correct WRT caching, file closure,
4408 # file truncation, and file removal.
4409 test_42a() {
4410         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4411
4412         setup_test42
4413         cancel_lru_locks $OSC
4414         stop_writeback
4415         sync; sleep 1; sync # just to be safe
4416         BEFOREWRITES=`count_ost_writes`
4417         lctl get_param -n osc.*[oO][sS][cC][_-]*.cur_grant_bytes | grep "[0-9]"
4418         dd if=/dev/zero of=$DIR/f42a bs=1024 count=100
4419         AFTERWRITES=`count_ost_writes`
4420         [ $BEFOREWRITES -eq $AFTERWRITES ] || \
4421                 error "$BEFOREWRITES < $AFTERWRITES"
4422         start_writeback
4423 }
4424 run_test 42a "ensure that we don't flush on close"
4425
4426 test_42b() {
4427         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4428
4429         setup_test42
4430         cancel_lru_locks $OSC
4431         stop_writeback
4432         sync
4433         dd if=/dev/zero of=$DIR/f42b bs=1024 count=100
4434         BEFOREWRITES=$(count_ost_writes)
4435         $MUNLINK $DIR/f42b || error "$MUNLINK $DIR/f42b: $?"
4436         AFTERWRITES=$(count_ost_writes)
4437         if [[ $BEFOREWRITES -lt $AFTERWRITES ]]; then
4438                 error "$BEFOREWRITES < $AFTERWRITES on unlink"
4439         fi
4440         BEFOREWRITES=$(count_ost_writes)
4441         sync || error "sync: $?"
4442         AFTERWRITES=$(count_ost_writes)
4443         if [[ $BEFOREWRITES -lt $AFTERWRITES ]]; then
4444                 error "$BEFOREWRITES < $AFTERWRITES on sync"
4445         fi
4446         dmesg | grep 'error from obd_brw_async' && error 'error writing back'
4447         start_writeback
4448         return 0
4449 }
4450 run_test 42b "test destroy of file with cached dirty data ======"
4451
4452 # if these tests just want to test the effect of truncation,
4453 # they have to be very careful.  consider:
4454 # - the first open gets a {0,EOF}PR lock
4455 # - the first write conflicts and gets a {0, count-1}PW
4456 # - the rest of the writes are under {count,EOF}PW
4457 # - the open for truncate tries to match a {0,EOF}PR
4458 #   for the filesize and cancels the PWs.
4459 # any number of fixes (don't get {0,EOF} on open, match
4460 # composite locks, do smarter file size management) fix
4461 # this, but for now we want these tests to verify that
4462 # the cancellation with truncate intent works, so we
4463 # start the file with a full-file pw lock to match against
4464 # until the truncate.
4465 trunc_test() {
4466         test=$1
4467         file=$DIR/$test
4468         offset=$2
4469         cancel_lru_locks $OSC
4470         stop_writeback
4471         # prime the file with 0,EOF PW to match
4472         touch $file
4473         $TRUNCATE $file 0
4474         sync; sync
4475         # now the real test..
4476         dd if=/dev/zero of=$file bs=1024 count=100
4477         BEFOREWRITES=`count_ost_writes`
4478         $TRUNCATE $file $offset
4479         cancel_lru_locks $OSC
4480         AFTERWRITES=`count_ost_writes`
4481         start_writeback
4482 }
4483
4484 test_42c() {
4485         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4486
4487         trunc_test 42c 1024
4488         [ $BEFOREWRITES -eq $AFTERWRITES ] &&
4489                 error "beforewrites $BEFOREWRITES == afterwrites $AFTERWRITES on truncate"
4490         rm $file
4491 }
4492 run_test 42c "test partial truncate of file with cached dirty data"
4493
4494 test_42d() {
4495         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4496
4497         trunc_test 42d 0
4498         [ $BEFOREWRITES -eq $AFTERWRITES ] ||
4499                 error "beforewrites $BEFOREWRITES != afterwrites $AFTERWRITES on truncate"
4500         rm $file
4501 }
4502 run_test 42d "test complete truncate of file with cached dirty data"
4503
4504 test_42e() { # bug22074
4505         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4506
4507         local TDIR=$DIR/${tdir}e
4508         local pages=16 # hardcoded 16 pages, don't change it.
4509         local files=$((OSTCOUNT * 500)) # hopefully 500 files on each OST
4510         local proc_osc0="osc.${FSNAME}-OST0000-osc-[^MDT]*"
4511         local max_dirty_mb
4512         local warmup_files
4513
4514         test_mkdir $DIR/${tdir}e
4515         $LFS setstripe -c 1 $TDIR
4516         createmany -o $TDIR/f $files
4517
4518         max_dirty_mb=$($LCTL get_param -n $proc_osc0/max_dirty_mb)
4519
4520         # we assume that with $OSTCOUNT files, at least one of them will
4521         # be allocated on OST0.
4522         warmup_files=$((OSTCOUNT * max_dirty_mb))
4523         createmany -o $TDIR/w $warmup_files
4524
4525         # write a large amount of data into one file and sync, to get good
4526         # avail_grant number from OST.
4527         for ((i=0; i<$warmup_files; i++)); do
4528                 idx=$($LFS getstripe -i $TDIR/w$i)
4529                 [ $idx -ne 0 ] && continue
4530                 dd if=/dev/zero of=$TDIR/w$i bs="$max_dirty_mb"M count=1
4531                 break
4532         done
4533         [[ $i -gt $warmup_files ]] && error "OST0 is still cold"
4534         sync
4535         $LCTL get_param $proc_osc0/cur_dirty_bytes
4536         $LCTL get_param $proc_osc0/cur_grant_bytes
4537
4538         # create as much dirty pages as we can while not to trigger the actual
4539         # RPCs directly. but depends on the env, VFS may trigger flush during this
4540         # period, hopefully we are good.
4541         for ((i=0; i<$warmup_files; i++)); do
4542                 idx=$($LFS getstripe -i $TDIR/w$i)
4543                 [ $idx -ne 0 ] && continue
4544                 dd if=/dev/zero of=$TDIR/w$i bs=1M count=1 2>/dev/null
4545         done
4546         $LCTL get_param $proc_osc0/cur_dirty_bytes
4547         $LCTL get_param $proc_osc0/cur_grant_bytes
4548
4549         # perform the real test
4550         $LCTL set_param $proc_osc0/rpc_stats 0
4551         for ((;i<$files; i++)); do
4552                 [ $($LFS getstripe -i $TDIR/f$i) -eq 0 ] || continue
4553                 dd if=/dev/zero of=$TDIR/f$i bs=$PAGE_SIZE count=$pages 2>/dev/null
4554         done
4555         sync
4556         $LCTL get_param $proc_osc0/rpc_stats
4557
4558         local percent=0
4559         local have_ppr=false
4560         $LCTL get_param $proc_osc0/rpc_stats |
4561                 while read PPR RRPC RPCT RCUM BAR WRPC WPCT WCUM; do
4562                         # skip lines until we are at the RPC histogram data
4563                         [ "$PPR" == "pages" ] && have_ppr=true && continue
4564                         $have_ppr || continue
4565
4566                         # we only want the percent stat for < 16 pages
4567                         [[ $(echo $PPR | tr -d ':') -ge $pages ]] && break
4568
4569                         percent=$((percent + WPCT))
4570                         if [[ $percent -gt 15 ]]; then
4571                                 error "less than 16-pages write RPCs" \
4572                                       "$percent% > 15%"
4573                                 break
4574                         fi
4575                 done
4576         rm -rf $TDIR
4577 }
4578 run_test 42e "verify sub-RPC writes are not done synchronously"
4579
4580 test_43A() { # was test_43
4581         test_mkdir $DIR/$tdir
4582         cp -p /bin/ls $DIR/$tdir/$tfile
4583         $MULTIOP $DIR/$tdir/$tfile Ow_c &
4584         pid=$!
4585         # give multiop a chance to open
4586         sleep 1
4587
4588         $DIR/$tdir/$tfile && error "execute $DIR/$tdir/$tfile succeeded" || true
4589         kill -USR1 $pid
4590 }
4591 run_test 43A "execution of file opened for write should return -ETXTBSY"
4592
4593 test_43a() {
4594         test_mkdir $DIR/$tdir
4595         cp -p $(which sleep) $DIR/$tdir/sleep || error "can't copy"
4596         $DIR/$tdir/sleep 60 &
4597         SLEEP_PID=$!
4598         # Make sure exec of $tdir/sleep wins race with truncate
4599         sleep 1
4600         $MULTIOP $DIR/$tdir/sleep Oc && error "expected error, got success"
4601         kill $SLEEP_PID
4602 }
4603 run_test 43a "open(RDWR) of file being executed should return -ETXTBSY"
4604
4605 test_43b() {
4606         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4607
4608         test_mkdir $DIR/$tdir
4609         cp -p $(which sleep) $DIR/$tdir/sleep || error "can't copy"
4610         $DIR/$tdir/sleep 60 &
4611         SLEEP_PID=$!
4612         # Make sure exec of $tdir/sleep wins race with truncate
4613         sleep 1
4614         $TRUNCATE $DIR/$tdir/sleep 0 && error "expected error, got success"
4615         kill $SLEEP_PID
4616 }
4617 run_test 43b "truncate of file being executed should return -ETXTBSY"
4618
4619 test_43c() {
4620         local testdir="$DIR/$tdir"
4621         test_mkdir $testdir
4622         cp $SHELL $testdir/
4623         ( cd $(dirname $SHELL) && md5sum $(basename $SHELL) ) |
4624                 ( cd $testdir && md5sum -c )
4625 }
4626 run_test 43c "md5sum of copy into lustre"
4627
4628 test_44A() { # was test_44
4629         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
4630
4631         dd if=/dev/zero of=$DIR/f1 bs=4k count=1 seek=1023
4632         dd if=$DIR/f1 bs=4k count=1 > /dev/null
4633 }
4634 run_test 44A "zero length read from a sparse stripe"
4635
4636 test_44a() {
4637         local nstripe=$($LCTL lov_getconfig $DIR | grep default_stripe_count: |
4638                 awk '{ print $2 }')
4639         [ -z "$nstripe" ] && skip "can't get stripe info"
4640         [[ $nstripe -gt $OSTCOUNT ]] &&
4641                 skip "Wrong default_stripe_count: $nstripe OSTCOUNT: $OSTCOUNT"
4642
4643         local stride=$($LCTL lov_getconfig $DIR | grep default_stripe_size: |
4644                 awk '{ print $2 }')
4645         if [[ $nstripe -eq 0 || $nstripe -eq -1 ]]; then
4646                 nstripe=$($LCTL lov_getconfig $DIR | grep obd_count: |
4647                         awk '{ print $2 }')
4648         fi
4649
4650         OFFSETS="0 $((stride/2)) $((stride-1))"
4651         for offset in $OFFSETS; do
4652                 for i in $(seq 0 $((nstripe-1))); do
4653                         local GLOBALOFFSETS=""
4654                         # size in Bytes
4655                         local size=$((((i + 2 * $nstripe )*$stride + $offset)))
4656                         local myfn=$DIR/d44a-$size
4657                         echo "--------writing $myfn at $size"
4658                         ll_sparseness_write $myfn $size ||
4659                                 error "ll_sparseness_write"
4660                         GLOBALOFFSETS="$GLOBALOFFSETS $size"
4661                         ll_sparseness_verify $myfn $GLOBALOFFSETS ||
4662                                 error "ll_sparseness_verify $GLOBALOFFSETS"
4663
4664                         for j in $(seq 0 $((nstripe-1))); do
4665                                 # size in Bytes
4666                                 size=$((((j + $nstripe )*$stride + $offset)))
4667                                 ll_sparseness_write $myfn $size ||
4668                                         error "ll_sparseness_write"
4669                                 GLOBALOFFSETS="$GLOBALOFFSETS $size"
4670                         done
4671                         ll_sparseness_verify $myfn $GLOBALOFFSETS ||
4672                                 error "ll_sparseness_verify $GLOBALOFFSETS"
4673                         rm -f $myfn
4674                 done
4675         done
4676 }
4677 run_test 44a "test sparse pwrite ==============================="
4678
4679 dirty_osc_total() {
4680         tot=0
4681         for d in `lctl get_param -n ${OSC}.*.cur_dirty_bytes`; do
4682                 tot=$(($tot + $d))
4683         done
4684         echo $tot
4685 }
4686 do_dirty_record() {
4687         before=`dirty_osc_total`
4688         echo executing "\"$*\""
4689         eval $*
4690         after=`dirty_osc_total`
4691         echo before $before, after $after
4692 }
4693 test_45() {
4694         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4695
4696         f="$DIR/f45"
4697         # Obtain grants from OST if it supports it
4698         echo blah > ${f}_grant
4699         stop_writeback
4700         sync
4701         do_dirty_record "echo blah > $f"
4702         [[ $before -eq $after ]] && error "write wasn't cached"
4703         do_dirty_record "> $f"
4704         [[ $before -gt $after ]] || error "truncate didn't lower dirty count"
4705         do_dirty_record "echo blah > $f"
4706         [[ $before -eq $after ]] && error "write wasn't cached"
4707         do_dirty_record "sync"
4708         [[ $before -gt $after ]] || error "writeback didn't lower dirty count"
4709         do_dirty_record "echo blah > $f"
4710         [[ $before -eq $after ]] && error "write wasn't cached"
4711         do_dirty_record "cancel_lru_locks osc"
4712         [[ $before -gt $after ]] ||
4713                 error "lock cancellation didn't lower dirty count"
4714         start_writeback
4715 }
4716 run_test 45 "osc io page accounting ============================"
4717
4718 # in a 2 stripe file (lov.sh), page 1023 maps to page 511 in its object.  this
4719 # test tickles a bug where re-dirtying a page was failing to be mapped to the
4720 # objects offset and an assert hit when an rpc was built with 1023's mapped
4721 # offset 511 and 511's raw 511 offset. it also found general redirtying bugs.
4722 test_46() {
4723         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4724
4725         f="$DIR/f46"
4726         stop_writeback
4727         sync
4728         dd if=/dev/zero of=$f bs=$PAGE_SIZE seek=511 count=1
4729         sync
4730         dd conv=notrunc if=/dev/zero of=$f bs=$PAGE_SIZE seek=1023 count=1
4731         dd conv=notrunc if=/dev/zero of=$f bs=$PAGE_SIZE seek=511 count=1
4732         sync
4733         start_writeback
4734 }
4735 run_test 46 "dirtying a previously written page ================"
4736
4737 # test_47 is removed "Device nodes check" is moved to test_28
4738
4739 test_48a() { # bug 2399
4740         [ "$mds1_FSTYPE" = "zfs" ] &&
4741         [ $MDS1_VERSION -lt $(version_code 2.3.63) ] &&
4742                 skip "MDS prior to 2.3.63 handle ZFS dir .. incorrectly"
4743
4744         test_mkdir $DIR/$tdir
4745         cd $DIR/$tdir
4746         mv $DIR/$tdir $DIR/$tdir.new || error "move directory failed"
4747         test_mkdir $DIR/$tdir
4748         touch foo || error "'touch foo' failed after recreating cwd"
4749         test_mkdir bar
4750         touch .foo || error "'touch .foo' failed after recreating cwd"
4751         test_mkdir .bar
4752         ls . > /dev/null || error "'ls .' failed after recreating cwd"
4753         ls .. > /dev/null || error "'ls ..' failed after removing cwd"
4754         cd . || error "'cd .' failed after recreating cwd"
4755         mkdir . && error "'mkdir .' worked after recreating cwd"
4756         rmdir . && error "'rmdir .' worked after recreating cwd"
4757         ln -s . baz || error "'ln -s .' failed after recreating cwd"
4758         cd .. || error "'cd ..' failed after recreating cwd"
4759 }
4760 run_test 48a "Access renamed working dir (should return errors)="
4761
4762 test_48b() { # bug 2399
4763         rm -rf $DIR/$tdir
4764         test_mkdir $DIR/$tdir
4765         cd $DIR/$tdir
4766         rmdir $DIR/$tdir || error "remove cwd $DIR/$tdir failed"
4767         touch foo && error "'touch foo' worked after removing cwd"
4768         mkdir foo && error "'mkdir foo' worked after removing cwd"
4769         touch .foo && error "'touch .foo' worked after removing cwd"
4770         mkdir .foo && error "'mkdir .foo' worked after removing cwd"
4771         ls . > /dev/null && error "'ls .' worked after removing cwd"
4772         ls .. > /dev/null || error "'ls ..' failed after removing cwd"
4773         mkdir . && error "'mkdir .' worked after removing cwd"
4774         rmdir . && error "'rmdir .' worked after removing cwd"
4775         ln -s . foo && error "'ln -s .' worked after removing cwd"
4776         cd .. || echo "'cd ..' failed after removing cwd `pwd`"  #bug 3517
4777 }
4778 run_test 48b "Access removed working dir (should return errors)="
4779
4780 test_48c() { # bug 2350
4781         #lctl set_param debug=-1
4782         #set -vx
4783         rm -rf $DIR/$tdir
4784         test_mkdir -p $DIR/$tdir/dir
4785         cd $DIR/$tdir/dir
4786         $TRACE rmdir $DIR/$tdir/dir || error "remove cwd $DIR/$tdir/dir failed"
4787         $TRACE touch foo && error "touch foo worked after removing cwd"
4788         $TRACE mkdir foo && error "'mkdir foo' worked after removing cwd"
4789         touch .foo && error "touch .foo worked after removing cwd"
4790         mkdir .foo && error "mkdir .foo worked after removing cwd"
4791         $TRACE ls . && error "'ls .' worked after removing cwd"
4792         $TRACE ls .. || error "'ls ..' failed after removing cwd"
4793         $TRACE mkdir . && error "'mkdir .' worked after removing cwd"
4794         $TRACE rmdir . && error "'rmdir .' worked after removing cwd"
4795         $TRACE ln -s . foo && error "'ln -s .' worked after removing cwd"
4796         $TRACE cd .. || echo "'cd ..' failed after removing cwd `pwd`" #bug 3415
4797 }
4798 run_test 48c "Access removed working subdir (should return errors)"
4799
4800 test_48d() { # bug 2350
4801         #lctl set_param debug=-1
4802         #set -vx
4803         rm -rf $DIR/$tdir
4804         test_mkdir -p $DIR/$tdir/dir
4805         cd $DIR/$tdir/dir
4806         $TRACE rmdir $DIR/$tdir/dir || error "remove cwd $DIR/$tdir/dir failed"
4807         $TRACE rmdir $DIR/$tdir || error "remove parent $DIR/$tdir failed"
4808         $TRACE touch foo && error "'touch foo' worked after removing parent"
4809         $TRACE mkdir foo && error "mkdir foo worked after removing parent"
4810         touch .foo && error "'touch .foo' worked after removing parent"
4811         mkdir .foo && error "mkdir .foo worked after removing parent"
4812         $TRACE ls . && error "'ls .' worked after removing parent"
4813         $TRACE ls .. && error "'ls ..' worked after removing parent"
4814         $TRACE mkdir . && error "'mkdir .' worked after removing parent"
4815         $TRACE rmdir . && error "'rmdir .' worked after removing parent"
4816         $TRACE ln -s . foo && error "'ln -s .' worked after removing parent"
4817         true
4818 }
4819 run_test 48d "Access removed parent subdir (should return errors)"
4820
4821 test_48e() { # bug 4134
4822         #lctl set_param debug=-1
4823         #set -vx
4824         rm -rf $DIR/$tdir
4825         test_mkdir -p $DIR/$tdir/dir
4826         cd $DIR/$tdir/dir
4827         $TRACE rmdir $DIR/$tdir/dir || error "remove cwd $DIR/$tdir/dir failed"
4828         $TRACE rmdir $DIR/$tdir || error "remove parent $DIR/$tdir failed"
4829         $TRACE touch $DIR/$tdir || error "'touch $DIR/$tdir' failed"
4830         $TRACE chmod +x $DIR/$tdir || error "'chmod +x $DIR/$tdir' failed"
4831         # On a buggy kernel addition of "touch foo" after cd .. will
4832         # produce kernel oops in lookup_hash_it
4833         touch ../foo && error "'cd ..' worked after recreate parent"
4834         cd $DIR
4835         $TRACE rm $DIR/$tdir || error "rm '$DIR/$tdir' failed"
4836 }
4837 run_test 48e "Access to recreated parent subdir (should return errors)"
4838
4839 test_49() { # LU-1030
4840         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4841         remote_ost_nodsh && skip "remote OST with nodsh"
4842
4843         # get ost1 size - lustre-OST0000
4844         ost1_size=$(do_facet ost1 $LFS df | grep ${ost1_svc} |
4845                 awk '{ print $4 }')
4846         # write 800M at maximum
4847         [[ $ost1_size -lt 2 ]] && ost1_size=2
4848         [[ $ost1_size -gt 819200 ]] && ost1_size=819200
4849
4850         $LFS setstripe -c 1 -i 0 $DIR/$tfile
4851         dd if=/dev/zero of=$DIR/$tfile bs=4k count=$((ost1_size >> 2)) &
4852         local dd_pid=$!
4853
4854         # change max_pages_per_rpc while writing the file
4855         local osc1_mppc=osc.$(get_osc_import_name client ost1).max_pages_per_rpc
4856         local orig_mppc=$($LCTL get_param -n $osc1_mppc)
4857         # loop until dd process exits
4858         while ps ax -opid | grep -wq $dd_pid; do
4859                 $LCTL set_param $osc1_mppc=$((RANDOM % 256 + 1))
4860                 sleep $((RANDOM % 5 + 1))
4861         done
4862         # restore original max_pages_per_rpc
4863         $LCTL set_param $osc1_mppc=$orig_mppc
4864         rm $DIR/$tfile || error "rm $DIR/$tfile failed"
4865 }
4866 run_test 49 "Change max_pages_per_rpc won't break osc extent"
4867
4868 test_50() {
4869         # bug 1485
4870         test_mkdir $DIR/$tdir
4871         cd $DIR/$tdir
4872         ls /proc/$$/cwd || error "ls /proc/$$/cwd failed"
4873 }
4874 run_test 50 "special situations: /proc symlinks  ==============="
4875
4876 test_51a() {    # was test_51
4877         # bug 1516 - create an empty entry right after ".." then split dir
4878         test_mkdir -c1 $DIR/$tdir
4879         touch $DIR/$tdir/foo
4880         $MCREATE $DIR/$tdir/bar
4881         rm $DIR/$tdir/foo
4882         createmany -m $DIR/$tdir/longfile 201
4883         FNUM=202
4884         while [[ $(ls -sd $DIR/$tdir | awk '{ print $1 }') -eq 4 ]]; do
4885                 $MCREATE $DIR/$tdir/longfile$FNUM
4886                 FNUM=$(($FNUM + 1))
4887                 echo -n "+"
4888         done
4889         echo
4890         ls -l $DIR/$tdir > /dev/null || error "ls -l $DIR/$tdir failed"
4891 }
4892 run_test 51a "special situations: split htree with empty entry =="
4893
4894 cleanup_print_lfs_df () {
4895         trap 0
4896         $LFS df
4897         $LFS df -i
4898 }
4899
4900 test_51b() {
4901         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4902
4903         local dir=$DIR/$tdir
4904         local nrdirs=$((65536 + 100))
4905
4906         # cleanup the directory
4907         rm -fr $dir
4908
4909         test_mkdir -c1 $dir
4910
4911         $LFS df
4912         $LFS df -i
4913         local mdtidx=$(printf "%04x" $($LFS getstripe -m $dir))
4914         local numfree=$(lctl get_param -n mdc.$FSNAME-MDT$mdtidx*.filesfree)
4915         [[ $numfree -lt $nrdirs ]] &&
4916                 skip "not enough free inodes ($numfree) on MDT$mdtidx"
4917
4918         # need to check free space for the directories as well
4919         local blkfree=$(lctl get_param -n mdc.$FSNAME-MDT$mdtidx*.kbytesavail)
4920         numfree=$(( blkfree / $(fs_inode_ksize) ))
4921         [[ $numfree -lt $nrdirs ]] && skip "not enough blocks ($numfree)"
4922
4923         trap cleanup_print_lfs_df EXIT
4924
4925         # create files
4926         createmany -d $dir/d $nrdirs || {
4927                 unlinkmany $dir/d $nrdirs
4928                 error "failed to create $nrdirs subdirs in MDT$mdtidx:$dir"
4929         }
4930
4931         # really created :
4932         nrdirs=$(ls -U $dir | wc -l)
4933
4934         # unlink all but 100 subdirectories, then check it still works
4935         local left=100
4936         local delete=$((nrdirs - left))
4937
4938         $LFS df
4939         $LFS df -i
4940
4941         # for ldiskfs the nlink count should be 1, but this is OSD specific
4942         # and so this is listed for informational purposes only
4943         echo "nlink before: $(stat -c %h $dir), created before: $nrdirs"
4944         unlinkmany -d $dir/d $delete ||
4945                 error "unlink of first $delete subdirs failed"
4946
4947         echo "nlink between: $(stat -c %h $dir)"
4948         local found=$(ls -U $dir | wc -l)
4949         [ $found -ne $left ] &&
4950                 error "can't find subdirs: found only $found, expected $left"
4951
4952         unlinkmany -d $dir/d $delete $left ||
4953                 error "unlink of second $left subdirs failed"
4954         # regardless of whether the backing filesystem tracks nlink accurately
4955         # or not, the nlink count shouldn't be more than "." and ".." here
4956         local after=$(stat -c %h $dir)
4957         [[ $after -gt 2 ]] && error "nlink after: $after > 2" ||
4958                 echo "nlink after: $after"
4959
4960         cleanup_print_lfs_df
4961 }
4962 run_test 51b "exceed 64k subdirectory nlink limit on create, verify unlink"
4963
4964 test_51d() {
4965         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4966         [[ $OSTCOUNT -lt 3 ]] && skip_env "needs >= 3 OSTs"
4967
4968         test_mkdir $DIR/$tdir
4969         createmany -o $DIR/$tdir/t- 1000
4970         $LFS getstripe $DIR/$tdir > $TMP/$tfile
4971         for N in $(seq 0 $((OSTCOUNT - 1))); do
4972                 OBJS[$N]=$(awk -vobjs=0 '($1 == '$N') { objs += 1 } \
4973                         END { printf("%0.0f", objs) }' $TMP/$tfile)
4974                 OBJS0[$N]=$(grep -A 1 idx $TMP/$tfile | awk -vobjs=0 \
4975                         '($1 == '$N') { objs += 1 } \
4976                         END { printf("%0.0f", objs) }')
4977                 log "OST$N has ${OBJS[$N]} objects, ${OBJS0[$N]} are index 0"
4978         done
4979         unlinkmany $DIR/$tdir/t- 1000
4980
4981         NLAST=0
4982         for N in $(seq 1 $((OSTCOUNT - 1))); do
4983                 [[ ${OBJS[$N]} -lt $((${OBJS[$NLAST]} - 20)) ]] &&
4984                         error "OST $N has less objects vs OST $NLAST" \
4985                               " (${OBJS[$N]} < ${OBJS[$NLAST]}"
4986                 [[ ${OBJS[$N]} -gt $((${OBJS[$NLAST]} + 20)) ]] &&
4987                         error "OST $N has less objects vs OST $NLAST" \
4988                               " (${OBJS[$N]} < ${OBJS[$NLAST]}"
4989
4990                 [[ ${OBJS0[$N]} -lt $((${OBJS0[$NLAST]} - 20)) ]] &&
4991                         error "OST $N has less #0 objects vs OST $NLAST" \
4992                               " (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
4993                 [[ ${OBJS0[$N]} -gt $((${OBJS0[$NLAST]} + 20)) ]] &&
4994                         error "OST $N has less #0 objects vs OST $NLAST" \
4995                               " (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
4996                 NLAST=$N
4997         done
4998         rm -f $TMP/$tfile
4999 }
5000 run_test 51d "check object distribution"
5001
5002 test_51e() {
5003         if [ "$mds1_FSTYPE" != ldiskfs ]; then
5004                 skip_env "ldiskfs only test"
5005         fi
5006
5007         test_mkdir -c1 $DIR/$tdir
5008         test_mkdir -c1 $DIR/$tdir/d0
5009
5010         touch $DIR/$tdir/d0/foo
5011         createmany -l $DIR/$tdir/d0/foo $DIR/$tdir/d0/f- 65001 &&
5012                 error "file exceed 65000 nlink limit!"
5013         unlinkmany $DIR/$tdir/d0/f- 65001
5014         return 0
5015 }
5016 run_test 51e "check file nlink limit"
5017
5018 test_51f() {
5019         test_mkdir $DIR/$tdir
5020
5021         local max=100000
5022         local ulimit_old=$(ulimit -n)
5023         local spare=20 # number of spare fd's for scripts/libraries, etc.
5024         local mdt=$($LFS getstripe -m $DIR/$tdir)
5025         local numfree=$($LFS df -i $DIR/$tdir | awk '/MDT:'$mdt'/ { print $4 }')
5026
5027         echo "MDT$mdt numfree=$numfree, max=$max"
5028         [[ $numfree -gt $max ]] && numfree=$max || numfree=$((numfree * 7 / 8))
5029         if [ $((numfree + spare)) -gt $ulimit_old ]; then
5030                 while ! ulimit -n $((numfree + spare)); do
5031                         numfree=$((numfree * 3 / 4))
5032                 done
5033                 echo "changed ulimit from $ulimit_old to $((numfree + spare))"
5034         else
5035                 echo "left ulimit at $ulimit_old"
5036         fi
5037
5038         createmany -o -k -t 120 $DIR/$tdir/f $numfree || {
5039                 unlinkmany $DIR/$tdir/f $numfree
5040                 error "create+open $numfree files in $DIR/$tdir failed"
5041         }
5042         ulimit -n $ulimit_old
5043
5044         # if createmany exits at 120s there will be fewer than $numfree files
5045         unlinkmany $DIR/$tdir/f $numfree || true
5046 }
5047 run_test 51f "check many open files limit"
5048
5049 test_52a() {
5050         [ -f $DIR/$tdir/foo ] && chattr -a $DIR/$tdir/foo
5051         test_mkdir $DIR/$tdir
5052         touch $DIR/$tdir/foo
5053         chattr +a $DIR/$tdir/foo || error "chattr +a failed"
5054         echo bar >> $DIR/$tdir/foo || error "append bar failed"
5055         cp /etc/hosts $DIR/$tdir/foo && error "cp worked"
5056         rm -f $DIR/$tdir/foo 2>/dev/null && error "rm worked"
5057         link $DIR/$tdir/foo $DIR/$tdir/foo_link 2>/dev/null &&
5058                                         error "link worked"
5059         echo foo >> $DIR/$tdir/foo || error "append foo failed"
5060         mrename $DIR/$tdir/foo $DIR/$tdir/foo_ren && error "rename worked"
5061         lsattr $DIR/$tdir/foo | egrep -q "^-+a[-e]+ $DIR/$tdir/foo" ||
5062                                                      error "lsattr"
5063         chattr -a $DIR/$tdir/foo || error "chattr -a failed"
5064         cp -r $DIR/$tdir $TMP/
5065         rm -fr $DIR/$tdir $TMP/$tdir || error "cleanup rm failed"
5066 }
5067 run_test 52a "append-only flag test (should return errors)"
5068
5069 test_52b() {
5070         [ -f $DIR/$tdir/foo ] && chattr -i $DIR/$tdir/foo
5071         test_mkdir $DIR/$tdir
5072         touch $DIR/$tdir/foo
5073         chattr +i $DIR/$tdir/foo || error "chattr +i failed"
5074         cat test > $DIR/$tdir/foo && error "cat test worked"
5075         cp /etc/hosts $DIR/$tdir/foo && error "cp worked"
5076         rm -f $DIR/$tdir/foo 2>/dev/null && error "rm worked"
5077         link $DIR/$tdir/foo $DIR/$tdir/foo_link 2>/dev/null &&
5078                                         error "link worked"
5079         echo foo >> $DIR/$tdir/foo && error "echo worked"
5080         mrename $DIR/$tdir/foo $DIR/$tdir/foo_ren && error "rename worked"
5081         [ -f $DIR/$tdir/foo ] || error "$tdir/foo is not a file"
5082         [ -f $DIR/$tdir/foo_ren ] && error "$tdir/foo_ren is not a file"
5083         lsattr $DIR/$tdir/foo | egrep -q "^-+i[-e]+ $DIR/$tdir/foo" ||
5084                                                         error "lsattr"
5085         chattr -i $DIR/$tdir/foo || error "chattr failed"
5086
5087         rm -fr $DIR/$tdir || error "unable to remove $DIR/$tdir"
5088 }
5089 run_test 52b "immutable flag test (should return errors) ======="
5090
5091 test_53() {
5092         [ $PARALLEL == "yes" ] && skip "skip parallel run"
5093         remote_mds_nodsh && skip "remote MDS with nodsh"
5094         remote_ost_nodsh && skip "remote OST with nodsh"
5095
5096         local param
5097         local param_seq
5098         local ostname
5099         local mds_last
5100         local mds_last_seq
5101         local ost_last
5102         local ost_last_seq
5103         local ost_last_id
5104         local ostnum
5105         local node
5106         local found=false
5107         local support_last_seq=true
5108
5109         [[ $MDS1_VERSION -ge $(version_code 2.3.60) ]] ||
5110                 support_last_seq=false
5111
5112         # only test MDT0000
5113         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS)
5114         local value
5115         for value in $(do_facet $SINGLEMDS \
5116                        $LCTL get_param osp.$mdtosc.prealloc_last_id) ; do
5117                 param=$(echo ${value[0]} | cut -d "=" -f1)
5118                 ostname=$(echo $param | cut -d "." -f2 | cut -d - -f 1-2)
5119
5120                 if $support_last_seq; then
5121                         param_seq=$(echo $param |
5122                                 sed -e s/prealloc_last_id/prealloc_last_seq/g)
5123                         mds_last_seq=$(do_facet $SINGLEMDS \
5124                                        $LCTL get_param -n $param_seq)
5125                 fi
5126                 mds_last=$(do_facet $SINGLEMDS $LCTL get_param -n $param)
5127
5128                 ostnum=$(index_from_ostuuid ${ostname}_UUID)
5129                 node=$(facet_active_host ost$((ostnum+1)))
5130                 param="obdfilter.$ostname.last_id"
5131                 for ost_last in $(do_node $node $LCTL get_param -n $param) ; do
5132                         echo "$ostname.last_id=$ost_last; MDS.last_id=$mds_last"
5133                         ost_last_id=$ost_last
5134
5135                         if $support_last_seq; then
5136                                 ost_last_id=$(echo $ost_last |
5137                                               awk -F':' '{print $2}' |
5138                                               sed -e "s/^0x//g")
5139                                 ost_last_seq=$(echo $ost_last |
5140                                                awk -F':' '{print $1}')
5141                                 [[ $ost_last_seq = $mds_last_seq ]] || continue
5142                         fi
5143
5144                         if [[ $ost_last_id != $mds_last ]]; then
5145                                 error "$ost_last_id != $mds_last"
5146                         else
5147                                 found=true
5148                                 break
5149                         fi
5150                 done
5151         done
5152         $found || error "can not match last_seq/last_id for $mdtosc"
5153         return 0
5154 }
5155 run_test 53 "verify that MDS and OSTs agree on pre-creation ===="
5156
5157 test_54a() {
5158         perl -MSocket -e ';' || skip "no Socket perl module installed"
5159
5160         $SOCKETSERVER $DIR/socket ||
5161                 error "$SOCKETSERVER $DIR/socket failed: $?"
5162         $SOCKETCLIENT $DIR/socket ||
5163                 error "$SOCKETCLIENT $DIR/socket failed: $?"
5164         $MUNLINK $DIR/socket || error "$MUNLINK $DIR/socket failed: $?"
5165 }
5166 run_test 54a "unix domain socket test =========================="
5167
5168 test_54b() {
5169         f="$DIR/f54b"
5170         mknod $f c 1 3
5171         chmod 0666 $f
5172         dd if=/dev/zero of=$f bs=$PAGE_SIZE count=1
5173 }
5174 run_test 54b "char device works in lustre ======================"
5175
5176 find_loop_dev() {
5177         [ -b /dev/loop/0 ] && LOOPBASE=/dev/loop/
5178         [ -b /dev/loop0 ] && LOOPBASE=/dev/loop
5179         [ -z "$LOOPBASE" ] && echo "/dev/loop/0 and /dev/loop0 gone?" && return
5180
5181         for i in $(seq 3 7); do
5182                 losetup $LOOPBASE$i > /dev/null 2>&1 && continue
5183                 LOOPDEV=$LOOPBASE$i
5184                 LOOPNUM=$i
5185                 break
5186         done
5187 }
5188
5189 cleanup_54c() {
5190         local rc=0
5191         loopdev="$DIR/loop54c"
5192
5193         trap 0
5194         $UMOUNT $DIR/$tdir || rc=$?
5195         losetup -d $loopdev || true
5196         losetup -d $LOOPDEV || true
5197         rm -rf $loopdev $DIR/$tfile $DIR/$tdir
5198         return $rc
5199 }
5200
5201 test_54c() {
5202         [ $PARALLEL == "yes" ] && skip "skip parallel run"
5203
5204         loopdev="$DIR/loop54c"
5205
5206         find_loop_dev
5207         [ -z "$LOOPNUM" ] && skip_env "couldn't find empty loop device"
5208         trap cleanup_54c EXIT
5209         mknod $loopdev b 7 $LOOPNUM
5210         echo "make a loop file system with $DIR/$tfile on $loopdev ($LOOPNUM)."
5211         dd if=/dev/zero of=$DIR/$tfile bs=$PAGE_SIZE seek=1024 count=1 > /dev/null
5212         losetup $loopdev $DIR/$tfile ||
5213                 error "can't set up $loopdev for $DIR/$tfile"
5214         mkfs.ext2 $loopdev || error "mke2fs on $loopdev"
5215         test_mkdir $DIR/$tdir
5216         mount -t ext2 $loopdev $DIR/$tdir ||
5217                 error "error mounting $loopdev on $DIR/$tdir"
5218         dd if=/dev/zero of=$DIR/$tdir/tmp bs=$PAGE_SIZE count=30 ||
5219                 error "dd write"
5220         df $DIR/$tdir
5221         dd if=$DIR/$tdir/tmp of=/dev/zero bs=$PAGE_SIZE count=30 ||
5222                 error "dd read"
5223         cleanup_54c
5224 }
5225 run_test 54c "block device works in lustre ====================="
5226
5227 test_54d() {
5228         f="$DIR/f54d"
5229         string="aaaaaa"
5230         mknod $f p
5231         [ "$string" = $(echo $string > $f | cat $f) ] || error "$f != $string"
5232 }
5233 run_test 54d "fifo device works in lustre ======================"
5234
5235 test_54e() {
5236         f="$DIR/f54e"
5237         string="aaaaaa"
5238         cp -aL /dev/console $f
5239         echo $string > $f || error "echo $string to $f failed"
5240 }
5241 run_test 54e "console/tty device works in lustre ======================"
5242
5243 test_56a() {
5244         local numfiles=3
5245         local dir=$DIR/$tdir
5246
5247         rm -rf $dir
5248         test_mkdir -p $dir/dir
5249         for i in $(seq $numfiles); do
5250                 touch $dir/file$i
5251                 touch $dir/dir/file$i
5252         done
5253
5254         local numcomp=$($LFS getstripe --component-count $dir)
5255
5256         [[ $numcomp == 0 ]] && numcomp=1
5257
5258         # test lfs getstripe with --recursive
5259         local filenum=$($LFS getstripe -r $dir | egrep -c "obdidx|l_ost_idx")
5260
5261         [[ $filenum -eq $((numfiles * 2)) ]] ||
5262                 error "$LFS getstripe -r: found $filenum != $((numfiles * 2))"
5263         filenum=$($LFS getstripe $dir | egrep -c "obdidx|l_ost_idx")
5264         [[ $filenum -eq $numfiles ]] ||
5265                 error "$LFS getstripe $dir: found $filenum, not $numfiles"
5266         echo "$LFS getstripe showed obdidx or l_ost_idx"
5267
5268         # test lfs getstripe with file instead of dir
5269         filenum=$($LFS getstripe $dir/file1 | egrep -c "obdidx|l_ost_idx")
5270         [[ $filenum -eq 1 ]] ||
5271                 error "$LFS getstripe $dir/file1: found $filenum, not 1"
5272         echo "$LFS getstripe file1 passed"
5273
5274         #test lfs getstripe with --verbose
5275         filenum=$($LFS getstripe --verbose $dir | grep -c lmm_magic)
5276         [[ $filenum -eq $((numfiles * numcomp)) ]] ||
5277                 error "$LFS getstripe --verbose $dir: "\
5278                       "got $filenum want $((numfiles * numcomp)) lmm_magic"
5279         [[ $($LFS getstripe $dir | grep -c lmm_magic) -eq 0 ]] ||
5280                 error "$LFS getstripe $dir: showed lmm_magic"
5281
5282         #test lfs getstripe with -v prints lmm_fid
5283         filenum=$($LFS getstripe -v $dir | grep -c lmm_fid)
5284         [[ $filenum -eq $((numfiles * numcomp)) ]] ||
5285                 error "$LFS getstripe -v $dir: "\
5286                       "got $filenum want $((numfiles * numcomp)) lmm_fid"
5287         [[ $($LFS getstripe $dir | grep -c lmm_fid) -eq 0 ]] ||
5288                 error "$LFS getstripe $dir: showed lmm_fid by default"
5289         echo "$LFS getstripe --verbose passed"
5290
5291         #check for FID information
5292         local fid1=$($LFS getstripe --fid $dir/file1)
5293         local fid2=$($LFS getstripe --verbose $dir/file1 |
5294                      awk '/lmm_fid: / { print $2; exit; }')
5295         local fid3=$($LFS path2fid $dir/file1)
5296
5297         [ "$fid1" != "$fid2" ] &&
5298                 error "getstripe --fid '$fid1' != getstripe --verbose '$fid2'"
5299         [ "$fid1" != "$fid3" ] &&
5300                 error "getstripe --fid '$fid1' != lfs path2fid '$fid3'"
5301         echo "$LFS getstripe --fid passed"
5302
5303         #test lfs getstripe with --obd
5304         $LFS getstripe --obd wrong_uuid $dir 2>&1 | grep -q "unknown obduuid" ||
5305                 error "$LFS getstripe --obd wrong_uuid: should return error"
5306
5307         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
5308
5309         local ostidx=1
5310         local obduuid=$(ostuuid_from_index $ostidx)
5311         local found=$($LFS getstripe -r --obd $obduuid $dir |
5312                 grep 'lmm_stripe_offset:' | grep -c " $ostidx\$")
5313
5314         filenum=$($LFS getstripe -ir $dir | grep -c "^$ostidx\$")
5315         [[ $($LFS getstripe -id $dir) -ne $ostidx ]] ||
5316                 ((filenum--))
5317         [[ $($LFS getstripe -id $dir/dir) -ne $ostidx ]] ||
5318                 ((filenum--))
5319
5320         [[ $found -eq $filenum ]] ||
5321                 error "$LFS getstripe --obd: found $found expect $filenum"
5322         [[ $($LFS getstripe -r -v --obd $obduuid $dir |
5323                 sed '/^[         ]*'${ostidx}'[  ]/d' |
5324                 sed -n '/^[      ]*[0-9][0-9]*[  ]/p' | wc -l) -eq 0 ]] ||
5325                 error "$LFS getstripe --obd: should not show file on other obd"
5326         echo "$LFS getstripe --obd passed"
5327 }
5328 run_test 56a "check $LFS getstripe"
5329
5330 test_56b() {
5331         local dir=$DIR/$tdir
5332         local numdirs=3
5333
5334         test_mkdir $dir
5335         for i in $(seq $numdirs); do
5336                 test_mkdir $dir/dir$i
5337         done
5338
5339         # test lfs getdirstripe default mode is non-recursion, which is
5340         # different from lfs getstripe
5341         local dircnt=$($LFS getdirstripe $dir | grep -c lmv_stripe_count)
5342
5343         [[ $dircnt -eq 1 ]] ||
5344                 error "$LFS getdirstripe: found $dircnt, not 1"
5345         dircnt=$($LFS getdirstripe --recursive $dir |
5346                 grep -c lmv_stripe_count)
5347         [[ $dircnt -eq $((numdirs + 1)) ]] ||
5348                 error "$LFS getdirstripe -r: $dircnt, != $((numdirs + 1))"
5349 }
5350 run_test 56b "check $LFS getdirstripe"
5351
5352 test_56c() {
5353         remote_ost_nodsh && skip "remote OST with nodsh"
5354
5355         local ost_idx=0
5356         local ost_name=$(ostname_from_index $ost_idx)
5357         local old_status=$(ost_dev_status $ost_idx)
5358
5359         [[ -z "$old_status" ]] ||
5360                 skip_env "OST $ost_name is in $old_status status"
5361
5362         do_facet ost1 $LCTL set_param -n obdfilter.$ost_name.degraded=1
5363         sleep_maxage
5364
5365         local new_status=$(ost_dev_status $ost_idx)
5366
5367         [[ "$new_status" = "D" ]] ||
5368                 error "OST $ost_name is in status of '$new_status', not 'D'"
5369
5370         do_facet ost1 $LCTL set_param -n obdfilter.$ost_name.degraded=0
5371         sleep_maxage
5372
5373         new_status=$(ost_dev_status $ost_idx)
5374         [[ -z "$new_status" ]] ||
5375                 error "OST $ost_name is in status of '$new_status', not ''"
5376 }
5377 run_test 56c "check 'lfs df' showing device status"
5378
5379 NUMFILES=3
5380 NUMDIRS=3
5381 setup_56() {
5382         local local_tdir="$1"
5383         local local_numfiles="$2"
5384         local local_numdirs="$3"
5385         local dir_params="$4"
5386         local dir_stripe_params="$5"
5387
5388         if [ ! -d "$local_tdir" ] ; then
5389                 test_mkdir -p $dir_stripe_params $local_tdir
5390                 [ "$dir_params" ] && $LFS setstripe $dir_params $local_tdir
5391                 for i in $(seq $local_numfiles) ; do
5392                         touch $local_tdir/file$i
5393                 done
5394                 for i in $(seq $local_numdirs) ; do
5395                         test_mkdir $dir_stripe_params $local_tdir/dir$i
5396                         for j in $(seq $local_numfiles) ; do
5397                                 touch $local_tdir/dir$i/file$j
5398                         done
5399                 done
5400         fi
5401 }
5402
5403 setup_56_special() {
5404         local local_tdir=$1
5405         local local_numfiles=$2
5406         local local_numdirs=$3
5407
5408         setup_56 $local_tdir $local_numfiles $local_numdirs
5409
5410         if [ ! -e "$local_tdir/loop${local_numfiles}b" ] ; then
5411                 for i in $(seq $local_numfiles) ; do
5412                         mknod $local_tdir/loop${i}b b 7 $i
5413                         mknod $local_tdir/null${i}c c 1 3
5414                         ln -s $local_tdir/file1 $local_tdir/link${i}
5415                 done
5416                 for i in $(seq $local_numdirs) ; do
5417                         mknod $local_tdir/dir$i/loop${i}b b 7 $i
5418                         mknod $local_tdir/dir$i/null${i}c c 1 3
5419                         ln -s $local_tdir/dir$i/file1 $local_tdir/dir$i/link${i}
5420                 done
5421         fi
5422 }
5423
5424 test_56g() {
5425         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5426         local expected=$(($NUMDIRS + 2))
5427
5428         setup_56 $dir $NUMFILES $NUMDIRS
5429
5430         # test lfs find with -name
5431         for i in $(seq $NUMFILES) ; do
5432                 local nums=$($LFS find -name "*$i" $dir | wc -l)
5433
5434                 [ $nums -eq $expected ] ||
5435                         error "lfs find -name '*$i' $dir wrong: "\
5436                               "found $nums, expected $expected"
5437         done
5438 }
5439 run_test 56g "check lfs find -name"
5440
5441 test_56h() {
5442         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5443         local expected=$(((NUMDIRS + 1) * (NUMFILES - 1) + NUMFILES))
5444
5445         setup_56 $dir $NUMFILES $NUMDIRS
5446
5447         # test lfs find with ! -name
5448         for i in $(seq $NUMFILES) ; do
5449                 local nums=$($LFS find ! -name "*$i" $dir | wc -l)
5450
5451                 [ $nums -eq $expected ] ||
5452                         error "lfs find ! -name '*$i' $dir wrong: "\
5453                               "found $nums, expected $expected"
5454         done
5455 }
5456 run_test 56h "check lfs find ! -name"
5457
5458 test_56i() {
5459         local dir=$DIR/$tdir
5460
5461         test_mkdir $dir
5462
5463         local cmd="$LFS find -ost $(ostuuid_from_index 0 $dir) $dir"
5464         local out=$($cmd)
5465
5466         [ -z "$out" ] || error "'$cmd' returned directory '$out'"
5467 }
5468 run_test 56i "check 'lfs find -ost UUID' skips directories"
5469
5470 test_56j() {
5471         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5472
5473         setup_56_special $dir $NUMFILES $NUMDIRS
5474
5475         local expected=$((NUMDIRS + 1))
5476         local cmd="$LFS find -type d $dir"
5477         local nums=$($cmd | wc -l)
5478
5479         [ $nums -eq $expected ] ||
5480                 error "'$cmd' wrong: found $nums, expected $expected"
5481 }
5482 run_test 56j "check lfs find -type d"
5483
5484 test_56k() {
5485         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5486
5487         setup_56_special $dir $NUMFILES $NUMDIRS
5488
5489         local expected=$(((NUMDIRS + 1) * NUMFILES))
5490         local cmd="$LFS find -type f $dir"
5491         local nums=$($cmd | wc -l)
5492
5493         [ $nums -eq $expected ] ||
5494                 error "'$cmd' wrong: found $nums, expected $expected"
5495 }
5496 run_test 56k "check lfs find -type f"
5497
5498 test_56l() {
5499         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5500
5501         setup_56_special $dir $NUMFILES $NUMDIRS
5502
5503         local expected=$((NUMDIRS + NUMFILES))
5504         local cmd="$LFS find -type b $dir"
5505         local nums=$($cmd | wc -l)
5506
5507         [ $nums -eq $expected ] ||
5508                 error "'$cmd' wrong: found $nums, expected $expected"
5509 }
5510 run_test 56l "check lfs find -type b"
5511
5512 test_56m() {
5513         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5514
5515         setup_56_special $dir $NUMFILES $NUMDIRS
5516
5517         local expected=$((NUMDIRS + NUMFILES))
5518         local cmd="$LFS find -type c $dir"
5519         local nums=$($cmd | wc -l)
5520         [ $nums -eq $expected ] ||
5521                 error "'$cmd' wrong: found $nums, expected $expected"
5522 }
5523 run_test 56m "check lfs find -type c"
5524
5525 test_56n() {
5526         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5527         setup_56_special $dir $NUMFILES $NUMDIRS
5528
5529         local expected=$((NUMDIRS + NUMFILES))
5530         local cmd="$LFS find -type l $dir"
5531         local nums=$($cmd | wc -l)
5532
5533         [ $nums -eq $expected ] ||
5534                 error "'$cmd' wrong: found $nums, expected $expected"
5535 }
5536 run_test 56n "check lfs find -type l"
5537
5538 test_56o() {
5539         local dir=$DIR/$tdir
5540
5541         setup_56 $dir $NUMFILES $NUMDIRS
5542         utime $dir/file1 > /dev/null || error "utime (1)"
5543         utime $dir/file2 > /dev/null || error "utime (2)"
5544         utime $dir/dir1 > /dev/null || error "utime (3)"
5545         utime $dir/dir2 > /dev/null || error "utime (4)"
5546         utime $dir/dir1/file1 > /dev/null || error "utime (5)"
5547         dd if=/dev/zero count=1 >> $dir/dir1/file1 && sync
5548
5549         local expected=4
5550         local nums=$($LFS find -mtime +0 $dir | wc -l)
5551
5552         [ $nums -eq $expected ] ||
5553                 error "lfs find -mtime +0 $dir: found $nums expect $expected"
5554
5555         expected=12
5556         cmd="$LFS find -mtime 0 $dir"
5557         nums=$($cmd | wc -l)
5558         [ $nums -eq $expected ] ||
5559                 error "'$cmd' wrong: found $nums, expected $expected"
5560 }
5561 run_test 56o "check lfs find -mtime for old files"
5562
5563 test_56ob() {
5564         local dir=$DIR/$tdir
5565         local expected=1
5566         local count=0
5567
5568         # just to make sure there is something that won't be found
5569         test_mkdir $dir
5570         touch $dir/$tfile.now
5571
5572         for age in year week day hour min; do
5573                 count=$((count + 1))
5574
5575                 touch $dir/$tfile-a.$age $dir/$tfile-m.$age
5576                 touch --date="$count $age ago" -a $dir/$tfile-a.$age
5577                 touch --date="$count $age ago" -m $dir/$tfile-m.$age
5578
5579                 local cmd="$LFS find $dir -mtime $count${age:0:1}"
5580                 local nums=$($cmd | wc -l)
5581                 [ $nums -eq $expected ] ||
5582                         error "'$cmd' wrong: found $nums, expected $expected"
5583
5584                 cmd="$LFS find $dir -atime $count${age:0:1}"
5585                 nums=$($cmd | wc -l)
5586                 [ $nums -eq $expected ] ||
5587                         error "'$cmd' wrong: found $nums, expected $expected"
5588         done
5589
5590         sleep 2
5591         cmd="$LFS find $dir -ctime +1s -type f"
5592         nums=$($cmd | wc -l)
5593         (( $nums == $count * 2 + 1)) ||
5594                 error "'$cmd' wrong: found $nums, expected $((expected*2+1))"
5595 }
5596 run_test 56ob "check lfs find -atime -mtime -ctime with units"
5597
5598 test_56p() {
5599         [ $RUNAS_ID -eq $UID ] &&
5600                 skip_env "RUNAS_ID = UID = $UID -- skipping"
5601
5602         local dir=$DIR/$tdir
5603
5604         setup_56 $dir $NUMFILES $NUMDIRS
5605         chown $RUNAS_ID $dir/file* || error "chown $DIR/${tdir}g/file$i failed"
5606
5607         local expected=$NUMFILES
5608         local cmd="$LFS find -uid $RUNAS_ID $dir"
5609         local nums=$($cmd | wc -l)
5610
5611         [ $nums -eq $expected ] ||
5612                 error "'$cmd' wrong: found $nums, expected $expected"
5613
5614         expected=$(((NUMFILES + 1) * NUMDIRS + 1))
5615         cmd="$LFS find ! -uid $RUNAS_ID $dir"
5616         nums=$($cmd | wc -l)
5617         [ $nums -eq $expected ] ||
5618                 error "'$cmd' wrong: found $nums, expected $expected"
5619 }
5620 run_test 56p "check lfs find -uid and ! -uid"
5621
5622 test_56q() {
5623         [ $RUNAS_ID -eq $UID ] &&
5624                 skip_env "RUNAS_ID = UID = $UID -- skipping"
5625
5626         local dir=$DIR/$tdir
5627
5628         setup_56 $dir $NUMFILES $NUMDIRS
5629         chgrp $RUNAS_GID $dir/file* || error "chown $dir/file$i failed"
5630
5631         local expected=$NUMFILES
5632         local cmd="$LFS find -gid $RUNAS_GID $dir"
5633         local nums=$($cmd | wc -l)
5634
5635         [ $nums -eq $expected ] ||
5636                 error "'$cmd' wrong: found $nums, expected $expected"
5637
5638         expected=$(( ($NUMFILES+1) * $NUMDIRS + 1))
5639         cmd="$LFS find ! -gid $RUNAS_GID $dir"
5640         nums=$($cmd | wc -l)
5641         [ $nums -eq $expected ] ||
5642                 error "'$cmd' wrong: found $nums, expected $expected"
5643 }
5644 run_test 56q "check lfs find -gid and ! -gid"
5645
5646 test_56r() {
5647         local dir=$DIR/$tdir
5648
5649         setup_56 $dir $NUMFILES $NUMDIRS
5650
5651         local expected=12
5652         local cmd="$LFS find -size 0 -type f $dir"
5653         local nums=$($cmd | wc -l)
5654
5655         [ $nums -eq $expected ] ||
5656                 error "'$cmd' wrong: found $nums, expected $expected"
5657         expected=0
5658         cmd="$LFS find ! -size 0 -type f $dir"
5659         nums=$($cmd | wc -l)
5660         [ $nums -eq $expected ] ||
5661                 error "'$cmd' wrong: found $nums, expected $expected"
5662         echo "test" > $dir/$tfile
5663         echo "test2" > $dir/$tfile.2 && sync
5664         expected=1
5665         cmd="$LFS find -size 5 -type f $dir"
5666         nums=$($cmd | wc -l)
5667         [ $nums -eq $expected ] ||
5668                 error "'$cmd' wrong: found $nums, expected $expected"
5669         expected=1
5670         cmd="$LFS find -size +5 -type f $dir"
5671         nums=$($cmd | wc -l)
5672         [ $nums -eq $expected ] ||
5673                 error "'$cmd' wrong: found $nums, expected $expected"
5674         expected=2
5675         cmd="$LFS find -size +0 -type f $dir"
5676         nums=$($cmd | wc -l)
5677         [ $nums -eq $expected ] ||
5678                 error "'$cmd' wrong: found $nums, expected $expected"
5679         expected=2
5680         cmd="$LFS find ! -size -5 -type f $dir"
5681         nums=$($cmd | wc -l)
5682         [ $nums -eq $expected ] ||
5683                 error "'$cmd' wrong: found $nums, expected $expected"
5684         expected=12
5685         cmd="$LFS find -size -5 -type f $dir"
5686         nums=$($cmd | wc -l)
5687         [ $nums -eq $expected ] ||
5688                 error "'$cmd' wrong: found $nums, expected $expected"
5689 }
5690 run_test 56r "check lfs find -size works"
5691
5692 test_56s() { # LU-611 #LU-9369
5693         [[ $OSTCOUNT -lt 2 ]] && skip_env "need at least 2 OSTs"
5694
5695         local dir=$DIR/$tdir
5696         local onestripe=$(((NUMDIRS + 1) * NUMFILES))
5697
5698         setup_56 $dir $NUMFILES $NUMDIRS "-c 1"
5699         for i in $(seq $NUMDIRS); do
5700                 $LFS setstripe -c $((OSTCOUNT + 1)) $dir/dir$i/$tfile
5701         done
5702
5703         local expected=$NUMDIRS
5704         local cmd="$LFS find -c $OSTCOUNT $dir"
5705         local nums=$($cmd | wc -l)
5706
5707         [ $nums -eq $expected ] || {
5708                 $LFS getstripe -R $dir
5709                 error "'$cmd' wrong: found $nums, expected $expected"
5710         }
5711
5712         expected=$((NUMDIRS + onestripe))
5713         cmd="$LFS find -stripe-count +0 -type f $dir"
5714         nums=$($cmd | wc -l)
5715         [ $nums -eq $expected ] || {
5716                 $LFS getstripe -R $dir
5717                 error "'$cmd' wrong: found $nums, expected $expected"
5718         }
5719
5720         expected=$onestripe
5721         cmd="$LFS find -stripe-count 1 -type f $dir"
5722         nums=$($cmd | wc -l)
5723         [ $nums -eq $expected ] || {
5724                 $LFS getstripe -R $dir
5725                 error "'$cmd' wrong: found $nums, expected $expected"
5726         }
5727
5728         cmd="$LFS find -stripe-count -2 -type f $dir"
5729         nums=$($cmd | wc -l)
5730         [ $nums -eq $expected ] || {
5731                 $LFS getstripe -R $dir
5732                 error "'$cmd' wrong: found $nums, expected $expected"
5733         }
5734
5735         expected=0
5736         cmd="$LFS find -stripe-count $((OSTCOUNT + 1)) -type f $dir"
5737         nums=$($cmd | wc -l)
5738         [ $nums -eq $expected ] || {
5739                 $LFS getstripe -R $dir
5740                 error "'$cmd' wrong: found $nums, expected $expected"
5741         }
5742 }
5743 run_test 56s "check lfs find -stripe-count works"
5744
5745 test_56t() { # LU-611 #LU-9369
5746         local dir=$DIR/$tdir
5747
5748         setup_56 $dir 0 $NUMDIRS
5749         for i in $(seq $NUMDIRS); do
5750                 $LFS setstripe -S 8M $dir/dir$i/$tfile
5751         done
5752
5753         local expected=$NUMDIRS
5754         local cmd="$LFS find -S 8M $dir"
5755         local nums=$($cmd | wc -l)
5756
5757         [ $nums -eq $expected ] || {
5758                 $LFS getstripe -R $dir
5759                 error "'$cmd' wrong: found $nums, expected $expected"
5760         }
5761         rm -rf $dir
5762
5763         setup_56 $dir $NUMFILES $NUMDIRS "--stripe-size 512k"
5764
5765         $LFS setstripe -S 256k $dir/$tfile.{0,1,2,3}
5766
5767         expected=$(((NUMDIRS + 1) * NUMFILES))
5768         cmd="$LFS find -stripe-size 512k -type f $dir"
5769         nums=$($cmd | wc -l)
5770         [ $nums -eq $expected ] ||
5771                 error "'$cmd' wrong: found $nums, expected $expected"
5772
5773         cmd="$LFS find -stripe-size +320k -type f $dir"
5774         nums=$($cmd | wc -l)
5775         [ $nums -eq $expected ] ||
5776                 error "'$cmd' wrong: found $nums, expected $expected"
5777
5778         expected=$(((NUMDIRS + 1) * NUMFILES + 4))
5779         cmd="$LFS find -stripe-size +200k -type f $dir"
5780         nums=$($cmd | wc -l)
5781         [ $nums -eq $expected ] ||
5782                 error "'$cmd' wrong: found $nums, expected $expected"
5783
5784         cmd="$LFS find -stripe-size -640k -type f $dir"
5785         nums=$($cmd | wc -l)
5786         [ $nums -eq $expected ] ||
5787                 error "'$cmd' wrong: found $nums, expected $expected"
5788
5789         expected=4
5790         cmd="$LFS find -stripe-size 256k -type f $dir"
5791         nums=$($cmd | wc -l)
5792         [ $nums -eq $expected ] ||
5793                 error "'$cmd' wrong: found $nums, expected $expected"
5794
5795         cmd="$LFS find -stripe-size -320k -type f $dir"
5796         nums=$($cmd | wc -l)
5797         [ $nums -eq $expected ] ||
5798                 error "'$cmd' wrong: found $nums, expected $expected"
5799
5800         expected=0
5801         cmd="$LFS find -stripe-size 1024k -type f $dir"
5802         nums=$($cmd | wc -l)
5803         [ $nums -eq $expected ] ||
5804                 error "'$cmd' wrong: found $nums, expected $expected"
5805 }
5806 run_test 56t "check lfs find -stripe-size works"
5807
5808 test_56u() { # LU-611
5809         local dir=$DIR/$tdir
5810
5811         setup_56 $dir $NUMFILES $NUMDIRS "-i 0 -c 1"
5812
5813         if [[ $OSTCOUNT -gt 1 ]]; then
5814                 $LFS setstripe -i 1 -c 1 $dir/$tfile.{0,1,2,3}
5815                 onestripe=4
5816         else
5817                 onestripe=0
5818         fi
5819
5820         local expected=$(((NUMDIRS + 1) * NUMFILES))
5821         local cmd="$LFS find -stripe-index 0 -type f $dir"
5822         local nums=$($cmd | wc -l)
5823
5824         [ $nums -eq $expected ] ||
5825                 error "'$cmd' wrong: found $nums, expected $expected"
5826
5827         expected=$onestripe
5828         cmd="$LFS find -stripe-index 1 -type f $dir"
5829         nums=$($cmd | wc -l)
5830         [ $nums -eq $expected ] ||
5831                 error "'$cmd' wrong: found $nums, expected $expected"
5832
5833         cmd="$LFS find ! -stripe-index 0 -type f $dir"
5834         nums=$($cmd | wc -l)
5835         [ $nums -eq $expected ] ||
5836                 error "'$cmd' wrong: found $nums, expected $expected"
5837
5838         expected=0
5839         # This should produce an error and not return any files
5840         cmd="$LFS find -stripe-index $OSTCOUNT -type f $dir"
5841         nums=$($cmd 2>/dev/null | wc -l)
5842         [ $nums -eq $expected ] ||
5843                 error "'$cmd' wrong: found $nums, expected $expected"
5844
5845         if [[ $OSTCOUNT -gt 1 ]]; then
5846                 expected=$(((NUMDIRS + 1) * NUMFILES + onestripe))
5847                 cmd="$LFS find -stripe-index 0,1 -type f $dir"
5848                 nums=$($cmd | wc -l)
5849                 [ $nums -eq $expected ] ||
5850                         error "'$cmd' wrong: found $nums, expected $expected"
5851         fi
5852 }
5853 run_test 56u "check lfs find -stripe-index works"
5854
5855 test_56v() {
5856         local mdt_idx=0
5857         local dir=$DIR/$tdir
5858
5859         setup_56 $dir $NUMFILES $NUMDIRS
5860
5861         UUID=$(mdtuuid_from_index $mdt_idx $dir)
5862         [ -z "$UUID" ] && error "mdtuuid_from_index cannot find MDT $mdt_idx"
5863
5864         for file in $($LFS find -m $UUID $dir); do
5865                 file_midx=$($LFS getstripe -m $file)
5866                 [ $file_midx -eq $mdt_idx ] ||
5867                         error "lfs find -m $UUID != getstripe -m $file_midx"
5868         done
5869 }
5870 run_test 56v "check 'lfs find -m match with lfs getstripe -m'"
5871
5872 test_56w() {
5873         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
5874         [ $PARALLEL == "yes" ] && skip "skip parallel run"
5875
5876         local dir=$DIR/$tdir
5877
5878         setup_56 $dir $NUMFILES $NUMDIRS "-c $OSTCOUNT" "-c1"
5879
5880         local stripe_size=$($LFS getstripe -S -d $dir) ||
5881                 error "$LFS getstripe -S -d $dir failed"
5882         stripe_size=${stripe_size%% *}
5883
5884         local file_size=$((stripe_size * OSTCOUNT))
5885         local file_num=$((NUMDIRS * NUMFILES + NUMFILES))
5886         local required_space=$((file_num * file_size))
5887         local free_space=$($LCTL get_param -n lov.$FSNAME-clilov-*.kbytesavail |
5888                            head -n1)
5889         [[ $free_space -le $((required_space / 1024)) ]] &&
5890                 skip_env "need $required_space, have $free_space kbytes"
5891
5892         local dd_bs=65536
5893         local dd_count=$((file_size / dd_bs))
5894
5895         # write data into the files
5896         local i
5897         local j
5898         local file
5899
5900         for i in $(seq $NUMFILES); do
5901                 file=$dir/file$i
5902                 yes | dd bs=$dd_bs count=$dd_count of=$file &>/dev/null ||
5903                         error "write data into $file failed"
5904         done
5905         for i in $(seq $NUMDIRS); do
5906                 for j in $(seq $NUMFILES); do
5907                         file=$dir/dir$i/file$j
5908                         yes|dd bs=$dd_bs count=$dd_count of=$file &>/dev/null ||
5909                                 error "write data into $file failed"
5910                 done
5911         done
5912
5913         # $LFS_MIGRATE will fail if hard link migration is unsupported
5914         if [[ $(lustre_version_code mds1) -gt $(version_code 2.5.55) ]]; then
5915                 createmany -l$dir/dir1/file1 $dir/dir1/link 200 ||
5916                         error "creating links to $dir/dir1/file1 failed"
5917         fi
5918
5919         local expected=-1
5920
5921         [[ $OSTCOUNT -gt 1 ]] && expected=$((OSTCOUNT - 1))
5922
5923         # lfs_migrate file
5924         local cmd="$LFS_MIGRATE -y -c $expected $dir/file1"
5925
5926         echo "$cmd"
5927         eval $cmd || error "$cmd failed"
5928
5929         check_stripe_count $dir/file1 $expected
5930
5931         if [ $MDS1_VERSION -ge $(version_code 2.6.90) ];
5932         then
5933                 # lfs_migrate file onto OST 0 if it is on OST 1, or onto
5934                 # OST 1 if it is on OST 0. This file is small enough to
5935                 # be on only one stripe.
5936                 file=$dir/migr_1_ost
5937                 dd bs=$dd_bs count=1 if=/dev/urandom of=$file >/dev/null 2>&1 ||
5938                         error "write data into $file failed"
5939                 local obdidx=$($LFS getstripe -i $file)
5940                 local oldmd5=$(md5sum $file)
5941                 local newobdidx=0
5942
5943                 [[ $obdidx -eq 0 ]] && newobdidx=1
5944                 cmd="$LFS migrate -i $newobdidx $file"
5945                 echo $cmd
5946                 eval $cmd || error "$cmd failed"
5947
5948                 local realobdix=$($LFS getstripe -i $file)
5949                 local newmd5=$(md5sum $file)
5950
5951                 [[ $newobdidx -ne $realobdix ]] &&
5952                         error "new OST is different (was=$obdidx, "\
5953                               "wanted=$newobdidx, got=$realobdix)"
5954                 [[ "$oldmd5" != "$newmd5" ]] &&
5955                         error "md5sum differ: $oldmd5, $newmd5"
5956         fi
5957
5958         # lfs_migrate dir
5959         cmd="$LFS_MIGRATE -y -c $expected $dir/dir1"
5960         echo "$cmd"
5961         eval $cmd || error "$cmd failed"
5962
5963         for j in $(seq $NUMFILES); do
5964                 check_stripe_count $dir/dir1/file$j $expected
5965         done
5966
5967         # lfs_migrate works with lfs find
5968         cmd="$LFS find -stripe_count $OSTCOUNT -type f $dir |
5969              $LFS_MIGRATE -y -c $expected"
5970         echo "$cmd"
5971         eval $cmd || error "$cmd failed"
5972
5973         for i in $(seq 2 $NUMFILES); do
5974                 check_stripe_count $dir/file$i $expected
5975         done
5976         for i in $(seq 2 $NUMDIRS); do
5977                 for j in $(seq $NUMFILES); do
5978                 check_stripe_count $dir/dir$i/file$j $expected
5979                 done
5980         done
5981 }
5982 run_test 56w "check lfs_migrate -c stripe_count works"
5983
5984 test_56wb() {
5985         local file1=$DIR/$tdir/file1
5986         local create_pool=false
5987         local initial_pool=$($LFS getstripe -p $DIR)
5988         local pool_list=()
5989         local pool=""
5990
5991         echo -n "Creating test dir..."
5992         test_mkdir $DIR/$tdir &> /dev/null || error "cannot create dir"
5993         echo "done."
5994
5995         echo -n "Creating test file..."
5996         touch $file1 || error "cannot create file"
5997         echo "done."
5998
5999         echo -n "Detecting existing pools..."
6000         pool_list=($($LFS pool_list $FSNAME | grep "$FSNAME\." | cut -d. -f2))
6001
6002         if [ ${#pool_list[@]} -gt 0 ]; then
6003                 echo "${pool_list[@]}"
6004                 for thispool in "${pool_list[@]}"; do
6005                         if [[ -z "$initial_pool" ||
6006                               "$initial_pool" != "$thispool" ]]; then
6007                                 pool="$thispool"
6008                                 echo "Using existing pool '$pool'"
6009                                 break
6010                         fi
6011                 done
6012         else
6013                 echo "none detected."
6014         fi
6015         if [ -z "$pool" ]; then
6016                 pool=${POOL:-testpool}
6017                 [ "$initial_pool" = "$pool" ] && pool="testpool2"
6018                 echo -n "Creating pool '$pool'..."
6019                 create_pool=true
6020                 pool_add $pool &> /dev/null ||
6021                         error "pool_add failed"
6022                 echo "done."
6023
6024                 echo -n "Adding target to pool..."
6025                 pool_add_targets $pool 0 0 1 &> /dev/null ||
6026                         error "pool_add_targets failed"
6027                 echo "done."
6028         fi
6029
6030         echo -n "Setting pool using -p option..."
6031         $LFS_MIGRATE -y -q --no-rsync -p $pool $file1 &> /dev/null ||
6032                 error "migrate failed rc = $?"
6033         echo "done."
6034
6035         echo -n "Verifying test file is in pool after migrating..."
6036         [ "$($LFS getstripe -p $file1)" = $pool ] ||
6037                 error "file was not migrated to pool $pool"
6038         echo "done."
6039
6040         echo -n "Removing test file from pool '$pool'..."
6041         $LFS migrate $file1 &> /dev/null ||
6042                 error "cannot remove from pool"
6043         [ "$($LFS getstripe -p $file1)" ] &&
6044                 error "pool still set"
6045         echo "done."
6046
6047         echo -n "Setting pool using --pool option..."
6048         $LFS_MIGRATE -y -q --no-rsync --pool $pool $file1 &> /dev/null ||
6049                 error "migrate failed rc = $?"
6050         echo "done."
6051
6052         # Clean up
6053         rm -f $file1
6054         if $create_pool; then
6055                 destroy_test_pools 2> /dev/null ||
6056                         error "destroy test pools failed"
6057         fi
6058 }
6059 run_test 56wb "check lfs_migrate pool support"
6060
6061 test_56wc() {
6062         local file1="$DIR/$tdir/file1"
6063
6064         echo -n "Creating test dir..."
6065         test_mkdir $DIR/$tdir &> /dev/null || error "cannot create dir"
6066         local def_stripe_size=$($LFS getstripe -S $DIR/$tdir 2>/dev/null)
6067         $LFS setstripe -S 1M -c 1 "$DIR/$tdir" &> /dev/null ||
6068                 error "cannot set stripe"
6069         echo "done"
6070
6071         echo -n "Setting initial stripe for test file..."
6072         $LFS setstripe -S 512K -c 1 "$file1" &> /dev/null ||
6073                 error "cannot set stripe"
6074         [ $($LFS getstripe -S "$file1") -eq 524288 ] ||
6075                 error "stripe size not set"
6076         echo "done."
6077
6078         # File currently set to -S 512K -c 1
6079
6080         # Ensure -c and -S options are rejected when -R is set
6081         echo -n "Verifying incompatible options are detected..."
6082         $LFS_MIGRATE -y -R -c 1 "$file1" &> /dev/null &&
6083                 error "incompatible -c and -R options not detected"
6084         $LFS_MIGRATE -y -R -S 1M "$file1" &> /dev/null &&
6085                 error "incompatible -S and -R options not detected"
6086         echo "done."
6087
6088         # Ensure unrecognized options are passed through to 'lfs migrate'
6089         echo -n "Verifying -S option is passed through to lfs migrate..."
6090         $LFS_MIGRATE -y -S 1M "$file1" &> /dev/null ||
6091                 error "migration failed"
6092         [ $($LFS getstripe -S "$file1") -eq 1048576 ] ||
6093                 error "file was not restriped"
6094         echo "done."
6095
6096         # File currently set to -S 1M -c 1
6097
6098         # Ensure long options are supported
6099         echo -n "Verifying long options supported..."
6100         $LFS_MIGRATE -y --non-block "$file1" &> /dev/null ||
6101                 error "long option without argument not supported"
6102         $LFS_MIGRATE -y --stripe-size 512K "$file1" &> /dev/null ||
6103                 error "long option with argument not supported"
6104         [ $($LFS getstripe -S "$file1") -eq 524288 ] ||
6105                 error "file not restriped with --stripe-size option"
6106         echo "done."
6107
6108         # File currently set to -S 512K -c 1
6109
6110         if [ "$OSTCOUNT" -gt 1 ]; then
6111                 echo -n "Verifying explicit stripe count can be set..."
6112                 $LFS_MIGRATE -y -c 2 "$file1" &> /dev/null ||
6113                         error "migrate failed"
6114                 [ $($LFS getstripe -c "$file1") -eq 2 ] ||
6115                         error "file not restriped to explicit count"
6116                 echo "done."
6117         fi
6118
6119         # File currently set to -S 512K -c 1 or -S 512K -c 2
6120
6121         # Ensure parent striping is used if -R is set, and no stripe
6122         # count or size is specified
6123         echo -n "Setting stripe for parent directory..."
6124         $LFS setstripe -S 1M -c 1 "$DIR/$tdir" &> /dev/null ||
6125                 error "cannot set stripe"
6126         echo "done."
6127
6128         echo -n "Verifying restripe option uses parent stripe settings..."
6129         $LFS_MIGRATE -y -R "$file1" &> /dev/null ||
6130                 error "migrate failed"
6131         [ $($LFS getstripe -S "$file1") -eq $def_stripe_size ] ||
6132                 error "file not restriped to parent settings"
6133         [ $($LFS getstripe -c "$file1") -eq 1 ] ||
6134                 error "file not restriped to parent settings"
6135         echo "done."
6136
6137         # File currently set to -S 1M -c 1
6138
6139         # Ensure striping is preserved if -R is not set, and no stripe
6140         # count or size is specified
6141         echo -n "Verifying striping size preserved when not specified..."
6142         local orig_stripe_size=$($LFS getstripe -S "$file1" 2>/dev/null)
6143         $LFS setstripe -S 2M -c 1 "$DIR/$tdir" &> /dev/null ||
6144                 error "cannot set stripe on parent directory"
6145         $LFS_MIGRATE -y "$file1" &> /dev/null ||
6146                 error "migrate failed"
6147         [ $($LFS getstripe -S "$file1") -eq $orig_stripe_size ] ||
6148                 error "file was restriped"
6149         echo "done."
6150
6151         # Ensure file name properly detected when final option has no argument
6152         echo -n "Verifying file name properly detected..."
6153         $LFS_MIGRATE -y "$file1" &> /dev/null ||
6154                 error "file name interpreted as option argument"
6155         echo "done."
6156
6157         # Clean up
6158         rm -f "$file1"
6159 }
6160 run_test 56wc "check unrecognized options for lfs_migrate are passed through"
6161
6162 test_56wd() {
6163         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
6164
6165         local file1=$DIR/$tdir/file1
6166
6167         echo -n "Creating test dir..."
6168         test_mkdir $DIR/$tdir || error "cannot create dir"
6169         echo "done."
6170
6171         echo -n "Creating test file..."
6172         touch $file1
6173         echo "done."
6174
6175         # Ensure 'lfs migrate' will fail by using a non-existent option,
6176         # and make sure rsync is not called to recover
6177         echo -n "Make sure --no-rsync option works..."
6178         $LFS_MIGRATE -y --no-rsync --invalid-opt $file1 2>&1 |
6179                 grep -q 'refusing to fall back to rsync' ||
6180                 error "rsync was called with --no-rsync set"
6181         echo "done."
6182
6183         # Ensure rsync is called without trying 'lfs migrate' first
6184         echo -n "Make sure --rsync option works..."
6185         $LFS_MIGRATE -y --rsync --invalid-opt $file1 2>&1 |
6186                 grep -q 'falling back to rsync' &&
6187                 error "lfs migrate was called with --rsync set"
6188         echo "done."
6189
6190         echo -n "Make sure --rsync and --no-rsync options are exclusive..."
6191         $LFS_MIGRATE -y --rsync --no-rsync $file1 2>&1 |
6192                 grep -q 'at the same time' ||
6193                 error "--rsync and --no-rsync accepted concurrently"
6194         echo "done."
6195
6196         # Clean up
6197         rm -f $file1
6198 }
6199 run_test 56wd "check lfs_migrate --rsync and --no-rsync work"
6200
6201 test_56x() {
6202         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
6203         check_swap_layouts_support
6204
6205         local dir=$DIR/$tdir
6206         local ref1=/etc/passwd
6207         local file1=$dir/file1
6208
6209         test_mkdir $dir || error "creating dir $dir"
6210         $LFS setstripe -c 2 $file1
6211         cp $ref1 $file1
6212         $LFS migrate -c 1 $file1 || error "migrate failed rc = $?"
6213         stripe=$($LFS getstripe -c $file1)
6214         [[ $stripe == 1 ]] || error "stripe of $file1 is $stripe != 1"
6215         cmp $file1 $ref1 || error "content mismatch $file1 differs from $ref1"
6216
6217         # clean up
6218         rm -f $file1
6219 }
6220 run_test 56x "lfs migration support"
6221
6222 test_56xa() {
6223         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
6224         check_swap_layouts_support
6225
6226         local dir=$DIR/$tdir/$testnum
6227
6228         test_mkdir -p $dir
6229
6230         local ref1=/etc/passwd
6231         local file1=$dir/file1
6232
6233         $LFS setstripe -c 2 $file1
6234         cp $ref1 $file1
6235         $LFS migrate --block -c 1 $file1 || error "migrate failed rc = $?"
6236
6237         local stripe=$($LFS getstripe -c $file1)
6238
6239         [[ $stripe == 1 ]] || error "stripe of $file1 is $stripe != 1"
6240         cmp $file1 $ref1 || error "content mismatch $file1 differs from $ref1"
6241
6242         # clean up
6243         rm -f $file1
6244 }
6245 run_test 56xa "lfs migration --block support"
6246
6247 check_migrate_links() {
6248         local dir="$1"
6249         local file1="$dir/file1"
6250         local begin="$2"
6251         local count="$3"
6252         local total_count=$(($begin + $count - 1))
6253         local symlink_count=10
6254         local uniq_count=10
6255
6256         if [ ! -f "$file1" ]; then
6257                 echo -n "creating initial file..."
6258                 $LFS setstripe -c 1 -S "512k" "$file1" ||
6259                         error "cannot setstripe initial file"
6260                 echo "done"
6261
6262                 echo -n "creating symlinks..."
6263                 for s in $(seq 1 $symlink_count); do
6264                         ln -s "$file1" "$dir/slink$s" ||
6265                                 error "cannot create symlinks"
6266                 done
6267                 echo "done"
6268
6269                 echo -n "creating nonlinked files..."
6270                 createmany -o "$dir/uniq" 1 10 &> /dev/null ||
6271                         error "cannot create nonlinked files"
6272                 echo "done"
6273         fi
6274
6275         # create hard links
6276         if [ ! -f "$dir/file$total_count" ]; then
6277                 echo -n "creating hard links $begin:$total_count..."
6278                 createmany -l"$file1" "$dir/file" "$begin" "$count" &>  \
6279                         /dev/null || error "cannot create hard links"
6280                 echo "done"
6281         fi
6282
6283         echo -n "checking number of hard links listed in xattrs..."
6284         local fid=$($LFS getstripe -F "$file1")
6285         local paths=($($LFS fid2path "$MOUNT" "$fid" 2> /dev/null))
6286
6287         echo "${#paths[*]}"
6288         if [ ${#paths[*]} -lt $total_count -a "$begin" -eq 2  ]; then
6289                         skip "hard link list has unexpected size, skipping test"
6290         fi
6291         if [ ${#paths[*]} -ge $total_count -a "$begin" -ne 2  ]; then
6292                         error "link names should exceed xattrs size"
6293         fi
6294
6295         echo -n "migrating files..."
6296         local migrate_out=$($LFS_MIGRATE -y -S '1m' $dir)
6297         local rc=$?
6298         [ $rc -eq 0 ] || error "migrate failed rc = $rc"
6299         echo "done"
6300
6301         # make sure all links have been properly migrated
6302         echo -n "verifying files..."
6303         fid=$($LFS getstripe -F "$file1") ||
6304                 error "cannot get fid for file $file1"
6305         for i in $(seq 2 $total_count); do
6306                 local fid2=$($LFS getstripe -F $dir/file$i)
6307
6308                 [ "$fid2" == "$fid" ] ||
6309                         error "migrated hard link has mismatched FID"
6310         done
6311
6312         # make sure hard links were properly detected, and migration was
6313         # performed only once for the entire link set; nonlinked files should
6314         # also be migrated
6315         local actual=$(grep -c 'done' <<< "$migrate_out")
6316         local expected=$(($uniq_count + 1))
6317
6318         [ "$actual" -eq  "$expected" ] ||
6319                 error "hard links individually migrated ($actual != $expected)"
6320
6321         # make sure the correct number of hard links are present
6322         local hardlinks=$(stat -c '%h' "$file1")
6323
6324         [ $hardlinks -eq $total_count ] ||
6325                 error "num hard links $hardlinks != $total_count"
6326         echo "done"
6327
6328         return 0
6329 }
6330
6331 test_56xb() {
6332         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
6333                 skip "Need MDS version at least 2.10.55"
6334
6335         local dir="$DIR/$tdir"
6336
6337         test_mkdir "$dir" || error "cannot create dir $dir"
6338
6339         echo "testing lfs migrate mode when all links fit within xattrs"
6340         LFS_MIGRATE_RSYNC_MODE=false check_migrate_links "$dir" 2 99
6341
6342         echo "testing rsync mode when all links fit within xattrs"
6343         LFS_MIGRATE_RSYNC_MODE=true check_migrate_links "$dir" 2 99
6344
6345         echo "testing lfs migrate mode when all links do not fit within xattrs"
6346         LFS_MIGRATE_RSYNC_MODE=false check_migrate_links "$dir" 101 100
6347
6348         echo "testing rsync mode when all links do not fit within xattrs"
6349         LFS_MIGRATE_RSYNC_MODE=true check_migrate_links "$dir" 101 100
6350
6351
6352         # clean up
6353         rm -rf $dir
6354 }
6355 run_test 56xb "lfs migration hard link support"
6356
6357 test_56xc() {
6358         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
6359
6360         local dir="$DIR/$tdir"
6361
6362         test_mkdir "$dir" || error "cannot create dir $dir"
6363
6364         # Test 1: ensure file < 1 GB is always migrated with 1 stripe
6365         echo -n "Setting initial stripe for 20MB test file..."
6366         $LFS setstripe -c 2 -i 0 "$dir/20mb" ||
6367                 error "cannot setstripe 20MB file"
6368         echo "done"
6369         echo -n "Sizing 20MB test file..."
6370         truncate "$dir/20mb" 20971520 || error "cannot create 20MB test file"
6371         echo "done"
6372         echo -n "Verifying small file autostripe count is 1..."
6373         $LFS_MIGRATE -y -A -C 1 "$dir/20mb" ||
6374                 error "cannot migrate 20MB file"
6375         local stripe_count=$($LFS getstripe -c "$dir/20mb") ||
6376                 error "cannot get stripe for $dir/20mb"
6377         [ $stripe_count -eq 1 ] ||
6378                 error "unexpected stripe count $stripe_count for 20MB file"
6379         rm -f "$dir/20mb"
6380         echo "done"
6381
6382         # Test 2: File is small enough to fit within the available space on
6383         # sqrt(size_in_gb) + 1 OSTs but is larger than 1GB.  The file must
6384         # have at least an additional 1KB for each desired stripe for test 3
6385         echo -n "Setting stripe for 1GB test file..."
6386         $LFS setstripe -c 1 -i 0 "$dir/1gb" || error "cannot setstripe 1GB file"
6387         echo "done"
6388         echo -n "Sizing 1GB test file..."
6389         # File size is 1GB + 3KB
6390         truncate "$dir/1gb" 1073744896 || error "cannot create 1GB test file"
6391         echo "done"
6392
6393         # need at least 512MB per OST for 1GB file to fit in 2 stripes
6394         local avail=$($LCTL get_param -n llite.$FSNAME*.kbytesavail)
6395         if (( avail > 524288 * OSTCOUNT )); then
6396                 echo -n "Migrating 1GB file..."
6397                 $LFS_MIGRATE -y -A -C 1 "$dir/1gb" ||
6398                         error "cannot migrate 1GB file"
6399                 echo "done"
6400                 echo -n "Verifying autostripe count is sqrt(n) + 1..."
6401                 stripe_count=$($LFS getstripe -c "$dir/1gb") ||
6402                         error "cannot getstripe for 1GB file"
6403                 [ $stripe_count -eq 2 ] ||
6404                         error "unexpected stripe count $stripe_count != 2"
6405                 echo "done"
6406         fi
6407
6408         # Test 3: File is too large to fit within the available space on
6409         # sqrt(n) + 1 OSTs.  Simulate limited available space with -X
6410         if [ $OSTCOUNT -ge 3 ]; then
6411                 # The required available space is calculated as
6412                 # file size (1GB + 3KB) / OST count (3).
6413                 local kb_per_ost=349526
6414
6415                 echo -n "Migrating 1GB file with limit..."
6416                 $LFS_MIGRATE -y -A -C 1 -X $kb_per_ost "$dir/1gb" ||
6417                         error "cannot migrate 1GB file with limit"
6418                 echo "done"
6419
6420                 stripe_count=$($LFS getstripe -c "$dir/1gb")
6421                 echo -n "Verifying 1GB autostripe count with limited space..."
6422                 [ "$stripe_count" -a $stripe_count -ge 3 ] ||
6423                         error "unexpected stripe count $stripe_count (min 3)"
6424                 echo "done"
6425         fi
6426
6427         # clean up
6428         rm -rf $dir
6429 }
6430 run_test 56xc "lfs migration autostripe"
6431
6432 test_56y() {
6433         [ $MDS1_VERSION -lt $(version_code 2.4.53) ] &&
6434                 skip "No HSM $(lustre_build_version $SINGLEMDS) MDS < 2.4.53"
6435
6436         local res=""
6437         local dir=$DIR/$tdir
6438         local f1=$dir/file1
6439         local f2=$dir/file2
6440
6441         test_mkdir -p $dir || error "creating dir $dir"
6442         touch $f1 || error "creating std file $f1"
6443         $MULTIOP $f2 H2c || error "creating released file $f2"
6444
6445         # a directory can be raid0, so ask only for files
6446         res=$($LFS find $dir -L raid0 -type f | wc -l)
6447         [[ $res == 2 ]] || error "search raid0: found $res files != 2"
6448
6449         res=$($LFS find $dir \! -L raid0 -type f | wc -l)
6450         [[ $res == 0 ]] || error "search !raid0: found $res files != 0"
6451
6452         # only files can be released, so no need to force file search
6453         res=$($LFS find $dir -L released)
6454         [[ $res == $f2 ]] || error "search released: found $res != $f2"
6455
6456         res=$($LFS find $dir -type f \! -L released)
6457         [[ $res == $f1 ]] || error "search !released: found $res != $f1"
6458 }
6459 run_test 56y "lfs find -L raid0|released"
6460
6461 test_56z() { # LU-4824
6462         # This checks to make sure 'lfs find' continues after errors
6463         # There are two classes of errors that should be caught:
6464         # - If multiple paths are provided, all should be searched even if one
6465         #   errors out
6466         # - If errors are encountered during the search, it should not terminate
6467         #   early
6468         local dir=$DIR/$tdir
6469         local i
6470
6471         test_mkdir $dir
6472         for i in d{0..9}; do
6473                 test_mkdir $dir/$i
6474                 touch $dir/$i/$tfile
6475         done
6476         $LFS find $DIR/non_existent_dir $dir &&
6477                 error "$LFS find did not return an error"
6478         # Make a directory unsearchable. This should NOT be the last entry in
6479         # directory order.  Arbitrarily pick the 6th entry
6480         chmod 700 $($LFS find $dir -type d | sed '6!d')
6481
6482         $RUNAS $LFS find $DIR/non_existent $dir
6483         local count=$($RUNAS $LFS find $DIR/non_existent $dir | wc -l)
6484
6485         # The user should be able to see 10 directories and 9 files
6486         (( count == 19 )) ||
6487                 error "$LFS find found $count != 19 entries after error"
6488 }
6489 run_test 56z "lfs find should continue after an error"
6490
6491 test_56aa() { # LU-5937
6492         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
6493
6494         local dir=$DIR/$tdir
6495
6496         mkdir $dir
6497         $LFS setdirstripe -c$MDSCOUNT $dir/striped_dir
6498
6499         createmany -o $dir/striped_dir/${tfile}- 1024
6500         local dirs=$($LFS find --size +8k $dir/)
6501
6502         [ -n "$dirs" ] || error "lfs find --size wrong under striped dir"
6503 }
6504 run_test 56aa "lfs find --size under striped dir"
6505
6506 test_56ab() { # LU-10705
6507         test_mkdir $DIR/$tdir
6508         dd if=/dev/zero of=$DIR/$tdir/$tfile.1 bs=8k count=1 seek=2k
6509         dd if=/dev/zero of=$DIR/$tdir/$tfile.2 bs=4k count=1 seek=4k
6510         dd if=/dev/zero of=$DIR/$tdir/$tfile.3 bs=1M count=2 seek=16
6511         # Flush writes to ensure valid blocks.  Need to be more thorough for
6512         # ZFS, since blocks are not allocated/returned to client immediately.
6513         sync_all_data
6514         wait_zfs_commit ost1 2
6515         cancel_lru_locks osc
6516         ls -ls $DIR/$tdir
6517
6518         local files=$($LFS find --size +16M $DIR/$tdir | wc -l)
6519
6520         [[ $files == 3 ]] || error ">16M size files $files isn't 3 as expected"
6521
6522         files=$($LFS find --blocks +1M $DIR/$tdir | wc -l)
6523         [[ $files == 1 ]] || error ">1M blocks files $files isn't 1 as expected"
6524
6525         rm -f $DIR/$tdir/$tfile.[123]
6526 }
6527 run_test 56ab "lfs find --blocks"
6528
6529 test_56ba() {
6530         [ $MDS1_VERSION -lt $(version_code 2.10.50) ] &&
6531                 skip "Need MDS version at least 2.10.50"
6532
6533         # Create composite files with one component
6534         local dir=$DIR/$tdir
6535
6536         setup_56 $dir/1Mfiles 5 1 "-S 1M --component-end 1M"
6537         # Create composite files with three components
6538         setup_56 $dir/2Mfiles 5 2 "-E 2M -S 1M -E 4M -E 6M"
6539         # Create non-composite files
6540         createmany -o $dir/${tfile}- 10
6541
6542         local nfiles=$($LFS find --component-end 1M --type f $dir | wc -l)
6543
6544         [[ $nfiles == 10 ]] ||
6545                 error "lfs find -E 1M found $nfiles != 10 files"
6546
6547         nfiles=$($LFS find ! -E 1M --type f $dir | wc -l)
6548         [[ $nfiles == 25 ]] ||
6549                 error "lfs find ! -E 1M found $nfiles != 25 files"
6550
6551         # All files have a component that starts at 0
6552         nfiles=$($LFS find --component-start 0 --type f $dir | wc -l)
6553         [[ $nfiles == 35 ]] ||
6554                 error "lfs find --component-start 0 - $nfiles != 35 files"
6555
6556         nfiles=$($LFS find --component-start 2M --type f $dir | wc -l)
6557         [[ $nfiles == 15 ]] ||
6558                 error "lfs find --component-start 2M - $nfiles != 15 files"
6559
6560         # All files created here have a componenet that does not starts at 2M
6561         nfiles=$($LFS find ! --component-start 2M --type f $dir | wc -l)
6562         [[ $nfiles == 35 ]] ||
6563                 error "lfs find ! --component-start 2M - $nfiles != 35 files"
6564
6565         # Find files with a specified number of components
6566         local nfiles=$($LFS find --component-count 3 --type f $dir | wc -l)
6567         [[ $nfiles == 15 ]] ||
6568                 error "lfs find --component-count 3 - $nfiles != 15 files"
6569
6570         # Remember non-composite files have a component count of zero
6571         local nfiles=$($LFS find --component-count 0 --type f $dir | wc -l)
6572         [[ $nfiles == 10 ]] ||
6573                 error "lfs find --component-count 0 - $nfiles != 10 files"
6574
6575         nfiles=$($LFS find ! --component-count 3 --type f $dir | wc -l)
6576         [[ $nfiles == 20 ]] ||
6577                 error "lfs find ! --component-count 3 - $nfiles != 20 files"
6578
6579         # All files have a flag called "init"
6580         local nfiles=$($LFS find --component-flags init --type f $dir | wc -l)
6581         [[ $nfiles == 35 ]] ||
6582                 error "lfs find --component-flags init - $nfiles != 35 files"
6583
6584         # Multi-component files will have a component not initialized
6585         local nfiles=$($LFS find ! --component-flags init --type f $dir | wc -l)
6586         [[ $nfiles == 15 ]] ||
6587                 error "lfs find !--component-flags init - $nfiles != 15 files"
6588
6589         rm -rf $dir
6590
6591 }
6592 run_test 56ba "test lfs find --component-end, -start, -count, and -flags"
6593
6594 test_56ca() {
6595         [[ $MDS1_VERSION -ge $(version_code 2.10.57) ]] ||
6596                 skip "Need MDS version at least 2.10.57"
6597
6598         local td=$DIR/$tdir
6599         local tf=$td/$tfile
6600         local dir
6601         local nfiles
6602         local cmd
6603         local i
6604         local j
6605
6606         # create mirrored directories and mirrored files
6607         mkdir $td || error "mkdir $td failed"
6608         $LFS mirror create -N3 $td || error "create mirrored dir $td failed"
6609         createmany -o $tf- 10 || error "create $tf- failed"
6610
6611         for i in $(seq 2); do
6612                 dir=$td/dir$i
6613                 mkdir $dir || error "mkdir $dir failed"
6614                 $LFS mirror create -N$((3 + i)) $dir ||
6615                         error "create mirrored dir $dir failed"
6616                 createmany -o $dir/$tfile- 10 ||
6617                         error "create $dir/$tfile- failed"
6618         done
6619
6620         # change the states of some mirrored files
6621         echo foo > $tf-6
6622         for i in $(seq 2); do
6623                 dir=$td/dir$i
6624                 for j in $(seq 4 9); do
6625                         echo foo > $dir/$tfile-$j
6626                 done
6627         done
6628
6629         # find mirrored files with specific mirror count
6630         cmd="$LFS find --mirror-count 3 --type f $td"
6631         nfiles=$($cmd | wc -l)
6632         [[ $nfiles = 10 ]] || error "$cmd: $nfiles != 10 files"
6633
6634         cmd="$LFS find ! --mirror-count 3 --type f $td"
6635         nfiles=$($cmd | wc -l)
6636         [[ $nfiles = 20 ]] || error "$cmd: $nfiles != 20 files"
6637
6638         cmd="$LFS find --mirror-count +2 --type f $td"
6639         nfiles=$($cmd | wc -l)
6640         [[ $nfiles = 30 ]] || error "$cmd: $nfiles != 30 files"
6641
6642         cmd="$LFS find --mirror-count -6 --type f $td"
6643         nfiles=$($cmd | wc -l)
6644         [[ $nfiles = 30 ]] || error "$cmd: $nfiles != 30 files"
6645
6646         # find mirrored files with specific file state
6647         cmd="$LFS find --maxdepth 1 --mirror-state=^ro --type f $td"
6648         [[ $($cmd) = $tf-6 ]] || error "$cmd: didn't return $tf-6"
6649
6650         cmd="$LFS find --mirror-state=ro --type f $td"
6651         nfiles=$($cmd | wc -l)
6652         [[ $nfiles = 17 ]] || error "$cmd: $nfiles != 17 files"
6653
6654         cmd="$LFS find ! --mirror-state=ro --type f $td"
6655         nfiles=$($cmd | wc -l)
6656         [[ $nfiles = 13 ]] || error "$cmd: $nfiles != 13 files"
6657
6658         cmd="$LFS find --mirror-state=wp --type f $td"
6659         nfiles=$($cmd | wc -l)
6660         [[ $nfiles = 13 ]] || error "$cmd: $nfiles != 13 files"
6661
6662         cmd="$LFS find ! --mirror-state=sp --type f $td"
6663         nfiles=$($cmd | wc -l)
6664         [[ $nfiles = 30 ]] || error "$cmd: $nfiles != 30 files"
6665 }
6666 run_test 56ca "check lfs find --mirror-count|-N and --mirror-state"
6667
6668 test_57a() {
6669         [ $PARALLEL == "yes" ] && skip "skip parallel run"
6670         # note test will not do anything if MDS is not local
6671         if [ "$mds1_FSTYPE" != ldiskfs ]; then
6672                 skip_env "ldiskfs only test"
6673         fi
6674         remote_mds_nodsh && skip "remote MDS with nodsh"
6675
6676         local MNTDEV="osd*.*MDT*.mntdev"
6677         DEV=$(do_facet $SINGLEMDS lctl get_param -n $MNTDEV)
6678         [ -z "$DEV" ] && error "can't access $MNTDEV"
6679         for DEV in $(do_facet $SINGLEMDS lctl get_param -n $MNTDEV); do
6680                 do_facet $SINGLEMDS $DUMPE2FS -h $DEV > $TMP/t57a.dump ||
6681                         error "can't access $DEV"
6682                 DEVISIZE=$(awk '/Inode size:/ { print $3 }' $TMP/t57a.dump)
6683                 [[ $DEVISIZE -gt 128 ]] || error "inode size $DEVISIZE"
6684                 rm $TMP/t57a.dump
6685         done
6686 }
6687 run_test 57a "verify MDS filesystem created with large inodes =="
6688
6689 test_57b() {
6690         [ $PARALLEL == "yes" ] && skip "skip parallel run"
6691         if [ "$mds1_FSTYPE" != ldiskfs ]; then
6692                 skip_env "ldiskfs only test"
6693         fi
6694         remote_mds_nodsh && skip "remote MDS with nodsh"
6695
6696         local dir=$DIR/$tdir
6697         local filecount=100
6698         local file1=$dir/f1
6699         local fileN=$dir/f$filecount
6700
6701         rm -rf $dir || error "removing $dir"
6702         test_mkdir -c1 $dir
6703         local mdtidx=$($LFS getstripe -m $dir)
6704         local mdtname=MDT$(printf %04x $mdtidx)
6705         local facet=mds$((mdtidx + 1))
6706
6707         echo "mcreating $filecount files"
6708         createmany -m $dir/f 1 $filecount || error "creating files in $dir"
6709
6710         # verify that files do not have EAs yet
6711         $LFS getstripe $file1 2>&1 | grep -q "no stripe" ||
6712                 error "$file1 has an EA"
6713         $LFS getstripe $fileN 2>&1 | grep -q "no stripe" ||
6714                 error "$fileN has an EA"
6715
6716         sync
6717         sleep 1
6718         df $dir  #make sure we get new statfs data
6719         local mdsfree=$(do_facet $facet \
6720                         lctl get_param -n osd*.*$mdtname.kbytesfree)
6721         local mdcfree=$(lctl get_param -n mdc.*$mdtname-mdc-*.kbytesfree)
6722         local file
6723
6724         echo "opening files to create objects/EAs"
6725         for file in $(seq -f $dir/f%g 1 $filecount); do
6726                 $OPENFILE -f O_RDWR $file > /dev/null 2>&1 ||
6727                         error "opening $file"
6728         done
6729
6730         # verify that files have EAs now
6731         $LFS getstripe $file1 | grep -q "obdidx" || error "$file1 missing EA"
6732         $LFS getstripe $fileN | grep -q "obdidx" || error "$fileN missing EA"
6733
6734         sleep 1  #make sure we get new statfs data
6735         df $dir
6736         local mdsfree2=$(do_facet $facet \
6737                          lctl get_param -n osd*.*$mdtname.kbytesfree)
6738         local mdcfree2=$(lctl get_param -n mdc.*$mdtname-mdc-*.kbytesfree)
6739
6740         if [[ $mdcfree2 -lt $((mdcfree - 16)) ]]; then
6741                 if [ "$mdsfree" != "$mdsfree2" ]; then
6742                         error "MDC before $mdcfree != after $mdcfree2"
6743                 else
6744                         echo "MDC before $mdcfree != after $mdcfree2"
6745                         echo "unable to confirm if MDS has large inodes"
6746                 fi
6747         fi
6748         rm -rf $dir
6749 }
6750 run_test 57b "default LOV EAs are stored inside large inodes ==="
6751
6752 test_58() {
6753         [ $PARALLEL == "yes" ] && skip "skip parallel run"
6754         [ -z "$(which wiretest 2>/dev/null)" ] &&
6755                         skip_env "could not find wiretest"
6756
6757         wiretest
6758 }
6759 run_test 58 "verify cross-platform wire constants =============="
6760
6761 test_59() {
6762         [ $PARALLEL == "yes" ] && skip "skip parallel run"
6763
6764         echo "touch 130 files"
6765         createmany -o $DIR/f59- 130
6766         echo "rm 130 files"
6767         unlinkmany $DIR/f59- 130
6768         sync
6769         # wait for commitment of removal
6770         wait_delete_completed
6771 }
6772 run_test 59 "verify cancellation of llog records async ========="
6773
6774 TEST60_HEAD="test_60 run $RANDOM"
6775 test_60a() {
6776         [ $PARALLEL == "yes" ] && skip "skip parallel run"
6777         remote_mgs_nodsh && skip "remote MGS with nodsh"
6778         do_facet mgs "! which run-llog.sh &> /dev/null" &&
6779                 do_facet mgs "! ls run-llog.sh &> /dev/null" &&
6780                         skip_env "missing subtest run-llog.sh"
6781
6782         log "$TEST60_HEAD - from kernel mode"
6783         do_facet mgs "$LCTL dk > /dev/null"
6784         do_facet mgs "bash run-llog.sh" || error "run-llog.sh failed"
6785         do_facet mgs $LCTL dk > $TMP/$tfile
6786
6787         # LU-6388: test llog_reader
6788         local llog_reader=$(do_facet mgs "which llog_reader 2> /dev/null")
6789         llog_reader=${llog_reader:-$LUSTRE/utils/llog_reader}
6790         [ -z $(do_facet mgs ls -d $llog_reader 2> /dev/null) ] &&
6791                         skip_env "missing llog_reader"
6792         local fstype=$(facet_fstype mgs)
6793         [ $fstype != ldiskfs -a $fstype != zfs ] &&
6794                 skip_env "Only for ldiskfs or zfs type mgs"
6795
6796         local mntpt=$(facet_mntpt mgs)
6797         local mgsdev=$(mgsdevname 1)
6798         local fid_list
6799         local fid
6800         local rec_list
6801         local rec
6802         local rec_type
6803         local obj_file
6804         local path
6805         local seq
6806         local oid
6807         local pass=true
6808
6809         #get fid and record list
6810         fid_list=($(awk '/9_sub.*record/ { print $NF }' /$TMP/$tfile |
6811                 tail -n 4))
6812         rec_list=($(awk '/9_sub.*record/ { print $((NF-3)) }' /$TMP/$tfile |
6813                 tail -n 4))
6814         #remount mgs as ldiskfs or zfs type
6815         stop mgs || error "stop mgs failed"
6816         mount_fstype mgs || error "remount mgs failed"
6817         for ((i = 0; i < ${#fid_list[@]}; i++)); do
6818                 fid=${fid_list[i]}
6819                 rec=${rec_list[i]}
6820                 seq=$(echo $fid | awk -F ':' '{ print $1 }' | sed -e "s/^0x//g")
6821                 oid=$(echo $fid | awk -F ':' '{ print $2 }' | sed -e "s/^0x//g")
6822                 oid=$((16#$oid))
6823
6824                 case $fstype in
6825                         ldiskfs )
6826                                 obj_file=$mntpt/O/$seq/d$((oid%32))/$oid ;;
6827                         zfs )
6828                                 obj_file=$mntpt/oi.$(($((16#$seq))&127))/$fid ;;
6829                 esac
6830                 echo "obj_file is $obj_file"
6831                 do_facet mgs $llog_reader $obj_file
6832
6833                 rec_type=$(do_facet mgs $llog_reader $obj_file | grep "type=" |
6834                         awk '{ print $3 }' | sed -e "s/^type=//g")
6835                 if [ $rec_type != $rec ]; then
6836                         echo "FAILED test_60a wrong record type $rec_type," \
6837                               "should be $rec"
6838                         pass=false
6839                         break
6840                 fi
6841
6842                 #check obj path if record type is LLOG_LOGID_MAGIC
6843                 if [ "$rec" == "1064553b" ]; then
6844                         path=$(do_facet mgs $llog_reader $obj_file |
6845                                 grep "path=" | awk '{ print $NF }' |
6846                                 sed -e "s/^path=//g")
6847                         if [ $obj_file != $mntpt/$path ]; then
6848                                 echo "FAILED test_60a wrong obj path" \
6849                                       "$montpt/$path, should be $obj_file"
6850                                 pass=false
6851                                 break
6852                         fi
6853                 fi
6854         done
6855         rm -f $TMP/$tfile
6856         #restart mgs before "error", otherwise it will block the next test
6857         stop mgs || error "stop mgs failed"
6858         start mgs $(mgsdevname) $MGS_MOUNT_OPTS || error "start mgs failed"
6859         $pass || error "test failed, see FAILED test_60a messages for specifics"
6860 }
6861 run_test 60a "llog_test run from kernel module and test llog_reader"
6862
6863 test_60b() { # bug 6411
6864         [ $PARALLEL == "yes" ] && skip "skip parallel run"
6865
6866         dmesg > $DIR/$tfile
6867         LLOG_COUNT=$(do_facet mgs dmesg |
6868                      awk "/$TEST60_HEAD/ { marker = 1; from_marker = 0; }
6869                           /llog_[a-z]*.c:[0-9]/ {
6870                                 if (marker)
6871                                         from_marker++
6872                                 from_begin++
6873                           }
6874                           END {
6875                                 if (marker)
6876                                         print from_marker
6877                                 else
6878                                         print from_begin
6879                           }")
6880
6881         [[ $LLOG_COUNT -gt 120 ]] &&
6882                 error "CDEBUG_LIMIT not limiting messages ($LLOG_COUNT)" || true
6883 }
6884 run_test 60b "limit repeated messages from CERROR/CWARN"
6885
6886 test_60c() {
6887         [ $PARALLEL == "yes" ] && skip "skip parallel run"
6888
6889         echo "create 5000 files"
6890         createmany -o $DIR/f60c- 5000
6891 #define OBD_FAIL_MDS_LLOG_CREATE_FAILED  0x137
6892         lctl set_param fail_loc=0x80000137
6893         unlinkmany $DIR/f60c- 5000
6894         lctl set_param fail_loc=0
6895 }
6896 run_test 60c "unlink file when mds full"
6897
6898 test_60d() {
6899         [ $PARALLEL == "yes" ] && skip "skip parallel run"
6900
6901         SAVEPRINTK=$(lctl get_param -n printk)
6902         # verify "lctl mark" is even working"
6903         MESSAGE="test message ID $RANDOM $$"
6904         $LCTL mark "$MESSAGE" || error "$LCTL mark failed"
6905         dmesg | grep -q "$MESSAGE" || error "didn't find debug marker in log"
6906
6907         lctl set_param printk=0 || error "set lnet.printk failed"
6908         lctl get_param -n printk | grep emerg || error "lnet.printk dropped emerg"
6909         MESSAGE="new test message ID $RANDOM $$"
6910         # Assume here that libcfs_debug_mark_buffer() uses D_WARNING
6911         $LCTL mark "$MESSAGE" || error "$LCTL mark failed"
6912         dmesg | grep -q "$MESSAGE" && error "D_WARNING wasn't masked" || true
6913
6914         lctl set_param -n printk="$SAVEPRINTK"
6915 }
6916 run_test 60d "test printk console message masking"
6917
6918 test_60e() {
6919         [ $PARALLEL == "yes" ] && skip "skip parallel run"
6920         remote_mds_nodsh && skip "remote MDS with nodsh"
6921
6922         touch $DIR/$tfile
6923 #define OBD_FAIL_MDS_LLOG_CREATE_FAILED2  0x15b
6924         do_facet mds1 lctl set_param fail_loc=0x15b
6925         rm $DIR/$tfile
6926 }
6927 run_test 60e "no space while new llog is being created"
6928
6929 test_60g() {
6930         local pid
6931
6932         test_mkdir -c $MDSCOUNT $DIR/$tdir
6933         $LFS setdirstripe -D -i -1 -c $MDSCOUNT $DIR/$tdir
6934
6935         (
6936                 local index=0
6937                 while true; do
6938                         mkdir $DIR/$tdir/subdir$index 2>/dev/null
6939                         rmdir $DIR/$tdir/subdir$index 2>/dev/null
6940                         index=$((index + 1))
6941                 done
6942         ) &
6943
6944         pid=$!
6945
6946         for i in $(seq 100); do
6947                 # define OBD_FAIL_OSD_TXN_START    0x19a
6948                 do_facet mds1 lctl set_param fail_loc=0x8000019a
6949                 usleep 100
6950         done
6951
6952         kill -9 $pid
6953
6954         mkdir $DIR/$tdir/new || error "mkdir failed"
6955         rmdir $DIR/$tdir/new || error "rmdir failed"
6956 }
6957 run_test 60g "transaction abort won't cause MDT hung"
6958
6959 test_60h() {
6960         [ $MDS1_VERSION -le $(version_code 2.12.52) ] &&
6961                 skip "Need MDS version at least 2.12.52"
6962         [ $MDSCOUNT -lt 2 ] && skip "Need at least 2 MDTs"
6963
6964         local f
6965
6966         #define OBD_FAIL_MDS_STRIPE_CREATE       0x188
6967         #define OBD_FAIL_MDS_STRIPE_FID          0x189
6968         for fail_loc in 0x80000188 0x80000189; do
6969                 do_facet mds1 "$LCTL set_param fail_loc=$fail_loc"
6970                 $LFS mkdir -c $MDSCOUNT -i 0 $DIR/$tdir-$fail_loc ||
6971                         error "mkdir $dir-$fail_loc failed"
6972                 for i in {0..10}; do
6973                         # create may fail on missing stripe
6974                         echo $i > $DIR/$tdir-$fail_loc/$i
6975                 done
6976                 $LFS getdirstripe $DIR/$tdir-$fail_loc ||
6977                         error "getdirstripe $tdir-$fail_loc failed"
6978                 $LFS migrate -m 1 $DIR/$tdir-$fail_loc ||
6979                         error "migrate $tdir-$fail_loc failed"
6980                 $LFS getdirstripe $DIR/$tdir-$fail_loc ||
6981                         error "getdirstripe $tdir-$fail_loc failed"
6982                 pushd $DIR/$tdir-$fail_loc
6983                 for f in *; do
6984                         echo $f | cmp $f - || error "$f data mismatch"
6985                 done
6986                 popd
6987                 rm -rf $DIR/$tdir-$fail_loc
6988         done
6989 }
6990 run_test 60h "striped directory with missing stripes can be accessed"
6991
6992 test_61a() {
6993         [ $PARALLEL == "yes" ] && skip "skip parallel run"
6994
6995         f="$DIR/f61"
6996         dd if=/dev/zero of=$f bs=$PAGE_SIZE count=1 || error "dd $f failed"
6997         cancel_lru_locks osc
6998         $MULTIOP $f OSMWUc || error "$MULTIOP $f failed"
6999         sync
7000 }
7001 run_test 61a "mmap() writes don't make sync hang ================"
7002
7003 test_61b() {
7004         mmap_mknod_test $DIR/$tfile || error "mmap_mknod_test failed"
7005 }
7006 run_test 61b "mmap() of unstriped file is successful"
7007
7008 # bug 2330 - insufficient obd_match error checking causes LBUG
7009 test_62() {
7010         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7011
7012         f="$DIR/f62"
7013         echo foo > $f
7014         cancel_lru_locks osc
7015         lctl set_param fail_loc=0x405
7016         cat $f && error "cat succeeded, expect -EIO"
7017         lctl set_param fail_loc=0
7018 }
7019 # This test is now irrelevant (as of bug 10718 inclusion), we no longer
7020 # match every page all of the time.
7021 #run_test 62 "verify obd_match failure doesn't LBUG (should -EIO)"
7022
7023 # bug 2319 - oig_wait() interrupted causes crash because of invalid waitq.
7024 # Though this test is irrelevant anymore, it helped to reveal some
7025 # other grant bugs (LU-4482), let's keep it.
7026 test_63a() {   # was test_63
7027         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7028
7029         MAX_DIRTY_MB=$(lctl get_param -n osc.*.max_dirty_mb | head -n 1)
7030
7031         for i in `seq 10` ; do
7032                 dd if=/dev/zero of=$DIR/f63 bs=8k &
7033                 sleep 5
7034                 kill $!
7035                 sleep 1
7036         done
7037
7038         rm -f $DIR/f63 || true
7039 }
7040 run_test 63a "Verify oig_wait interruption does not crash ======="
7041
7042 # bug 2248 - async write errors didn't return to application on sync
7043 # bug 3677 - async write errors left page locked
7044 test_63b() {
7045         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7046
7047         debugsave
7048         lctl set_param debug=-1
7049
7050         # ensure we have a grant to do async writes
7051         dd if=/dev/zero of=$DIR/$tfile bs=4k count=1
7052         rm $DIR/$tfile
7053
7054         sync    # sync lest earlier test intercept the fail_loc
7055
7056         #define OBD_FAIL_OSC_BRW_PREP_REQ        0x406
7057         lctl set_param fail_loc=0x80000406
7058         $MULTIOP $DIR/$tfile Owy && \
7059                 error "sync didn't return ENOMEM"
7060         sync; sleep 2; sync     # do a real sync this time to flush page
7061         lctl get_param -n llite.*.dump_page_cache | grep locked && \
7062                 error "locked page left in cache after async error" || true
7063         debugrestore
7064 }
7065 run_test 63b "async write errors should be returned to fsync ==="
7066
7067 test_64a () {
7068         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7069
7070         df $DIR
7071         lctl get_param -n osc.*[oO][sS][cC][_-]*.cur* | grep "[0-9]"
7072 }
7073 run_test 64a "verify filter grant calculations (in kernel) ====="
7074
7075 test_64b () {
7076         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7077
7078         sh oos.sh $MOUNT || error "oos.sh failed: $?"
7079 }
7080 run_test 64b "check out-of-space detection on client"
7081
7082 test_64c() {
7083         $LCTL set_param osc.*OST0000-osc-[^mM]*.cur_grant_bytes=0
7084 }
7085 run_test 64c "verify grant shrink"
7086
7087 # this does exactly what osc_request.c:osc_announce_cached() does in
7088 # order to calculate max amount of grants to ask from server
7089 want_grant() {
7090         local tgt=$1
7091
7092         local nrpages=$($LCTL get_param -n osc.${tgt}.max_pages_per_rpc)
7093         local rpc_in_flight=$($LCTL get_param -n osc.${tgt}.max_rpcs_in_flight)
7094
7095         ((rpc_in_flight ++));
7096         nrpages=$((nrpages * rpc_in_flight))
7097
7098         local dirty_max_pages=$($LCTL get_param -n osc.${tgt}.max_dirty_mb)
7099
7100         dirty_max_pages=$((dirty_max_pages * 1024 * 1024 / PAGE_SIZE))
7101
7102         [[ $dirty_max_pages -gt $nrpages ]] && nrpages=$dirty_max_pages
7103         local undirty=$((nrpages * PAGE_SIZE))
7104
7105         local max_extent_pages
7106         max_extent_pages=$($LCTL get_param osc.${tgt}.import |
7107             grep grant_max_extent_size | awk '{print $2}')
7108         max_extent_pages=$((max_extent_pages / PAGE_SIZE))
7109         local nrextents=$(((nrpages + max_extent_pages - 1) / max_extent_pages))
7110         local grant_extent_tax
7111         grant_extent_tax=$($LCTL get_param osc.${tgt}.import |
7112             grep grant_extent_tax | awk '{print $2}')
7113
7114         undirty=$((undirty + nrextents * grant_extent_tax))
7115
7116         echo $undirty
7117 }
7118
7119 # this is size of unit for grant allocation. It should be equal to
7120 # what tgt_grant.c:tgt_grant_chunk() calculates
7121 grant_chunk() {
7122         local tgt=$1
7123         local max_brw_size
7124         local grant_extent_tax
7125
7126         max_brw_size=$($LCTL get_param osc.${tgt}.import |
7127             grep max_brw_size | awk '{print $2}')
7128
7129         grant_extent_tax=$($LCTL get_param osc.${tgt}.import |
7130             grep grant_extent_tax | awk '{print $2}')
7131
7132         echo $(((max_brw_size + grant_extent_tax) * 2))
7133 }
7134
7135 test_64d() {
7136         [ $OST1_VERSION -lt $(version_code 2.10.56) ] &&
7137                 skip "OST < 2.10.55 doesn't limit grants enough"
7138
7139         local tgt=$($LCTL dl | grep "0000-osc-[^mM]" | awk '{print $4}')
7140         local file=$DIR/$tfile
7141
7142         [[ $($LCTL get_param osc.${tgt}.import |
7143              grep "connect_flags:.*grant_param") ]] ||
7144                 skip "no grant_param connect flag"
7145
7146         local olddebug=$($LCTL get_param -n debug 2> /dev/null)
7147
7148         $LCTL set_param debug="$OLDDEBUG" 2> /dev/null || true
7149
7150         local max_cur_granted=$(($(want_grant $tgt) + $(grant_chunk $tgt)))
7151         stack_trap "rm -f $file" EXIT
7152
7153         $LFS setstripe $file -i 0 -c 1
7154         dd if=/dev/zero of=$file bs=1M count=1000 &
7155         ddpid=$!
7156
7157         while true
7158         do
7159                 local cur_grant=$($LCTL get_param -n osc.${tgt}.cur_grant_bytes)
7160                 if [[ $cur_grant -gt $max_cur_granted ]]
7161                 then
7162                         kill $ddpid
7163                         error "cur_grant $cur_grant > $max_cur_granted"
7164                 fi
7165                 kill -0 $ddpid
7166                 [[ $? -ne 0 ]] && break;
7167                 sleep 2
7168         done
7169
7170         rm -f $DIR/$tfile
7171         wait_delete_completed
7172         $LCTL set_param debug="$olddebug" 2> /dev/null || true
7173 }
7174 run_test 64d "check grant limit exceed"
7175
7176 # bug 1414 - set/get directories' stripe info
7177 test_65a() {
7178         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7179
7180         test_mkdir $DIR/$tdir
7181         touch $DIR/$tdir/f1
7182         $LVERIFY $DIR/$tdir $DIR/$tdir/f1 || error "lverify failed"
7183 }
7184 run_test 65a "directory with no stripe info"
7185
7186 test_65b() {
7187         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7188
7189         test_mkdir $DIR/$tdir
7190         local STRIPESIZE=$($LFS getstripe -S $DIR/$tdir)
7191
7192         $LFS setstripe -S $((STRIPESIZE * 2)) -i 0 -c 1 $DIR/$tdir ||
7193                                                 error "setstripe"
7194         touch $DIR/$tdir/f2
7195         $LVERIFY $DIR/$tdir $DIR/$tdir/f2 || error "lverify failed"
7196 }
7197 run_test 65b "directory setstripe -S stripe_size*2 -i 0 -c 1"
7198
7199 test_65c() {
7200         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7201         [ $OSTCOUNT -lt 2 ] && skip_env "need at least 2 OSTs"
7202
7203         test_mkdir $DIR/$tdir
7204         local stripesize=$($LFS getstripe -S $DIR/$tdir)
7205
7206         $LFS setstripe -S $((stripesize * 4)) -i 1 \
7207                 -c $((OSTCOUNT - 1)) $DIR/$tdir || error "setstripe"
7208         touch $DIR/$tdir/f3
7209         $LVERIFY $DIR/$tdir $DIR/$tdir/f3 || error "lverify failed"
7210 }
7211 run_test 65c "directory setstripe -S stripe_size*4 -i 1 -c $((OSTCOUNT-1))"
7212
7213 test_65d() {
7214         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7215
7216         test_mkdir $DIR/$tdir
7217         local STRIPECOUNT=$($LFS getstripe -c $DIR/$tdir)
7218         local STRIPESIZE=$($LFS getstripe -S $DIR/$tdir)
7219
7220         if [[ $STRIPECOUNT -le 0 ]]; then
7221                 sc=1
7222         elif [[ $STRIPECOUNT -gt $LOV_MAX_STRIPE_COUNT ]]; then
7223                 [[ $OSTCOUNT -gt $LOV_MAX_STRIPE_COUNT ]] &&
7224                         sc=$LOV_MAX_STRIPE_COUNT || sc=$(($OSTCOUNT - 1))
7225         else
7226                 sc=$(($STRIPECOUNT - 1))
7227         fi
7228         $LFS setstripe -S $STRIPESIZE -c $sc $DIR/$tdir || error "setstripe"
7229         touch $DIR/$tdir/f4 $DIR/$tdir/f5
7230         $LVERIFY $DIR/$tdir $DIR/$tdir/f4 $DIR/$tdir/f5 ||
7231                 error "lverify failed"
7232 }
7233 run_test 65d "directory setstripe -S stripe_size -c stripe_count"
7234
7235 test_65e() {
7236         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7237
7238         test_mkdir $DIR/$tdir
7239
7240         $LFS setstripe $DIR/$tdir || error "setstripe"
7241         $LFS getstripe -v $DIR/$tdir | grep "Default" ||
7242                                         error "no stripe info failed"
7243         touch $DIR/$tdir/f6
7244         $LVERIFY $DIR/$tdir $DIR/$tdir/f6 || error "lverify failed"
7245 }
7246 run_test 65e "directory setstripe defaults"
7247
7248 test_65f() {
7249         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7250
7251         test_mkdir $DIR/${tdir}f
7252         $RUNAS $LFS setstripe $DIR/${tdir}f &&
7253                 error "setstripe succeeded" || true
7254 }
7255 run_test 65f "dir setstripe permission (should return error) ==="
7256
7257 test_65g() {
7258         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7259
7260         test_mkdir $DIR/$tdir
7261         local STRIPESIZE=$($LFS getstripe -S $DIR/$tdir)
7262
7263         $LFS setstripe -S $((STRIPESIZE * 2)) -i 0 -c 1 $DIR/$tdir ||
7264                 error "setstripe -S failed"
7265         $LFS setstripe -d $DIR/$tdir || error "setstripe -d failed"
7266         $LFS getstripe -v $DIR/$tdir | grep "Default" ||
7267                 error "delete default stripe failed"
7268 }
7269 run_test 65g "directory setstripe -d"
7270
7271 test_65h() {
7272         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7273
7274         test_mkdir $DIR/$tdir
7275         local STRIPESIZE=$($LFS getstripe -S $DIR/$tdir)
7276
7277         $LFS setstripe -S $((STRIPESIZE * 2)) -i 0 -c 1 $DIR/$tdir ||
7278                 error "setstripe -S failed"
7279         test_mkdir $DIR/$tdir/dd1
7280         [ $($LFS getstripe -c $DIR/$tdir) = $($LFS getstripe -c $DIR/$tdir/dd1) ] ||
7281                 error "stripe info inherit failed"
7282 }
7283 run_test 65h "directory stripe info inherit ===================="
7284
7285 test_65i() {
7286         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7287
7288         save_layout_restore_at_exit $MOUNT
7289
7290         # bug6367: set non-default striping on root directory
7291         $LFS setstripe -S 65536 -c -1 $MOUNT || error "error setting stripe"
7292
7293         # bug12836: getstripe on -1 default directory striping
7294         $LFS getstripe $MOUNT || error "getstripe $MOUNT failed"
7295
7296         # bug12836: getstripe -v on -1 default directory striping
7297         $LFS getstripe -v $MOUNT || error "getstripe -v $MOUNT failed"
7298
7299         # bug12836: new find on -1 default directory striping
7300         $LFS find -mtime -1 $MOUNT > /dev/null || error "find $MOUNT failed"
7301 }
7302 run_test 65i "various tests to set root directory striping"
7303
7304 test_65j() { # bug6367
7305         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7306
7307         sync; sleep 1
7308
7309         # if we aren't already remounting for each test, do so for this test
7310         if [ "$I_MOUNTED" = "yes" ]; then
7311                 cleanup || error "failed to unmount"
7312                 setup
7313         fi
7314
7315         save_layout_restore_at_exit $MOUNT
7316
7317         $LFS setstripe -d $MOUNT || error "setstripe failed"
7318 }
7319 run_test 65j "set default striping on root directory (bug 6367)="
7320
7321 cleanup_65k() {
7322         rm -rf $DIR/$tdir
7323         wait_delete_completed
7324         do_facet $SINGLEMDS "lctl set_param -n \
7325                 osp.$ost*MDT0000.max_create_count=$max_count"
7326         do_facet $SINGLEMDS "lctl set_param -n \
7327                 osp.$ost*MDT0000.create_count=$count"
7328         do_facet $SINGLEMDS lctl --device  %$INACTIVE_OSC activate
7329         echo $INACTIVE_OSC "is Activate"
7330
7331         wait_osc_import_state mds ost$(( ostnum + 1 )) FULL
7332 }
7333
7334 test_65k() { # bug11679
7335         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7336         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
7337         remote_mds_nodsh && skip "remote MDS with nodsh"
7338
7339         local disable_precreate=true
7340         [ $MDS1_VERSION -le $(version_code 2.8.54) ] &&
7341                 disable_precreate=false
7342
7343         echo "Check OST status: "
7344         local MDS_OSCS=$(do_facet $SINGLEMDS lctl dl |
7345                 awk '/[oO][sS][cC].*md[ts]/ { print $4 }')
7346
7347         for OSC in $MDS_OSCS; do
7348                 echo $OSC "is active"
7349                 do_facet $SINGLEMDS lctl --device %$OSC activate
7350         done
7351
7352         for INACTIVE_OSC in $MDS_OSCS; do
7353                 local ost=$(osc_to_ost $INACTIVE_OSC)
7354                 local ostnum=$(do_facet $SINGLEMDS lctl get_param -n \
7355                                lov.*md*.target_obd |
7356                                awk -F: /$ost/'{ print $1 }' | head -n 1)
7357
7358                 mkdir -p $DIR/$tdir
7359                 $LFS setstripe -i $ostnum -c 1 $DIR/$tdir
7360                 createmany -o $DIR/$tdir/$tfile.$ostnum. 1000
7361
7362                 echo "Deactivate: " $INACTIVE_OSC
7363                 do_facet $SINGLEMDS lctl --device %$INACTIVE_OSC deactivate
7364
7365                 local count=$(do_facet $SINGLEMDS "lctl get_param -n \
7366                               osp.$ost*MDT0000.create_count")
7367                 local max_count=$(do_facet $SINGLEMDS "lctl get_param -n \
7368                                   osp.$ost*MDT0000.max_create_count")
7369                 $disable_precreate &&
7370                         do_facet $SINGLEMDS "lctl set_param -n \
7371                                 osp.$ost*MDT0000.max_create_count=0"
7372
7373                 for idx in $(seq 0 $((OSTCOUNT - 1))); do
7374                         [ -f $DIR/$tdir/$idx ] && continue
7375                         echo "$LFS setstripe -i $idx -c 1 $DIR/$tdir/$idx"
7376                         $LFS setstripe -i $idx -c 1 $DIR/$tdir/$idx ||
7377                                 { cleanup_65k;
7378                                   error "setstripe $idx should succeed"; }
7379                         rm -f $DIR/$tdir/$idx || error "rm $idx failed"
7380                 done
7381                 unlinkmany $DIR/$tdir/$tfile.$ostnum. 1000
7382                 rmdir $DIR/$tdir
7383
7384                 do_facet $SINGLEMDS "lctl set_param -n \
7385                         osp.$ost*MDT0000.max_create_count=$max_count"
7386                 do_facet $SINGLEMDS "lctl set_param -n \
7387                         osp.$ost*MDT0000.create_count=$count"
7388                 do_facet $SINGLEMDS lctl --device  %$INACTIVE_OSC activate
7389                 echo $INACTIVE_OSC "is Activate"
7390
7391                 wait_osc_import_state mds ost$(( ostnum + 1 )) FULL
7392         done
7393 }
7394 run_test 65k "validate manual striping works properly with deactivated OSCs"
7395
7396 test_65l() { # bug 12836
7397         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7398
7399         test_mkdir -p $DIR/$tdir/test_dir
7400         $LFS setstripe -c -1 $DIR/$tdir/test_dir
7401         $LFS find -mtime -1 $DIR/$tdir >/dev/null
7402 }
7403 run_test 65l "lfs find on -1 stripe dir ========================"
7404
7405 test_65m() {
7406         local layout=$(save_layout $MOUNT)
7407         $RUNAS $LFS setstripe -c 2 $MOUNT && {
7408                 restore_layout $MOUNT $layout
7409                 error "setstripe should fail by non-root users"
7410         }
7411         true
7412 }
7413 run_test 65m "normal user can't set filesystem default stripe"
7414
7415 test_65n() {
7416         [ -n "$FILESET" ] && skip "Not functional for FILESET set"
7417         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.12.50) ]] ||
7418                 skip "Need MDS version at least 2.12.50"
7419         [[ $PARALLEL != "yes" ]] || skip "skip parallel run"
7420
7421         [[ $OSTCOUNT -ge 2 ]] || skip_env "needs >= 2 OSTs"
7422         which getfattr > /dev/null 2>&1 || skip_env "no getfattr command"
7423         which setfattr > /dev/null 2>&1 || skip_env "no setfattr command"
7424
7425         local root_layout=$(save_layout $MOUNT)
7426         stack_trap "restore_layout $MOUNT $root_layout" EXIT
7427
7428         # new subdirectory under root directory should not inherit
7429         # the default layout from root
7430         local dir1=$MOUNT/$tdir-1
7431         mkdir $dir1 || error "mkdir $dir1 failed"
7432         ! getfattr -n trusted.lov $dir1 &> /dev/null ||
7433                 error "$dir1 shouldn't have LOV EA"
7434
7435         # delete the default layout on root directory
7436         $LFS setstripe -d $MOUNT || error "delete root default layout failed"
7437
7438         local dir2=$MOUNT/$tdir-2
7439         mkdir $dir2 || error "mkdir $dir2 failed"
7440         ! getfattr -n trusted.lov $dir2 &> /dev/null ||
7441                 error "$dir2 shouldn't have LOV EA"
7442
7443         # set a new striping pattern on root directory
7444         local def_stripe_size=$($LFS getstripe -S $MOUNT)
7445         local new_def_stripe_size=$((def_stripe_size * 2))
7446         $LFS setstripe -S $new_def_stripe_size $MOUNT ||
7447                 error "set stripe size on $MOUNT failed"
7448
7449         # new file created in $dir2 should inherit the new stripe size from
7450         # the filesystem default
7451         local file2=$dir2/$tfile-2
7452         touch $file2 || error "touch $file2 failed"
7453
7454         local file2_stripe_size=$($LFS getstripe -S $file2)
7455         [[ $file2_stripe_size -eq $new_def_stripe_size ]] ||
7456                 error "$file2 didn't inherit stripe size $new_def_stripe_size"
7457
7458         local dir3=$MOUNT/$tdir-3
7459         mkdir $dir3 || error "mkdir $dir3 failed"
7460         ! getfattr -n trusted.lov $dir3 &> /dev/null ||
7461                 error "$dir3 shouldn't have LOV EA"
7462
7463         # set OST pool on root directory
7464         local pool=$TESTNAME
7465         pool_add $pool || error "add $pool failed"
7466         pool_add_targets $pool 0 $((OSTCOUNT - 1)) 1 ||
7467                 error "add targets to $pool failed"
7468
7469         $LFS setstripe -p $pool $MOUNT ||
7470                 error "set OST pool on $MOUNT failed"
7471
7472         # new file created in $dir3 should inherit the pool from
7473         # the filesystem default
7474         local file3=$dir3/$tfile-3
7475         touch $file3 || error "touch $file3 failed"
7476
7477         local file3_pool=$($LFS getstripe -p $file3)
7478         [[ "$file3_pool" = "$pool" ]] ||
7479                 error "$file3 didn't inherit OST pool $pool"
7480
7481         local dir4=$MOUNT/$tdir-4
7482         mkdir $dir4 || error "mkdir $dir4 failed"
7483         ! getfattr -n trusted.lov $dir4 &> /dev/null ||
7484                 error "$dir4 shouldn't have LOV EA"
7485
7486         # new file created in $dir4 should inherit the pool from
7487         # the filesystem default
7488         local file4=$dir4/$tfile-4
7489         touch $file4 || error "touch $file4 failed"
7490
7491         local file4_pool=$($LFS getstripe -p $file4)
7492         [[ "$file4_pool" = "$pool" ]] ||
7493                 error "$file4 didn't inherit OST pool $pool"
7494
7495         # new subdirectory under non-root directory should inherit
7496         # the default layout from its parent directory
7497         $LFS setstripe -S $new_def_stripe_size -p $pool $dir4 ||
7498                 error "set directory layout on $dir4 failed"
7499
7500         local dir5=$dir4/$tdir-5
7501         mkdir $dir5 || error "mkdir $dir5 failed"
7502
7503         local dir4_layout=$(get_layout_param $dir4)
7504         local dir5_layout=$(get_layout_param $dir5)
7505         [[ "$dir4_layout" = "$dir5_layout" ]] ||
7506                 error "$dir5 should inherit the default layout from $dir4"
7507 }
7508 run_test 65n "don't inherit default layout from root for new subdirectories"
7509
7510 # bug 2543 - update blocks count on client
7511 test_66() {
7512         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7513
7514         COUNT=${COUNT:-8}
7515         dd if=/dev/zero of=$DIR/f66 bs=1k count=$COUNT
7516         sync; sync_all_data; sync; sync_all_data
7517         cancel_lru_locks osc
7518         BLOCKS=`ls -s $DIR/f66 | awk '{ print $1 }'`
7519         [ $BLOCKS -ge $COUNT ] || error "$DIR/f66 blocks $BLOCKS < $COUNT"
7520 }
7521 run_test 66 "update inode blocks count on client ==============="
7522
7523 meminfo() {
7524         awk '($1 == "'$1':") { print $2 }' /proc/meminfo
7525 }
7526
7527 swap_used() {
7528         swapon -s | awk '($1 == "'$1'") { print $4 }'
7529 }
7530
7531 # bug5265, obdfilter oa2dentry return -ENOENT
7532 # #define OBD_FAIL_SRV_ENOENT 0x217
7533 test_69() {
7534         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7535         remote_ost_nodsh && skip "remote OST with nodsh"
7536
7537         f="$DIR/$tfile"
7538         $LFS setstripe -c 1 -i 0 $f
7539
7540         $DIRECTIO write ${f}.2 0 1 || error "directio write error"
7541
7542         do_facet ost1 lctl set_param fail_loc=0x217
7543         $TRUNCATE $f 1 # vmtruncate() will ignore truncate() error.
7544         $DIRECTIO write $f 0 2 && error "write succeeded, expect -ENOENT"
7545
7546         do_facet ost1 lctl set_param fail_loc=0
7547         $DIRECTIO write $f 0 2 || error "write error"
7548
7549         cancel_lru_locks osc
7550         $DIRECTIO read $f 0 1 || error "read error"
7551
7552         do_facet ost1 lctl set_param fail_loc=0x217
7553         $DIRECTIO read $f 1 1 && error "read succeeded, expect -ENOENT"
7554
7555         do_facet ost1 lctl set_param fail_loc=0
7556         rm -f $f
7557 }
7558 run_test 69 "verify oa2dentry return -ENOENT doesn't LBUG ======"
7559
7560 test_71() {
7561         test_mkdir $DIR/$tdir
7562         $LFS setdirstripe -D -c$MDSCOUNT $DIR/$tdir
7563         sh rundbench -C -D $DIR/$tdir 2 || error "dbench failed!"
7564 }
7565 run_test 71 "Running dbench on lustre (don't segment fault) ===="
7566
7567 test_72a() { # bug 5695 - Test that on 2.6 remove_suid works properly
7568         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7569         [ "$RUNAS_ID" = "$UID" ] &&
7570                 skip_env "RUNAS_ID = UID = $UID -- skipping"
7571         # Check that testing environment is properly set up. Skip if not
7572         FAIL_ON_ERROR=false check_runas_id_ret $RUNAS_ID $RUNAS_GID $RUNAS ||
7573                 skip_env "User $RUNAS_ID does not exist - skipping"
7574
7575         touch $DIR/$tfile
7576         chmod 777 $DIR/$tfile
7577         chmod ug+s $DIR/$tfile
7578         $RUNAS dd if=/dev/zero of=$DIR/$tfile bs=512 count=1 ||
7579                 error "$RUNAS dd $DIR/$tfile failed"
7580         # See if we are still setuid/sgid
7581         [ -u $DIR/$tfile ] || [ -g $DIR/$tfile ] &&
7582                 error "S/gid is not dropped on write"
7583         # Now test that MDS is updated too
7584         cancel_lru_locks mdc
7585         [ -u $DIR/$tfile ] || [ -g $DIR/$tfile ] &&
7586                 error "S/gid is not dropped on MDS"
7587         rm -f $DIR/$tfile
7588 }
7589 run_test 72a "Test that remove suid works properly (bug5695) ===="
7590
7591 test_72b() { # bug 24226 -- keep mode setting when size is not changing
7592         local perm
7593
7594         [ "$RUNAS_ID" = "$UID" ] &&
7595                 skip_env "RUNAS_ID = UID = $UID -- skipping"
7596         [ "$RUNAS_ID" -eq 0 ] &&
7597                 skip_env "RUNAS_ID = 0 -- skipping"
7598         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7599         # Check that testing environment is properly set up. Skip if not
7600         FAIL_ON_ERROR=false check_runas_id_ret $RUNAS_ID $RUNAS_ID $RUNAS ||
7601                 skip_env "User $RUNAS_ID does not exist - skipping"
7602
7603         touch $DIR/${tfile}-f{g,u}
7604         test_mkdir $DIR/${tfile}-dg
7605         test_mkdir $DIR/${tfile}-du
7606         chmod 770 $DIR/${tfile}-{f,d}{g,u}
7607         chmod g+s $DIR/${tfile}-{f,d}g
7608         chmod u+s $DIR/${tfile}-{f,d}u
7609         for perm in 777 2777 4777; do
7610                 $RUNAS chmod $perm $DIR/${tfile}-fg && error "S/gid file allowed improper chmod to $perm"
7611                 $RUNAS chmod $perm $DIR/${tfile}-fu && error "S/uid file allowed improper chmod to $perm"
7612                 $RUNAS chmod $perm $DIR/${tfile}-dg && error "S/gid dir allowed improper chmod to $perm"
7613                 $RUNAS chmod $perm $DIR/${tfile}-du && error "S/uid dir allowed improper chmod to $perm"
7614         done
7615         true
7616 }
7617 run_test 72b "Test that we keep mode setting if without file data changed (bug 24226)"
7618
7619 # bug 3462 - multiple simultaneous MDC requests
7620 test_73() {
7621         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7622
7623         test_mkdir $DIR/d73-1
7624         test_mkdir $DIR/d73-2
7625         multiop_bg_pause $DIR/d73-1/f73-1 O_c || return 1
7626         pid1=$!
7627
7628         lctl set_param fail_loc=0x80000129
7629         $MULTIOP $DIR/d73-1/f73-2 Oc &
7630         sleep 1
7631         lctl set_param fail_loc=0
7632
7633         $MULTIOP $DIR/d73-2/f73-3 Oc &
7634         pid3=$!
7635
7636         kill -USR1 $pid1
7637         wait $pid1 || return 1
7638
7639         sleep 25
7640
7641         $CHECKSTAT -t file $DIR/d73-1/f73-1 || return 4
7642         $CHECKSTAT -t file $DIR/d73-1/f73-2 || return 5
7643         $CHECKSTAT -t file $DIR/d73-2/f73-3 || return 6
7644
7645         rm -rf $DIR/d73-*
7646 }
7647 run_test 73 "multiple MDC requests (should not deadlock)"
7648
7649 test_74a() { # bug 6149, 6184
7650         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7651
7652         touch $DIR/f74a
7653         #define OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT 0x30e
7654         #
7655         # very important to OR with OBD_FAIL_ONCE (0x80000000) -- otherwise it
7656         # will spin in a tight reconnection loop
7657         $LCTL set_param fail_loc=0x8000030e
7658         # get any lock that won't be difficult - lookup works.
7659         ls $DIR/f74a
7660         $LCTL set_param fail_loc=0
7661         rm -f $DIR/f74a
7662         true
7663 }
7664 run_test 74a "ldlm_enqueue freed-export error path, ls (shouldn't LBUG)"
7665
7666 test_74b() { # bug 13310
7667         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7668
7669         #define OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT 0x30e
7670         #
7671         # very important to OR with OBD_FAIL_ONCE (0x80000000) -- otherwise it
7672         # will spin in a tight reconnection loop
7673         $LCTL set_param fail_loc=0x8000030e
7674         # get a "difficult" lock
7675         touch $DIR/f74b
7676         $LCTL set_param fail_loc=0
7677         rm -f $DIR/f74b
7678         true
7679 }
7680 run_test 74b "ldlm_enqueue freed-export error path, touch (shouldn't LBUG)"
7681
7682 test_74c() {
7683         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7684
7685         #define OBD_FAIL_LDLM_NEW_LOCK
7686         $LCTL set_param fail_loc=0x319
7687         touch $DIR/$tfile && error "touch successful"
7688         $LCTL set_param fail_loc=0
7689         true
7690 }
7691 run_test 74c "ldlm_lock_create error path, (shouldn't LBUG)"
7692
7693 num_inodes() {
7694         awk '/lustre_inode_cache/ {print $2; exit}' /proc/slabinfo
7695 }
7696
7697 test_76() { # Now for bug 20433, added originally in bug 1443
7698         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7699
7700         local CPUS=$(getconf _NPROCESSORS_ONLN 2>/dev/null)
7701
7702         cancel_lru_locks osc
7703         BEFORE_INODES=$(num_inodes)
7704         echo "before inodes: $BEFORE_INODES"
7705         local COUNT=1000
7706         [ "$SLOW" = "no" ] && COUNT=100
7707         for i in $(seq $COUNT); do
7708                 touch $DIR/$tfile
7709                 rm -f $DIR/$tfile
7710         done
7711         cancel_lru_locks osc
7712         AFTER_INODES=$(num_inodes)
7713         echo "after inodes: $AFTER_INODES"
7714         local wait=0
7715         while [[ $((AFTER_INODES-1*${CPUS:-1})) -gt $BEFORE_INODES ]]; do
7716                 sleep 2
7717                 AFTER_INODES=$(num_inodes)
7718                 wait=$((wait+2))
7719                 echo "wait $wait seconds inodes: $AFTER_INODES"
7720                 if [ $wait -gt 30 ]; then
7721                         error "inode slab grew from $BEFORE_INODES to $AFTER_INODES"
7722                 fi
7723         done
7724 }
7725 run_test 76 "confirm clients recycle inodes properly ===="
7726
7727
7728 export ORIG_CSUM=""
7729 set_checksums()
7730 {
7731         # Note: in sptlrpc modes which enable its own bulk checksum, the
7732         # original crc32_le bulk checksum will be automatically disabled,
7733         # and the OBD_FAIL_OSC_CHECKSUM_SEND/OBD_FAIL_OSC_CHECKSUM_RECEIVE
7734         # will be checked by sptlrpc code against sptlrpc bulk checksum.
7735         # In this case set_checksums() will not be no-op, because sptlrpc
7736         # bulk checksum will be enabled all through the test.
7737
7738         [ "$ORIG_CSUM" ] || ORIG_CSUM=`lctl get_param -n osc.*.checksums | head -n1`
7739         lctl set_param -n osc.*.checksums $1
7740         return 0
7741 }
7742
7743 export ORIG_CSUM_TYPE="`lctl get_param -n osc.*osc-[^mM]*.checksum_type |
7744                         sed 's/.*\[\(.*\)\].*/\1/g' | head -n1`"
7745 CKSUM_TYPES=${CKSUM_TYPES:-$(lctl get_param -n osc.*osc-[^mM]*.checksum_type |
7746                              tr -d [] | head -n1)}
7747 set_checksum_type()
7748 {
7749         lctl set_param -n osc.*osc-[^mM]*.checksum_type $1
7750         rc=$?
7751         log "set checksum type to $1, rc = $rc"
7752         return $rc
7753 }
7754
7755 get_osc_checksum_type()
7756 {
7757         # arugment 1: OST name, like OST0000
7758         ost=$1
7759         checksum_type=$(lctl get_param -n osc.*${ost}-osc-[^mM]*.checksum_type |
7760                         sed 's/.*\[\(.*\)\].*/\1/g')
7761         rc=$?
7762         [ $rc -ne 0 ] && error "failed to get checksum type of $ost, rc = $rc, output = $checksum_type"
7763         echo $checksum_type
7764 }
7765
7766 F77_TMP=$TMP/f77-temp
7767 F77SZ=8
7768 setup_f77() {
7769         dd if=/dev/urandom of=$F77_TMP bs=1M count=$F77SZ || \
7770                 error "error writing to $F77_TMP"
7771 }
7772
7773 test_77a() { # bug 10889
7774         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7775         $GSS && skip_env "could not run with gss"
7776
7777         [ ! -f $F77_TMP ] && setup_f77
7778         set_checksums 1
7779         dd if=$F77_TMP of=$DIR/$tfile bs=1M count=$F77SZ || error "dd error"
7780         set_checksums 0
7781         rm -f $DIR/$tfile
7782 }
7783 run_test 77a "normal checksum read/write operation"
7784
7785 test_77b() { # bug 10889
7786         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7787         $GSS && skip_env "could not run with gss"
7788
7789         [ ! -f $F77_TMP ] && setup_f77
7790         #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
7791         $LCTL set_param fail_loc=0x80000409
7792         set_checksums 1
7793
7794         dd if=$F77_TMP of=$DIR/$tfile bs=1M count=$F77SZ conv=sync ||
7795                 error "dd error: $?"
7796         $LCTL set_param fail_loc=0
7797
7798         for algo in $CKSUM_TYPES; do
7799                 cancel_lru_locks osc
7800                 set_checksum_type $algo
7801                 #define OBD_FAIL_OSC_CHECKSUM_RECEIVE    0x408
7802                 $LCTL set_param fail_loc=0x80000408
7803                 cmp $F77_TMP $DIR/$tfile || error "file compare failed"
7804                 $LCTL set_param fail_loc=0
7805         done
7806         set_checksums 0
7807         set_checksum_type $ORIG_CSUM_TYPE
7808         rm -f $DIR/$tfile
7809 }
7810 run_test 77b "checksum error on client write, read"
7811
7812 cleanup_77c() {
7813         trap 0
7814         set_checksums 0
7815         $LCTL set_param osc.*osc-[^mM]*.checksum_dump=0
7816         $check_ost &&
7817                 do_facet ost1 $LCTL set_param obdfilter.*-OST*.checksum_dump=0
7818         [ -n "$osc_file_prefix" ] && rm -f ${osc_file_prefix}*
7819         $check_ost && [ -n "$ost_file_prefix" ] &&
7820                 do_facet ost1 rm -f ${ost_file_prefix}\*
7821 }
7822
7823 test_77c() {
7824         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7825         $GSS && skip_env "could not run with gss"
7826         remote_ost_nodsh && skip "remote OST with nodsh"
7827
7828         local bad1
7829         local osc_file_prefix
7830         local osc_file
7831         local check_ost=false
7832         local ost_file_prefix
7833         local ost_file
7834         local orig_cksum
7835         local dump_cksum
7836         local fid
7837
7838         # ensure corruption will occur on first OSS/OST
7839         $LFS setstripe -i 0 $DIR/$tfile
7840
7841         [ ! -f $F77_TMP ] && setup_f77
7842         dd if=$F77_TMP of=$DIR/$tfile bs=1M count=$F77SZ conv=sync ||
7843                 error "dd write error: $?"
7844         fid=$($LFS path2fid $DIR/$tfile)
7845
7846         if [ $OST1_VERSION -ge $(version_code 2.9.57) ]
7847         then
7848                 check_ost=true
7849                 ost_file_prefix=$(do_facet ost1 $LCTL get_param -n debug_path)
7850                 ost_file_prefix=${ost_file_prefix}-checksum_dump-ost-\\${fid}
7851         else
7852                 echo "OSS do not support bulk pages dump upon error"
7853         fi
7854
7855         osc_file_prefix=$($LCTL get_param -n debug_path)
7856         osc_file_prefix=${osc_file_prefix}-checksum_dump-osc-\\${fid}
7857
7858         trap cleanup_77c EXIT
7859
7860         set_checksums 1
7861         # enable bulk pages dump upon error on Client
7862         $LCTL set_param osc.*osc-[^mM]*.checksum_dump=1
7863         # enable bulk pages dump upon error on OSS
7864         $check_ost &&
7865                 do_facet ost1 $LCTL set_param obdfilter.*-OST*.checksum_dump=1
7866
7867         # flush Client cache to allow next read to reach OSS
7868         cancel_lru_locks osc
7869
7870         #define OBD_FAIL_OSC_CHECKSUM_RECEIVE       0x408
7871         $LCTL set_param fail_loc=0x80000408
7872         dd if=$DIR/$tfile of=/dev/null bs=1M || error "dd read error: $?"
7873         $LCTL set_param fail_loc=0
7874
7875         rm -f $DIR/$tfile
7876
7877         # check cksum dump on Client
7878         osc_file=$(ls ${osc_file_prefix}*)
7879         [ -n "$osc_file" ] || error "no checksum dump file on Client"
7880         # OBD_FAIL_OSC_CHECKSUM_RECEIVE corrupts with "bad1" at start of file
7881         bad1=$(dd if=$osc_file bs=1 count=4 2>/dev/null) || error "dd error: $?"
7882         [ $bad1 == "bad1" ] || error "unexpected corrupt pattern"
7883         orig_cksum=$(dd if=$F77_TMP bs=1 skip=4 count=1048572 2>/dev/null |
7884                      cksum)
7885         dump_cksum=$(dd if=$osc_file bs=1 skip=4 2>/dev/null | cksum)
7886         [[ "$orig_cksum" == "$dump_cksum" ]] ||
7887                 error "dump content does not match on Client"
7888
7889         $check_ost || skip "No need to check cksum dump on OSS"
7890
7891         # check cksum dump on OSS
7892         ost_file=$(do_facet ost1 ls ${ost_file_prefix}\*)
7893         [ -n "$ost_file" ] || error "no checksum dump file on OSS"
7894         orig_cksum=$(dd if=$F77_TMP bs=1048576 count=1 2>/dev/null | cksum)
7895         dump_cksum=$(do_facet ost1 dd if=$ost_file 2>/dev/null \| cksum)
7896         [[ "$orig_cksum" == "$dump_cksum" ]] ||
7897                 error "dump content does not match on OSS"
7898
7899         cleanup_77c
7900 }
7901 run_test 77c "checksum error on client read with debug"
7902
7903 test_77d() { # bug 10889
7904         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7905         $GSS && skip_env "could not run with gss"
7906
7907         #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
7908         $LCTL set_param fail_loc=0x80000409
7909         set_checksums 1
7910         $DIRECTIO write $DIR/$tfile 0 $F77SZ $((1024 * 1024)) ||
7911                 error "direct write: rc=$?"
7912         $LCTL set_param fail_loc=0
7913         set_checksums 0
7914
7915         #define OBD_FAIL_OSC_CHECKSUM_RECEIVE    0x408
7916         $LCTL set_param fail_loc=0x80000408
7917         set_checksums 1
7918         cancel_lru_locks osc
7919         $DIRECTIO read $DIR/$tfile 0 $F77SZ $((1024 * 1024)) ||
7920                 error "direct read: rc=$?"
7921         $LCTL set_param fail_loc=0
7922         set_checksums 0
7923 }
7924 run_test 77d "checksum error on OST direct write, read"
7925
7926 test_77f() { # bug 10889
7927         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7928         $GSS && skip_env "could not run with gss"
7929
7930         set_checksums 1
7931         for algo in $CKSUM_TYPES; do
7932                 cancel_lru_locks osc
7933                 set_checksum_type $algo
7934                 #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
7935                 $LCTL set_param fail_loc=0x409
7936                 $DIRECTIO write $DIR/$tfile 0 $F77SZ $((1024 * 1024)) &&
7937                         error "direct write succeeded"
7938                 $LCTL set_param fail_loc=0
7939         done
7940         set_checksum_type $ORIG_CSUM_TYPE
7941         set_checksums 0
7942 }
7943 run_test 77f "repeat checksum error on write (expect error)"
7944
7945 test_77g() { # bug 10889
7946         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7947         $GSS && skip_env "could not run with gss"
7948         remote_ost_nodsh && skip "remote OST with nodsh"
7949
7950         [ ! -f $F77_TMP ] && setup_f77
7951
7952         local file=$DIR/$tfile
7953         stack_trap "rm -f $file" EXIT
7954
7955         $LFS setstripe -c 1 -i 0 $file
7956         #define OBD_FAIL_OST_CHECKSUM_RECEIVE       0x21a
7957         do_facet ost1 lctl set_param fail_loc=0x8000021a
7958         set_checksums 1
7959         dd if=$F77_TMP of=$file bs=1M count=$F77SZ ||
7960                 error "write error: rc=$?"
7961         do_facet ost1 lctl set_param fail_loc=0
7962         set_checksums 0
7963
7964         cancel_lru_locks osc
7965         #define OBD_FAIL_OST_CHECKSUM_SEND          0x21b
7966         do_facet ost1 lctl set_param fail_loc=0x8000021b
7967         set_checksums 1
7968         cmp $F77_TMP $file || error "file compare failed"
7969         do_facet ost1 lctl set_param fail_loc=0
7970         set_checksums 0
7971 }
7972 run_test 77g "checksum error on OST write, read"
7973
7974 test_77k() { # LU-10906
7975         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7976         $GSS && skip_env "could not run with gss"
7977
7978         local cksum_param="osc.$FSNAME*.checksums"
7979         local get_checksum="$LCTL get_param -n $cksum_param | head -n1"
7980         local checksum
7981         local i
7982
7983         [ "$ORIG_CSUM" ] || ORIG_CSUM=$(eval $get_checksum)
7984         stack_trap "wait_update $HOSTNAME '$get_checksum' $ORIG_CSUM" EXIT
7985         stack_trap "do_facet mgs $LCTL set_param -P $cksum_param=$ORIG_CSUM" \
7986                 EXIT
7987
7988         for i in 0 1; do
7989                 do_facet mgs $LCTL set_param -P $cksum_param=$i ||
7990                         error "failed to set checksum=$i on MGS"
7991                 wait_update $HOSTNAME "$get_checksum" $i
7992                 #remount
7993                 echo "remount client, checksum should be $i"
7994                 remount_client $MOUNT || "failed to remount client"
7995                 checksum=$(eval $get_checksum)
7996                 [ $checksum -eq $i ] || error "checksum($checksum) != $i"
7997         done
7998         # remove persistent param to avoid races with checksum mountopt below
7999         do_facet mgs $LCTL set_param -P -d $cksum_param ||
8000                 error "failed to delete checksum on MGS"
8001
8002         for opt in "checksum" "nochecksum"; do
8003                 #remount with mount option
8004                 echo "remount client with option $opt, checksum should be $i"
8005                 umount_client $MOUNT || "failed to umount client"
8006                 mount_client $MOUNT "$MOUNT_OPTS,$opt" ||
8007                         "failed to mount client with option '$opt'"
8008                 checksum=$(eval $get_checksum)
8009                 [ $checksum -eq $i ] || error "checksum($checksum) != $i"
8010                 i=$((i - 1))
8011         done
8012
8013         remount_client $MOUNT || "failed to remount client"
8014 }
8015 run_test 77k "enable/disable checksum correctly"
8016
8017 test_77l() {
8018         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8019         $GSS && skip_env "could not run with gss"
8020
8021         set_checksums 1
8022         stack_trap "set_checksums $ORIG_CSUM" EXIT
8023         stack_trap "set_checksum_type $ORIG_CSUM_TYPE" EXIT
8024
8025         set_checksum_type invalid && error "unexpected success of invalid checksum type"
8026
8027         $LFS setstripe -c 1 -i 0 $DIR/$tfile
8028         for algo in $CKSUM_TYPES; do
8029                 set_checksum_type $algo || error "fail to set checksum type $algo"
8030                 osc_algo=$(get_osc_checksum_type OST0000)
8031                 [ "$osc_algo" != "$algo" ] && error "checksum type is $osc_algo after setting it to $algo"
8032
8033                 # no locks, no reqs to let the connection idle
8034                 cancel_lru_locks osc
8035                 lru_resize_disable osc
8036                 wait_osc_import_state client ost1 IDLE
8037
8038                 # ensure ost1 is connected
8039                 stat $DIR/$tfile >/dev/null || error "can't stat"
8040                 wait_osc_import_state client ost1 FULL
8041
8042                 osc_algo=$(get_osc_checksum_type OST0000)
8043                 [ "$osc_algo" != "$algo" ] && error "checksum type changed from $algo to $osc_algo after reconnection"
8044         done
8045         return 0
8046 }
8047 run_test 77l "preferred checksum type is remembered after reconnected"
8048
8049 [ "$ORIG_CSUM" ] && set_checksums $ORIG_CSUM || true
8050 rm -f $F77_TMP
8051 unset F77_TMP
8052
8053 cleanup_test_78() {
8054         trap 0
8055         rm -f $DIR/$tfile
8056 }
8057
8058 test_78() { # bug 10901
8059         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8060         remote_ost || skip_env "local OST"
8061
8062         NSEQ=5
8063         F78SIZE=$(($(awk '/MemFree:/ { print $2 }' /proc/meminfo) / 1024))
8064         echo "MemFree: $F78SIZE, Max file size: $MAXFREE"
8065         MEMTOTAL=$(($(awk '/MemTotal:/ { print $2 }' /proc/meminfo) / 1024))
8066         echo "MemTotal: $MEMTOTAL"
8067
8068         # reserve 256MB of memory for the kernel and other running processes,
8069         # and then take 1/2 of the remaining memory for the read/write buffers.
8070         if [ $MEMTOTAL -gt 512 ] ;then
8071                 MEMTOTAL=$(((MEMTOTAL - 256 ) / 2))
8072         else
8073                 # for those poor memory-starved high-end clusters...
8074                 MEMTOTAL=$((MEMTOTAL / 2))
8075         fi
8076         echo "Mem to use for directio: $MEMTOTAL"
8077
8078         [[ $F78SIZE -gt $MEMTOTAL ]] && F78SIZE=$MEMTOTAL
8079         [[ $F78SIZE -gt 512 ]] && F78SIZE=512
8080         [[ $F78SIZE -gt $((MAXFREE / 1024)) ]] && F78SIZE=$((MAXFREE / 1024))
8081         SMALLESTOST=$($LFS df $DIR | grep OST | awk '{ print $4 }' | sort -n |
8082                 head -n1)
8083         echo "Smallest OST: $SMALLESTOST"
8084         [[ $SMALLESTOST -lt 10240 ]] &&
8085                 skip "too small OSTSIZE, useless to run large O_DIRECT test"
8086
8087         trap cleanup_test_78 EXIT
8088
8089         [[ $F78SIZE -gt $((SMALLESTOST * $OSTCOUNT / 1024 - 80)) ]] &&
8090                 F78SIZE=$((SMALLESTOST * $OSTCOUNT / 1024 - 80))
8091
8092         [ "$SLOW" = "no" ] && NSEQ=1 && [ $F78SIZE -gt 32 ] && F78SIZE=32
8093         echo "File size: $F78SIZE"
8094         $LFS setstripe -c $OSTCOUNT $DIR/$tfile || error "setstripe failed"
8095         for i in $(seq 1 $NSEQ); do
8096                 FSIZE=$(($F78SIZE / ($NSEQ - $i + 1)))
8097                 echo directIO rdwr round $i of $NSEQ
8098                 $DIRECTIO rdwr $DIR/$tfile 0 $FSIZE 1048576||error "rdwr failed"
8099         done
8100
8101         cleanup_test_78
8102 }
8103 run_test 78 "handle large O_DIRECT writes correctly ============"
8104
8105 test_79() { # bug 12743
8106         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8107
8108         wait_delete_completed
8109
8110         BKTOTAL=$(calc_osc_kbytes kbytestotal)
8111         BKFREE=$(calc_osc_kbytes kbytesfree)
8112         BKAVAIL=$(calc_osc_kbytes kbytesavail)
8113
8114         STRING=`df -P $MOUNT | tail -n 1 | awk '{print $2","$3","$4}'`
8115         DFTOTAL=`echo $STRING | cut -d, -f1`
8116         DFUSED=`echo $STRING  | cut -d, -f2`
8117         DFAVAIL=`echo $STRING | cut -d, -f3`
8118         DFFREE=$(($DFTOTAL - $DFUSED))
8119
8120         ALLOWANCE=$((64 * $OSTCOUNT))
8121
8122         if [ $DFTOTAL -lt $(($BKTOTAL - $ALLOWANCE)) ] ||
8123            [ $DFTOTAL -gt $(($BKTOTAL + $ALLOWANCE)) ] ; then
8124                 error "df total($DFTOTAL) mismatch OST total($BKTOTAL)"
8125         fi
8126         if [ $DFFREE -lt $(($BKFREE - $ALLOWANCE)) ] ||
8127            [ $DFFREE -gt $(($BKFREE + $ALLOWANCE)) ] ; then
8128                 error "df free($DFFREE) mismatch OST free($BKFREE)"
8129         fi
8130         if [ $DFAVAIL -lt $(($BKAVAIL - $ALLOWANCE)) ] ||
8131            [ $DFAVAIL -gt $(($BKAVAIL + $ALLOWANCE)) ] ; then
8132                 error "df avail($DFAVAIL) mismatch OST avail($BKAVAIL)"
8133         fi
8134 }
8135 run_test 79 "df report consistency check ======================="
8136
8137 test_80() { # bug 10718
8138         remote_ost_nodsh && skip "remote OST with nodsh"
8139         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8140
8141         # relax strong synchronous semantics for slow backends like ZFS
8142         local soc="obdfilter.*.sync_on_lock_cancel"
8143         local soc_old=$(do_facet ost1 lctl get_param -n $soc | head -n1)
8144         local hosts=
8145         if [ "$soc_old" != "never" ] &&
8146                 [ "$ost1_FSTYPE" != "ldiskfs" ]; then
8147                         hosts=$(for host in $(seq -f "ost%g" 1 $OSTCOUNT); do
8148                                 facet_active_host $host; done | sort -u)
8149                         do_nodes $hosts lctl set_param $soc=never
8150         fi
8151
8152         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1M
8153         sync; sleep 1; sync
8154         local BEFORE=`date +%s`
8155         cancel_lru_locks osc
8156         local AFTER=`date +%s`
8157         local DIFF=$((AFTER-BEFORE))
8158         if [ $DIFF -gt 1 ] ; then
8159                 error "elapsed for 1M@1T = $DIFF"
8160         fi
8161
8162         [ -n "$hosts" ] && do_nodes $hosts lctl set_param $soc=$soc_old
8163
8164         rm -f $DIR/$tfile
8165 }
8166 run_test 80 "Page eviction is equally fast at high offsets too  ===="
8167
8168 test_81a() { # LU-456
8169         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8170         remote_ost_nodsh && skip "remote OST with nodsh"
8171
8172         # define OBD_FAIL_OST_MAPBLK_ENOSPC    0x228
8173         # MUST OR with the OBD_FAIL_ONCE (0x80000000)
8174         do_facet ost1 lctl set_param fail_loc=0x80000228
8175
8176         # write should trigger a retry and success
8177         $LFS setstripe -i 0 -c 1 $DIR/$tfile
8178         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
8179         RC=$?
8180         if [ $RC -ne 0 ] ; then
8181                 error "write should success, but failed for $RC"
8182         fi
8183 }
8184 run_test 81a "OST should retry write when get -ENOSPC ==============="
8185
8186 test_81b() { # LU-456
8187         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8188         remote_ost_nodsh && skip "remote OST with nodsh"
8189
8190         # define OBD_FAIL_OST_MAPBLK_ENOSPC    0x228
8191         # Don't OR with the OBD_FAIL_ONCE (0x80000000)
8192         do_facet ost1 lctl set_param fail_loc=0x228
8193
8194         # write should retry several times and return -ENOSPC finally
8195         $LFS setstripe -i 0 -c 1 $DIR/$tfile
8196         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
8197         RC=$?
8198         ENOSPC=28
8199         if [ $RC -ne $ENOSPC ] ; then
8200                 error "dd should fail for -ENOSPC, but succeed."
8201         fi
8202 }
8203 run_test 81b "OST should return -ENOSPC when retry still fails ======="
8204
8205 test_82() { # LU-1031
8206         dd if=/dev/zero of=$DIR/$tfile bs=1M count=10
8207         local gid1=14091995
8208         local gid2=16022000
8209
8210         multiop_bg_pause $DIR/$tfile OG${gid1}_g${gid1}c || return 1
8211         local MULTIPID1=$!
8212         multiop_bg_pause $DIR/$tfile O_G${gid2}r10g${gid2}c || return 2
8213         local MULTIPID2=$!
8214         kill -USR1 $MULTIPID2
8215         sleep 2
8216         if [[ `ps h -o comm -p $MULTIPID2` == "" ]]; then
8217                 error "First grouplock does not block second one"
8218         else
8219                 echo "Second grouplock blocks first one"
8220         fi
8221         kill -USR1 $MULTIPID1
8222         wait $MULTIPID1
8223         wait $MULTIPID2
8224 }
8225 run_test 82 "Basic grouplock test"
8226
8227 test_99() {
8228         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs"
8229
8230         test_mkdir $DIR/$tdir.cvsroot
8231         chown $RUNAS_ID $DIR/$tdir.cvsroot
8232
8233         cd $TMP
8234         $RUNAS cvs -d $DIR/$tdir.cvsroot init || error "cvs init failed"
8235
8236         cd /etc/init.d
8237         # some versions of cvs import exit(1) when asked to import links or
8238         # files they can't read.  ignore those files.
8239         local toignore=$(find . -type l -printf '-I %f\n' -o \
8240                          ! -perm /4 -printf '-I %f\n')
8241         $RUNAS cvs -d $DIR/$tdir.cvsroot import -m "nomesg" $toignore \
8242                 $tdir.reposname vtag rtag
8243
8244         cd $DIR
8245         test_mkdir $DIR/$tdir.reposname
8246         chown $RUNAS_ID $DIR/$tdir.reposname
8247         $RUNAS cvs -d $DIR/$tdir.cvsroot co $tdir.reposname
8248
8249         cd $DIR/$tdir.reposname
8250         $RUNAS touch foo99
8251         $RUNAS cvs add -m 'addmsg' foo99
8252         $RUNAS cvs update
8253         $RUNAS cvs commit -m 'nomsg' foo99
8254         rm -fr $DIR/$tdir.cvsroot
8255 }
8256 run_test 99 "cvs strange file/directory operations"
8257
8258 test_100() {
8259         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8260         [[ "$NETTYPE" =~ tcp ]] ||
8261                 skip_env "TCP secure port test, not useful for NETTYPE=$NETTYPE"
8262         remote_ost_nodsh && skip "remote OST with nodsh"
8263         remote_mds_nodsh && skip "remote MDS with nodsh"
8264         remote_servers ||
8265                 skip "useless for local single node setup"
8266
8267         netstat -tna | ( rc=1; while read PROT SND RCV LOCAL REMOTE STAT; do
8268                 [ "$PROT" != "tcp" ] && continue
8269                 RPORT=$(echo $REMOTE | cut -d: -f2)
8270                 [ "$RPORT" != "$ACCEPTOR_PORT" ] && continue
8271
8272                 rc=0
8273                 LPORT=`echo $LOCAL | cut -d: -f2`
8274                 if [ $LPORT -ge 1024 ]; then
8275                         echo "bad: $PROT $SND $RCV $LOCAL $REMOTE $STAT"
8276                         netstat -tna
8277                         error_exit "local: $LPORT > 1024, remote: $RPORT"
8278                 fi
8279         done
8280         [ "$rc" = 0 ] || error_exit "privileged port not found" )
8281 }
8282 run_test 100 "check local port using privileged port ==========="
8283
8284 function get_named_value()
8285 {
8286     local tag
8287
8288     tag=$1
8289     while read ;do
8290         line=$REPLY
8291         case $line in
8292         $tag*)
8293             echo $line | sed "s/^$tag[ ]*//"
8294             break
8295             ;;
8296         esac
8297     done
8298 }
8299
8300 export CACHE_MAX=$($LCTL get_param -n llite.*.max_cached_mb |
8301                    awk '/^max_cached_mb/ { print $2 }')
8302
8303 cleanup_101a() {
8304         $LCTL set_param -n llite.*.max_cached_mb $CACHE_MAX
8305         trap 0
8306 }
8307
8308 test_101a() {
8309         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8310         [ $MDSCOUNT -ge 2 ] && skip_env "needs < 2 MDTs" #LU-4322
8311
8312         local s
8313         local discard
8314         local nreads=10000
8315         local cache_limit=32
8316
8317         $LCTL set_param -n osc.*-osc*.rpc_stats 0
8318         trap cleanup_101a EXIT
8319         $LCTL set_param -n llite.*.read_ahead_stats 0
8320         $LCTL set_param -n llite.*.max_cached_mb $cache_limit
8321
8322         #
8323         # randomly read 10000 of 64K chunks from file 3x 32MB in size
8324         #
8325         echo "nreads: $nreads file size: $((cache_limit * 3))MB"
8326         $READS -f $DIR/$tfile -s$((cache_limit * 3192 * 1024)) -b65536 -C -n$nreads -t 180
8327
8328         discard=0
8329         for s in $($LCTL get_param -n llite.*.read_ahead_stats |
8330                 get_named_value 'read but discarded' | cut -d" " -f1); do
8331                         discard=$(($discard + $s))
8332         done
8333         cleanup_101a
8334
8335         if [[ $(($discard * 10)) -gt $nreads ]]; then
8336                 $LCTL get_param osc.*-osc*.rpc_stats
8337                 $LCTL get_param llite.*.read_ahead_stats
8338                 error "too many ($discard) discarded pages"
8339         fi
8340         rm -f $DIR/$tfile || true
8341 }
8342 run_test 101a "check read-ahead for random reads"
8343
8344 setup_test101bc() {
8345         test_mkdir $DIR/$tdir
8346         local ssize=$1
8347         local FILE_LENGTH=$2
8348         STRIPE_OFFSET=0
8349
8350         local FILE_SIZE_MB=$((FILE_LENGTH / ssize))
8351
8352         local list=$(comma_list $(osts_nodes))
8353         set_osd_param $list '' read_cache_enable 0
8354         set_osd_param $list '' writethrough_cache_enable 0
8355
8356         trap cleanup_test101bc EXIT
8357         # prepare the read-ahead file
8358         $LFS setstripe -S $ssize -i $STRIPE_OFFSET -c $OSTCOUNT $DIR/$tfile
8359
8360         dd if=/dev/zero of=$DIR/$tfile bs=$ssize \
8361                                 count=$FILE_SIZE_MB 2> /dev/null
8362
8363 }
8364
8365 cleanup_test101bc() {
8366         trap 0
8367         rm -rf $DIR/$tdir
8368         rm -f $DIR/$tfile
8369
8370         local list=$(comma_list $(osts_nodes))
8371         set_osd_param $list '' read_cache_enable 1
8372         set_osd_param $list '' writethrough_cache_enable 1
8373 }
8374
8375 calc_total() {
8376         awk 'BEGIN{total=0}; {total+=$1}; END{print total}'
8377 }
8378
8379 ra_check_101() {
8380         local READ_SIZE=$1
8381         local STRIPE_SIZE=$2
8382         local FILE_LENGTH=$3
8383         local RA_INC=1048576
8384         local STRIDE_LENGTH=$((STRIPE_SIZE/READ_SIZE))
8385         local discard_limit=$((((STRIDE_LENGTH - 1)*3/(STRIDE_LENGTH*OSTCOUNT))* \
8386                              (STRIDE_LENGTH*OSTCOUNT - STRIDE_LENGTH)))
8387         DISCARD=$($LCTL get_param -n llite.*.read_ahead_stats |
8388                         get_named_value 'read but discarded' |
8389                         cut -d" " -f1 | calc_total)
8390         if [[ $DISCARD -gt $discard_limit ]]; then
8391                 $LCTL get_param llite.*.read_ahead_stats
8392                 error "Too many ($DISCARD) discarded pages with size (${READ_SIZE})"
8393         else
8394                 echo "Read-ahead success for size ${READ_SIZE}"
8395         fi
8396 }
8397
8398 test_101b() {
8399         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8400         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
8401
8402         local STRIPE_SIZE=1048576
8403         local STRIDE_SIZE=$((STRIPE_SIZE*OSTCOUNT))
8404
8405         if [ $SLOW == "yes" ]; then
8406                 local FILE_LENGTH=$((STRIDE_SIZE * 64))
8407         else
8408                 local FILE_LENGTH=$((STRIDE_SIZE * 8))
8409         fi
8410
8411         local ITERATION=$((FILE_LENGTH / STRIDE_SIZE))
8412
8413         # prepare the read-ahead file
8414         setup_test101bc $STRIPE_SIZE $FILE_LENGTH
8415         cancel_lru_locks osc
8416         for BIDX in 2 4 8 16 32 64 128 256
8417         do
8418                 local BSIZE=$((BIDX*4096))
8419                 local READ_COUNT=$((STRIPE_SIZE/BSIZE))
8420                 local STRIDE_LENGTH=$((STRIDE_SIZE/BSIZE))
8421                 local OFFSET=$((STRIPE_SIZE/BSIZE*(OSTCOUNT - 1)))
8422                 $LCTL set_param -n llite.*.read_ahead_stats 0
8423                 $READS -f $DIR/$tfile  -l $STRIDE_LENGTH -o $OFFSET \
8424                               -s $FILE_LENGTH -b $STRIPE_SIZE -a $READ_COUNT -n $ITERATION
8425                 cancel_lru_locks osc
8426                 ra_check_101 $BSIZE $STRIPE_SIZE $FILE_LENGTH
8427         done
8428         cleanup_test101bc
8429         true
8430 }
8431 run_test 101b "check stride-io mode read-ahead ================="
8432
8433 test_101c() {
8434         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8435
8436         local STRIPE_SIZE=1048576
8437         local FILE_LENGTH=$((STRIPE_SIZE*100))
8438         local nreads=10000
8439         local rsize=65536
8440         local osc_rpc_stats
8441
8442         setup_test101bc $STRIPE_SIZE $FILE_LENGTH
8443
8444         cancel_lru_locks osc
8445         $LCTL set_param osc.*.rpc_stats 0
8446         $READS -f $DIR/$tfile -s$FILE_LENGTH -b$rsize -n$nreads -t 180
8447         for osc_rpc_stats in $($LCTL get_param -N osc.*.rpc_stats); do
8448                 local stats=$($LCTL get_param -n $osc_rpc_stats)
8449                 local lines=$(echo "$stats" | awk 'END {print NR;}')
8450                 local size
8451
8452                 if [ $lines -le 20 ]; then
8453                         continue
8454                 fi
8455                 for size in 1 2 4 8; do
8456                         local rpc=$(echo "$stats" |
8457                                     awk '($1 == "'$size':") {print $2; exit; }')
8458                         [ $rpc != 0 ] && ((size * PAGE_SIZE < rsize)) &&
8459                                 error "Small $((size*PAGE_SIZE)) read IO $rpc!"
8460                 done
8461                 echo "$osc_rpc_stats check passed!"
8462         done
8463         cleanup_test101bc
8464         true
8465 }
8466 run_test 101c "check stripe_size aligned read-ahead ================="
8467
8468 set_read_ahead() {
8469         $LCTL get_param -n llite.*.max_read_ahead_mb | head -n 1
8470         $LCTL set_param -n llite.*.max_read_ahead_mb $1 > /dev/null 2>&1
8471 }
8472
8473 test_101d() {
8474         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8475
8476         local file=$DIR/$tfile
8477         local sz_MB=${FILESIZE_101d:-500}
8478         local ra_MB=${READAHEAD_MB:-40}
8479
8480         local free_MB=$(($(df -P $DIR | tail -n 1 | awk '{ print $4 }') / 1024))
8481         [ $free_MB -lt $sz_MB ] &&
8482                 skip "Need free space ${sz_MB}M, have ${free_MB}M"
8483
8484         echo "Create test file $file size ${sz_MB}M, ${free_MB}M free"
8485         $LFS setstripe -c -1 $file || error "setstripe failed"
8486
8487         dd if=/dev/zero of=$file bs=1M count=$sz_MB || error "dd failed"
8488         echo Cancel LRU locks on lustre client to flush the client cache
8489         cancel_lru_locks osc
8490
8491         echo Disable read-ahead
8492         local old_READAHEAD=$(set_read_ahead 0)
8493
8494         echo Reading the test file $file with read-ahead disabled
8495         local raOFF=$(do_and_time "dd if=$file of=/dev/null bs=1M count=$sz_MB")
8496
8497         echo Cancel LRU locks on lustre client to flush the client cache
8498         cancel_lru_locks osc
8499         echo Enable read-ahead with ${ra_MB}MB
8500         set_read_ahead $ra_MB
8501
8502         echo Reading the test file $file with read-ahead enabled
8503         local raON=$(do_and_time "dd if=$file of=/dev/null bs=1M count=$sz_MB")
8504
8505         echo "read-ahead disabled time read $raOFF"
8506         echo "read-ahead enabled  time read $raON"
8507
8508         set_read_ahead $old_READAHEAD
8509         rm -f $file
8510         wait_delete_completed
8511
8512         [ $raOFF -le 1 ] || [ $raON -lt $raOFF ] ||
8513                 error "readahead ${raON}s > no-readahead ${raOFF}s ${sz_MB}M"
8514 }
8515 run_test 101d "file read with and without read-ahead enabled"
8516
8517 test_101e() {
8518         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8519
8520         local file=$DIR/$tfile
8521         local size_KB=500  #KB
8522         local count=100
8523         local bsize=1024
8524
8525         local free_KB=$(df -P $DIR | tail -n 1 | awk '{ print $4 }')
8526         local need_KB=$((count * size_KB))
8527         [[ $free_KB -le $need_KB ]] &&
8528                 skip_env "Need free space $need_KB, have $free_KB"
8529
8530         echo "Creating $count ${size_KB}K test files"
8531         for ((i = 0; i < $count; i++)); do
8532                 dd if=/dev/zero of=$file.$i bs=$bsize count=$size_KB 2>/dev/null
8533         done
8534
8535         echo "Cancel LRU locks on lustre client to flush the client cache"
8536         cancel_lru_locks $OSC
8537
8538         echo "Reset readahead stats"
8539         $LCTL set_param -n llite.*.read_ahead_stats 0
8540
8541         for ((i = 0; i < $count; i++)); do
8542                 dd if=$file.$i of=/dev/null bs=$bsize count=$size_KB 2>/dev/null
8543         done
8544
8545         local miss=$($LCTL get_param -n llite.*.read_ahead_stats |
8546                      get_named_value 'misses' | cut -d" " -f1 | calc_total)
8547
8548         for ((i = 0; i < $count; i++)); do
8549                 rm -rf $file.$i 2>/dev/null
8550         done
8551
8552         #10000 means 20% reads are missing in readahead
8553         [[ $miss -lt 10000 ]] ||  error "misses too much for small reads"
8554 }
8555 run_test 101e "check read-ahead for small read(1k) for small files(500k)"
8556
8557 test_101f() {
8558         which iozone || skip_env "no iozone installed"
8559
8560         local old_debug=$($LCTL get_param debug)
8561         old_debug=${old_debug#*=}
8562         $LCTL set_param debug="reada mmap"
8563
8564         # create a test file
8565         iozone -i 0 -+n -r 1m -s 128m -w -f $DIR/$tfile > /dev/null 2>&1
8566
8567         echo Cancel LRU locks on lustre client to flush the client cache
8568         cancel_lru_locks osc
8569
8570         echo Reset readahead stats
8571         $LCTL set_param -n llite.*.read_ahead_stats 0
8572
8573         echo mmap read the file with small block size
8574         iozone -i 1 -u 1 -l 1 -+n -r 32k -s 128m -B -f $DIR/$tfile \
8575                 > /dev/null 2>&1
8576
8577         echo checking missing pages
8578         $LCTL get_param llite.*.read_ahead_stats
8579         local miss=$($LCTL get_param -n llite.*.read_ahead_stats |
8580                         get_named_value 'misses' | cut -d" " -f1 | calc_total)
8581
8582         $LCTL set_param debug="$old_debug"
8583         [ $miss -lt 3 ] || error "misses too much pages ('$miss')!"
8584         rm -f $DIR/$tfile
8585 }
8586 run_test 101f "check mmap read performance"
8587
8588 test_101g_brw_size_test() {
8589         local mb=$1
8590         local pages=$((mb * 1048576 / PAGE_SIZE))
8591         local file=$DIR/$tfile
8592
8593         $LCTL set_param osc.*.max_pages_per_rpc=${mb}M ||
8594                 { error "unable to set max_pages_per_rpc=${mb}M"; return 1; }
8595         for mp in $($LCTL get_param -n osc.*.max_pages_per_rpc); do
8596                 [ $mp -ne $pages ] && error "max_pages_per_rpc $mp != $pages" &&
8597                         return 2
8598         done
8599
8600         stack_trap "rm -f $file" EXIT
8601         $LCTL set_param -n osc.*.rpc_stats=0
8602
8603         # 10 RPCs should be enough for the test
8604         local count=10
8605         dd if=/dev/zero of=$file bs=${mb}M count=$count ||
8606                 { error "dd write ${mb} MB blocks failed"; return 3; }
8607         cancel_lru_locks osc
8608         dd of=/dev/null if=$file bs=${mb}M count=$count ||
8609                 { error "dd write ${mb} MB blocks failed"; return 4; }
8610
8611         # calculate number of full-sized read and write RPCs
8612         rpcs=($($LCTL get_param -n 'osc.*.rpc_stats' |
8613                 sed -n '/pages per rpc/,/^$/p' |
8614                 awk '/'$pages':/ { reads += $2; writes += $6 }; \
8615                 END { print reads,writes }'))
8616         [ ${rpcs[0]} -ne $count ] && error "${rpcs[0]} != $count read RPCs" &&
8617                 return 5
8618         [ ${rpcs[1]} -ne $count ] && error "${rpcs[1]} != $count write RPCs" &&
8619                 return 6
8620
8621         return 0
8622 }
8623
8624 test_101g() {
8625         remote_ost_nodsh && skip "remote OST with nodsh"
8626
8627         local rpcs
8628         local osts=$(get_facets OST)
8629         local list=$(comma_list $(osts_nodes))
8630         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
8631         local brw_size="obdfilter.*.brw_size"
8632
8633         $LFS setstripe -i 0 -c 1 $DIR/$tfile
8634
8635         local orig_mb=$(do_facet ost1 $LCTL get_param -n $brw_size | head -n 1)
8636
8637         if { [ $OST1_VERSION -ge $(version_code 2.8.52) ] ||
8638                 { [ $OST1_VERSION -ge $(version_code 2.7.17) ] &&
8639                   [ $OST1_VERSION -lt $(version_code 2.7.50) ]; }; } &&
8640            { [ $CLIENT_VERSION -ge $(version_code 2.8.52) ] ||
8641                 { [ $CLIENT_VERSION -ge $(version_code 2.7.17) ] &&
8642                   [ $CLIENT_VERSION -lt $(version_code 2.7.50) ]; }; }; then
8643
8644                 [ $OST1_VERSION -ge $(version_code 2.9.52) ] &&
8645                         suffix="M"
8646
8647                 if [[ $orig_mb -lt 16 ]]; then
8648                         save_lustre_params $osts "$brw_size" > $p
8649                         do_nodes $list $LCTL set_param -n $brw_size=16$suffix ||
8650                                 error "set 16MB RPC size failed"
8651
8652                         echo "remount client to enable new RPC size"
8653                         remount_client $MOUNT || error "remount_client failed"
8654                 fi
8655
8656                 test_101g_brw_size_test 16 || error "16MB RPC test failed"
8657                 # should be able to set brw_size=12, but no rpc_stats for that
8658                 test_101g_brw_size_test 8 || error "8MB RPC test failed"
8659         fi
8660
8661         test_101g_brw_size_test 4 || error "4MB RPC test failed"
8662
8663         if [[ $orig_mb -lt 16 ]]; then
8664                 restore_lustre_params < $p
8665                 remount_client $MOUNT || error "remount_client restore failed"
8666         fi
8667
8668         rm -f $p $DIR/$tfile
8669 }
8670 run_test 101g "Big bulk(4/16 MiB) readahead"
8671
8672 test_101h() {
8673         $LFS setstripe -i 0 -c 1 $DIR/$tfile
8674
8675         dd if=/dev/zero of=$DIR/$tfile bs=1M count=70 ||
8676                 error "dd 70M file failed"
8677         echo Cancel LRU locks on lustre client to flush the client cache
8678         cancel_lru_locks osc
8679
8680         echo "Reset readahead stats"
8681         $LCTL set_param -n llite.*.read_ahead_stats 0
8682
8683         echo "Read 10M of data but cross 64M bundary"
8684         dd if=$DIR/$tfile of=/dev/null bs=10M skip=6 count=1
8685         local miss=$($LCTL get_param -n llite.*.read_ahead_stats |
8686                         get_named_value 'misses' | cut -d" " -f1 | calc_total)
8687         [ $miss -eq 1 ] || error "expected miss 1 but got $miss"
8688         rm -f $p $DIR/$tfile
8689 }
8690 run_test 101h "Readahead should cover current read window"
8691
8692 setup_test102() {
8693         test_mkdir $DIR/$tdir
8694         chown $RUNAS_ID $DIR/$tdir
8695         STRIPE_SIZE=65536
8696         STRIPE_OFFSET=1
8697         STRIPE_COUNT=$OSTCOUNT
8698         [[ $OSTCOUNT -gt 4 ]] && STRIPE_COUNT=4
8699
8700         trap cleanup_test102 EXIT
8701         cd $DIR
8702         $1 $LFS setstripe -S $STRIPE_SIZE -i $STRIPE_OFFSET -c $STRIPE_COUNT $tdir
8703         cd $DIR/$tdir
8704         for num in 1 2 3 4; do
8705                 for count in $(seq 1 $STRIPE_COUNT); do
8706                         for idx in $(seq 0 $[$STRIPE_COUNT - 1]); do
8707                                 local size=`expr $STRIPE_SIZE \* $num`
8708                                 local file=file"$num-$idx-$count"
8709                                 $1 $LFS setstripe -S $size -i $idx -c $count $file
8710                         done
8711                 done
8712         done
8713
8714         cd $DIR
8715         $1 tar cf $TMP/f102.tar $tdir --xattrs
8716 }
8717
8718 cleanup_test102() {
8719         trap 0
8720         rm -f $TMP/f102.tar
8721         rm -rf $DIR/d0.sanity/d102
8722 }
8723
8724 test_102a() {
8725         [ "$UID" != 0 ] && skip "must run as root"
8726         [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep xattr)" ] &&
8727                 skip_env "must have user_xattr"
8728
8729         [ -z "$(which setfattr 2>/dev/null)" ] &&
8730                 skip_env "could not find setfattr"
8731
8732         local testfile=$DIR/$tfile
8733
8734         touch $testfile
8735         echo "set/get xattr..."
8736         setfattr -n trusted.name1 -v value1 $testfile ||
8737                 error "setfattr -n trusted.name1=value1 $testfile failed"
8738         getfattr -n trusted.name1 $testfile 2> /dev/null |
8739           grep "trusted.name1=.value1" ||
8740                 error "$testfile missing trusted.name1=value1"
8741
8742         setfattr -n user.author1 -v author1 $testfile ||
8743                 error "setfattr -n user.author1=author1 $testfile failed"
8744         getfattr -n user.author1 $testfile 2> /dev/null |
8745           grep "user.author1=.author1" ||
8746                 error "$testfile missing trusted.author1=author1"
8747
8748         echo "listxattr..."
8749         setfattr -n trusted.name2 -v value2 $testfile ||
8750                 error "$testfile unable to set trusted.name2"
8751         setfattr -n trusted.name3 -v value3 $testfile ||
8752                 error "$testfile unable to set trusted.name3"
8753         [ $(getfattr -d -m "^trusted" $testfile 2> /dev/null |
8754             grep "trusted.name" | wc -l) -eq 3 ] ||
8755                 error "$testfile missing 3 trusted.name xattrs"
8756
8757         setfattr -n user.author2 -v author2 $testfile ||
8758                 error "$testfile unable to set user.author2"
8759         setfattr -n user.author3 -v author3 $testfile ||
8760                 error "$testfile unable to set user.author3"
8761         [ $(getfattr -d -m "^user" $testfile 2> /dev/null |
8762             grep "user.author" | wc -l) -eq 3 ] ||
8763                 error "$testfile missing 3 user.author xattrs"
8764
8765         echo "remove xattr..."
8766         setfattr -x trusted.name1 $testfile ||
8767                 error "$testfile error deleting trusted.name1"
8768         getfattr -d -m trusted $testfile 2> /dev/null | grep "trusted.name1" &&
8769                 error "$testfile did not delete trusted.name1 xattr"
8770
8771         setfattr -x user.author1 $testfile ||
8772                 error "$testfile error deleting user.author1"
8773         echo "set lustre special xattr ..."
8774         $LFS setstripe -c1 $testfile
8775         local lovea=$(getfattr -n "trusted.lov" -e hex $testfile |
8776                 awk -F "=" '/trusted.lov/ { print $2 }' )
8777         setfattr -n "trusted.lov" -v $lovea $testfile ||
8778                 error "$testfile doesn't ignore setting trusted.lov again"
8779         setfattr -n "trusted.lov" -v "invalid_value" $testfile &&
8780                 error "$testfile allow setting invalid trusted.lov"
8781         rm -f $testfile
8782 }
8783 run_test 102a "user xattr test =================================="
8784
8785 test_102b() {
8786         [ -z "$(which setfattr 2>/dev/null)" ] &&
8787                 skip_env "could not find setfattr"
8788         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
8789
8790         # b10930: get/set/list trusted.lov xattr
8791         echo "get/set/list trusted.lov xattr ..."
8792         local testfile=$DIR/$tfile
8793         $LFS setstripe -S 65536 -i 1 -c $OSTCOUNT $testfile ||
8794                 error "setstripe failed"
8795         local STRIPECOUNT=$($LFS getstripe -c $testfile) ||
8796                 error "getstripe failed"
8797         getfattr -d -m "^trusted" $testfile 2>/dev/null | grep "trusted.lov" ||
8798                 error "can't get trusted.lov from $testfile"
8799
8800         local testfile2=${testfile}2
8801         local value=$(getfattr -n trusted.lov $testfile 2>/dev/null |
8802                         grep "trusted.lov" | sed -e 's/[^=]\+=//')
8803
8804         $MCREATE $testfile2
8805         setfattr -n trusted.lov -v $value $testfile2
8806         local stripe_size=$($LFS getstripe -S $testfile2)
8807         local stripe_count=$($LFS getstripe -c $testfile2)
8808         [[ $stripe_size -eq 65536 ]] ||
8809                 error "stripe size $stripe_size != 65536"
8810         [[ $stripe_count -eq $STRIPECOUNT ]] ||
8811                 error "stripe count $stripe_count != $STRIPECOUNT"
8812         rm -f $DIR/$tfile
8813 }
8814 run_test 102b "getfattr/setfattr for trusted.lov EAs ============"
8815
8816 test_102c() {
8817         [ -z "$(which setfattr 2>/dev/null)" ] &&
8818                 skip_env "could not find setfattr"
8819         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
8820
8821         # b10930: get/set/list lustre.lov xattr
8822         echo "get/set/list lustre.lov xattr ..."
8823         test_mkdir $DIR/$tdir
8824         chown $RUNAS_ID $DIR/$tdir
8825         local testfile=$DIR/$tdir/$tfile
8826         $RUNAS $LFS setstripe -S 65536 -i 1 -c $OSTCOUNT $testfile ||
8827                 error "setstripe failed"
8828         local STRIPECOUNT=$($RUNAS $LFS getstripe -c $testfile) ||
8829                 error "getstripe failed"
8830         $RUNAS getfattr -d -m "^lustre" $testfile 2> /dev/null | \
8831         grep "lustre.lov" || error "can't get lustre.lov from $testfile"
8832
8833         local testfile2=${testfile}2
8834         local value=`getfattr -n lustre.lov $testfile 2> /dev/null | \
8835                      grep "lustre.lov" |sed -e 's/[^=]\+=//'  `
8836
8837         $RUNAS $MCREATE $testfile2
8838         $RUNAS setfattr -n lustre.lov -v $value $testfile2
8839         local stripe_size=$($RUNAS $LFS getstripe -S $testfile2)
8840         local stripe_count=$($RUNAS $LFS getstripe -c $testfile2)
8841         [ $stripe_size -eq 65536 ] || error "stripe size $stripe_size != 65536"
8842         [ $stripe_count -eq $STRIPECOUNT ] ||
8843                 error "stripe count $stripe_count != $STRIPECOUNT"
8844 }
8845 run_test 102c "non-root getfattr/setfattr for lustre.lov EAs ==========="
8846
8847 compare_stripe_info1() {
8848         local stripe_index_all_zero=true
8849
8850         for num in 1 2 3 4; do
8851                 for count in $(seq 1 $STRIPE_COUNT); do
8852                         for offset in $(seq 0 $[$STRIPE_COUNT - 1]); do
8853                                 local size=$((STRIPE_SIZE * num))
8854                                 local file=file"$num-$offset-$count"
8855                                 stripe_size=$($LFS getstripe -S $PWD/$file)
8856                                 [[ $stripe_size -ne $size ]] &&
8857                                     error "$file: size $stripe_size != $size"
8858                                 stripe_count=$($LFS getstripe -c $PWD/$file)
8859                                 # allow fewer stripes to be created, ORI-601
8860                                 [[ $stripe_count -lt $(((3 * count + 3) / 4)) ]] &&
8861                                     error "$file: count $stripe_count != $count"
8862                                 stripe_index=$($LFS getstripe -i $PWD/$file)
8863                                 [[ $stripe_index -ne 0 ]] &&
8864                                         stripe_index_all_zero=false
8865                         done
8866                 done
8867         done
8868         $stripe_index_all_zero &&
8869                 error "all files are being extracted starting from OST index 0"
8870         return 0
8871 }
8872
8873 have_xattrs_include() {
8874         tar --help | grep -q xattrs-include &&
8875                 echo --xattrs-include="lustre.*"
8876 }
8877
8878 test_102d() {
8879         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8880         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
8881
8882         XINC=$(have_xattrs_include)
8883         setup_test102
8884         tar xf $TMP/f102.tar -C $DIR/$tdir --xattrs $XINC
8885         cd $DIR/$tdir/$tdir
8886         compare_stripe_info1
8887 }
8888 run_test 102d "tar restore stripe info from tarfile,not keep osts"
8889
8890 test_102f() {
8891         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8892         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
8893
8894         XINC=$(have_xattrs_include)
8895         setup_test102
8896         test_mkdir $DIR/$tdir.restore
8897         cd $DIR
8898         tar cf - --xattrs $tdir | tar xf - \
8899                 -C $DIR/$tdir.restore --xattrs $XINC
8900         cd $DIR/$tdir.restore/$tdir
8901         compare_stripe_info1
8902 }
8903 run_test 102f "tar copy files, not keep osts"
8904
8905 grow_xattr() {
8906         [ -z "$(lctl get_param -n mdc.*.connect_flags | grep xattr)" ] &&
8907                 skip "must have user_xattr"
8908         [ -z "$(which setfattr 2>/dev/null)" ] &&
8909                 skip_env "could not find setfattr"
8910         [ -z "$(which getfattr 2>/dev/null)" ] &&
8911                 skip_env "could not find getfattr"
8912
8913         local xsize=${1:-1024}  # in bytes
8914         local file=$DIR/$tfile
8915         local value="$(generate_string $xsize)"
8916         local xbig=trusted.big
8917         local toobig=$2
8918
8919         touch $file
8920         log "save $xbig on $file"
8921         if [ -z "$toobig" ]
8922         then
8923                 setfattr -n $xbig -v $value $file ||
8924                         error "saving $xbig on $file failed"
8925         else
8926                 setfattr -n $xbig -v $value $file &&
8927                         error "saving $xbig on $file succeeded"
8928                 return 0
8929         fi
8930
8931         local orig=$(get_xattr_value $xbig $file)
8932         [[ "$orig" != "$value" ]] && error "$xbig different after saving $xbig"
8933
8934         local xsml=trusted.sml
8935         log "save $xsml on $file"
8936         setfattr -n $xsml -v val $file || error "saving $xsml on $file failed"
8937
8938         local new=$(get_xattr_value $xbig $file)
8939         [[ "$new" != "$orig" ]] && error "$xbig different after saving $xsml"
8940
8941         log "grow $xsml on $file"
8942         setfattr -n $xsml -v "$value" $file ||
8943                 error "growing $xsml on $file failed"
8944
8945         new=$(get_xattr_value $xbig $file)
8946         [[ "$new" != "$orig" ]] && error "$xbig different after growing $xsml"
8947         log "$xbig still valid after growing $xsml"
8948
8949         rm -f $file
8950 }
8951
8952 test_102h() { # bug 15777
8953         grow_xattr 1024
8954 }
8955 run_test 102h "grow xattr from inside inode to external block"
8956
8957 test_102ha() {
8958         large_xattr_enabled || skip_env "ea_inode feature disabled"
8959
8960         echo "setting xattr of max xattr size: $(max_xattr_size)"
8961         grow_xattr $(max_xattr_size)
8962
8963         echo "setting xattr of > max xattr size: $(max_xattr_size) + 10"
8964         echo "This should fail:"
8965         grow_xattr $(($(max_xattr_size) + 10)) 1
8966 }
8967 run_test 102ha "grow xattr from inside inode to external inode"
8968
8969 test_102i() { # bug 17038
8970         [ -z "$(which getfattr 2>/dev/null)" ] &&
8971                 skip "could not find getfattr"
8972
8973         touch $DIR/$tfile
8974         ln -s $DIR/$tfile $DIR/${tfile}link
8975         getfattr -n trusted.lov $DIR/$tfile ||
8976                 error "lgetxattr on $DIR/$tfile failed"
8977         getfattr -h -n trusted.lov $DIR/${tfile}link 2>&1 |
8978                 grep -i "no such attr" ||
8979                 error "error for lgetxattr on $DIR/${tfile}link is not ENODATA"
8980         rm -f $DIR/$tfile $DIR/${tfile}link
8981 }
8982 run_test 102i "lgetxattr test on symbolic link ============"
8983
8984 test_102j() {
8985         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8986         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
8987
8988         XINC=$(have_xattrs_include)
8989         setup_test102 "$RUNAS"
8990         chown $RUNAS_ID $DIR/$tdir
8991         $RUNAS tar xf $TMP/f102.tar -C $DIR/$tdir --xattrs $XINC
8992         cd $DIR/$tdir/$tdir
8993         compare_stripe_info1 "$RUNAS"
8994 }
8995 run_test 102j "non-root tar restore stripe info from tarfile, not keep osts ==="
8996
8997 test_102k() {
8998         [ -z "$(which setfattr 2>/dev/null)" ] &&
8999                 skip "could not find setfattr"
9000
9001         touch $DIR/$tfile
9002         # b22187 just check that does not crash for regular file.
9003         setfattr -n trusted.lov $DIR/$tfile
9004         # b22187 'setfattr -n trusted.lov' should remove LOV EA for directories
9005         local test_kdir=$DIR/$tdir
9006         test_mkdir $test_kdir
9007         local default_size=$($LFS getstripe -S $test_kdir)
9008         local default_count=$($LFS getstripe -c $test_kdir)
9009         local default_offset=$($LFS getstripe -i $test_kdir)
9010         $LFS setstripe -S 65536 -i 0 -c $OSTCOUNT $test_kdir ||
9011                 error 'dir setstripe failed'
9012         setfattr -n trusted.lov $test_kdir
9013         local stripe_size=$($LFS getstripe -S $test_kdir)
9014         local stripe_count=$($LFS getstripe -c $test_kdir)
9015         local stripe_offset=$($LFS getstripe -i $test_kdir)
9016         [ $stripe_size -eq $default_size ] ||
9017                 error "stripe size $stripe_size != $default_size"
9018         [ $stripe_count -eq $default_count ] ||
9019                 error "stripe count $stripe_count != $default_count"
9020         [ $stripe_offset -eq $default_offset ] ||
9021                 error "stripe offset $stripe_offset != $default_offset"
9022         rm -rf $DIR/$tfile $test_kdir
9023 }
9024 run_test 102k "setfattr without parameter of value shouldn't cause a crash"
9025
9026 test_102l() {
9027         [ -z "$(which getfattr 2>/dev/null)" ] &&
9028                 skip "could not find getfattr"
9029
9030         # LU-532 trusted. xattr is invisible to non-root
9031         local testfile=$DIR/$tfile
9032
9033         touch $testfile
9034
9035         echo "listxattr as user..."
9036         chown $RUNAS_ID $testfile
9037         $RUNAS getfattr -d -m '.*' $testfile 2>&1 |
9038             grep -q "trusted" &&
9039                 error "$testfile trusted xattrs are user visible"
9040
9041         return 0;
9042 }
9043 run_test 102l "listxattr size test =================================="
9044
9045 test_102m() { # LU-3403 llite: error of listxattr when buffer is small
9046         local path=$DIR/$tfile
9047         touch $path
9048
9049         listxattr_size_check $path || error "listattr_size_check $path failed"
9050 }
9051 run_test 102m "Ensure listxattr fails on small bufffer ========"
9052
9053 cleanup_test102
9054
9055 getxattr() { # getxattr path name
9056         # Return the base64 encoding of the value of xattr name on path.
9057         local path=$1
9058         local name=$2
9059
9060         # # getfattr --absolute-names --encoding=base64 --name=trusted.lov $path
9061         # file: $path
9062         # trusted.lov=0s0AvRCwEAAAAGAAAAAAAAAAAEAAACAAAAAAAQAAEAA...AAAAAAAAA=
9063         #
9064         # We print just 0s0AvRCwEAAAAGAAAAAAAAAAAEAAACAAAAAAAQAAEAA...AAAAAAAAA=
9065
9066         getfattr --absolute-names --encoding=base64 --name=$name $path |
9067                 awk -F= -v name=$name '$1 == name {
9068                         print substr($0, index($0, "=") + 1);
9069         }'
9070 }
9071
9072 test_102n() { # LU-4101 mdt: protect internal xattrs
9073         [ -z "$(which setfattr 2>/dev/null)" ] &&
9074                 skip "could not find setfattr"
9075         if [ $MDS1_VERSION -lt $(version_code 2.5.50) ]
9076         then
9077                 skip "MDT < 2.5.50 allows setxattr on internal trusted xattrs"
9078         fi
9079
9080         local file0=$DIR/$tfile.0
9081         local file1=$DIR/$tfile.1
9082         local xattr0=$TMP/$tfile.0
9083         local xattr1=$TMP/$tfile.1
9084         local namelist="lov lma lmv link fid version som hsm"
9085         local name
9086         local value
9087
9088         rm -rf $file0 $file1 $xattr0 $xattr1
9089         touch $file0 $file1
9090
9091         # Get 'before' xattrs of $file1.
9092         getfattr --absolute-names --dump --match=- $file1 > $xattr0
9093
9094         [ $MDS1_VERSION -lt $(version_code 2.8.53) ] &&
9095                 namelist+=" lfsck_namespace"
9096         for name in $namelist; do
9097                 # Try to copy xattr from $file0 to $file1.
9098                 value=$(getxattr $file0 trusted.$name 2> /dev/null)
9099
9100                 setfattr --name=trusted.$name --value="$value" $file1 ||
9101                         error "setxattr 'trusted.$name' failed"
9102
9103                 # Try to set a garbage xattr.
9104                 value=0sVGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIGl0c2VsZi4=
9105
9106                 if [[ x$name == "xlov" ]]; then
9107                         setfattr --name=trusted.lov --value="$value" $file1 &&
9108                         error "setxattr invalid 'trusted.lov' success"
9109                 else
9110                         setfattr --name=trusted.$name --value="$value" $file1 ||
9111                                 error "setxattr invalid 'trusted.$name' failed"
9112                 fi
9113
9114                 # Try to remove the xattr from $file1. We don't care if this
9115                 # appears to succeed or fail, we just don't want there to be
9116                 # any changes or crashes.
9117                 setfattr --remove=$trusted.$name $file1 2> /dev/null
9118         done
9119
9120         if [ $MDS1_VERSION -gt $(version_code 2.6.50) ]
9121         then
9122                 name="lfsck_ns"
9123                 # Try to copy xattr from $file0 to $file1.
9124                 value=$(getxattr $file0 trusted.$name 2> /dev/null)
9125
9126                 setfattr --name=trusted.$name --value="$value" $file1 ||
9127                         error "setxattr 'trusted.$name' failed"
9128
9129                 # Try to set a garbage xattr.
9130                 value=0sVGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIGl0c2VsZi4=
9131
9132                 setfattr --name=trusted.$name --value="$value" $file1 ||
9133                         error "setxattr 'trusted.$name' failed"
9134
9135                 # Try to remove the xattr from $file1. We don't care if this
9136                 # appears to succeed or fail, we just don't want there to be
9137                 # any changes or crashes.
9138                 setfattr --remove=$trusted.$name $file1 2> /dev/null
9139         fi
9140
9141         # Get 'after' xattrs of file1.
9142         getfattr --absolute-names --dump --match=- $file1 > $xattr1
9143
9144         if ! diff $xattr0 $xattr1; then
9145                 error "before and after xattrs of '$file1' differ"
9146         fi
9147
9148         rm -rf $file0 $file1 $xattr0 $xattr1
9149
9150         return 0
9151 }
9152 run_test 102n "silently ignore setxattr on internal trusted xattrs"
9153
9154 test_102p() { # LU-4703 setxattr did not check ownership
9155         [ $MDS1_VERSION -lt $(version_code 2.5.56) ] &&
9156                 skip "MDS needs to be at least 2.5.56"
9157
9158         local testfile=$DIR/$tfile
9159
9160         touch $testfile
9161
9162         echo "setfacl as user..."
9163         $RUNAS setfacl -m "u:$RUNAS_ID:rwx" $testfile
9164         [ $? -ne 0 ] || error "setfacl by $RUNAS_ID was allowed on $testfile"
9165
9166         echo "setfattr as user..."
9167         setfacl -m "u:$RUNAS_ID:---" $testfile
9168         $RUNAS setfattr -x system.posix_acl_access $testfile
9169         [ $? -ne 0 ] || error "setfattr by $RUNAS_ID was allowed on $testfile"
9170 }
9171 run_test 102p "check setxattr(2) correctly fails without permission"
9172
9173 test_102q() {
9174         [ $MDS1_VERSION -lt $(version_code 2.6.92) ] &&
9175                 skip "MDS needs to be at least 2.6.92"
9176
9177         orphan_linkea_check $DIR/$tfile || error "orphan_linkea_check"
9178 }
9179 run_test 102q "flistxattr should not return trusted.link EAs for orphans"
9180
9181 test_102r() {
9182         [ $MDS1_VERSION -lt $(version_code 2.6.93) ] &&
9183                 skip "MDS needs to be at least 2.6.93"
9184
9185         touch $DIR/$tfile || error "touch"
9186         setfattr -n user.$(basename $tfile) $DIR/$tfile || error "setfattr"
9187         getfattr -n user.$(basename $tfile) $DIR/$tfile || error "getfattr"
9188         rm $DIR/$tfile || error "rm"
9189
9190         #normal directory
9191         mkdir -p $DIR/$tdir || error "mkdir"
9192         setfattr -n user.$(basename $tdir) $DIR/$tdir || error "setfattr dir"
9193         getfattr -n user.$(basename $tdir) $DIR/$tdir || error "getfattr dir"
9194         setfattr -x user.$(basename $tdir) $DIR/$tdir ||
9195                 error "$testfile error deleting user.author1"
9196         getfattr -d -m user.$(basename $tdir) 2> /dev/null |
9197                 grep "user.$(basename $tdir)" &&
9198                 error "$tdir did not delete user.$(basename $tdir)"
9199         rmdir $DIR/$tdir || error "rmdir"
9200
9201         #striped directory
9202         test_mkdir $DIR/$tdir
9203         setfattr -n user.$(basename $tdir) $DIR/$tdir || error "setfattr dir"
9204         getfattr -n user.$(basename $tdir) $DIR/$tdir || error "getfattr dir"
9205         setfattr -x user.$(basename $tdir) $DIR/$tdir ||
9206                 error "$testfile error deleting user.author1"
9207         getfattr -d -m user.$(basename $tdir) 2> /dev/null |
9208                 grep "user.$(basename $tdir)" &&
9209                 error "$tdir did not delete user.$(basename $tdir)"
9210         rmdir $DIR/$tdir || error "rm striped dir"
9211 }
9212 run_test 102r "set EAs with empty values"
9213
9214 test_102s() {
9215         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
9216                 skip "MDS needs to be at least 2.11.52"
9217
9218         local save="$TMP/$TESTSUITE-$TESTNAME.parameters"
9219
9220         save_lustre_params client "llite.*.xattr_cache" > $save
9221
9222         for cache in 0 1; do
9223                 lctl set_param llite.*.xattr_cache=$cache
9224
9225                 rm -f $DIR/$tfile
9226                 touch $DIR/$tfile || error "touch"
9227                 for prefix in lustre security system trusted user; do
9228                         # Note getxattr() may fail with 'Operation not
9229                         # supported' or 'No such attribute' depending
9230                         # on prefix and cache.
9231                         getfattr -n $prefix.n102s $DIR/$tfile &&
9232                                 error "getxattr '$prefix.n102s' should fail (cache = $cache)"
9233                 done
9234         done
9235
9236         restore_lustre_params < $save
9237 }
9238 run_test 102s "getting nonexistent xattrs should fail"
9239
9240 test_102t() {
9241         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
9242                 skip "MDS needs to be at least 2.11.52"
9243
9244         local save="$TMP/$TESTSUITE-$TESTNAME.parameters"
9245
9246         save_lustre_params client "llite.*.xattr_cache" > $save
9247
9248         for cache in 0 1; do
9249                 lctl set_param llite.*.xattr_cache=$cache
9250
9251                 for buf_size in 0 256; do
9252                         rm -f $DIR/$tfile
9253                         touch $DIR/$tfile || error "touch"
9254                         setfattr -n user.multiop $DIR/$tfile
9255                         $MULTIOP $DIR/$tfile oa$buf_size ||
9256                                 error "cannot get zero length xattr value (buf_size = $buf_size)"
9257                 done
9258         done
9259
9260         restore_lustre_params < $save
9261 }
9262 run_test 102t "zero length xattr values handled correctly"
9263
9264 run_acl_subtest()
9265 {
9266     $LUSTRE/tests/acl/run $LUSTRE/tests/acl/$1.test
9267     return $?
9268 }
9269
9270 test_103a() {
9271         [ "$UID" != 0 ] && skip "must run as root"
9272         $GSS && skip_env "could not run under gss"
9273         [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep acl)" ] &&
9274                 skip_env "must have acl enabled"
9275         [ -z "$(which setfacl 2>/dev/null)" ] &&
9276                 skip_env "could not find setfacl"
9277         remote_mds_nodsh && skip "remote MDS with nodsh"
9278
9279         gpasswd -a daemon bin                           # LU-5641
9280         do_facet $SINGLEMDS gpasswd -a daemon bin       # LU-5641
9281
9282         declare -a identity_old
9283
9284         for num in $(seq $MDSCOUNT); do
9285                 switch_identity $num true || identity_old[$num]=$?
9286         done
9287
9288         SAVE_UMASK=$(umask)
9289         umask 0022
9290         mkdir -p $DIR/$tdir
9291         cd $DIR/$tdir
9292
9293         echo "performing cp ..."
9294         run_acl_subtest cp || error "run_acl_subtest cp failed"
9295         echo "performing getfacl-noacl..."
9296         run_acl_subtest getfacl-noacl || error "getfacl-noacl test failed"
9297         echo "performing misc..."
9298         run_acl_subtest misc || error  "misc test failed"
9299         echo "performing permissions..."
9300         run_acl_subtest permissions || error "permissions failed"
9301         # LU-1482 mdd: Setting xattr are properly checked with and without ACLs
9302         if [ $MDS1_VERSION -gt $(version_code 2.8.55) ] ||
9303                 { [ $MDS1_VERSION -lt $(version_code 2.6) ] &&
9304                         [ $MDS1_VERSION -ge $(version_code 2.5.29) ]; }
9305         then
9306                 echo "performing permissions xattr..."
9307                 run_acl_subtest permissions_xattr ||
9308                         error "permissions_xattr failed"
9309         fi
9310         echo "performing setfacl..."
9311         run_acl_subtest setfacl || error  "setfacl test failed"
9312
9313         # inheritance test got from HP
9314         echo "performing inheritance..."
9315         cp $LUSTRE/tests/acl/make-tree . || error "cannot copy make-tree"
9316         chmod +x make-tree || error "chmod +x failed"
9317         run_acl_subtest inheritance || error "inheritance test failed"
9318         rm -f make-tree
9319
9320         echo "LU-974 ignore umask when acl is enabled..."
9321         run_acl_subtest 974 || error "LU-974 umask test failed"
9322         if [ $MDSCOUNT -ge 2 ]; then
9323                 run_acl_subtest 974_remote ||
9324                         error "LU-974 umask test failed under remote dir"
9325         fi
9326
9327         echo "LU-2561 newly created file is same size as directory..."
9328         if [ "$mds1_FSTYPE" != "zfs" ]; then
9329                 run_acl_subtest 2561 || error "LU-2561 test failed"
9330         else
9331                 run_acl_subtest 2561_zfs || error "LU-2561 zfs test failed"
9332         fi
9333
9334         run_acl_subtest 4924 || error "LU-4924 test failed"
9335
9336         cd $SAVE_PWD
9337         umask $SAVE_UMASK
9338
9339         for num in $(seq $MDSCOUNT); do
9340                 if [ "${identity_old[$num]}" = 1 ]; then
9341                         switch_identity $num false || identity_old[$num]=$?
9342                 fi
9343         done
9344 }
9345 run_test 103a "acl test"
9346
9347 test_103b() {
9348         declare -a pids
9349         local U
9350
9351         for U in {0..511}; do
9352                 {
9353                 local O=$(printf "%04o" $U)
9354
9355                 umask $(printf "%04o" $((511 ^ $O)))
9356                 $LFS setstripe -c 1 $DIR/$tfile.s$O
9357                 local S=$(printf "%04o" 0$(stat -c%a $DIR/$tfile.s$O))
9358
9359                 (( $S == ($O & 0666) )) ||
9360                         error "lfs setstripe $DIR/$tfile.s$O '$S' != '$O'"
9361
9362                 $LFS setstripe -E16M -c 1 -E1G -S4M $DIR/$tfile.p$O
9363                 S=$(printf "%04o" 0$(stat -c%a $DIR/$tfile.p$O))
9364                 (( $S == ($O & 0666) )) ||
9365                         error "lfs setstripe -E $DIR/$tfile.p$O '$S' != '$O'"
9366
9367                 $LFS setstripe -N2 -c 1 $DIR/$tfile.m$O
9368                 S=$(printf "%04o" 0$(stat -c%a $DIR/$tfile.m$O))
9369                 (( $S == ($O & 0666) )) ||
9370                         error "lfs setstripe -N2 $DIR/$tfile.m$O '$S' != '$O'"
9371                 rm -f $DIR/$tfile.[smp]$0
9372                 } &
9373                 local pid=$!
9374
9375                 # limit the concurrently running threads to 64. LU-11878
9376                 local idx=$((U % 64))
9377                 [ -z "${pids[idx]}" ] || wait ${pids[idx]}
9378                 pids[idx]=$pid
9379         done
9380         wait
9381 }
9382 run_test 103b "umask lfs setstripe"
9383
9384 test_103c() {
9385         mkdir -p $DIR/$tdir
9386         cp -rp $DIR/$tdir $DIR/$tdir.bak
9387
9388         [ -n "$(getfattr -d -m. $DIR/$tdir | grep posix_acl_default)" ] &&
9389                 error "$DIR/$tdir shouldn't contain default ACL"
9390         [ -n "$(getfattr -d -m. $DIR/$tdir.bak | grep posix_acl_default)" ] &&
9391                 error "$DIR/$tdir.bak shouldn't contain default ACL"
9392         true
9393 }
9394 run_test 103c "'cp -rp' won't set empty acl"
9395
9396 test_104a() {
9397         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9398
9399         touch $DIR/$tfile
9400         lfs df || error "lfs df failed"
9401         lfs df -ih || error "lfs df -ih failed"
9402         lfs df -h $DIR || error "lfs df -h $DIR failed"
9403         lfs df -i $DIR || error "lfs df -i $DIR failed"
9404         lfs df $DIR/$tfile || error "lfs df $DIR/$tfile failed"
9405         lfs df -ih $DIR/$tfile || error "lfs df -ih $DIR/$tfile failed"
9406
9407         local OSC=$(lctl dl | grep OST0000-osc-[^M] | awk '{ print $4 }')
9408         lctl --device %$OSC deactivate
9409         lfs df || error "lfs df with deactivated OSC failed"
9410         lctl --device %$OSC activate
9411         # wait the osc back to normal
9412         wait_osc_import_ready client ost
9413
9414         lfs df || error "lfs df with reactivated OSC failed"
9415         rm -f $DIR/$tfile
9416 }
9417 run_test 104a "lfs df [-ih] [path] test ========================="
9418
9419 test_104b() {
9420         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9421         [ $RUNAS_ID -eq $UID ] &&
9422                 skip_env "RUNAS_ID = UID = $UID -- skipping"
9423
9424         denied_cnt=$(($($RUNAS $LFS check servers 2>&1 |
9425                         grep "Permission denied" | wc -l)))
9426         if [ $denied_cnt -ne 0 ]; then
9427                 error "lfs check servers test failed"
9428         fi
9429 }
9430 run_test 104b "$RUNAS lfs check servers test ===================="
9431
9432 test_105a() {
9433         # doesn't work on 2.4 kernels
9434         touch $DIR/$tfile
9435         if $(flock_is_enabled); then
9436                 flocks_test 1 on -f $DIR/$tfile || error "fail flock on"
9437         else
9438                 flocks_test 1 off -f $DIR/$tfile || error "fail flock off"
9439         fi
9440         rm -f $DIR/$tfile
9441 }
9442 run_test 105a "flock when mounted without -o flock test ========"
9443
9444 test_105b() {
9445         touch $DIR/$tfile
9446         if $(flock_is_enabled); then
9447                 flocks_test 1 on -c $DIR/$tfile || error "fail flock on"
9448         else
9449                 flocks_test 1 off -c $DIR/$tfile || error "fail flock off"
9450         fi
9451         rm -f $DIR/$tfile
9452 }
9453 run_test 105b "fcntl when mounted without -o flock test ========"
9454
9455 test_105c() {
9456         touch $DIR/$tfile
9457         if $(flock_is_enabled); then
9458                 flocks_test 1 on -l $DIR/$tfile || error "fail flock on"
9459         else
9460                 flocks_test 1 off -l $DIR/$tfile || error "fail flock off"
9461         fi
9462         rm -f $DIR/$tfile
9463 }
9464 run_test 105c "lockf when mounted without -o flock test"
9465
9466 test_105d() { # bug 15924
9467         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9468
9469         test_mkdir $DIR/$tdir
9470         flock_is_enabled || skip_env "mount w/o flock enabled"
9471         #define OBD_FAIL_LDLM_CP_CB_WAIT  0x315
9472         $LCTL set_param fail_loc=0x80000315
9473         flocks_test 2 $DIR/$tdir
9474 }
9475 run_test 105d "flock race (should not freeze) ========"
9476
9477 test_105e() { # bug 22660 && 22040
9478         flock_is_enabled || skip_env "mount w/o flock enabled"
9479
9480         touch $DIR/$tfile
9481         flocks_test 3 $DIR/$tfile
9482 }
9483 run_test 105e "Two conflicting flocks from same process"
9484
9485 test_106() { #bug 10921
9486         test_mkdir $DIR/$tdir
9487         $DIR/$tdir && error "exec $DIR/$tdir succeeded"
9488         chmod 777 $DIR/$tdir || error "chmod $DIR/$tdir failed"
9489 }
9490 run_test 106 "attempt exec of dir followed by chown of that dir"
9491
9492 test_107() {
9493         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9494
9495         CDIR=`pwd`
9496         local file=core
9497
9498         cd $DIR
9499         rm -f $file
9500
9501         local save_pattern=$(sysctl -n kernel.core_pattern)
9502         local save_uses_pid=$(sysctl -n kernel.core_uses_pid)
9503         sysctl -w kernel.core_pattern=$file
9504         sysctl -w kernel.core_uses_pid=0
9505
9506         ulimit -c unlimited
9507         sleep 60 &
9508         SLEEPPID=$!
9509
9510         sleep 1
9511
9512         kill -s 11 $SLEEPPID
9513         wait $SLEEPPID
9514         if [ -e $file ]; then
9515                 size=`stat -c%s $file`
9516                 [ $size -eq 0 ] && error "Fail to create core file $file"
9517         else
9518                 error "Fail to create core file $file"
9519         fi
9520         rm -f $file
9521         sysctl -w kernel.core_pattern=$save_pattern
9522         sysctl -w kernel.core_uses_pid=$save_uses_pid
9523         cd $CDIR
9524 }
9525 run_test 107 "Coredump on SIG"
9526
9527 test_110() {
9528         test_mkdir $DIR/$tdir
9529         test_mkdir $DIR/$tdir/$(str_repeat 'a' 255)
9530         $LFS mkdir -c $MDSCOUNT $DIR/$tdir/$(str_repeat 'b' 256) &&
9531                 error "mkdir with 256 char should fail, but did not"
9532         touch $DIR/$tdir/$(str_repeat 'x' 255) ||
9533                 error "create with 255 char failed"
9534         touch $DIR/$tdir/$(str_repeat 'y' 256) &&
9535                 error "create with 256 char should fail, but did not"
9536
9537         ls -l $DIR/$tdir
9538         rm -rf $DIR/$tdir
9539 }
9540 run_test 110 "filename length checking"
9541
9542 #
9543 # Purpose: To verify dynamic thread (OSS) creation.
9544 #
9545 test_115() {
9546         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9547         remote_ost_nodsh && skip "remote OST with nodsh"
9548
9549         # Lustre does not stop service threads once they are started.
9550         # Reset number of running threads to default.
9551         stopall
9552         setupall
9553
9554         local OSTIO_pre
9555         local save_params="$TMP/sanity-$TESTNAME.parameters"
9556
9557         # Get ll_ost_io count before I/O
9558         OSTIO_pre=$(do_facet ost1 \
9559                 "$LCTL get_param ost.OSS.ost_io.threads_started | cut -d= -f2")
9560         # Exit if lustre is not running (ll_ost_io not running).
9561         [ -z "$OSTIO_pre" ] && error "no OSS threads"
9562
9563         echo "Starting with $OSTIO_pre threads"
9564         local thread_max=$((OSTIO_pre * 2))
9565         local rpc_in_flight=$((thread_max * 2))
9566         # Number of I/O Process proposed to be started.
9567         local nfiles
9568         local facets=$(get_facets OST)
9569
9570         save_lustre_params client "osc.*OST*.max_rpcs_in_flight" > $save_params
9571         save_lustre_params $facets "ost.OSS.ost_io.threads_max" >> $save_params
9572
9573         # Set in_flight to $rpc_in_flight
9574         $LCTL set_param osc.*OST*.max_rpcs_in_flight=$rpc_in_flight ||
9575                 error "Failed to set max_rpcs_in_flight to $rpc_in_flight"
9576         nfiles=${rpc_in_flight}
9577         # Set ost thread_max to $thread_max
9578         do_facet ost1 "$LCTL set_param ost.OSS.ost_io.threads_max=$thread_max"
9579
9580         # 5 Minutes should be sufficient for max number of OSS
9581         # threads(thread_max) to be created.
9582         local timeout=300
9583
9584         # Start I/O.
9585         local WTL=${WTL:-"$LUSTRE/tests/write_time_limit"}
9586         test_mkdir $DIR/$tdir
9587         for i in $(seq $nfiles); do
9588                 local file=$DIR/$tdir/${tfile}-$i
9589                 $LFS setstripe -c -1 -i 0 $file
9590                 ($WTL $file $timeout)&
9591         done
9592
9593         # I/O Started - Wait for thread_started to reach thread_max or report
9594         # error if thread_started is more than thread_max.
9595         echo "Waiting for thread_started to reach thread_max"
9596         local thread_started=0
9597         local end_time=$((SECONDS + timeout))
9598
9599         while [ $SECONDS -le $end_time ] ; do
9600                 echo -n "."
9601                 # Get ost i/o thread_started count.
9602                 thread_started=$(do_facet ost1 \
9603                         "$LCTL get_param \
9604                         ost.OSS.ost_io.threads_started | cut -d= -f2")
9605                 # Break out if thread_started is equal/greater than thread_max
9606                 if [[ $thread_started -ge $thread_max ]]; then
9607                         echo ll_ost_io thread_started $thread_started, \
9608                                 equal/greater than thread_max $thread_max
9609                         break
9610                 fi
9611                 sleep 1
9612         done
9613
9614         # Cleanup - We have the numbers, Kill i/o jobs if running.
9615         jobcount=($(jobs -p))
9616         for i in $(seq 0 $((${#jobcount[@]}-1)))
9617         do
9618                 kill -9 ${jobcount[$i]}
9619                 if [ $? -ne 0 ] ; then
9620                         echo Warning: \
9621                         Failed to Kill \'WTL\(I/O\)\' with pid ${jobcount[$i]}
9622                 fi
9623         done
9624
9625         # Cleanup files left by WTL binary.
9626         for i in $(seq $nfiles); do
9627                 local file=$DIR/$tdir/${tfile}-$i
9628                 rm -rf $file
9629                 if [ $? -ne 0 ] ; then
9630                         echo "Warning: Failed to delete file $file"
9631                 fi
9632         done
9633
9634         restore_lustre_params <$save_params
9635         rm -f $save_params || echo "Warning: delete file '$save_params' failed"
9636
9637         # Error out if no new thread has started or Thread started is greater
9638         # than thread max.
9639         if [[ $thread_started -le $OSTIO_pre ||
9640                         $thread_started -gt $thread_max ]]; then
9641                 error "ll_ost_io: thread_started $thread_started" \
9642                       "OSTIO_pre $OSTIO_pre, thread_max $thread_max." \
9643                       "No new thread started or thread started greater " \
9644                       "than thread_max."
9645         fi
9646 }
9647 run_test 115 "verify dynamic thread creation===================="
9648
9649 free_min_max () {
9650         wait_delete_completed
9651         AVAIL=($(lctl get_param -n osc.*[oO][sS][cC]-[^M]*.kbytesavail))
9652         echo "OST kbytes available: ${AVAIL[@]}"
9653         MAXV=${AVAIL[0]}
9654         MAXI=0
9655         MINV=${AVAIL[0]}
9656         MINI=0
9657         for ((i = 0; i < ${#AVAIL[@]}; i++)); do
9658                 #echo OST $i: ${AVAIL[i]}kb
9659                 if [[ ${AVAIL[i]} -gt $MAXV ]]; then
9660                         MAXV=${AVAIL[i]}
9661                         MAXI=$i
9662                 fi
9663                 if [[ ${AVAIL[i]} -lt $MINV ]]; then
9664                         MINV=${AVAIL[i]}
9665                         MINI=$i
9666                 fi
9667         done
9668         echo "Min free space: OST $MINI: $MINV"
9669         echo "Max free space: OST $MAXI: $MAXV"
9670 }
9671
9672 test_116a() { # was previously test_116()
9673         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9674         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
9675         remote_mds_nodsh && skip "remote MDS with nodsh"
9676
9677         echo -n "Free space priority "
9678         do_facet $SINGLEMDS lctl get_param -n lo[vd].*-mdtlov.qos_prio_free |
9679                 head -n1
9680         declare -a AVAIL
9681         free_min_max
9682
9683         [ $MINV -eq 0 ] && skip "no free space in OST$MINI, skip"
9684         [ $MINV -gt 10000000 ] && skip "too much free space in OST$MINI, skip"
9685         trap simple_cleanup_common EXIT
9686
9687         # Check if we need to generate uneven OSTs
9688         test_mkdir -p $DIR/$tdir/OST${MINI}
9689         local FILL=$((MINV / 4))
9690         local DIFF=$((MAXV - MINV))
9691         local DIFF2=$((DIFF * 100 / MINV))
9692
9693         local threshold=$(do_facet $SINGLEMDS \
9694                 lctl get_param -n *.*MDT0000-mdtlov.qos_threshold_rr | head -n1)
9695         threshold=${threshold%%%}
9696         echo -n "Check for uneven OSTs: "
9697         echo -n "diff=${DIFF}KB (${DIFF2}%) must be > ${threshold}% ..."
9698
9699         if [[ $DIFF2 -gt $threshold ]]; then
9700                 echo "ok"
9701                 echo "Don't need to fill OST$MINI"
9702         else
9703                 # generate uneven OSTs. Write 2% over the QOS threshold value
9704                 echo "no"
9705                 DIFF=$((threshold - DIFF2 + 2))
9706                 DIFF2=$((MINV * DIFF / 100))
9707                 echo "Fill $DIFF% remaining space in OST$MINI with ${DIFF2}KB"
9708                 $LFS setstripe -i $MINI -c 1 $DIR/$tdir/OST${MINI} ||
9709                         error "setstripe failed"
9710                 DIFF=$((DIFF2 / 2048))
9711                 i=0
9712                 while [ $i -lt $DIFF ]; do
9713                         i=$((i + 1))
9714                         dd if=/dev/zero of=$DIR/$tdir/OST${MINI}/$tfile-$i \
9715                                 bs=2M count=1 2>/dev/null
9716                         echo -n .
9717                 done
9718                 echo .
9719                 sync
9720                 sleep_maxage
9721                 free_min_max
9722         fi
9723
9724         DIFF=$((MAXV - MINV))
9725         DIFF2=$((DIFF * 100 / MINV))
9726         echo -n "diff=$DIFF=$DIFF2% must be > $threshold% for QOS mode..."
9727         if [ $DIFF2 -gt $threshold ]; then
9728                 echo "ok"
9729         else
9730                 echo "failed - QOS mode won't be used"
9731                 simple_cleanup_common
9732                 skip "QOS imbalance criteria not met"
9733         fi
9734
9735         MINI1=$MINI
9736         MINV1=$MINV
9737         MAXI1=$MAXI
9738         MAXV1=$MAXV
9739
9740         # now fill using QOS
9741         $LFS setstripe -c 1 $DIR/$tdir
9742         FILL=$((FILL / 200))
9743         if [ $FILL -gt 600 ]; then
9744                 FILL=600
9745         fi
9746         echo "writing $FILL files to QOS-assigned OSTs"
9747         i=0
9748         while [ $i -lt $FILL ]; do
9749                 i=$((i + 1))
9750                 dd if=/dev/zero of=$DIR/$tdir/$tfile-$i bs=200k \
9751                         count=1 2>/dev/null
9752                 echo -n .
9753         done
9754         echo "wrote $i 200k files"
9755         sync
9756         sleep_maxage
9757
9758         echo "Note: free space may not be updated, so measurements might be off"
9759         free_min_max
9760         DIFF2=$((MAXV - MINV))
9761         echo "free space delta: orig $DIFF final $DIFF2"
9762         [ $DIFF2 -gt $DIFF ] && echo "delta got worse!"
9763         DIFF=$((MINV1 - ${AVAIL[$MINI1]}))
9764         echo "Wrote ${DIFF}KB to smaller OST $MINI1"
9765         DIFF2=$((MAXV1 - ${AVAIL[$MAXI1]}))
9766         echo "Wrote ${DIFF2}KB to larger OST $MAXI1"
9767         if [[ $DIFF -gt 0 ]]; then
9768                 FILL=$((DIFF2 * 100 / DIFF - 100))
9769                 echo "Wrote ${FILL}% more data to larger OST $MAXI1"
9770         fi
9771
9772         # Figure out which files were written where
9773         UUID=$(lctl get_param -n lov.${FSNAME}-clilov-*.target_obd |
9774                awk '/'$MINI1': / {print $2; exit}')
9775         echo $UUID
9776         MINC=$($LFS getstripe --ost $UUID $DIR/$tdir | grep $DIR | wc -l)
9777         echo "$MINC files created on smaller OST $MINI1"
9778         UUID=$(lctl get_param -n lov.${FSNAME}-clilov-*.target_obd |
9779                awk '/'$MAXI1': / {print $2; exit}')
9780         echo $UUID
9781         MAXC=$($LFS getstripe --ost $UUID $DIR/$tdir | grep $DIR | wc -l)
9782         echo "$MAXC files created on larger OST $MAXI1"
9783         if [[ $MINC -gt 0 ]]; then
9784                 FILL=$((MAXC * 100 / MINC - 100))
9785                 echo "Wrote ${FILL}% more files to larger OST $MAXI1"
9786         fi
9787         [[ $MAXC -gt $MINC ]] ||
9788                 error_ignore LU-9 "stripe QOS didn't balance free space"
9789         simple_cleanup_common
9790 }
9791 run_test 116a "stripe QOS: free space balance ==================="
9792
9793 test_116b() { # LU-2093
9794         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9795         remote_mds_nodsh && skip "remote MDS with nodsh"
9796
9797 #define OBD_FAIL_MDS_OSC_CREATE_FAIL     0x147
9798         local old_rr=$(do_facet $SINGLEMDS lctl get_param -n \
9799                        lo[vd].$FSNAME-MDT0000-mdtlov.qos_threshold_rr | head -1)
9800         [ -z "$old_rr" ] && skip "no QOS"
9801         do_facet $SINGLEMDS lctl set_param \
9802                 lo[vd].$FSNAME-MDT0000-mdtlov.qos_threshold_rr=0
9803         mkdir -p $DIR/$tdir
9804         do_facet $SINGLEMDS lctl set_param fail_loc=0x147
9805         createmany -o $DIR/$tdir/f- 20 || error "can't create"
9806         do_facet $SINGLEMDS lctl set_param fail_loc=0
9807         rm -rf $DIR/$tdir
9808         do_facet $SINGLEMDS lctl set_param \
9809                 lo[vd].$FSNAME-MDT0000-mdtlov.qos_threshold_rr=$old_rr
9810 }
9811 run_test 116b "QoS shouldn't LBUG if not enough OSTs found on the 2nd pass"
9812
9813 test_117() # bug 10891
9814 {
9815         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9816
9817         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1
9818         #define OBD_FAIL_OST_SETATTR_CREDITS 0x21e
9819         lctl set_param fail_loc=0x21e
9820         > $DIR/$tfile || error "truncate failed"
9821         lctl set_param fail_loc=0
9822         echo "Truncate succeeded."
9823         rm -f $DIR/$tfile
9824 }
9825 run_test 117 "verify osd extend =========="
9826
9827 NO_SLOW_RESENDCOUNT=4
9828 export OLD_RESENDCOUNT=""
9829 set_resend_count () {
9830         local PROC_RESENDCOUNT="osc.${FSNAME}-OST*-osc-*.resend_count"
9831         OLD_RESENDCOUNT=$(lctl get_param -n $PROC_RESENDCOUNT | head -n1)
9832         lctl set_param -n $PROC_RESENDCOUNT $1
9833         echo resend_count is set to $(lctl get_param -n $PROC_RESENDCOUNT)
9834 }
9835
9836 # for reduce test_118* time (b=14842)
9837 [ "$SLOW" = "no" ] && set_resend_count $NO_SLOW_RESENDCOUNT
9838
9839 # Reset async IO behavior after error case
9840 reset_async() {
9841         FILE=$DIR/reset_async
9842
9843         # Ensure all OSCs are cleared
9844         $LFS setstripe -c -1 $FILE
9845         dd if=/dev/zero of=$FILE bs=64k count=$OSTCOUNT
9846         sync
9847         rm $FILE
9848 }
9849
9850 test_118a() #bug 11710
9851 {
9852         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9853
9854         reset_async
9855
9856         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
9857         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
9858         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
9859
9860         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
9861                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
9862                 return 1;
9863         fi
9864         rm -f $DIR/$tfile
9865 }
9866 run_test 118a "verify O_SYNC works =========="
9867
9868 test_118b()
9869 {
9870         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9871         remote_ost_nodsh && skip "remote OST with nodsh"
9872
9873         reset_async
9874
9875         #define OBD_FAIL_SRV_ENOENT 0x217
9876         set_nodes_failloc "$(osts_nodes)" 0x217
9877         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
9878         RC=$?
9879         set_nodes_failloc "$(osts_nodes)" 0
9880         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
9881         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
9882                     grep -c writeback)
9883
9884         if [[ $RC -eq 0 ]]; then
9885                 error "Must return error due to dropped pages, rc=$RC"
9886                 return 1;
9887         fi
9888
9889         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
9890                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
9891                 return 1;
9892         fi
9893
9894         echo "Dirty pages not leaked on ENOENT"
9895
9896         # Due to the above error the OSC will issue all RPCs syncronously
9897         # until a subsequent RPC completes successfully without error.
9898         $MULTIOP $DIR/$tfile Ow4096yc
9899         rm -f $DIR/$tfile
9900
9901         return 0
9902 }
9903 run_test 118b "Reclaim dirty pages on fatal error =========="
9904
9905 test_118c()
9906 {
9907         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9908
9909         # for 118c, restore the original resend count, LU-1940
9910         [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] &&
9911                                 set_resend_count $OLD_RESENDCOUNT
9912         remote_ost_nodsh && skip "remote OST with nodsh"
9913
9914         reset_async
9915
9916         #define OBD_FAIL_OST_EROFS               0x216
9917         set_nodes_failloc "$(osts_nodes)" 0x216
9918
9919         # multiop should block due to fsync until pages are written
9920         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
9921         MULTIPID=$!
9922         sleep 1
9923
9924         if [[ `ps h -o comm -p $MULTIPID` != "multiop" ]]; then
9925                 error "Multiop failed to block on fsync, pid=$MULTIPID"
9926         fi
9927
9928         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
9929                     grep -c writeback)
9930         if [[ $WRITEBACK -eq 0 ]]; then
9931                 error "No page in writeback, writeback=$WRITEBACK"
9932         fi
9933
9934         set_nodes_failloc "$(osts_nodes)" 0
9935         wait $MULTIPID
9936         RC=$?
9937         if [[ $RC -ne 0 ]]; then
9938                 error "Multiop fsync failed, rc=$RC"
9939         fi
9940
9941         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
9942         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
9943                     grep -c writeback)
9944         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
9945                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
9946         fi
9947
9948         rm -f $DIR/$tfile
9949         echo "Dirty pages flushed via fsync on EROFS"
9950         return 0
9951 }
9952 run_test 118c "Fsync blocks on EROFS until dirty pages are flushed =========="
9953
9954 # continue to use small resend count to reduce test_118* time (b=14842)
9955 [ "$SLOW" = "no" ] && set_resend_count $NO_SLOW_RESENDCOUNT
9956
9957 test_118d()
9958 {
9959         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9960         remote_ost_nodsh && skip "remote OST with nodsh"
9961
9962         reset_async
9963
9964         #define OBD_FAIL_OST_BRW_PAUSE_BULK
9965         set_nodes_failloc "$(osts_nodes)" 0x214
9966         # multiop should block due to fsync until pages are written
9967         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
9968         MULTIPID=$!
9969         sleep 1
9970
9971         if [[ `ps h -o comm -p $MULTIPID` != "multiop" ]]; then
9972                 error "Multiop failed to block on fsync, pid=$MULTIPID"
9973         fi
9974
9975         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
9976                     grep -c writeback)
9977         if [[ $WRITEBACK -eq 0 ]]; then
9978                 error "No page in writeback, writeback=$WRITEBACK"
9979         fi
9980
9981         wait $MULTIPID || error "Multiop fsync failed, rc=$?"
9982         set_nodes_failloc "$(osts_nodes)" 0
9983
9984         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
9985         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
9986                     grep -c writeback)
9987         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
9988                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
9989         fi
9990
9991         rm -f $DIR/$tfile
9992         echo "Dirty pages gaurenteed flushed via fsync"
9993         return 0
9994 }
9995 run_test 118d "Fsync validation inject a delay of the bulk =========="
9996
9997 test_118f() {
9998         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9999
10000         reset_async
10001
10002         #define OBD_FAIL_OSC_BRW_PREP_REQ2        0x40a
10003         lctl set_param fail_loc=0x8000040a
10004
10005         # Should simulate EINVAL error which is fatal
10006         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
10007         RC=$?
10008         if [[ $RC -eq 0 ]]; then
10009                 error "Must return error due to dropped pages, rc=$RC"
10010         fi
10011
10012         lctl set_param fail_loc=0x0
10013
10014         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
10015         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10016         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
10017                     grep -c writeback)
10018         if [[ $LOCKED -ne 0 ]]; then
10019                 error "Locked pages remain in cache, locked=$LOCKED"
10020         fi
10021
10022         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10023                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10024         fi
10025
10026         rm -f $DIR/$tfile
10027         echo "No pages locked after fsync"
10028
10029         reset_async
10030         return 0
10031 }
10032 run_test 118f "Simulate unrecoverable OSC side error =========="
10033
10034 test_118g() {
10035         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10036
10037         reset_async
10038
10039         #define OBD_FAIL_OSC_BRW_PREP_REQ        0x406
10040         lctl set_param fail_loc=0x406
10041
10042         # simulate local -ENOMEM
10043         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
10044         RC=$?
10045
10046         lctl set_param fail_loc=0
10047         if [[ $RC -eq 0 ]]; then
10048                 error "Must return error due to dropped pages, rc=$RC"
10049         fi
10050
10051         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
10052         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10053         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
10054                         grep -c writeback)
10055         if [[ $LOCKED -ne 0 ]]; then
10056                 error "Locked pages remain in cache, locked=$LOCKED"
10057         fi
10058
10059         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10060                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10061         fi
10062
10063         rm -f $DIR/$tfile
10064         echo "No pages locked after fsync"
10065
10066         reset_async
10067         return 0
10068 }
10069 run_test 118g "Don't stay in wait if we got local -ENOMEM  =========="
10070
10071 test_118h() {
10072         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10073         remote_ost_nodsh && skip "remote OST with nodsh"
10074
10075         reset_async
10076
10077         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
10078         set_nodes_failloc "$(osts_nodes)" 0x20e
10079         # Should simulate ENOMEM error which is recoverable and should be handled by timeout
10080         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
10081         RC=$?
10082
10083         set_nodes_failloc "$(osts_nodes)" 0
10084         if [[ $RC -eq 0 ]]; then
10085                 error "Must return error due to dropped pages, rc=$RC"
10086         fi
10087
10088         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
10089         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10090         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
10091                     grep -c writeback)
10092         if [[ $LOCKED -ne 0 ]]; then
10093                 error "Locked pages remain in cache, locked=$LOCKED"
10094         fi
10095
10096         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10097                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10098         fi
10099
10100         rm -f $DIR/$tfile
10101         echo "No pages locked after fsync"
10102
10103         return 0
10104 }
10105 run_test 118h "Verify timeout in handling recoverables errors  =========="
10106
10107 [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] && set_resend_count $OLD_RESENDCOUNT
10108
10109 test_118i() {
10110         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10111         remote_ost_nodsh && skip "remote OST with nodsh"
10112
10113         reset_async
10114
10115         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
10116         set_nodes_failloc "$(osts_nodes)" 0x20e
10117
10118         # Should simulate ENOMEM error which is recoverable and should be handled by timeout
10119         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
10120         PID=$!
10121         sleep 5
10122         set_nodes_failloc "$(osts_nodes)" 0
10123
10124         wait $PID
10125         RC=$?
10126         if [[ $RC -ne 0 ]]; then
10127                 error "got error, but should be not, rc=$RC"
10128         fi
10129
10130         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
10131         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10132         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
10133         if [[ $LOCKED -ne 0 ]]; then
10134                 error "Locked pages remain in cache, locked=$LOCKED"
10135         fi
10136
10137         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10138                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10139         fi
10140
10141         rm -f $DIR/$tfile
10142         echo "No pages locked after fsync"
10143
10144         return 0
10145 }
10146 run_test 118i "Fix error before timeout in recoverable error  =========="
10147
10148 [ "$SLOW" = "no" ] && set_resend_count 4
10149
10150 test_118j() {
10151         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10152         remote_ost_nodsh && skip "remote OST with nodsh"
10153
10154         reset_async
10155
10156         #define OBD_FAIL_OST_BRW_WRITE_BULK2     0x220
10157         set_nodes_failloc "$(osts_nodes)" 0x220
10158
10159         # return -EIO from OST
10160         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
10161         RC=$?
10162         set_nodes_failloc "$(osts_nodes)" 0x0
10163         if [[ $RC -eq 0 ]]; then
10164                 error "Must return error due to dropped pages, rc=$RC"
10165         fi
10166
10167         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
10168         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10169         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
10170         if [[ $LOCKED -ne 0 ]]; then
10171                 error "Locked pages remain in cache, locked=$LOCKED"
10172         fi
10173
10174         # in recoverable error on OST we want resend and stay until it finished
10175         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10176                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10177         fi
10178
10179         rm -f $DIR/$tfile
10180         echo "No pages locked after fsync"
10181
10182         return 0
10183 }
10184 run_test 118j "Simulate unrecoverable OST side error =========="
10185
10186 test_118k()
10187 {
10188         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10189         remote_ost_nodsh && skip "remote OSTs with nodsh"
10190
10191         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
10192         set_nodes_failloc "$(osts_nodes)" 0x20e
10193         test_mkdir $DIR/$tdir
10194
10195         for ((i=0;i<10;i++)); do
10196                 (dd if=/dev/zero of=$DIR/$tdir/$tfile-$i bs=1M count=10 || \
10197                         error "dd to $DIR/$tdir/$tfile-$i failed" )&
10198                 SLEEPPID=$!
10199                 sleep 0.500s
10200                 kill $SLEEPPID
10201                 wait $SLEEPPID
10202         done
10203
10204         set_nodes_failloc "$(osts_nodes)" 0
10205         rm -rf $DIR/$tdir
10206 }
10207 run_test 118k "bio alloc -ENOMEM and IO TERM handling ========="
10208
10209 test_118l() # LU-646
10210 {
10211         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10212
10213         test_mkdir $DIR/$tdir
10214         $MULTIOP $DIR/$tdir Dy || error "fsync dir failed"
10215         rm -rf $DIR/$tdir
10216 }
10217 run_test 118l "fsync dir"
10218
10219 test_118m() # LU-3066
10220 {
10221         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10222
10223         test_mkdir $DIR/$tdir
10224         $MULTIOP $DIR/$tdir DY || error "fdatasync dir failed"
10225         rm -rf $DIR/$tdir
10226 }
10227 run_test 118m "fdatasync dir ========="
10228
10229 [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] && set_resend_count $OLD_RESENDCOUNT
10230
10231 test_118n()
10232 {
10233         local begin
10234         local end
10235
10236         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10237         remote_ost_nodsh && skip "remote OSTs with nodsh"
10238
10239         # Sleep to avoid a cached response.
10240         #define OBD_STATFS_CACHE_SECONDS 1
10241         sleep 2
10242
10243         # Inject a 10 second delay in the OST_STATFS handler.
10244         #define OBD_FAIL_OST_STATFS_DELAY 0x242
10245         set_nodes_failloc "$(osts_nodes)" 0x242
10246
10247         begin=$SECONDS
10248         stat --file-system $MOUNT > /dev/null
10249         end=$SECONDS
10250
10251         set_nodes_failloc "$(osts_nodes)" 0
10252
10253         if ((end - begin > 20)); then
10254             error "statfs took $((end - begin)) seconds, expected 10"
10255         fi
10256 }
10257 run_test 118n "statfs() sends OST_STATFS requests in parallel"
10258
10259 test_119a() # bug 11737
10260 {
10261         BSIZE=$((512 * 1024))
10262         directio write $DIR/$tfile 0 1 $BSIZE
10263         # We ask to read two blocks, which is more than a file size.
10264         # directio will indicate an error when requested and actual
10265         # sizes aren't equeal (a normal situation in this case) and
10266         # print actual read amount.
10267         NOB=`directio read $DIR/$tfile 0 2 $BSIZE | awk '/error/ {print $6}'`
10268         if [ "$NOB" != "$BSIZE" ]; then
10269                 error "read $NOB bytes instead of $BSIZE"
10270         fi
10271         rm -f $DIR/$tfile
10272 }
10273 run_test 119a "Short directIO read must return actual read amount"
10274
10275 test_119b() # bug 11737
10276 {
10277         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
10278
10279         $LFS setstripe -c 2 $DIR/$tfile || error "setstripe failed"
10280         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1 || error "dd failed"
10281         sync
10282         $MULTIOP $DIR/$tfile oO_RDONLY:O_DIRECT:r$((2048 * 1024)) ||
10283                 error "direct read failed"
10284         rm -f $DIR/$tfile
10285 }
10286 run_test 119b "Sparse directIO read must return actual read amount"
10287
10288 test_119c() # bug 13099
10289 {
10290         BSIZE=1048576
10291         directio write $DIR/$tfile 3 1 $BSIZE || error "direct write failed"
10292         directio readhole $DIR/$tfile 0 2 $BSIZE || error "reading hole failed"
10293         rm -f $DIR/$tfile
10294 }
10295 run_test 119c "Testing for direct read hitting hole"
10296
10297 test_119d() # bug 15950
10298 {
10299         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10300
10301         MAX_RPCS_IN_FLIGHT=`$LCTL get_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight`
10302         $LCTL set_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight 1
10303         BSIZE=1048576
10304         $LFS setstripe $DIR/$tfile -i 0 -c 1 || error "setstripe failed"
10305         $DIRECTIO write $DIR/$tfile 0 1 $BSIZE || error "first directio failed"
10306         #define OBD_FAIL_OSC_DIO_PAUSE           0x40d
10307         lctl set_param fail_loc=0x40d
10308         $DIRECTIO write $DIR/$tfile 1 4 $BSIZE &
10309         pid_dio=$!
10310         sleep 1
10311         cat $DIR/$tfile > /dev/null &
10312         lctl set_param fail_loc=0
10313         pid_reads=$!
10314         wait $pid_dio
10315         log "the DIO writes have completed, now wait for the reads (should not block very long)"
10316         sleep 2
10317         [ -n "`ps h -p $pid_reads -o comm`" ] && \
10318         error "the read rpcs have not completed in 2s"
10319         rm -f $DIR/$tfile
10320         $LCTL set_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight $MAX_RPCS_IN_FLIGHT
10321 }
10322 run_test 119d "The DIO path should try to send a new rpc once one is completed"
10323
10324 test_120a() {
10325         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10326         remote_mds_nodsh && skip "remote MDS with nodsh"
10327         test_mkdir -i0 -c1 $DIR/$tdir
10328         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10329                 skip_env "no early lock cancel on server"
10330
10331         lru_resize_disable mdc
10332         lru_resize_disable osc
10333         cancel_lru_locks mdc
10334         # asynchronous object destroy at MDT could cause bl ast to client
10335         cancel_lru_locks osc
10336
10337         stat $DIR/$tdir > /dev/null
10338         can1=$(do_facet mds1 \
10339                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10340                awk '/ldlm_cancel/ {print $2}')
10341         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10342                awk '/ldlm_bl_callback/ {print $2}')
10343         test_mkdir -i0 -c1 $DIR/$tdir/d1
10344         can2=$(do_facet mds1 \
10345                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10346                awk '/ldlm_cancel/ {print $2}')
10347         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10348                awk '/ldlm_bl_callback/ {print $2}')
10349         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
10350         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
10351         lru_resize_enable mdc
10352         lru_resize_enable osc
10353 }
10354 run_test 120a "Early Lock Cancel: mkdir test"
10355
10356 test_120b() {
10357         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10358         remote_mds_nodsh && skip "remote MDS with nodsh"
10359         test_mkdir $DIR/$tdir
10360         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10361                 skip_env "no early lock cancel on server"
10362
10363         lru_resize_disable mdc
10364         lru_resize_disable osc
10365         cancel_lru_locks mdc
10366         stat $DIR/$tdir > /dev/null
10367         can1=$(do_facet $SINGLEMDS \
10368                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10369                awk '/ldlm_cancel/ {print $2}')
10370         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10371                awk '/ldlm_bl_callback/ {print $2}')
10372         touch $DIR/$tdir/f1
10373         can2=$(do_facet $SINGLEMDS \
10374                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10375                awk '/ldlm_cancel/ {print $2}')
10376         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10377                awk '/ldlm_bl_callback/ {print $2}')
10378         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
10379         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
10380         lru_resize_enable mdc
10381         lru_resize_enable osc
10382 }
10383 run_test 120b "Early Lock Cancel: create test"
10384
10385 test_120c() {
10386         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10387         remote_mds_nodsh && skip "remote MDS with nodsh"
10388         test_mkdir -i0 -c1 $DIR/$tdir
10389         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10390                 skip "no early lock cancel on server"
10391
10392         lru_resize_disable mdc
10393         lru_resize_disable osc
10394         test_mkdir -i0 -c1 $DIR/$tdir/d1
10395         test_mkdir -i0 -c1 $DIR/$tdir/d2
10396         touch $DIR/$tdir/d1/f1
10397         cancel_lru_locks mdc
10398         stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 > /dev/null
10399         can1=$(do_facet mds1 \
10400                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10401                awk '/ldlm_cancel/ {print $2}')
10402         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10403                awk '/ldlm_bl_callback/ {print $2}')
10404         ln $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2
10405         can2=$(do_facet mds1 \
10406                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10407                awk '/ldlm_cancel/ {print $2}')
10408         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10409                awk '/ldlm_bl_callback/ {print $2}')
10410         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
10411         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
10412         lru_resize_enable mdc
10413         lru_resize_enable osc
10414 }
10415 run_test 120c "Early Lock Cancel: link test"
10416
10417 test_120d() {
10418         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10419         remote_mds_nodsh && skip "remote MDS with nodsh"
10420         test_mkdir -i0 -c1 $DIR/$tdir
10421         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10422                 skip_env "no early lock cancel on server"
10423
10424         lru_resize_disable mdc
10425         lru_resize_disable osc
10426         touch $DIR/$tdir
10427         cancel_lru_locks mdc
10428         stat $DIR/$tdir > /dev/null
10429         can1=$(do_facet mds1 \
10430                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10431                awk '/ldlm_cancel/ {print $2}')
10432         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10433                awk '/ldlm_bl_callback/ {print $2}')
10434         chmod a+x $DIR/$tdir
10435         can2=$(do_facet mds1 \
10436                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10437                awk '/ldlm_cancel/ {print $2}')
10438         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10439                awk '/ldlm_bl_callback/ {print $2}')
10440         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
10441         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
10442         lru_resize_enable mdc
10443         lru_resize_enable osc
10444 }
10445 run_test 120d "Early Lock Cancel: setattr test"
10446
10447 test_120e() {
10448         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10449         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10450                 skip_env "no early lock cancel on server"
10451         remote_mds_nodsh && skip "remote MDS with nodsh"
10452
10453         local dlmtrace_set=false
10454
10455         test_mkdir -i0 -c1 $DIR/$tdir
10456         lru_resize_disable mdc
10457         lru_resize_disable osc
10458         ! $LCTL get_param debug | grep -q dlmtrace &&
10459                 $LCTL set_param debug=+dlmtrace && dlmtrace_set=true
10460         dd if=/dev/zero of=$DIR/$tdir/f1 count=1
10461         cancel_lru_locks mdc
10462         cancel_lru_locks osc
10463         dd if=$DIR/$tdir/f1 of=/dev/null
10464         stat $DIR/$tdir $DIR/$tdir/f1 > /dev/null
10465         # XXX client can not do early lock cancel of OST lock
10466         # during unlink (LU-4206), so cancel osc lock now.
10467         sleep 2
10468         cancel_lru_locks osc
10469         can1=$(do_facet mds1 \
10470                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10471                awk '/ldlm_cancel/ {print $2}')
10472         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10473                awk '/ldlm_bl_callback/ {print $2}')
10474         unlink $DIR/$tdir/f1
10475         sleep 5
10476         can2=$(do_facet mds1 \
10477                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10478                awk '/ldlm_cancel/ {print $2}')
10479         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10480                awk '/ldlm_bl_callback/ {print $2}')
10481         [ $can1 -ne $can2 ] && error "$((can2 - can1)) cancel RPC occured" &&
10482                 $LCTL dk $TMP/cancel.debug.txt
10483         [ $blk1 -ne $blk2 ] && error "$((blk2 - blk1)) blocking RPC occured" &&
10484                 $LCTL dk $TMP/blocking.debug.txt
10485         $dlmtrace_set && $LCTL set_param debug=-dlmtrace
10486         lru_resize_enable mdc
10487         lru_resize_enable osc
10488 }
10489 run_test 120e "Early Lock Cancel: unlink test"
10490
10491 test_120f() {
10492         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10493         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10494                 skip_env "no early lock cancel on server"
10495         remote_mds_nodsh && skip "remote MDS with nodsh"
10496
10497         test_mkdir -i0 -c1 $DIR/$tdir
10498         lru_resize_disable mdc
10499         lru_resize_disable osc
10500         test_mkdir -i0 -c1 $DIR/$tdir/d1
10501         test_mkdir -i0 -c1 $DIR/$tdir/d2
10502         dd if=/dev/zero of=$DIR/$tdir/d1/f1 count=1
10503         dd if=/dev/zero of=$DIR/$tdir/d2/f2 count=1
10504         cancel_lru_locks mdc
10505         cancel_lru_locks osc
10506         dd if=$DIR/$tdir/d1/f1 of=/dev/null
10507         dd if=$DIR/$tdir/d2/f2 of=/dev/null
10508         stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2 > /dev/null
10509         # XXX client can not do early lock cancel of OST lock
10510         # during rename (LU-4206), so cancel osc lock now.
10511         sleep 2
10512         cancel_lru_locks osc
10513         can1=$(do_facet mds1 \
10514                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10515                awk '/ldlm_cancel/ {print $2}')
10516         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10517                awk '/ldlm_bl_callback/ {print $2}')
10518         mrename $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2
10519         sleep 5
10520         can2=$(do_facet mds1 \
10521                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10522                awk '/ldlm_cancel/ {print $2}')
10523         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10524                awk '/ldlm_bl_callback/ {print $2}')
10525         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
10526         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
10527         lru_resize_enable mdc
10528         lru_resize_enable osc
10529 }
10530 run_test 120f "Early Lock Cancel: rename test"
10531
10532 test_120g() {
10533         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10534         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10535                 skip_env "no early lock cancel on server"
10536         remote_mds_nodsh && skip "remote MDS with nodsh"
10537
10538         lru_resize_disable mdc
10539         lru_resize_disable osc
10540         count=10000
10541         echo create $count files
10542         test_mkdir $DIR/$tdir
10543         cancel_lru_locks mdc
10544         cancel_lru_locks osc
10545         t0=$(date +%s)
10546
10547         can0=$(do_facet $SINGLEMDS \
10548                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10549                awk '/ldlm_cancel/ {print $2}')
10550         blk0=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10551                awk '/ldlm_bl_callback/ {print $2}')
10552         createmany -o $DIR/$tdir/f $count
10553         sync
10554         can1=$(do_facet $SINGLEMDS \
10555                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10556                awk '/ldlm_cancel/ {print $2}')
10557         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10558                awk '/ldlm_bl_callback/ {print $2}')
10559         t1=$(date +%s)
10560         echo total: $((can1-can0)) cancels, $((blk1-blk0)) blockings
10561         echo rm $count files
10562         rm -r $DIR/$tdir
10563         sync
10564         can2=$(do_facet $SINGLEMDS \
10565                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10566                awk '/ldlm_cancel/ {print $2}')
10567         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10568                awk '/ldlm_bl_callback/ {print $2}')
10569         t2=$(date +%s)
10570         echo total: $count removes in $((t2-t1))
10571         echo total: $((can2-can1)) cancels, $((blk2-blk1)) blockings
10572         sleep 2
10573         # wait for commitment of removal
10574         lru_resize_enable mdc
10575         lru_resize_enable osc
10576 }
10577 run_test 120g "Early Lock Cancel: performance test"
10578
10579 test_121() { #bug #10589
10580         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10581
10582         rm -rf $DIR/$tfile
10583         writes=$(LANG=C dd if=/dev/zero of=$DIR/$tfile count=1 2>&1 | awk -F '+' '/out$/ {print $1}')
10584 #define OBD_FAIL_LDLM_CANCEL_RACE        0x310
10585         lctl set_param fail_loc=0x310
10586         cancel_lru_locks osc > /dev/null
10587         reads=$(LANG=C dd if=$DIR/$tfile of=/dev/null 2>&1 | awk -F '+' '/in$/ {print $1}')
10588         lctl set_param fail_loc=0
10589         [[ $reads -eq $writes ]] ||
10590                 error "read $reads blocks, must be $writes blocks"
10591 }
10592 run_test 121 "read cancel race ========="
10593
10594 test_123a() { # was test 123, statahead(bug 11401)
10595         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10596
10597         SLOWOK=0
10598         if ! grep -q "processor.*: 1" /proc/cpuinfo; then
10599                 log "testing UP system. Performance may be lower than expected."
10600                 SLOWOK=1
10601         fi
10602
10603         rm -rf $DIR/$tdir
10604         test_mkdir $DIR/$tdir
10605         NUMFREE=$(df -i -P $DIR | tail -n 1 | awk '{ print $4 }')
10606         [[ $NUMFREE -gt 100000 ]] && NUMFREE=100000 || NUMFREE=$((NUMFREE-1000))
10607         MULT=10
10608         for ((i=100, j=0; i<=$NUMFREE; j=$i, i=$((i * MULT)) )); do
10609                 createmany -o $DIR/$tdir/$tfile $j $((i - j))
10610
10611                 max=`lctl get_param -n llite.*.statahead_max | head -n 1`
10612                 lctl set_param -n llite.*.statahead_max 0
10613                 lctl get_param llite.*.statahead_max
10614                 cancel_lru_locks mdc
10615                 cancel_lru_locks osc
10616                 stime=`date +%s`
10617                 time ls -l $DIR/$tdir | wc -l
10618                 etime=`date +%s`
10619                 delta=$((etime - stime))
10620                 log "ls $i files without statahead: $delta sec"
10621                 lctl set_param llite.*.statahead_max=$max
10622
10623                 swrong=`lctl get_param -n llite.*.statahead_stats | grep "statahead wrong:" | awk '{print $3}'`
10624                 lctl get_param -n llite.*.statahead_max | grep '[0-9]'
10625                 cancel_lru_locks mdc
10626                 cancel_lru_locks osc
10627                 stime=`date +%s`
10628                 time ls -l $DIR/$tdir | wc -l
10629                 etime=`date +%s`
10630                 delta_sa=$((etime - stime))
10631                 log "ls $i files with statahead: $delta_sa sec"
10632                 lctl get_param -n llite.*.statahead_stats
10633                 ewrong=`lctl get_param -n llite.*.statahead_stats | grep "statahead wrong:" | awk '{print $3}'`
10634
10635                 [[ $swrong -lt $ewrong ]] &&
10636                         log "statahead was stopped, maybe too many locks held!"
10637                 [[ $delta -eq 0 || $delta_sa -eq 0 ]] && continue
10638
10639                 if [ $((delta_sa * 100)) -gt $((delta * 105)) -a $delta_sa -gt $((delta + 2)) ]; then
10640                     max=`lctl get_param -n llite.*.statahead_max | head -n 1`
10641                     lctl set_param -n llite.*.statahead_max 0
10642                     lctl get_param llite.*.statahead_max
10643                     cancel_lru_locks mdc
10644                     cancel_lru_locks osc
10645                     stime=`date +%s`
10646                     time ls -l $DIR/$tdir | wc -l
10647                     etime=`date +%s`
10648                     delta=$((etime - stime))
10649                     log "ls $i files again without statahead: $delta sec"
10650                     lctl set_param llite.*.statahead_max=$max
10651                     if [ $((delta_sa * 100)) -gt $((delta * 105)) -a $delta_sa -gt $((delta + 2)) ]; then
10652                         if [  $SLOWOK -eq 0 ]; then
10653                                 error "ls $i files is slower with statahead!"
10654                         else
10655                                 log "ls $i files is slower with statahead!"
10656                         fi
10657                         break
10658                     fi
10659                 fi
10660
10661                 [ $delta -gt 20 ] && break
10662                 [ $delta -gt 8 ] && MULT=$((50 / delta))
10663                 [ "$SLOW" = "no" -a $delta -gt 5 ] && break
10664         done
10665         log "ls done"
10666
10667         stime=`date +%s`
10668         rm -r $DIR/$tdir
10669         sync
10670         etime=`date +%s`
10671         delta=$((etime - stime))
10672         log "rm -r $DIR/$tdir/: $delta seconds"
10673         log "rm done"
10674         lctl get_param -n llite.*.statahead_stats
10675 }
10676 run_test 123a "verify statahead work"
10677
10678 test_123b () { # statahead(bug 15027)
10679         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10680
10681         test_mkdir $DIR/$tdir
10682         createmany -o $DIR/$tdir/$tfile-%d 1000
10683
10684         cancel_lru_locks mdc
10685         cancel_lru_locks osc
10686
10687 #define OBD_FAIL_MDC_GETATTR_ENQUEUE     0x803
10688         lctl set_param fail_loc=0x80000803
10689         ls -lR $DIR/$tdir > /dev/null
10690         log "ls done"
10691         lctl set_param fail_loc=0x0
10692         lctl get_param -n llite.*.statahead_stats
10693         rm -r $DIR/$tdir
10694         sync
10695
10696 }
10697 run_test 123b "not panic with network error in statahead enqueue (bug 15027)"
10698
10699 test_124a() {
10700         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10701         $LCTL get_param -n mdc.*.connect_flags | grep -q lru_resize ||
10702                 skip_env "no lru resize on server"
10703
10704         local NR=2000
10705
10706         test_mkdir $DIR/$tdir
10707
10708         log "create $NR files at $DIR/$tdir"
10709         createmany -o $DIR/$tdir/f $NR ||
10710                 error "failed to create $NR files in $DIR/$tdir"
10711
10712         cancel_lru_locks mdc
10713         ls -l $DIR/$tdir > /dev/null
10714
10715         local NSDIR=""
10716         local LRU_SIZE=0
10717         for VALUE in $($LCTL get_param ldlm.namespaces.*mdc-*.lru_size); do
10718                 local PARAM=$(echo ${VALUE[0]} | cut -d "=" -f1)
10719                 LRU_SIZE=$($LCTL get_param -n $PARAM)
10720                 if [[ $LRU_SIZE -gt $(default_lru_size) ]]; then
10721                         NSDIR=$(echo $PARAM | cut -d "." -f1-3)
10722                         log "NSDIR=$NSDIR"
10723                         log "NS=$(basename $NSDIR)"
10724                         break
10725                 fi
10726         done
10727
10728         if [[ -z "$NSDIR" || $LRU_SIZE -lt $(default_lru_size) ]]; then
10729                 skip "Not enough cached locks created!"
10730         fi
10731         log "LRU=$LRU_SIZE"
10732
10733         local SLEEP=30
10734
10735         # We know that lru resize allows one client to hold $LIMIT locks
10736         # for 10h. After that locks begin to be killed by client.
10737         local MAX_HRS=10
10738         local LIMIT=$($LCTL get_param -n $NSDIR.pool.limit)
10739         log "LIMIT=$LIMIT"
10740         if [ $LIMIT -lt $LRU_SIZE ]; then
10741                 skip "Limit is too small $LIMIT"
10742         fi
10743
10744         # Make LVF so higher that sleeping for $SLEEP is enough to _start_
10745         # killing locks. Some time was spent for creating locks. This means
10746         # that up to the moment of sleep finish we must have killed some of
10747         # them (10-100 locks). This depends on how fast ther were created.
10748         # Many of them were touched in almost the same moment and thus will
10749         # be killed in groups.
10750         local LVF=$(($MAX_HRS * 60 * 60 / $SLEEP * $LIMIT / $LRU_SIZE))
10751
10752         # Use $LRU_SIZE_B here to take into account real number of locks
10753         # created in the case of CMD, LRU_SIZE_B != $NR in most of cases
10754         local LRU_SIZE_B=$LRU_SIZE
10755         log "LVF=$LVF"
10756         local OLD_LVF=$($LCTL get_param -n $NSDIR.pool.lock_volume_factor)
10757         log "OLD_LVF=$OLD_LVF"
10758         $LCTL set_param -n $NSDIR.pool.lock_volume_factor $LVF
10759
10760         # Let's make sure that we really have some margin. Client checks
10761         # cached locks every 10 sec.
10762         SLEEP=$((SLEEP+20))
10763         log "Sleep ${SLEEP} sec"
10764         local SEC=0
10765         while ((SEC<$SLEEP)); do
10766                 echo -n "..."
10767                 sleep 5
10768                 SEC=$((SEC+5))
10769                 LRU_SIZE=$($LCTL get_param -n $NSDIR/lru_size)
10770                 echo -n "$LRU_SIZE"
10771         done
10772         echo ""
10773         $LCTL set_param -n $NSDIR.pool.lock_volume_factor $OLD_LVF
10774         local LRU_SIZE_A=$($LCTL get_param -n $NSDIR.lru_size)
10775
10776         [[ $LRU_SIZE_B -gt $LRU_SIZE_A ]] || {
10777                 error "No locks dropped in ${SLEEP}s. LRU size: $LRU_SIZE_A"
10778                 unlinkmany $DIR/$tdir/f $NR
10779                 return
10780         }
10781
10782         log "Dropped "$((LRU_SIZE_B-LRU_SIZE_A))" locks in ${SLEEP}s"
10783         log "unlink $NR files at $DIR/$tdir"
10784         unlinkmany $DIR/$tdir/f $NR
10785 }
10786 run_test 124a "lru resize ======================================="
10787
10788 get_max_pool_limit()
10789 {
10790         local limit=$($LCTL get_param \
10791                       -n ldlm.namespaces.*-MDT0000-mdc-*.pool.limit)
10792         local max=0
10793         for l in $limit; do
10794                 if [[ $l -gt $max ]]; then
10795                         max=$l
10796                 fi
10797         done
10798         echo $max
10799 }
10800
10801 test_124b() {
10802         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10803         $LCTL get_param -n mdc.*.connect_flags | grep -q lru_resize ||
10804                 skip_env "no lru resize on server"
10805
10806         LIMIT=$(get_max_pool_limit)
10807
10808         NR=$(($(default_lru_size)*20))
10809         if [[ $NR -gt $LIMIT ]]; then
10810                 log "Limit lock number by $LIMIT locks"
10811                 NR=$LIMIT
10812         fi
10813
10814         IFree=$(mdsrate_inodes_available)
10815         if [ $IFree -lt $NR ]; then
10816                 log "Limit lock number by $IFree inodes"
10817                 NR=$IFree
10818         fi
10819
10820         lru_resize_disable mdc
10821         test_mkdir -p $DIR/$tdir/disable_lru_resize
10822
10823         createmany -o $DIR/$tdir/disable_lru_resize/f $NR
10824         log "doing ls -la $DIR/$tdir/disable_lru_resize 3 times"
10825         cancel_lru_locks mdc
10826         stime=`date +%s`
10827         PID=""
10828         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
10829         PID="$PID $!"
10830         sleep 2
10831         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
10832         PID="$PID $!"
10833         sleep 2
10834         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
10835         PID="$PID $!"
10836         wait $PID
10837         etime=`date +%s`
10838         nolruresize_delta=$((etime-stime))
10839         log "ls -la time: $nolruresize_delta seconds"
10840         log "lru_size = $(lctl get_param -n ldlm.namespaces.*mdc*.lru_size)"
10841         unlinkmany $DIR/$tdir/disable_lru_resize/f $NR
10842
10843         lru_resize_enable mdc
10844         test_mkdir -p $DIR/$tdir/enable_lru_resize
10845
10846         createmany -o $DIR/$tdir/enable_lru_resize/f $NR
10847         log "doing ls -la $DIR/$tdir/enable_lru_resize 3 times"
10848         cancel_lru_locks mdc
10849         stime=`date +%s`
10850         PID=""
10851         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
10852         PID="$PID $!"
10853         sleep 2
10854         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
10855         PID="$PID $!"
10856         sleep 2
10857         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
10858         PID="$PID $!"
10859         wait $PID
10860         etime=`date +%s`
10861         lruresize_delta=$((etime-stime))
10862         log "ls -la time: $lruresize_delta seconds"
10863         log "lru_size = $(lctl get_param -n ldlm.namespaces.*mdc*.lru_size)"
10864
10865         if [ $lruresize_delta -gt $nolruresize_delta ]; then
10866                 log "ls -la is $(((lruresize_delta - $nolruresize_delta) * 100 / $nolruresize_delta))% slower with lru resize enabled"
10867         elif [ $nolruresize_delta -gt $lruresize_delta ]; then
10868                 log "ls -la is $(((nolruresize_delta - $lruresize_delta) * 100 / $nolruresize_delta))% faster with lru resize enabled"
10869         else
10870                 log "lru resize performs the same with no lru resize"
10871         fi
10872         unlinkmany $DIR/$tdir/enable_lru_resize/f $NR
10873 }
10874 run_test 124b "lru resize (performance test) ======================="
10875
10876 test_124c() {
10877         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10878         $LCTL get_param -n mdc.*.connect_flags | grep -q lru_resize ||
10879                 skip_env "no lru resize on server"
10880
10881         # cache ununsed locks on client
10882         local nr=100
10883         cancel_lru_locks mdc
10884         test_mkdir $DIR/$tdir
10885         createmany -o $DIR/$tdir/f $nr ||
10886                 error "failed to create $nr files in $DIR/$tdir"
10887         ls -l $DIR/$tdir > /dev/null
10888
10889         local nsdir="ldlm.namespaces.*-MDT0000-mdc-*"
10890         local unused=$($LCTL get_param -n $nsdir.lock_unused_count)
10891         local max_age=$($LCTL get_param -n $nsdir.lru_max_age)
10892         local recalc_p=$($LCTL get_param -n $nsdir.pool.recalc_period)
10893         echo "unused=$unused, max_age=$max_age, recalc_p=$recalc_p"
10894
10895         # set lru_max_age to 1 sec
10896         $LCTL set_param $nsdir.lru_max_age=1000 # milliseconds
10897         echo "sleep $((recalc_p * 2)) seconds..."
10898         sleep $((recalc_p * 2))
10899
10900         local remaining=$($LCTL get_param -n $nsdir.lock_unused_count)
10901         # restore lru_max_age
10902         $LCTL set_param -n $nsdir.lru_max_age $max_age
10903         [ $remaining -eq 0 ] || error "$remaining locks are not canceled"
10904         unlinkmany $DIR/$tdir/f $nr
10905 }
10906 run_test 124c "LRUR cancel very aged locks"
10907
10908 test_124d() {
10909         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10910         $LCTL get_param -n mdc.*.connect_flags | grep -q lru_resize ||
10911                 skip_env "no lru resize on server"
10912
10913         # cache ununsed locks on client
10914         local nr=100
10915
10916         lru_resize_disable mdc
10917         stack_trap "lru_resize_enable mdc" EXIT
10918
10919         cancel_lru_locks mdc
10920
10921         # asynchronous object destroy at MDT could cause bl ast to client
10922         test_mkdir $DIR/$tdir
10923         createmany -o $DIR/$tdir/f $nr ||
10924                 error "failed to create $nr files in $DIR/$tdir"
10925         stack_trap "unlinkmany $DIR/$tdir/f $nr" EXIT
10926
10927         ls -l $DIR/$tdir > /dev/null
10928
10929         local nsdir="ldlm.namespaces.*-MDT0000-mdc-*"
10930         local unused=$($LCTL get_param -n $nsdir.lock_unused_count)
10931         local max_age=$($LCTL get_param -n $nsdir.lru_max_age)
10932         local recalc_p=$($LCTL get_param -n $nsdir.pool.recalc_period)
10933
10934         echo "unused=$unused, max_age=$max_age, recalc_p=$recalc_p"
10935
10936         # set lru_max_age to 1 sec
10937         $LCTL set_param $nsdir.lru_max_age=1000 # milliseconds
10938         stack_trap "$LCTL set_param -n $nsdir.lru_max_age $max_age" EXIT
10939
10940         echo "sleep $((recalc_p * 2)) seconds..."
10941         sleep $((recalc_p * 2))
10942
10943         local remaining=$($LCTL get_param -n $nsdir.lock_unused_count)
10944
10945         [ $remaining -eq 0 ] || error "$remaining locks are not canceled"
10946 }
10947 run_test 124d "cancel very aged locks if lru-resize diasbaled"
10948
10949 test_125() { # 13358
10950         $LCTL get_param -n llite.*.client_type | grep -q local ||
10951                 skip "must run as local client"
10952         $LCTL get_param -n mdc.*-mdc-*.connect_flags | grep -q acl ||
10953                 skip_env "must have acl enabled"
10954         [ -z "$(which setfacl)" ] && skip_env "must have setfacl tool"
10955
10956         test_mkdir $DIR/$tdir
10957         $LFS setstripe -S 65536 -c -1 $DIR/$tdir || error "setstripe failed"
10958         setfacl -R -m u:bin:rwx $DIR/$tdir || error "setfacl $DIR/$tdir failed"
10959         ls -ld $DIR/$tdir || error "cannot access $DIR/$tdir"
10960 }
10961 run_test 125 "don't return EPROTO when a dir has a non-default striping and ACLs"
10962
10963 test_126() { # bug 12829/13455
10964         $GSS && skip_env "must run as gss disabled"
10965         $LCTL get_param -n llite.*.client_type | grep -q local ||
10966                 skip "must run as local client"
10967         [ "$UID" != 0 ] && skip "must run as root, not UID $UID"
10968
10969         $RUNAS -u 0 -g 1 touch $DIR/$tfile || error "touch failed"
10970         gid=`ls -n $DIR/$tfile | awk '{print $4}'`
10971         rm -f $DIR/$tfile
10972         [ $gid -eq "1" ] || error "gid is set to" $gid "instead of 1"
10973 }
10974 run_test 126 "check that the fsgid provided by the client is taken into account"
10975
10976 test_127a() { # bug 15521
10977         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10978
10979         $LFS setstripe -i 0 -c 1 $DIR/$tfile || error "setstripe failed"
10980         $LCTL set_param osc.*.stats=0
10981         FSIZE=$((2048 * 1024))
10982         dd if=/dev/zero of=$DIR/$tfile bs=$FSIZE count=1
10983         cancel_lru_locks osc
10984         dd if=$DIR/$tfile of=/dev/null bs=$FSIZE
10985
10986         $LCTL get_param osc.*0000-osc-*.stats | grep samples > $DIR/${tfile}.tmp
10987         while read NAME COUNT SAMP UNIT MIN MAX SUM SUMSQ; do
10988                 echo "got $COUNT $NAME"
10989                 [ ! $MIN ] && error "Missing min value for $NAME proc entry"
10990                 eval $NAME=$COUNT || error "Wrong proc format"
10991
10992                 case $NAME in
10993                         read_bytes|write_bytes)
10994                         [ $MIN -lt 4096 ] && error "min is too small: $MIN"
10995                         [ $MIN -gt $FSIZE ] && error "min is too big: $MIN"
10996                         [ $MAX -lt 4096 ] && error "max is too small: $MAX"
10997                         [ $MAX -gt $FSIZE ] && error "max is too big: $MAX"
10998                         [ $SUM -ne $FSIZE ] && error "sum is wrong: $SUM"
10999                         [ $SUMSQ -lt $(((FSIZE /4096) * (4096 * 4096))) ] &&
11000                                 error "sumsquare is too small: $SUMSQ"
11001                         [ $SUMSQ -gt $((FSIZE * FSIZE)) ] &&
11002                                 error "sumsquare is too big: $SUMSQ"
11003                         ;;
11004                         *) ;;
11005                 esac
11006         done < $DIR/${tfile}.tmp
11007
11008         #check that we actually got some stats
11009         [ "$read_bytes" ] || error "Missing read_bytes stats"
11010         [ "$write_bytes" ] || error "Missing write_bytes stats"
11011         [ "$read_bytes" != 0 ] || error "no read done"
11012         [ "$write_bytes" != 0 ] || error "no write done"
11013 }
11014 run_test 127a "verify the client stats are sane"
11015
11016 test_127b() { # bug LU-333
11017         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11018         local name count samp unit min max sum sumsq
11019
11020         $LCTL set_param llite.*.stats=0
11021
11022         # perform 2 reads and writes so MAX is different from SUM.
11023         dd if=/dev/zero of=$DIR/$tfile bs=$PAGE_SIZE count=1
11024         dd if=/dev/zero of=$DIR/$tfile bs=$PAGE_SIZE count=1
11025         cancel_lru_locks osc
11026         dd if=$DIR/$tfile of=/dev/null bs=$PAGE_SIZE count=1
11027         dd if=$DIR/$tfile of=/dev/null bs=$PAGE_SIZE count=1
11028
11029         $LCTL get_param llite.*.stats | grep samples > $TMP/$tfile.tmp
11030         while read name count samp unit min max sum sumsq; do
11031                 echo "got $count $name"
11032                 eval $name=$count || error "Wrong proc format"
11033
11034                 case $name in
11035                 read_bytes)
11036                         [ $count -ne 2 ] && error "count is not 2: $count"
11037                         [ $min -ne $PAGE_SIZE ] &&
11038                                 error "min is not $PAGE_SIZE: $min"
11039                         [ $max -ne $PAGE_SIZE ] &&
11040                                 error "max is incorrect: $max"
11041                         [ $sum -ne $((PAGE_SIZE * 2)) ] &&
11042                                 error "sum is wrong: $sum"
11043                         ;;
11044                 write_bytes)
11045                         [ $count -ne 2 ] && error "count is not 2: $count"
11046                         [ $min -ne $PAGE_SIZE ] &&
11047                                 error "min is not $PAGE_SIZE: $min"
11048                         [ $max -ne $PAGE_SIZE ] &&
11049                                 error "max is incorrect: $max"
11050                         [ $sum -ne $((PAGE_SIZE * 2)) ] &&
11051                                 error "sum is wrong: $sum"
11052                         ;;
11053                 *) ;;
11054                 esac
11055         done < $TMP/$tfile.tmp
11056
11057         #check that we actually got some stats
11058         [ "$read_bytes" ] || error "Missing read_bytes stats"
11059         [ "$write_bytes" ] || error "Missing write_bytes stats"
11060         [ "$read_bytes" != 0 ] || error "no read done"
11061         [ "$write_bytes" != 0 ] || error "no write done"
11062
11063         rm -f $TMP/${tfile}.tmp
11064 }
11065 run_test 127b "verify the llite client stats are sane"
11066
11067 test_127c() { # LU-12394
11068         [ "$OSTCOUNT" -lt "2" ] && skip_env "needs >= 2 OSTs"
11069         local size
11070         local bsize
11071         local reads
11072         local writes
11073         local count
11074
11075         $LCTL set_param llite.*.extents_stats=1
11076         stack_trap "$LCTL set_param llite.*.extents_stats=0" EXIT
11077
11078         # Use two stripes so there is enough space in default config
11079         $LFS setstripe -c 2 $DIR/$tfile
11080
11081         # Extent stats start at 0-4K and go in power of two buckets
11082         # LL_HIST_START = 12 --> 2^12 = 4K
11083         # We do 3K*2^i, so 3K, 6K, 12K, 24K... hitting each bucket.
11084         # We do not do buckets larger than 64 MiB to avoid ENOSPC issues on
11085         # small configs
11086         for size in 3K 6K 12K 24K 48K 96K 192K 384K 768K 1536K 3M 6M 12M 24M 48M;
11087                 do
11088                 # Write and read, 2x each, second time at a non-zero offset
11089                 dd if=/dev/zero of=$DIR/$tfile bs=$size count=1
11090                 dd if=/dev/zero of=$DIR/$tfile bs=$size count=1 seek=10
11091                 dd if=$DIR/$tfile of=/dev/null bs=$size count=1
11092                 dd if=$DIR/$tfile of=/dev/null bs=$size count=1 seek=10
11093                 rm -f $DIR/$tfile
11094         done
11095
11096         $LCTL get_param llite.*.extents_stats
11097
11098         count=2
11099         for bsize in 4K 8K 16K 32K 64K 128K 256K 512K 1M 2M 4M 8M 16M 32M 64M;
11100                 do
11101                 local bucket=$($LCTL get_param -n llite.*.extents_stats |
11102                                 grep -m 1 $bsize)
11103                 reads=$(echo $bucket | awk '{print $5}')
11104                 writes=$(echo $bucket | awk '{print $9}')
11105                 [ "$reads" -eq $count ] ||
11106                         error "$reads reads in < $bsize bucket, expect $count"
11107                 [ "$writes" -eq $count ] ||
11108                         error "$writes writes in < $bsize bucket, expect $count"
11109         done
11110
11111         # Test mmap write and read
11112         $LCTL set_param llite.*.extents_stats=c
11113         size=512
11114         dd if=/dev/zero of=$DIR/$tfile bs=${size}K count=1
11115         $MULTIOP $DIR/$tfile OSMRUc || error "$MULTIOP $DIR/$tfile failed"
11116         $MULTIOP $DIR/$tfile OSMWUc || error "$MULTIOP $DIR/$tfile failed"
11117
11118         $LCTL get_param llite.*.extents_stats
11119
11120         count=$(((size*1024) / PAGE_SIZE))
11121
11122         bsize=$((2 * PAGE_SIZE / 1024))K
11123
11124         bucket=$($LCTL get_param -n llite.*.extents_stats |
11125                         grep -m 1 $bsize)
11126         reads=$(echo $bucket | awk '{print $5}')
11127         writes=$(echo $bucket | awk '{print $9}')
11128         # mmap writes fault in the page first, creating an additonal read
11129         [ "$reads" -eq $((2 * count)) ] ||
11130                 error "$reads reads in < $bsize bucket, expect $count"
11131         [ "$writes" -eq $count ] ||
11132                 error "$writes writes in < $bsize bucket, expect $count"
11133 }
11134 run_test 127c "test llite extent stats with regular & mmap i/o"
11135
11136 test_128() { # bug 15212
11137         touch $DIR/$tfile
11138         $LFS 2>&1 <<-EOF | tee $TMP/$tfile.log
11139                 find $DIR/$tfile
11140                 find $DIR/$tfile
11141         EOF
11142
11143         result=$(grep error $TMP/$tfile.log)
11144         rm -f $DIR/$tfile $TMP/$tfile.log
11145         [ -z "$result" ] ||
11146                 error "consecutive find's under interactive lfs failed"
11147 }
11148 run_test 128 "interactive lfs for 2 consecutive find's"
11149
11150 set_dir_limits () {
11151         local mntdev
11152         local canondev
11153         local node
11154
11155         local ldproc=/proc/fs/ldiskfs
11156         local facets=$(get_facets MDS)
11157
11158         for facet in ${facets//,/ }; do
11159                 canondev=$(ldiskfs_canon \
11160                            *.$(convert_facet2label $facet).mntdev $facet)
11161                 do_facet $facet "test -e $ldproc/$canondev/max_dir_size" ||
11162                         ldproc=/sys/fs/ldiskfs
11163                 do_facet $facet "echo $1 >$ldproc/$canondev/max_dir_size"
11164                 do_facet $facet "echo $2 >$ldproc/$canondev/warning_dir_size"
11165         done
11166 }
11167
11168 check_mds_dmesg() {
11169         local facets=$(get_facets MDS)
11170         for facet in ${facets//,/ }; do
11171                 do_facet $facet "dmesg | tail -3 | grep -q $1" && return 0
11172         done
11173         return 1
11174 }
11175
11176 test_129() {
11177         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11178         [[ $MDS1_VERSION -ge $(version_code 2.5.56) ]] ||
11179                 skip "Need MDS version with at least 2.5.56"
11180         if [ "$mds1_FSTYPE" != ldiskfs ]; then
11181                 skip_env "ldiskfs only test"
11182         fi
11183         remote_mds_nodsh && skip "remote MDS with nodsh"
11184
11185         local ENOSPC=28
11186         local EFBIG=27
11187         local has_warning=false
11188
11189         rm -rf $DIR/$tdir
11190         mkdir -p $DIR/$tdir
11191
11192         # block size of mds1
11193         local maxsize=$(($($LCTL get_param -n mdc.*MDT0000*.blocksize) * 5))
11194         set_dir_limits $maxsize $maxsize
11195         local dirsize=$(stat -c%s "$DIR/$tdir")
11196         local nfiles=0
11197         while [[ $dirsize -le $maxsize ]]; do
11198                 $MULTIOP $DIR/$tdir/file_base_$nfiles Oc
11199                 rc=$?
11200                 if ! $has_warning; then
11201                         check_mds_dmesg '"is approaching"' && has_warning=true
11202                 fi
11203                 # check two errors:
11204                 # ENOSPC for new ext4 max_dir_size (kernel commit df981d03ee)
11205                 # EFBIG for previous versions included in ldiskfs series
11206                 if [ $rc -eq $EFBIG ] || [ $rc -eq $ENOSPC ]; then
11207                         set_dir_limits 0 0
11208                         echo "return code $rc received as expected"
11209
11210                         createmany -o $DIR/$tdir/file_extra_$nfiles. 5 ||
11211                                 error_exit "create failed w/o dir size limit"
11212
11213                         check_mds_dmesg '"has reached"' ||
11214                                 error_exit "reached message should be output"
11215
11216                         [ $has_warning = "false" ] &&
11217                                 error_exit "warning message should be output"
11218
11219                         dirsize=$(stat -c%s "$DIR/$tdir")
11220
11221                         [[ $dirsize -ge $maxsize ]] && return 0
11222                         error_exit "current dir size $dirsize, " \
11223                                    "previous limit $maxsize"
11224                 elif [ $rc -ne 0 ]; then
11225                         set_dir_limits 0 0
11226                         error_exit "return $rc received instead of expected " \
11227                                    "$EFBIG or $ENOSPC, files in dir $dirsize"
11228                 fi
11229                 nfiles=$((nfiles + 1))
11230                 dirsize=$(stat -c%s "$DIR/$tdir")
11231         done
11232
11233         set_dir_limits 0 0
11234         error "exceeded dir size limit $maxsize($MDSCOUNT) : $dirsize bytes"
11235 }
11236 run_test 129 "test directory size limit ========================"
11237
11238 OLDIFS="$IFS"
11239 cleanup_130() {
11240         trap 0
11241         IFS="$OLDIFS"
11242 }
11243
11244 test_130a() {
11245         local filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
11246         [ -n "$filefrag_op" ] && skip_env "filefrag does not support FIEMAP"
11247
11248         trap cleanup_130 EXIT RETURN
11249
11250         local fm_file=$DIR/$tfile
11251         $LFS setstripe -S 65536 -c 1 $fm_file || error "setstripe on $fm_file"
11252         dd if=/dev/zero of=$fm_file bs=65536 count=1 ||
11253                 error "dd failed for $fm_file"
11254
11255         # LU-1795: test filefrag/FIEMAP once, even if unsupported
11256         filefrag -ves $fm_file
11257         RC=$?
11258         [ "$(facet_fstype ost$(($($LFS getstripe -i $fm_file) + 1)))" = "zfs" ] &&
11259                 skip_env "ORI-366/LU-1941: FIEMAP unimplemented on ZFS"
11260         [ $RC != 0 ] && error "filefrag $fm_file failed"
11261
11262         filefrag_op=$(filefrag -ve -k $fm_file |
11263                         sed -n '/ext:/,/found/{/ext:/d; /found/d; p}')
11264         lun=$($LFS getstripe -i $fm_file)
11265
11266         start_blk=`echo $filefrag_op | cut -d: -f2 | cut -d. -f1`
11267         IFS=$'\n'
11268         tot_len=0
11269         for line in $filefrag_op
11270         do
11271                 frag_lun=`echo $line | cut -d: -f5`
11272                 ext_len=`echo $line | cut -d: -f4`
11273                 if (( $frag_lun != $lun )); then
11274                         cleanup_130
11275                         error "FIEMAP on 1-stripe file($fm_file) failed"
11276                         return
11277                 fi
11278                 (( tot_len += ext_len ))
11279         done
11280
11281         if (( lun != frag_lun || start_blk != 0 || tot_len != 64 )); then
11282                 cleanup_130
11283                 error "FIEMAP on 1-stripe file($fm_file) failed;"
11284                 return
11285         fi
11286
11287         cleanup_130
11288
11289         echo "FIEMAP on single striped file succeeded"
11290 }
11291 run_test 130a "FIEMAP (1-stripe file)"
11292
11293 test_130b() {
11294         [ "$OSTCOUNT" -lt "2" ] && skip_env "needs >= 2 OSTs"
11295
11296         local filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
11297         [ -n "$filefrag_op" ] && skip_env "filefrag does not support FIEMAP"
11298
11299         trap cleanup_130 EXIT RETURN
11300
11301         local fm_file=$DIR/$tfile
11302         $LFS setstripe -S 65536 -c $OSTCOUNT $fm_file ||
11303                         error "setstripe on $fm_file"
11304         [ "$(facet_fstype ost$(($($LFS getstripe -i $fm_file) + 1)))" = "zfs" ] &&
11305                 skip_env "ORI-366/LU-1941: FIEMAP unimplemented on ZFS"
11306
11307         dd if=/dev/zero of=$fm_file bs=1M count=$OSTCOUNT ||
11308                 error "dd failed on $fm_file"
11309
11310         filefrag -ves $fm_file || error "filefrag $fm_file failed"
11311         filefrag_op=$(filefrag -ve -k $fm_file |
11312                         sed -n '/ext:/,/found/{/ext:/d; /found/d; p}')
11313
11314         last_lun=$(echo $filefrag_op | cut -d: -f5 |
11315                 sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11316
11317         IFS=$'\n'
11318         tot_len=0
11319         num_luns=1
11320         for line in $filefrag_op
11321         do
11322                 frag_lun=$(echo $line | cut -d: -f5 |
11323                         sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11324                 ext_len=$(echo $line | cut -d: -f4)
11325                 if (( $frag_lun != $last_lun )); then
11326                         if (( tot_len != 1024 )); then
11327                                 cleanup_130
11328                                 error "FIEMAP on $fm_file failed; returned " \
11329                                 "len $tot_len for OST $last_lun instead of 1024"
11330                                 return
11331                         else
11332                                 (( num_luns += 1 ))
11333                                 tot_len=0
11334                         fi
11335                 fi
11336                 (( tot_len += ext_len ))
11337                 last_lun=$frag_lun
11338         done
11339         if (( num_luns != $OSTCOUNT || tot_len != 1024 )); then
11340                 cleanup_130
11341                 error "FIEMAP on $fm_file failed; returned wrong number of " \
11342                         "luns or wrong len for OST $last_lun"
11343                 return
11344         fi
11345
11346         cleanup_130
11347
11348         echo "FIEMAP on $OSTCOUNT-stripe file succeeded"
11349 }
11350 run_test 130b "FIEMAP ($OSTCOUNT-stripe file)"
11351
11352 test_130c() {
11353         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
11354
11355         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
11356         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP"
11357
11358         trap cleanup_130 EXIT RETURN
11359
11360         local fm_file=$DIR/$tfile
11361         $LFS setstripe -S 65536 -c 2 $fm_file || error "setstripe on $fm_file"
11362         [ "$(facet_fstype ost$(($($LFS getstripe -i $fm_file) + 1)))" = "zfs" ] &&
11363                 skip_env "ORI-366/LU-1941: FIEMAP unimplemented on ZFS"
11364
11365         dd if=/dev/zero of=$fm_file seek=1 bs=1M count=1 ||
11366                         error "dd failed on $fm_file"
11367
11368         filefrag -ves $fm_file || error "filefrag $fm_file failed"
11369         filefrag_op=$(filefrag -ve -k $fm_file |
11370                 sed -n '/ext:/,/found/{/ext:/d; /found/d; p}')
11371
11372         last_lun=$(echo $filefrag_op | cut -d: -f5 |
11373                 sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11374
11375         IFS=$'\n'
11376         tot_len=0
11377         num_luns=1
11378         for line in $filefrag_op
11379         do
11380                 frag_lun=$(echo $line | cut -d: -f5 |
11381                         sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11382                 ext_len=$(echo $line | cut -d: -f4)
11383                 if (( $frag_lun != $last_lun )); then
11384                         logical=`echo $line | cut -d: -f2 | cut -d. -f1`
11385                         if (( logical != 512 )); then
11386                                 cleanup_130
11387                                 error "FIEMAP on $fm_file failed; returned " \
11388                                 "logical start for lun $logical instead of 512"
11389                                 return
11390                         fi
11391                         if (( tot_len != 512 )); then
11392                                 cleanup_130
11393                                 error "FIEMAP on $fm_file failed; returned " \
11394                                 "len $tot_len for OST $last_lun instead of 1024"
11395                                 return
11396                         else
11397                                 (( num_luns += 1 ))
11398                                 tot_len=0
11399                         fi
11400                 fi
11401                 (( tot_len += ext_len ))
11402                 last_lun=$frag_lun
11403         done
11404         if (( num_luns != 2 || tot_len != 512 )); then
11405                 cleanup_130
11406                 error "FIEMAP on $fm_file failed; returned wrong number of " \
11407                         "luns or wrong len for OST $last_lun"
11408                 return
11409         fi
11410
11411         cleanup_130
11412
11413         echo "FIEMAP on 2-stripe file with hole succeeded"
11414 }
11415 run_test 130c "FIEMAP (2-stripe file with hole)"
11416
11417 test_130d() {
11418         [[ $OSTCOUNT -lt 3 ]] && skip_env "needs >= 3 OSTs"
11419
11420         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
11421         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP"
11422
11423         trap cleanup_130 EXIT RETURN
11424
11425         local fm_file=$DIR/$tfile
11426         $LFS setstripe -S 65536 -c $OSTCOUNT $fm_file ||
11427                         error "setstripe on $fm_file"
11428         [ "$(facet_fstype ost$(($($LFS getstripe -i $fm_file) + 1)))" = "zfs" ] &&
11429                 skip_env "ORI-366/LU-1941: FIEMAP unimplemented on ZFS"
11430
11431         local actual_stripe_count=$($LFS getstripe -c $fm_file)
11432         dd if=/dev/zero of=$fm_file bs=1M count=$actual_stripe_count ||
11433                 error "dd failed on $fm_file"
11434
11435         filefrag -ves $fm_file || error "filefrag $fm_file failed"
11436         filefrag_op=$(filefrag -ve -k $fm_file |
11437                         sed -n '/ext:/,/found/{/ext:/d; /found/d; p}')
11438
11439         last_lun=$(echo $filefrag_op | cut -d: -f5 |
11440                 sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11441
11442         IFS=$'\n'
11443         tot_len=0
11444         num_luns=1
11445         for line in $filefrag_op
11446         do
11447                 frag_lun=$(echo $line | cut -d: -f5 |
11448                         sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11449                 ext_len=$(echo $line | cut -d: -f4)
11450                 if (( $frag_lun != $last_lun )); then
11451                         if (( tot_len != 1024 )); then
11452                                 cleanup_130
11453                                 error "FIEMAP on $fm_file failed; returned " \
11454                                 "len $tot_len for OST $last_lun instead of 1024"
11455                                 return
11456                         else
11457                                 (( num_luns += 1 ))
11458                                 tot_len=0
11459                         fi
11460                 fi
11461                 (( tot_len += ext_len ))
11462                 last_lun=$frag_lun
11463         done
11464         if (( num_luns != actual_stripe_count || tot_len != 1024 )); then
11465                 cleanup_130
11466                 error "FIEMAP on $fm_file failed; returned wrong number of " \
11467                         "luns or wrong len for OST $last_lun"
11468                 return
11469         fi
11470
11471         cleanup_130
11472
11473         echo "FIEMAP on N-stripe file succeeded"
11474 }
11475 run_test 130d "FIEMAP (N-stripe file)"
11476
11477 test_130e() {
11478         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
11479
11480         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
11481         [ -n "$filefrag_op" ] && skip_env "filefrag does not support FIEMAP"
11482
11483         trap cleanup_130 EXIT RETURN
11484
11485         local fm_file=$DIR/$tfile
11486         $LFS setstripe -S 131072 -c 2 $fm_file || error "setstripe on $fm_file"
11487         [ "$(facet_fstype ost$(($($LFS getstripe -i $fm_file) + 1)))" = "zfs" ] &&
11488                 skip_env "ORI-366/LU-1941: FIEMAP unimplemented on ZFS"
11489
11490         NUM_BLKS=512
11491         EXPECTED_LEN=$(( (NUM_BLKS / 2) * 64 ))
11492         for ((i = 0; i < $NUM_BLKS; i++))
11493         do
11494                 dd if=/dev/zero of=$fm_file count=1 bs=64k seek=$((2*$i)) conv=notrunc > /dev/null 2>&1
11495         done
11496
11497         filefrag -ves $fm_file || error "filefrag $fm_file failed"
11498         filefrag_op=$(filefrag -ve -k $fm_file |
11499                         sed -n '/ext:/,/found/{/ext:/d; /found/d; p}')
11500
11501         last_lun=$(echo $filefrag_op | cut -d: -f5 |
11502                 sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11503
11504         IFS=$'\n'
11505         tot_len=0
11506         num_luns=1
11507         for line in $filefrag_op
11508         do
11509                 frag_lun=$(echo $line | cut -d: -f5 |
11510                         sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11511                 ext_len=$(echo $line | cut -d: -f4)
11512                 if (( $frag_lun != $last_lun )); then
11513                         if (( tot_len != $EXPECTED_LEN )); then
11514                                 cleanup_130
11515                                 error "FIEMAP on $fm_file failed; returned " \
11516                                 "len $tot_len for OST $last_lun instead " \
11517                                 "of $EXPECTED_LEN"
11518                                 return
11519                         else
11520                                 (( num_luns += 1 ))
11521                                 tot_len=0
11522                         fi
11523                 fi
11524                 (( tot_len += ext_len ))
11525                 last_lun=$frag_lun
11526         done
11527         if (( num_luns != 2 || tot_len != $EXPECTED_LEN )); then
11528                 cleanup_130
11529                 error "FIEMAP on $fm_file failed; returned wrong number " \
11530                         "of luns or wrong len for OST $last_lun"
11531                 return
11532         fi
11533
11534         cleanup_130
11535
11536         echo "FIEMAP with continuation calls succeeded"
11537 }
11538 run_test 130e "FIEMAP (test continuation FIEMAP calls)"
11539
11540 test_130f() {
11541         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
11542         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP"
11543
11544         local fm_file=$DIR/$tfile
11545         $MULTIOP $fm_file oO_RDWR:O_CREAT:O_LOV_DELAY_CREATE:T33554432c ||
11546                 error "multiop create with lov_delay_create on $fm_file"
11547
11548         filefrag -ves $fm_file || error "filefrag $fm_file failed"
11549         filefrag_extents=$(filefrag -vek $fm_file |
11550                            awk '/extents? found/ { print $2 }')
11551         if [[ "$filefrag_extents" != "0" ]]; then
11552                 error "FIEMAP on $fm_file failed; " \
11553                       "returned $filefrag_extents expected 0"
11554         fi
11555
11556         rm -f $fm_file
11557 }
11558 run_test 130f "FIEMAP (unstriped file)"
11559
11560 # Test for writev/readv
11561 test_131a() {
11562         rwv -f $DIR/$tfile -w -n 3 524288 1048576 1572864 ||
11563                 error "writev test failed"
11564         rwv -f $DIR/$tfile -r -v -n 2 1572864 1048576 ||
11565                 error "readv failed"
11566         rm -f $DIR/$tfile
11567 }
11568 run_test 131a "test iov's crossing stripe boundary for writev/readv"
11569
11570 test_131b() {
11571         local fsize=$((524288 + 1048576 + 1572864))
11572         rwv -f $DIR/$tfile -w -a -n 3 524288 1048576 1572864 &&
11573                 $CHECKSTAT -t file $DIR/$tfile -s $fsize ||
11574                         error "append writev test failed"
11575
11576         ((fsize += 1572864 + 1048576))
11577         rwv -f $DIR/$tfile -w -a -n 2 1572864 1048576 &&
11578                 $CHECKSTAT -t file $DIR/$tfile -s $fsize ||
11579                         error "append writev test failed"
11580         rm -f $DIR/$tfile
11581 }
11582 run_test 131b "test append writev"
11583
11584 test_131c() {
11585         rwv -f $DIR/$tfile -w -d -n 1 1048576 || return 0
11586         error "NOT PASS"
11587 }
11588 run_test 131c "test read/write on file w/o objects"
11589
11590 test_131d() {
11591         rwv -f $DIR/$tfile -w -n 1 1572864
11592         NOB=`rwv -f $DIR/$tfile -r -n 3 524288 524288 1048576 | awk '/error/ {print $6}'`
11593         if [ "$NOB" != 1572864 ]; then
11594                 error "Short read filed: read $NOB bytes instead of 1572864"
11595         fi
11596         rm -f $DIR/$tfile
11597 }
11598 run_test 131d "test short read"
11599
11600 test_131e() {
11601         rwv -f $DIR/$tfile -w -s 1048576 -n 1 1048576
11602         rwv -f $DIR/$tfile -r -z -s 0 -n 1 524288 || \
11603         error "read hitting hole failed"
11604         rm -f $DIR/$tfile
11605 }
11606 run_test 131e "test read hitting hole"
11607
11608 check_stats() {
11609         local facet=$1
11610         local op=$2
11611         local want=${3:-0}
11612         local res
11613
11614         case $facet in
11615         mds*) res=$(do_facet $facet \
11616                    $LCTL get_param mdt.$FSNAME-MDT0000.md_stats | grep "$op")
11617                  ;;
11618         ost*) res=$(do_facet $facet \
11619                    $LCTL get_param obdfilter.$FSNAME-OST0000.stats | grep "$op")
11620                  ;;
11621         *) error "Wrong facet '$facet'" ;;
11622         esac
11623         [ "$res" ] || error "The counter for $op on $facet was not incremented"
11624         # if the argument $3 is zero, it means any stat increment is ok.
11625         if [[ $want -gt 0 ]]; then
11626                 local count=$(echo $res | awk '{ print $2 }')
11627                 [[ $count -ne $want ]] &&
11628                         error "The $op counter on $facet is $count, not $want"
11629         fi
11630 }
11631
11632 test_133a() {
11633         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11634         remote_ost_nodsh && skip "remote OST with nodsh"
11635         remote_mds_nodsh && skip "remote MDS with nodsh"
11636         do_facet $SINGLEMDS $LCTL list_param mdt.*.rename_stats ||
11637                 skip_env "MDS doesn't support rename stats"
11638
11639         local testdir=$DIR/${tdir}/stats_testdir
11640
11641         mkdir -p $DIR/${tdir}
11642
11643         # clear stats.
11644         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
11645         do_facet ost1 $LCTL set_param obdfilter.*.stats=clear
11646
11647         # verify mdt stats first.
11648         mkdir ${testdir} || error "mkdir failed"
11649         check_stats $SINGLEMDS "mkdir" 1
11650         touch ${testdir}/${tfile} || error "touch failed"
11651         check_stats $SINGLEMDS "open" 1
11652         check_stats $SINGLEMDS "close" 1
11653         [ $MDS1_VERSION -ge $(version_code 2.8.54) ] && {
11654                 mknod ${testdir}/${tfile}-pipe p || error "mknod failed"
11655                 check_stats $SINGLEMDS "mknod" 2
11656         }
11657         rm -f ${testdir}/${tfile}-pipe || error "pipe remove failed"
11658         check_stats $SINGLEMDS "unlink" 1
11659         rm -f ${testdir}/${tfile} || error "file remove failed"
11660         check_stats $SINGLEMDS "unlink" 2
11661
11662         # remove working dir and check mdt stats again.
11663         rmdir ${testdir} || error "rmdir failed"
11664         check_stats $SINGLEMDS "rmdir" 1
11665
11666         local testdir1=$DIR/${tdir}/stats_testdir1
11667         mkdir -p ${testdir}
11668         mkdir -p ${testdir1}
11669         touch ${testdir1}/test1
11670         mv ${testdir1}/test1 ${testdir} || error "file crossdir rename"
11671         check_stats $SINGLEMDS "crossdir_rename" 1
11672
11673         mv ${testdir}/test1 ${testdir}/test0 || error "file samedir rename"
11674         check_stats $SINGLEMDS "samedir_rename" 1
11675
11676         rm -rf $DIR/${tdir}
11677 }
11678 run_test 133a "Verifying MDT stats ========================================"
11679
11680 test_133b() {
11681         local res
11682
11683         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11684         remote_ost_nodsh && skip "remote OST with nodsh"
11685         remote_mds_nodsh && skip "remote MDS with nodsh"
11686
11687         local testdir=$DIR/${tdir}/stats_testdir
11688
11689         mkdir -p ${testdir} || error "mkdir failed"
11690         touch ${testdir}/${tfile} || error "touch failed"
11691         cancel_lru_locks mdc
11692
11693         # clear stats.
11694         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
11695         do_facet ost1 $LCTL set_param obdfilter.*.stats=clear
11696
11697         # extra mdt stats verification.
11698         chmod 444 ${testdir}/${tfile} || error "chmod failed"
11699         check_stats $SINGLEMDS "setattr" 1
11700         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
11701         if [ $MDS1_VERSION -ne $(version_code 2.2.0) ]
11702         then            # LU-1740
11703                 ls -l ${testdir}/${tfile} > /dev/null|| error "ls failed"
11704                 check_stats $SINGLEMDS "getattr" 1
11705         fi
11706         rm -rf $DIR/${tdir}
11707
11708         # when DNE is enabled, MDT uses STATFS RPC to ping other targets
11709         # so the check below is not reliable
11710         [ $MDSCOUNT -eq 1 ] || return 0
11711
11712         # Sleep to avoid a cached response.
11713         #define OBD_STATFS_CACHE_SECONDS 1
11714         sleep 2
11715         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
11716         do_facet ost1 $LCTL set_param obdfilter.*.exports.*.stats=clear
11717         $LFS df || error "lfs failed"
11718         check_stats $SINGLEMDS "statfs" 1
11719
11720         # check aggregated statfs (LU-10018)
11721         [ $MDS1_VERSION -lt $(version_code 2.11.54) ] &&
11722                 return 0
11723         [ $CLIENT_VERSION -lt $(version_code 2.11.54) ] &&
11724                 return 0
11725         sleep 2
11726         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
11727         do_facet ost1 $LCTL set_param obdfilter.*.exports.*.stats=clear
11728         df $DIR
11729         check_stats $SINGLEMDS "statfs" 1
11730
11731         # We want to check that the client didn't send OST_STATFS to
11732         # ost1 but the MDT also uses OST_STATFS for precreate. So some
11733         # extra care is needed here.
11734         if remote_mds; then
11735                 local nid=$($LCTL list_nids | head -1 | sed  "s/\./\\\./g")
11736                 local param="obdfilter.$FSNAME-OST0000.exports.'$nid'.stats"
11737
11738                 res=$(do_facet ost1 $LCTL get_param $param | grep statfs)
11739                 [ "$res" ] && error "OST got STATFS"
11740         fi
11741
11742         return 0
11743 }
11744 run_test 133b "Verifying extra MDT stats =================================="
11745
11746 test_133c() {
11747         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11748         remote_ost_nodsh && skip "remote OST with nodsh"
11749         remote_mds_nodsh && skip "remote MDS with nodsh"
11750
11751         local testdir=$DIR/$tdir/stats_testdir
11752
11753         test_mkdir -p $testdir
11754
11755         # verify obdfilter stats.
11756         $LFS setstripe -c 1 -i 0 $testdir/$tfile
11757         sync
11758         cancel_lru_locks osc
11759         wait_delete_completed
11760
11761         # clear stats.
11762         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
11763         do_facet ost1 $LCTL set_param obdfilter.*.stats=clear
11764
11765         dd if=/dev/zero of=$testdir/$tfile conv=notrunc bs=512k count=1 ||
11766                 error "dd failed"
11767         sync
11768         cancel_lru_locks osc
11769         check_stats ost1 "write" 1
11770
11771         dd if=$testdir/$tfile of=/dev/null bs=1k count=1 || error "dd failed"
11772         check_stats ost1 "read" 1
11773
11774         > $testdir/$tfile || error "truncate failed"
11775         check_stats ost1 "punch" 1
11776
11777         rm -f $testdir/$tfile || error "file remove failed"
11778         wait_delete_completed
11779         check_stats ost1 "destroy" 1
11780
11781         rm -rf $DIR/$tdir
11782 }
11783 run_test 133c "Verifying OST stats ========================================"
11784
11785 order_2() {
11786         local value=$1
11787         local orig=$value
11788         local order=1
11789
11790         while [ $value -ge 2 ]; do
11791                 order=$((order*2))
11792                 value=$((value/2))
11793         done
11794
11795         if [ $orig -gt $order ]; then
11796                 order=$((order*2))
11797         fi
11798         echo $order
11799 }
11800
11801 size_in_KMGT() {
11802     local value=$1
11803     local size=('K' 'M' 'G' 'T');
11804     local i=0
11805     local size_string=$value
11806
11807     while [ $value -ge 1024 ]; do
11808         if [ $i -gt 3 ]; then
11809             #T is the biggest unit we get here, if that is bigger,
11810             #just return XXXT
11811             size_string=${value}T
11812             break
11813         fi
11814         value=$((value >> 10))
11815         if [ $value -lt 1024 ]; then
11816             size_string=${value}${size[$i]}
11817             break
11818         fi
11819         i=$((i + 1))
11820     done
11821
11822     echo $size_string
11823 }
11824
11825 get_rename_size() {
11826         local size=$1
11827         local context=${2:-.}
11828         local sample=$(do_facet $SINGLEMDS $LCTL \
11829                 get_param mdt.$FSNAME-MDT0000.rename_stats |
11830                 grep -A1 $context |
11831                 awk '/ '${size}'/ {print $4}' | sed -e "s/,//g")
11832         echo $sample
11833 }
11834
11835 test_133d() {
11836         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11837         remote_ost_nodsh && skip "remote OST with nodsh"
11838         remote_mds_nodsh && skip "remote MDS with nodsh"
11839         do_facet $SINGLEMDS $LCTL list_param mdt.*.rename_stats ||
11840                 skip_env "MDS doesn't support rename stats"
11841
11842         local testdir1=$DIR/${tdir}/stats_testdir1
11843         local testdir2=$DIR/${tdir}/stats_testdir2
11844         mkdir -p $DIR/${tdir}
11845
11846         do_facet $SINGLEMDS $LCTL set_param mdt.*.rename_stats=clear
11847
11848         lfs mkdir -i 0 -c 1 ${testdir1} || error "mkdir failed"
11849         lfs mkdir -i 0 -c 1 ${testdir2} || error "mkdir failed"
11850
11851         createmany -o $testdir1/test 512 || error "createmany failed"
11852
11853         # check samedir rename size
11854         mv ${testdir1}/test0 ${testdir1}/test_0
11855
11856         local testdir1_size=$(ls -l $DIR/${tdir} |
11857                 awk '/stats_testdir1/ {print $5}')
11858         local testdir2_size=$(ls -l $DIR/${tdir} |
11859                 awk '/stats_testdir2/ {print $5}')
11860
11861         testdir1_size=$(order_2 $testdir1_size)
11862         testdir2_size=$(order_2 $testdir2_size)
11863
11864         testdir1_size=$(size_in_KMGT $testdir1_size)
11865         testdir2_size=$(size_in_KMGT $testdir2_size)
11866
11867         echo "source rename dir size: ${testdir1_size}"
11868         echo "target rename dir size: ${testdir2_size}"
11869
11870         local cmd="do_facet $SINGLEMDS $LCTL "
11871         cmd+="get_param mdt.$FSNAME-MDT0000.rename_stats"
11872
11873         eval $cmd || error "$cmd failed"
11874         local samedir=$($cmd | grep 'same_dir')
11875         local same_sample=$(get_rename_size $testdir1_size)
11876         [ -z "$samedir" ] && error "samedir_rename_size count error"
11877         [[ $same_sample -eq 1 ]] ||
11878                 error "samedir_rename_size error $same_sample"
11879         echo "Check same dir rename stats success"
11880
11881         do_facet $SINGLEMDS $LCTL set_param mdt.*.rename_stats=clear
11882
11883         # check crossdir rename size
11884         mv ${testdir1}/test_0 ${testdir2}/test_0
11885
11886         testdir1_size=$(ls -l $DIR/${tdir} |
11887                 awk '/stats_testdir1/ {print $5}')
11888         testdir2_size=$(ls -l $DIR/${tdir} |
11889                 awk '/stats_testdir2/ {print $5}')
11890
11891         testdir1_size=$(order_2 $testdir1_size)
11892         testdir2_size=$(order_2 $testdir2_size)
11893
11894         testdir1_size=$(size_in_KMGT $testdir1_size)
11895         testdir2_size=$(size_in_KMGT $testdir2_size)
11896
11897         echo "source rename dir size: ${testdir1_size}"
11898         echo "target rename dir size: ${testdir2_size}"
11899
11900         eval $cmd || error "$cmd failed"
11901         local crossdir=$($cmd | grep 'crossdir')
11902         local src_sample=$(get_rename_size $testdir1_size crossdir_src)
11903         local tgt_sample=$(get_rename_size $testdir2_size crossdir_tgt)
11904         [ -z "$crossdir" ] && error "crossdir_rename_size count error"
11905         [[ $src_sample -eq 1 ]] ||
11906                 error "crossdir_rename_size error $src_sample"
11907         [[ $tgt_sample -eq 1 ]] ||
11908                 error "crossdir_rename_size error $tgt_sample"
11909         echo "Check cross dir rename stats success"
11910         rm -rf $DIR/${tdir}
11911 }
11912 run_test 133d "Verifying rename_stats ========================================"
11913
11914 test_133e() {
11915         remote_mds_nodsh && skip "remote MDS with nodsh"
11916         remote_ost_nodsh && skip "remote OST with nodsh"
11917         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11918
11919         local testdir=$DIR/${tdir}/stats_testdir
11920         local ctr f0 f1 bs=32768 count=42 sum
11921
11922         mkdir -p ${testdir} || error "mkdir failed"
11923
11924         $LFS setstripe -c 1 -i 0 ${testdir}/${tfile}
11925
11926         for ctr in {write,read}_bytes; do
11927                 sync
11928                 cancel_lru_locks osc
11929
11930                 do_facet ost1 $LCTL set_param -n \
11931                         "obdfilter.*.exports.clear=clear"
11932
11933                 if [ $ctr = write_bytes ]; then
11934                         f0=/dev/zero
11935                         f1=${testdir}/${tfile}
11936                 else
11937                         f0=${testdir}/${tfile}
11938                         f1=/dev/null
11939                 fi
11940
11941                 dd if=$f0 of=$f1 conv=notrunc bs=$bs count=$count || \
11942                         error "dd failed"
11943                 sync
11944                 cancel_lru_locks osc
11945
11946                 sum=$(do_facet ost1 $LCTL get_param \
11947                         "obdfilter.*.exports.*.stats" |
11948                         awk -v ctr=$ctr 'BEGIN { sum = 0 }
11949                                 $1 == ctr { sum += $7 }
11950                                 END { printf("%0.0f", sum) }')
11951
11952                 if ((sum != bs * count)); then
11953                         error "Bad $ctr sum, expected $((bs * count)), got $sum"
11954                 fi
11955         done
11956
11957         rm -rf $DIR/${tdir}
11958 }
11959 run_test 133e "Verifying OST {read,write}_bytes nid stats ================="
11960
11961 proc_regexp="/{proc,sys}/{fs,sys,kernel/debug}/{lustre,lnet}/"
11962
11963 # Some versions of find (4.5.11, 4.5.14) included in CentOS 7.3-7.5 do
11964 # not honor the -ignore_readdir_race option correctly. So we call
11965 # error_ignore() rather than error() in these cases. See LU-11152.
11966 error_133() {
11967         if (find --version; do_facet mds1 find --version) |
11968                 grep -q '\b4\.5\.1[1-4]\b'; then
11969                 error_ignore LU-11152 "$@"
11970         else
11971                 error "$@"
11972         fi
11973 }
11974
11975 test_133f() {
11976         # First without trusting modes.
11977         local proc_dirs=$(eval \ls -d $proc_regexp 2>/dev/null)
11978         echo "proc_dirs='$proc_dirs'"
11979         [ -n "$proc_dirs" ] || error "no proc_dirs on $HOSTNAME"
11980         find $proc_dirs -exec cat '{}' \; &> /dev/null
11981
11982         # Second verifying readability.
11983         $LCTL get_param -R '*' &> /dev/null
11984
11985         # Verifing writability with badarea_io.
11986         find $proc_dirs \
11987                 -ignore_readdir_race \
11988                 -type f \
11989                 -not -name force_lbug \
11990                 -not -name changelog_mask \
11991                 -exec badarea_io '{}' \; ||
11992                         error_133 "find $proc_dirs failed"
11993 }
11994 run_test 133f "Check reads/writes of client lustre proc files with bad area io"
11995
11996 test_133g() {
11997         remote_mds_nodsh && skip "remote MDS with nodsh"
11998         remote_ost_nodsh && skip "remote OST with nodsh"
11999
12000         # eventually, this can also be replaced with "lctl get_param -R",
12001         # but not until that option is always available on the server
12002         local facet
12003         for facet in mds1 ost1; do
12004                 [ $(lustre_version_code $facet) -le $(version_code 2.5.54) ] &&
12005                         skip_noexit "Too old lustre on $facet"
12006                 local facet_proc_dirs=$(do_facet $facet \
12007                                         \\\ls -d $proc_regexp 2>/dev/null)
12008                 echo "${facet}_proc_dirs='$facet_proc_dirs'"
12009                 [ -z "$facet_proc_dirs" ] && error "no proc_dirs on $facet"
12010                 do_facet $facet find $facet_proc_dirs \
12011                         ! -name req_history \
12012                         -exec cat '{}' \\\; &> /dev/null
12013
12014                 do_facet $facet find $facet_proc_dirs \
12015                         ! -name req_history \
12016                         -type f \
12017                         -exec cat '{}' \\\; &> /dev/null ||
12018                                 error "proc file read failed"
12019
12020                 do_facet $facet find $facet_proc_dirs \
12021                         -ignore_readdir_race \
12022                         -type f \
12023                         -not -name force_lbug \
12024                         -not -name changelog_mask \
12025                         -exec badarea_io '{}' \\\; ||
12026                                 error_133 "$facet find $facet_proc_dirs failed"
12027         done
12028
12029         # remount the FS in case writes/reads /proc break the FS
12030         cleanup || error "failed to unmount"
12031         setup || error "failed to setup"
12032         true
12033 }
12034 run_test 133g "Check reads/writes of server lustre proc files with bad area io"
12035
12036 test_133h() {
12037         remote_mds_nodsh && skip "remote MDS with nodsh"
12038         remote_ost_nodsh && skip "remote OST with nodsh"
12039         [[ $MDS1_VERSION -lt $(version_code 2.9.54) ]] &&
12040                 skip "Need MDS version at least 2.9.54"
12041
12042         local facet
12043
12044         for facet in client mds1 ost1; do
12045                 local facet_proc_dirs=$(do_facet $facet \
12046                                         \\\ls -d $proc_regexp 2> /dev/null)
12047                 [ -z "$facet_proc_dirs" ] && error "no proc_dirs on $facet"
12048                 echo "${facet}_proc_dirs='$facet_proc_dirs'"
12049                 # Get the list of files that are missing the terminating newline
12050                 local missing=($(do_facet $facet \
12051                         find ${facet_proc_dirs} -type f \|              \
12052                                 while read F\; do                       \
12053                                         awk -v FS='\v' -v RS='\v\v'     \
12054                                         "'END { if(NR>0 &&              \
12055                                         \\\$NF !~ /.*\\\n\$/)           \
12056                                                 print FILENAME}'"       \
12057                                         '\$F'\;                         \
12058                                 done 2>/dev/null))
12059                 [ ${#missing[*]} -eq 0 ] ||
12060                         error "files do not end with newline: ${missing[*]}"
12061         done
12062 }
12063 run_test 133h "Proc files should end with newlines"
12064
12065 test_134a() {
12066         remote_mds_nodsh && skip "remote MDS with nodsh"
12067         [[ $MDS1_VERSION -lt $(version_code 2.7.54) ]] &&
12068                 skip "Need MDS version at least 2.7.54"
12069
12070         mkdir -p $DIR/$tdir || error "failed to create $DIR/$tdir"
12071         cancel_lru_locks mdc
12072
12073         local nsdir="ldlm.namespaces.*-MDT0000-mdc-*"
12074         local unused=$($LCTL get_param -n $nsdir.lock_unused_count)
12075         [ $unused -eq 0 ] || error "$unused locks are not cleared"
12076
12077         local nr=1000
12078         createmany -o $DIR/$tdir/f $nr ||
12079                 error "failed to create $nr files in $DIR/$tdir"
12080         unused=$($LCTL get_param -n $nsdir.lock_unused_count)
12081
12082         #define OBD_FAIL_LDLM_WATERMARK_LOW     0x327
12083         do_facet mds1 $LCTL set_param fail_loc=0x327
12084         do_facet mds1 $LCTL set_param fail_val=500
12085         touch $DIR/$tdir/m
12086
12087         echo "sleep 10 seconds ..."
12088         sleep 10
12089         local lck_cnt=$($LCTL get_param -n $nsdir.lock_unused_count)
12090
12091         do_facet mds1 $LCTL set_param fail_loc=0
12092         do_facet mds1 $LCTL set_param fail_val=0
12093         [ $lck_cnt -lt $unused ] ||
12094                 error "No locks reclaimed, before:$unused, after:$lck_cnt"
12095
12096         rm $DIR/$tdir/m
12097         unlinkmany $DIR/$tdir/f $nr
12098 }
12099 run_test 134a "Server reclaims locks when reaching lock_reclaim_threshold"
12100
12101 test_134b() {
12102         remote_mds_nodsh && skip "remote MDS with nodsh"
12103         [[ $MDS1_VERSION -lt $(version_code 2.7.54) ]] &&
12104                 skip "Need MDS version at least 2.7.54"
12105
12106         mkdir -p $DIR/$tdir || error "failed to create $DIR/$tdir"
12107         cancel_lru_locks mdc
12108
12109         local low_wm=$(do_facet mds1 $LCTL get_param -n \
12110                         ldlm.lock_reclaim_threshold_mb)
12111         # disable reclaim temporarily
12112         do_facet mds1 $LCTL set_param ldlm.lock_reclaim_threshold_mb=0
12113
12114         #define OBD_FAIL_LDLM_WATERMARK_HIGH     0x328
12115         do_facet mds1 $LCTL set_param fail_loc=0x328
12116         do_facet mds1 $LCTL set_param fail_val=500
12117
12118         $LCTL set_param debug=+trace
12119
12120         local nr=600
12121         createmany -o $DIR/$tdir/f $nr &
12122         local create_pid=$!
12123
12124         echo "Sleep $TIMEOUT seconds ..."
12125         sleep $TIMEOUT
12126         if ! ps -p $create_pid  > /dev/null 2>&1; then
12127                 do_facet mds1 $LCTL set_param fail_loc=0
12128                 do_facet mds1 $LCTL set_param fail_val=0
12129                 do_facet mds1 $LCTL set_param \
12130                         ldlm.lock_reclaim_threshold_mb=${low_wm}m
12131                 error "createmany finished incorrectly!"
12132         fi
12133         do_facet mds1 $LCTL set_param fail_loc=0
12134         do_facet mds1 $LCTL set_param fail_val=0
12135         do_facet mds1 $LCTL set_param ldlm.lock_reclaim_threshold_mb=${low_wm}m
12136         wait $create_pid || return 1
12137
12138         unlinkmany $DIR/$tdir/f $nr
12139 }
12140 run_test 134b "Server rejects lock request when reaching lock_limit_mb"
12141
12142 test_140() { #bug-17379
12143         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12144
12145         test_mkdir $DIR/$tdir
12146         cd $DIR/$tdir || error "Changing to $DIR/$tdir"
12147         cp $(which stat) . || error "Copying stat to $DIR/$tdir"
12148
12149         # VFS limits max symlink depth to 5(4KSTACK) or 7(8KSTACK) or 8
12150         # For kernel > 3.5, bellow only tests consecutive symlink (MAX 40)
12151         local i=0
12152         while i=$((i + 1)); do
12153                 test_mkdir $i
12154                 cd $i || error "Changing to $i"
12155                 ln -s ../stat stat || error "Creating stat symlink"
12156                 # Read the symlink until ELOOP present,
12157                 # not LBUGing the system is considered success,
12158                 # we didn't overrun the stack.
12159                 $OPENFILE -f O_RDONLY stat >/dev/null 2>&1; ret=$?
12160                 if [ $ret -ne 0 ]; then
12161                         if [ $ret -eq 40 ]; then
12162                                 break  # -ELOOP
12163                         else
12164                                 error "Open stat symlink"
12165                                         return
12166                         fi
12167                 fi
12168         done
12169         i=$((i - 1))
12170         echo "The symlink depth = $i"
12171         [ $i -eq 5 ] || [ $i -eq 7 ] || [ $i -eq 8 ] || [ $i -eq 40 ] ||
12172                 error "Invalid symlink depth"
12173
12174         # Test recursive symlink
12175         ln -s symlink_self symlink_self
12176         $OPENFILE -f O_RDONLY symlink_self >/dev/null 2>&1; ret=$?
12177         echo "open symlink_self returns $ret"
12178         [ $ret -eq 40 ] || error "recursive symlink doesn't return -ELOOP"
12179 }
12180 run_test 140 "Check reasonable stack depth (shouldn't LBUG) ===="
12181
12182 test_150() {
12183         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12184
12185         local TF="$TMP/$tfile"
12186
12187         dd if=/dev/urandom of=$TF bs=6096 count=1 || error "dd failed"
12188         cp $TF $DIR/$tfile
12189         cancel_lru_locks $OSC
12190         cmp $TF $DIR/$tfile || error "$TMP/$tfile $DIR/$tfile differ"
12191         remount_client $MOUNT
12192         df -P $MOUNT
12193         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (remount)"
12194
12195         $TRUNCATE $TF 6000
12196         $TRUNCATE $DIR/$tfile 6000
12197         cancel_lru_locks $OSC
12198         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (truncate1)"
12199
12200         echo "12345" >>$TF
12201         echo "12345" >>$DIR/$tfile
12202         cancel_lru_locks $OSC
12203         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (append1)"
12204
12205         echo "12345" >>$TF
12206         echo "12345" >>$DIR/$tfile
12207         cancel_lru_locks $OSC
12208         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (append2)"
12209
12210         rm -f $TF
12211         true
12212 }
12213 run_test 150 "truncate/append tests"
12214
12215 #LU-2902 roc_hit was not able to read all values from lproc
12216 function roc_hit_init() {
12217         local list=$(comma_list $(osts_nodes))
12218         local dir=$DIR/$tdir-check
12219         local file=$dir/$tfile
12220         local BEFORE
12221         local AFTER
12222         local idx
12223
12224         test_mkdir $dir
12225         #use setstripe to do a write to every ost
12226         for i in $(seq 0 $((OSTCOUNT-1))); do
12227                 $LFS setstripe -c 1 -i $i $dir || error "$LFS setstripe $file failed"
12228                 dd if=/dev/urandom of=$file bs=4k count=4 2>&1 > /dev/null
12229                 idx=$(printf %04x $i)
12230                 BEFORE=$(get_osd_param $list *OST*$idx stats |
12231                         awk '$1 == "cache_access" {sum += $7}
12232                                 END { printf("%0.0f", sum) }')
12233
12234                 cancel_lru_locks osc
12235                 cat $file >/dev/null
12236
12237                 AFTER=$(get_osd_param $list *OST*$idx stats |
12238                         awk '$1 == "cache_access" {sum += $7}
12239                                 END { printf("%0.0f", sum) }')
12240
12241                 echo BEFORE:$BEFORE AFTER:$AFTER
12242                 if ! let "AFTER - BEFORE == 4"; then
12243                         rm -rf $dir
12244                         error "roc_hit is not safe to use"
12245                 fi
12246                 rm $file
12247         done
12248
12249         rm -rf $dir
12250 }
12251
12252 function roc_hit() {
12253         local list=$(comma_list $(osts_nodes))
12254         echo $(get_osd_param $list '' stats |
12255                 awk '$1 == "cache_hit" {sum += $7}
12256                         END { printf("%0.0f", sum) }')
12257 }
12258
12259 function set_cache() {
12260         local on=1
12261
12262         if [ "$2" == "off" ]; then
12263                 on=0;
12264         fi
12265         local list=$(comma_list $(osts_nodes))
12266         set_osd_param $list '' $1_cache_enable $on
12267
12268         cancel_lru_locks osc
12269 }
12270
12271 test_151() {
12272         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12273         remote_ost_nodsh && skip "remote OST with nodsh"
12274
12275         local CPAGES=3
12276         local list=$(comma_list $(osts_nodes))
12277
12278         # check whether obdfilter is cache capable at all
12279         if ! get_osd_param $list '' read_cache_enable >/dev/null; then
12280                 skip "not cache-capable obdfilter"
12281         fi
12282
12283         # check cache is enabled on all obdfilters
12284         if get_osd_param $list '' read_cache_enable | grep 0; then
12285                 skip "oss cache is disabled"
12286         fi
12287
12288         set_osd_param $list '' writethrough_cache_enable 1
12289
12290         # check write cache is enabled on all obdfilters
12291         if get_osd_param $list '' writethrough_cache_enable | grep 0; then
12292                 skip "oss write cache is NOT enabled"
12293         fi
12294
12295         roc_hit_init
12296
12297         #define OBD_FAIL_OBD_NO_LRU  0x609
12298         do_nodes $list $LCTL set_param fail_loc=0x609
12299
12300         # pages should be in the case right after write
12301         dd if=/dev/urandom of=$DIR/$tfile bs=4k count=$CPAGES ||
12302                 error "dd failed"
12303
12304         local BEFORE=$(roc_hit)
12305         cancel_lru_locks osc
12306         cat $DIR/$tfile >/dev/null
12307         local AFTER=$(roc_hit)
12308
12309         do_nodes $list $LCTL set_param fail_loc=0
12310
12311         if ! let "AFTER - BEFORE == CPAGES"; then
12312                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
12313         fi
12314
12315         # the following read invalidates the cache
12316         cancel_lru_locks osc
12317         set_osd_param $list '' read_cache_enable 0
12318         cat $DIR/$tfile >/dev/null
12319
12320         # now data shouldn't be found in the cache
12321         BEFORE=$(roc_hit)
12322         cancel_lru_locks osc
12323         cat $DIR/$tfile >/dev/null
12324         AFTER=$(roc_hit)
12325         if let "AFTER - BEFORE != 0"; then
12326                 error "IN CACHE: before: $BEFORE, after: $AFTER"
12327         fi
12328
12329         set_osd_param $list '' read_cache_enable 1
12330         rm -f $DIR/$tfile
12331 }
12332 run_test 151 "test cache on oss and controls ==============================="
12333
12334 test_152() {
12335         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12336
12337         local TF="$TMP/$tfile"
12338
12339         # simulate ENOMEM during write
12340 #define OBD_FAIL_OST_NOMEM      0x226
12341         lctl set_param fail_loc=0x80000226
12342         dd if=/dev/urandom of=$TF bs=6096 count=1 || error "dd failed"
12343         cp $TF $DIR/$tfile
12344         sync || error "sync failed"
12345         lctl set_param fail_loc=0
12346
12347         # discard client's cache
12348         cancel_lru_locks osc
12349
12350         # simulate ENOMEM during read
12351         lctl set_param fail_loc=0x80000226
12352         cmp $TF $DIR/$tfile || error "cmp failed"
12353         lctl set_param fail_loc=0
12354
12355         rm -f $TF
12356 }
12357 run_test 152 "test read/write with enomem ============================"
12358
12359 test_153() {
12360         $MULTIOP $DIR/$tfile Ow4096Ycu || error "multiop failed"
12361 }
12362 run_test 153 "test if fdatasync does not crash ======================="
12363
12364 dot_lustre_fid_permission_check() {
12365         local fid=$1
12366         local ffid=$MOUNT/.lustre/fid/$fid
12367         local test_dir=$2
12368
12369         echo "stat fid $fid"
12370         stat $ffid > /dev/null || error "stat $ffid failed."
12371         echo "touch fid $fid"
12372         touch $ffid || error "touch $ffid failed."
12373         echo "write to fid $fid"
12374         cat /etc/hosts > $ffid || error "write $ffid failed."
12375         echo "read fid $fid"
12376         diff /etc/hosts $ffid || error "read $ffid failed."
12377         echo "append write to fid $fid"
12378         cat /etc/hosts >> $ffid || error "append write $ffid failed."
12379         echo "rename fid $fid"
12380         mv $ffid $test_dir/$tfile.1 &&
12381                 error "rename $ffid to $tfile.1 should fail."
12382         touch $test_dir/$tfile.1
12383         mv $test_dir/$tfile.1 $ffid &&
12384                 error "rename $tfile.1 to $ffid should fail."
12385         rm -f $test_dir/$tfile.1
12386         echo "truncate fid $fid"
12387         $TRUNCATE $ffid 777 || error "truncate $ffid failed."
12388         echo "link fid $fid"
12389         ln -f $ffid $test_dir/tfile.lnk || error "link $ffid failed."
12390         if [[ $($LCTL get_param -n mdc.*-mdc-*.connect_flags) =~ acl ]]; then
12391                 echo "setfacl fid $fid"
12392                 setfacl -R -m u:bin:rwx $ffid || error "setfacl $ffid failed."
12393                 echo "getfacl fid $fid"
12394                 getfacl $ffid >/dev/null || error "getfacl $ffid failed."
12395         fi
12396         echo "unlink fid $fid"
12397         unlink $MOUNT/.lustre/fid/$fid && error "unlink $ffid should fail."
12398         echo "mknod fid $fid"
12399         mknod $ffid c 1 3 && error "mknod $ffid should fail."
12400
12401         fid=[0xf00000400:0x1:0x0]
12402         ffid=$MOUNT/.lustre/fid/$fid
12403
12404         echo "stat non-exist fid $fid"
12405         stat $ffid > /dev/null && error "stat non-exist $ffid should fail."
12406         echo "write to non-exist fid $fid"
12407         cat /etc/hosts > $ffid && error "write non-exist $ffid should fail."
12408         echo "link new fid $fid"
12409         ln $test_dir/$tfile $ffid && error "link $ffid should fail."
12410
12411         mkdir -p $test_dir/$tdir
12412         touch $test_dir/$tdir/$tfile
12413         fid=$($LFS path2fid $test_dir/$tdir)
12414         rc=$?
12415         [ $rc -ne 0 ] &&
12416                 error "error: could not get fid for $test_dir/$dir/$tfile."
12417
12418         ffid=$MOUNT/.lustre/fid/$fid
12419
12420         echo "ls $fid"
12421         ls $ffid > /dev/null || error "ls $ffid failed."
12422         echo "touch $fid/$tfile.1"
12423         touch $ffid/$tfile.1 || error "touch $ffid/$tfile.1 failed."
12424
12425         echo "touch $MOUNT/.lustre/fid/$tfile"
12426         touch $MOUNT/.lustre/fid/$tfile && \
12427                 error "touch $MOUNT/.lustre/fid/$tfile should fail."
12428
12429         echo "setxattr to $MOUNT/.lustre/fid"
12430         setfattr -n trusted.name1 -v value1 $MOUNT/.lustre/fid
12431
12432         echo "listxattr for $MOUNT/.lustre/fid"
12433         getfattr -d -m "^trusted" $MOUNT/.lustre/fid
12434
12435         echo "delxattr from $MOUNT/.lustre/fid"
12436         setfattr -x trusted.name1 $MOUNT/.lustre/fid
12437
12438         echo "touch invalid fid: $MOUNT/.lustre/fid/[0x200000400:0x2:0x3]"
12439         touch $MOUNT/.lustre/fid/[0x200000400:0x2:0x3] &&
12440                 error "touch invalid fid should fail."
12441
12442         echo "touch non-normal fid: $MOUNT/.lustre/fid/[0x1:0x2:0x0]"
12443         touch $MOUNT/.lustre/fid/[0x1:0x2:0x0] &&
12444                 error "touch non-normal fid should fail."
12445
12446         echo "rename $tdir to $MOUNT/.lustre/fid"
12447         mrename $test_dir/$tdir $MOUNT/.lustre/fid &&
12448                 error "rename to $MOUNT/.lustre/fid should fail."
12449
12450         if [ $MDS1_VERSION -ge $(version_code 2.3.51) ]
12451         then            # LU-3547
12452                 local old_obf_mode=$(stat --format="%a" $DIR/.lustre/fid)
12453                 local new_obf_mode=777
12454
12455                 echo "change mode of $DIR/.lustre/fid to $new_obf_mode"
12456                 chmod $new_obf_mode $DIR/.lustre/fid ||
12457                         error "chmod $new_obf_mode $DIR/.lustre/fid failed"
12458
12459                 local obf_mode=$(stat --format=%a $DIR/.lustre/fid)
12460                 [ $obf_mode -eq $new_obf_mode ] ||
12461                         error "stat $DIR/.lustre/fid returned wrong mode $obf_mode"
12462
12463                 echo "restore mode of $DIR/.lustre/fid to $old_obf_mode"
12464                 chmod $old_obf_mode $DIR/.lustre/fid ||
12465                         error "chmod $old_obf_mode $DIR/.lustre/fid failed"
12466         fi
12467
12468         $OPENFILE -f O_LOV_DELAY_CREATE:O_CREAT $test_dir/$tfile-2
12469         fid=$($LFS path2fid $test_dir/$tfile-2)
12470
12471         if [ $MDS1_VERSION -ge $(version_code 2.6.50) ]
12472         then # LU-5424
12473                 echo "cp /etc/passwd $MOUNT/.lustre/fid/$fid"
12474                 cp /etc/passwd $MOUNT/.lustre/fid/$fid ||
12475                         error "create lov data thru .lustre failed"
12476         fi
12477         echo "cp /etc/passwd $test_dir/$tfile-2"
12478         cp /etc/passwd $test_dir/$tfile-2 ||
12479                 error "copy to $test_dir/$tfile-2 failed."
12480         echo "diff /etc/passwd $MOUNT/.lustre/fid/$fid"
12481         diff /etc/passwd $MOUNT/.lustre/fid/$fid ||
12482                 error "diff /etc/passwd $MOUNT/.lustre/fid/$fid failed."
12483
12484         rm -rf $test_dir/tfile.lnk
12485         rm -rf $test_dir/$tfile-2
12486 }
12487
12488 test_154A() {
12489         [[ $MDS1_VERSION -lt $(version_code 2.4.1) ]] &&
12490                 skip "Need MDS version at least 2.4.1"
12491
12492         local tf=$DIR/$tfile
12493         touch $tf
12494
12495         local fid=$($LFS path2fid $tf)
12496         [ -z "$fid" ] && error "path2fid unable to get $tf FID"
12497
12498         # check that we get the same pathname back
12499         local found=$($LFS fid2path $MOUNT "$fid")
12500         [ -z "$found" ] && error "fid2path unable to get '$fid' path"
12501         [ "$found" == "$tf" ] ||
12502                 error "fid2path($fid=path2fid($tf)) = $found != $tf"
12503 }
12504 run_test 154A "lfs path2fid and fid2path basic checks"
12505
12506 test_154B() {
12507         [[ $MDS1_VERSION -lt $(version_code 2.4.1) ]] &&
12508                 skip "Need MDS version at least 2.4.1"
12509
12510         mkdir -p $DIR/$tdir || error "mkdir $tdir failed"
12511         touch $DIR/$tdir/$tfile || error "touch $DIR/$tdir/$tfile failed"
12512         local linkea=$($LL_DECODE_LINKEA $DIR/$tdir/$tfile | grep 'pfid')
12513         [ -z "$linkea" ] && error "decode linkea $DIR/$tdir/$tfile failed"
12514
12515         local name=$(echo $linkea | awk '/pfid/ {print $5}' | sed -e "s/'//g")
12516         local PFID=$(echo $linkea | awk '/pfid/ {print $3}' | sed -e "s/,//g")
12517
12518         # check that we get the same pathname
12519         echo "PFID: $PFID, name: $name"
12520         local FOUND=$($LFS fid2path $MOUNT "$PFID")
12521         [ -z "$FOUND" ] && error "fid2path unable to get $PFID path"
12522         [ "$FOUND/$name" != "$DIR/$tdir/$tfile" ] &&
12523                 error "ll_decode_linkea has $FOUND/$name != $DIR/$tdir/$tfile"
12524
12525         rm -rf $DIR/$tdir || error "Can not delete directory $DIR/$tdir"
12526 }
12527 run_test 154B "verify the ll_decode_linkea tool"
12528
12529 test_154a() {
12530         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12531         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
12532         [[ $MDS1_VERSION -ge $(version_code 2.2.51) ]] ||
12533                 skip "Need MDS version at least 2.2.51"
12534         [ -z "$(which setfacl)" ] && skip_env "must have setfacl tool"
12535
12536         cp /etc/hosts $DIR/$tfile
12537
12538         fid=$($LFS path2fid $DIR/$tfile)
12539         rc=$?
12540         [ $rc -ne 0 ] && error "error: could not get fid for $DIR/$tfile."
12541
12542         dot_lustre_fid_permission_check "$fid" $DIR ||
12543                 error "dot lustre permission check $fid failed"
12544
12545         ls -a $MOUNT | grep "\.lustre" && error ".lustre should not be listed"
12546
12547         rm -rf $MOUNT/.lustre && error ".lustre is not allowed to be unlinked"
12548
12549         touch $MOUNT/.lustre/file &&
12550                 error "creation is not allowed under .lustre"
12551
12552         mkdir $MOUNT/.lustre/dir &&
12553                 error "mkdir is not allowed under .lustre"
12554
12555         rm -rf $DIR/$tfile
12556 }
12557 run_test 154a "Open-by-FID"
12558
12559 test_154b() {
12560         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12561         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
12562         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
12563         [[ $MDS1_VERSION -ge $(version_code 2.2.51) ]] ||
12564                 skip "Need MDS version at least 2.2.51"
12565
12566         local remote_dir=$DIR/$tdir/remote_dir
12567         local MDTIDX=1
12568         local rc=0
12569
12570         mkdir -p $DIR/$tdir
12571         $LFS mkdir -i $MDTIDX $remote_dir ||
12572                 error "create remote directory failed"
12573
12574         cp /etc/hosts $remote_dir/$tfile
12575
12576         fid=$($LFS path2fid $remote_dir/$tfile)
12577         rc=$?
12578         [ $rc -ne 0 ] && error "error: could not get fid for $remote_dir/$tfile"
12579
12580         dot_lustre_fid_permission_check "$fid" $remote_dir ||
12581                 error "dot lustre permission check $fid failed"
12582         rm -rf $DIR/$tdir
12583 }
12584 run_test 154b "Open-by-FID for remote directory"
12585
12586 test_154c() {
12587         [[ $MDS1_VERSION -lt $(version_code 2.4.1) ]] &&
12588                 skip "Need MDS version at least 2.4.1"
12589
12590         touch $DIR/$tfile.1 $DIR/$tfile.2 $DIR/$tfile.3
12591         local FID1=$($LFS path2fid $DIR/$tfile.1)
12592         local FID2=$($LFS path2fid $DIR/$tfile.2)
12593         local FID3=$($LFS path2fid $DIR/$tfile.3)
12594
12595         local N=1
12596         $LFS path2fid $DIR/$tfile.[123] | while read PATHNAME FID; do
12597                 [ "$PATHNAME" = "$DIR/$tfile.$N:" ] ||
12598                         error "path2fid pathname $PATHNAME != $DIR/$tfile.$N:"
12599                 local want=FID$N
12600                 [ "$FID" = "${!want}" ] ||
12601                         error "path2fid $PATHNAME FID $FID != FID$N ${!want}"
12602                 N=$((N + 1))
12603         done
12604
12605         $LFS fid2path $MOUNT "$FID1" "$FID2" "$FID3" | while read PATHNAME;
12606         do
12607                 [ "$PATHNAME" = "$DIR/$tfile.$N" ] ||
12608                         error "fid2path pathname $PATHNAME != $DIR/$tfile.$N:"
12609                 N=$((N + 1))
12610         done
12611 }
12612 run_test 154c "lfs path2fid and fid2path multiple arguments"
12613
12614 test_154d() {
12615         remote_mds_nodsh && skip "remote MDS with nodsh"
12616         [[ $MDS1_VERSION -lt $(version_code 2.5.53) ]] &&
12617                 skip "Need MDS version at least 2.5.53"
12618
12619         if remote_mds; then
12620                 nid=$($LCTL list_nids | sed  "s/\./\\\./g")
12621         else
12622                 nid="0@lo"
12623         fi
12624         local proc_ofile="mdt.*.exports.'$nid'.open_files"
12625         local fd
12626         local cmd
12627
12628         rm -f $DIR/$tfile
12629         touch $DIR/$tfile
12630
12631         local fid=$($LFS path2fid $DIR/$tfile)
12632         # Open the file
12633         fd=$(free_fd)
12634         cmd="exec $fd<$DIR/$tfile"
12635         eval $cmd
12636         local fid_list=$(do_facet $SINGLEMDS $LCTL get_param $proc_ofile)
12637         echo "$fid_list" | grep "$fid"
12638         rc=$?
12639
12640         cmd="exec $fd>/dev/null"
12641         eval $cmd
12642         if [ $rc -ne 0 ]; then
12643                 error "FID $fid not found in open files list $fid_list"
12644         fi
12645 }
12646 run_test 154d "Verify open file fid"
12647
12648 test_154e()
12649 {
12650         [[ $MDS1_VERSION -lt $(version_code 2.6.50) ]] &&
12651                 skip "Need MDS version at least 2.6.50"
12652
12653         if ls -a $MOUNT | grep -q '^\.lustre$'; then
12654                 error ".lustre returned by readdir"
12655         fi
12656 }
12657 run_test 154e ".lustre is not returned by readdir"
12658
12659 test_154f() {
12660         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
12661
12662         # create parent directory on a single MDT to avoid cross-MDT hardlinks
12663         test_mkdir -p -c1 $DIR/$tdir/d
12664         # test dirs inherit from its stripe
12665         mkdir -p $DIR/$tdir/d/foo1 || error "mkdir error"
12666         mkdir -p $DIR/$tdir/d/foo2 || error "mkdir error"
12667         cp /etc/hosts $DIR/$tdir/d/foo1/$tfile
12668         ln $DIR/$tdir/d/foo1/$tfile $DIR/$tdir/d/foo2/link
12669         touch $DIR/f
12670
12671         # get fid of parents
12672         local FID0=$($LFS path2fid $DIR/$tdir/d)
12673         local FID1=$($LFS path2fid $DIR/$tdir/d/foo1)
12674         local FID2=$($LFS path2fid $DIR/$tdir/d/foo2)
12675         local FID3=$($LFS path2fid $DIR)
12676
12677         # check that path2fid --parents returns expected <parent_fid>/name
12678         # 1) test for a directory (single parent)
12679         local parent=$($LFS path2fid --parents $DIR/$tdir/d/foo1)
12680         [ "$parent" == "$FID0/foo1" ] ||
12681                 error "expected parent: $FID0/foo1, got: $parent"
12682
12683         # 2) test for a file with nlink > 1 (multiple parents)
12684         parent=$($LFS path2fid --parents $DIR/$tdir/d/foo1/$tfile)
12685         echo "$parent" | grep -F "$FID1/$tfile" ||
12686                 error "$FID1/$tfile not returned in parent list"
12687         echo "$parent" | grep -F "$FID2/link" ||
12688                 error "$FID2/link not returned in parent list"
12689
12690         # 3) get parent by fid
12691         local file_fid=$($LFS path2fid $DIR/$tdir/d/foo1/$tfile)
12692         parent=$($LFS path2fid --parents $MOUNT/.lustre/fid/$file_fid)
12693         echo "$parent" | grep -F "$FID1/$tfile" ||
12694                 error "$FID1/$tfile not returned in parent list (by fid)"
12695         echo "$parent" | grep -F "$FID2/link" ||
12696                 error "$FID2/link not returned in parent list (by fid)"
12697
12698         # 4) test for entry in root directory
12699         parent=$($LFS path2fid --parents $DIR/f)
12700         echo "$parent" | grep -F "$FID3/f" ||
12701                 error "$FID3/f not returned in parent list"
12702
12703         # 5) test it on root directory
12704         [ -z "$($LFS path2fid --parents $MOUNT 2>/dev/null)" ] ||
12705                 error "$MOUNT should not have parents"
12706
12707         # enable xattr caching and check that linkea is correctly updated
12708         local save="$TMP/$TESTSUITE-$TESTNAME.parameters"
12709         save_lustre_params client "llite.*.xattr_cache" > $save
12710         lctl set_param llite.*.xattr_cache 1
12711
12712         # 6.1) linkea update on rename
12713         mv $DIR/$tdir/d/foo1/$tfile $DIR/$tdir/d/foo2/$tfile.moved
12714
12715         # get parents by fid
12716         parent=$($LFS path2fid --parents $MOUNT/.lustre/fid/$file_fid)
12717         # foo1 should no longer be returned in parent list
12718         echo "$parent" | grep -F "$FID1" &&
12719                 error "$FID1 should no longer be in parent list"
12720         # the new path should appear
12721         echo "$parent" | grep -F "$FID2/$tfile.moved" ||
12722                 error "$FID2/$tfile.moved is not in parent list"
12723
12724         # 6.2) linkea update on unlink
12725         rm -f $DIR/$tdir/d/foo2/link
12726         parent=$($LFS path2fid --parents $MOUNT/.lustre/fid/$file_fid)
12727         # foo2/link should no longer be returned in parent list
12728         echo "$parent" | grep -F "$FID2/link" &&
12729                 error "$FID2/link should no longer be in parent list"
12730         true
12731
12732         rm -f $DIR/f
12733         restore_lustre_params < $save
12734         rm -f $save
12735 }
12736 run_test 154f "get parent fids by reading link ea"
12737
12738 test_154g()
12739 {
12740         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
12741         [[ $MDS1_VERSION -ge $(version_code 2.6.92) &&
12742            $CLIENT_VERSION -gt $(version_code 2.6.99) ]] ||
12743                 skip "Need MDS version at least 2.6.92"
12744
12745         mkdir -p $DIR/$tdir
12746         llapi_fid_test -d $DIR/$tdir
12747 }
12748 run_test 154g "various llapi FID tests"
12749
12750 test_155_small_load() {
12751     local temp=$TMP/$tfile
12752     local file=$DIR/$tfile
12753
12754     dd if=/dev/urandom of=$temp bs=6096 count=1 || \
12755         error "dd of=$temp bs=6096 count=1 failed"
12756     cp $temp $file
12757     cancel_lru_locks $OSC
12758     cmp $temp $file || error "$temp $file differ"
12759
12760     $TRUNCATE $temp 6000
12761     $TRUNCATE $file 6000
12762     cmp $temp $file || error "$temp $file differ (truncate1)"
12763
12764     echo "12345" >>$temp
12765     echo "12345" >>$file
12766     cmp $temp $file || error "$temp $file differ (append1)"
12767
12768     echo "12345" >>$temp
12769     echo "12345" >>$file
12770     cmp $temp $file || error "$temp $file differ (append2)"
12771
12772     rm -f $temp $file
12773     true
12774 }
12775
12776 test_155_big_load() {
12777         remote_ost_nodsh && skip "remote OST with nodsh"
12778
12779         local temp=$TMP/$tfile
12780         local file=$DIR/$tfile
12781
12782         free_min_max
12783         local cache_size=$(do_facet ost$((MAXI+1)) \
12784                 "awk '/cache/ {sum+=\\\$4} END {print sum}' /proc/cpuinfo")
12785         local large_file_size=$((cache_size * 2))
12786
12787         echo "OSS cache size: $cache_size KB"
12788         echo "Large file size: $large_file_size KB"
12789
12790         [ $MAXV -le $large_file_size ] &&
12791                 skip_env "max available OST size needs > $large_file_size KB"
12792
12793         $LFS setstripe $file -c 1 -i $MAXI || error "$LFS setstripe $file failed"
12794
12795         dd if=/dev/urandom of=$temp bs=$large_file_size count=1k ||
12796                 error "dd of=$temp bs=$large_file_size count=1k failed"
12797         cp $temp $file
12798         ls -lh $temp $file
12799         cancel_lru_locks osc
12800         cmp $temp $file || error "$temp $file differ"
12801
12802         rm -f $temp $file
12803         true
12804 }
12805
12806 save_writethrough() {
12807         local facets=$(get_facets OST)
12808
12809         save_lustre_params $facets "osd-*.*.writethrough_cache_enable" > $1
12810 }
12811
12812 test_155a() {
12813         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12814
12815         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
12816
12817         save_writethrough $p
12818
12819         set_cache read on
12820         set_cache writethrough on
12821         test_155_small_load
12822         restore_lustre_params < $p
12823         rm -f $p
12824 }
12825 run_test 155a "Verify small file correctness: read cache:on write_cache:on"
12826
12827 test_155b() {
12828         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12829
12830         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
12831
12832         save_writethrough $p
12833
12834         set_cache read on
12835         set_cache writethrough off
12836         test_155_small_load
12837         restore_lustre_params < $p
12838         rm -f $p
12839 }
12840 run_test 155b "Verify small file correctness: read cache:on write_cache:off"
12841
12842 test_155c() {
12843         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12844
12845         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
12846
12847         save_writethrough $p
12848
12849         set_cache read off
12850         set_cache writethrough on
12851         test_155_small_load
12852         restore_lustre_params < $p
12853         rm -f $p
12854 }
12855 run_test 155c "Verify small file correctness: read cache:off write_cache:on"
12856
12857 test_155d() {
12858         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12859
12860         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
12861
12862         save_writethrough $p
12863
12864         set_cache read off
12865         set_cache writethrough off
12866         test_155_small_load
12867         restore_lustre_params < $p
12868         rm -f $p
12869 }
12870 run_test 155d "Verify small file correctness: read cache:off write_cache:off"
12871
12872 test_155e() {
12873         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12874
12875         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
12876
12877         save_writethrough $p
12878
12879         set_cache read on
12880         set_cache writethrough on
12881         test_155_big_load
12882         restore_lustre_params < $p
12883         rm -f $p
12884 }
12885 run_test 155e "Verify big file correctness: read cache:on write_cache:on"
12886
12887 test_155f() {
12888         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12889
12890         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
12891
12892         save_writethrough $p
12893
12894         set_cache read on
12895         set_cache writethrough off
12896         test_155_big_load
12897         restore_lustre_params < $p
12898         rm -f $p
12899 }
12900 run_test 155f "Verify big file correctness: read cache:on write_cache:off"
12901
12902 test_155g() {
12903         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12904
12905         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
12906
12907         save_writethrough $p
12908
12909         set_cache read off
12910         set_cache writethrough on
12911         test_155_big_load
12912         restore_lustre_params < $p
12913         rm -f $p
12914 }
12915 run_test 155g "Verify big file correctness: read cache:off write_cache:on"
12916
12917 test_155h() {
12918         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12919
12920         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
12921
12922         save_writethrough $p
12923
12924         set_cache read off
12925         set_cache writethrough off
12926         test_155_big_load
12927         restore_lustre_params < $p
12928         rm -f $p
12929 }
12930 run_test 155h "Verify big file correctness: read cache:off write_cache:off"
12931
12932 test_156() {
12933         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12934         remote_ost_nodsh && skip "remote OST with nodsh"
12935         [ $OST1_VERSION -lt $(version_code 2.6.93) ] &&
12936                 skip "stats not implemented on old servers"
12937         [ "$ost1_FSTYPE" = "zfs" ] &&
12938                 skip "LU-1956/LU-2261: stats not implemented on OSD ZFS"
12939
12940         local CPAGES=3
12941         local BEFORE
12942         local AFTER
12943         local file="$DIR/$tfile"
12944         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
12945
12946         save_writethrough $p
12947         roc_hit_init
12948
12949         log "Turn on read and write cache"
12950         set_cache read on
12951         set_cache writethrough on
12952
12953         log "Write data and read it back."
12954         log "Read should be satisfied from the cache."
12955         dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
12956         BEFORE=$(roc_hit)
12957         cancel_lru_locks osc
12958         cat $file >/dev/null
12959         AFTER=$(roc_hit)
12960         if ! let "AFTER - BEFORE == CPAGES"; then
12961                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
12962         else
12963                 log "cache hits:: before: $BEFORE, after: $AFTER"
12964         fi
12965
12966         log "Read again; it should be satisfied from the cache."
12967         BEFORE=$AFTER
12968         cancel_lru_locks osc
12969         cat $file >/dev/null
12970         AFTER=$(roc_hit)
12971         if ! let "AFTER - BEFORE == CPAGES"; then
12972                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
12973         else
12974                 log "cache hits:: before: $BEFORE, after: $AFTER"
12975         fi
12976
12977         log "Turn off the read cache and turn on the write cache"
12978         set_cache read off
12979         set_cache writethrough on
12980
12981         log "Read again; it should be satisfied from the cache."
12982         BEFORE=$(roc_hit)
12983         cancel_lru_locks osc
12984         cat $file >/dev/null
12985         AFTER=$(roc_hit)
12986         if ! let "AFTER - BEFORE == CPAGES"; then
12987                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
12988         else
12989                 log "cache hits:: before: $BEFORE, after: $AFTER"
12990         fi
12991
12992         log "Read again; it should not be satisfied from the cache."
12993         BEFORE=$AFTER
12994         cancel_lru_locks osc
12995         cat $file >/dev/null
12996         AFTER=$(roc_hit)
12997         if ! let "AFTER - BEFORE == 0"; then
12998                 error "IN CACHE: before: $BEFORE, after: $AFTER"
12999         else
13000                 log "cache hits:: before: $BEFORE, after: $AFTER"
13001         fi
13002
13003         log "Write data and read it back."
13004         log "Read should be satisfied from the cache."
13005         dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
13006         BEFORE=$(roc_hit)
13007         cancel_lru_locks osc
13008         cat $file >/dev/null
13009         AFTER=$(roc_hit)
13010         if ! let "AFTER - BEFORE == CPAGES"; then
13011                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
13012         else
13013                 log "cache hits:: before: $BEFORE, after: $AFTER"
13014         fi
13015
13016         log "Read again; it should not be satisfied from the cache."
13017         BEFORE=$AFTER
13018         cancel_lru_locks osc
13019         cat $file >/dev/null
13020         AFTER=$(roc_hit)
13021         if ! let "AFTER - BEFORE == 0"; then
13022                 error "IN CACHE: before: $BEFORE, after: $AFTER"
13023         else
13024                 log "cache hits:: before: $BEFORE, after: $AFTER"
13025         fi
13026
13027         log "Turn off read and write cache"
13028         set_cache read off
13029         set_cache writethrough off
13030
13031         log "Write data and read it back"
13032         log "It should not be satisfied from the cache."
13033         rm -f $file
13034         dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
13035         cancel_lru_locks osc
13036         BEFORE=$(roc_hit)
13037         cat $file >/dev/null
13038         AFTER=$(roc_hit)
13039         if ! let "AFTER - BEFORE == 0"; then
13040                 error_ignore bz20762 "IN CACHE: before: $BEFORE, after: $AFTER"
13041         else
13042                 log "cache hits:: before: $BEFORE, after: $AFTER"
13043         fi
13044
13045         log "Turn on the read cache and turn off the write cache"
13046         set_cache read on
13047         set_cache writethrough off
13048
13049         log "Write data and read it back"
13050         log "It should not be satisfied from the cache."
13051         rm -f $file
13052         dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
13053         BEFORE=$(roc_hit)
13054         cancel_lru_locks osc
13055         cat $file >/dev/null
13056         AFTER=$(roc_hit)
13057         if ! let "AFTER - BEFORE == 0"; then
13058                 error_ignore bz20762 "IN CACHE: before: $BEFORE, after: $AFTER"
13059         else
13060                 log "cache hits:: before: $BEFORE, after: $AFTER"
13061         fi
13062
13063         log "Read again; it should be satisfied from the cache."
13064         BEFORE=$(roc_hit)
13065         cancel_lru_locks osc
13066         cat $file >/dev/null
13067         AFTER=$(roc_hit)
13068         if ! let "AFTER - BEFORE == CPAGES"; then
13069                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
13070         else
13071                 log "cache hits:: before: $BEFORE, after: $AFTER"
13072         fi
13073
13074         restore_lustre_params < $p
13075         rm -f $p $file
13076 }
13077 run_test 156 "Verification of tunables"
13078
13079 test_160a() {
13080         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13081         remote_mds_nodsh && skip "remote MDS with nodsh"
13082         [ $MDS1_VERSION -ge $(version_code 2.2.0) ] ||
13083                 skip "Need MDS version at least 2.2.0"
13084
13085         changelog_register || error "changelog_register failed"
13086         local cl_user="${CL_USERS[$SINGLEMDS]%% *}"
13087         changelog_users $SINGLEMDS | grep -q $cl_user ||
13088                 error "User $cl_user not found in changelog_users"
13089
13090         # change something
13091         test_mkdir -p $DIR/$tdir/pics/2008/zachy
13092         changelog_clear 0 || error "changelog_clear failed"
13093         touch $DIR/$tdir/pics/2008/zachy/$tfile                 # open 1
13094         cp /etc/hosts $DIR/$tdir/pics/2008/zachy/pic1.jpg       # open 2
13095         mv $DIR/$tdir/pics/2008/zachy $DIR/$tdir/pics/zach
13096         ln $DIR/$tdir/pics/zach/pic1.jpg $DIR/$tdir/pics/2008/portland.jpg
13097         ln -s $DIR/$tdir/pics/2008/portland.jpg $DIR/$tdir/pics/desktop.jpg
13098         rm $DIR/$tdir/pics/desktop.jpg
13099
13100         changelog_dump | tail -10
13101
13102         echo "verifying changelog mask"
13103         changelog_chmask "-MKDIR"
13104         changelog_chmask "-CLOSE"
13105
13106         test_mkdir -p $DIR/$tdir/pics/zach/sofia                # not logged
13107         echo "zzzzzz" > $DIR/$tdir/pics/zach/file               # not logged
13108
13109         changelog_chmask "+MKDIR"
13110         changelog_chmask "+CLOSE"
13111
13112         test_mkdir -p $DIR/$tdir/pics/2008/sofia                # mkdir 1
13113         echo "zzzzzz" > $DIR/$tdir/pics/zach/file               # open 3
13114
13115         changelog_dump | tail -10
13116         MKDIRS=$(changelog_dump | grep -c "MKDIR")
13117         CLOSES=$(changelog_dump | grep -c "CLOSE")
13118         [ $MKDIRS -eq 1 ] || error "MKDIR changelog mask count $MKDIRS != 1"
13119         [ $CLOSES -eq 3 ] || error "CLOSE changelog mask count $CLOSES != 3"
13120
13121         # verify contents
13122         echo "verifying target fid"
13123         local fidc=$(changelog_extract_field "CREAT" "$tfile" "t=")
13124         local fidf=$($LFS path2fid $DIR/$tdir/pics/zach/$tfile)
13125         [ "$fidc" == "$fidf" ] ||
13126                 error "changelog '$tfile' fid $fidc != file fid $fidf"
13127         echo "verifying parent fid"
13128         # The FID returned from the Changelog may be the directory shard on
13129         # a different MDT, and not the FID returned by path2fid on the parent.
13130         # Instead of comparing FIDs, verify that fid2path(fidp) is correct,
13131         # since this is what will matter when recreating this file in the tree.
13132         local fidp=$(changelog_extract_field "CREAT" "$tfile" "p=")
13133         local pathp=$($LFS fid2path $MOUNT "$fidp")
13134         [ "${pathp%/}" == "$DIR/$tdir/pics/zach" ] ||
13135                 error "changelog fid2path($fidc) $pathp != $DIR/$tdir/pics/zach"
13136
13137         echo "getting records for $cl_user"
13138         changelog_users $SINGLEMDS
13139         local user_rec1=$(changelog_user_rec $SINGLEMDS $cl_user)
13140         local nclr=3
13141         __changelog_clear $SINGLEMDS $cl_user +$nclr ||
13142                 error "changelog_clear failed"
13143         local user_rec2=$(changelog_user_rec $SINGLEMDS $cl_user)
13144         echo "verifying user clear: $user_rec1 + $nclr == $user_rec2"
13145         [ $user_rec2 == $((user_rec1 + nclr)) ] ||
13146                 error "user index expect $user_rec1 + $nclr != $user_rec2"
13147
13148         local min0_rec=$(changelog_users $SINGLEMDS |
13149                 awk 'min == "" || $2 < min { min = $2 }; END { print min }')
13150         local first_rec=$($LFS changelog $(facet_svc $SINGLEMDS) |
13151                           awk '{ print $1; exit; }')
13152
13153         changelog_dump | tail -n 5
13154         echo "verifying user min purge: $min0_rec + 1 == $first_rec"
13155         [ $first_rec == $((min0_rec + 1)) ] ||
13156                 error "first index should be $min0_rec + 1 not $first_rec"
13157
13158         # LU-3446 changelog index reset on MDT restart
13159         local cur_rec1=$(changelog_users $SINGLEMDS |
13160                          awk '/^current.index:/ { print $NF }')
13161         changelog_clear 0 ||
13162                 error "clear all changelog records for $cl_user failed"
13163         stop $SINGLEMDS || error "Fail to stop $SINGLEMDS"
13164         start $SINGLEMDS $(mdsdevname ${SINGLEMDS//mds/}) $MDS_MOUNT_OPTS ||
13165                 error "Fail to start $SINGLEMDS"
13166         local cur_rec2=$(changelog_users $SINGLEMDS |
13167                          awk '/^current.index:/ { print $NF }')
13168         echo "verifying index survives MDT restart: $cur_rec1 == $cur_rec2"
13169         [ $cur_rec1 == $cur_rec2 ] ||
13170                 error "current index should be $cur_rec1 not $cur_rec2"
13171
13172         echo "verifying users from this test are deregistered"
13173         changelog_deregister || error "changelog_deregister failed"
13174         changelog_users $SINGLEMDS | grep -q $cl_user &&
13175                 error "User '$cl_user' still in changelog_users"
13176
13177         # lctl get_param -n mdd.*.changelog_users
13178         # current index: 144
13179         # ID    index (idle seconds)
13180         # cl3   144 (2)
13181         if ! changelog_users $SINGLEMDS | grep "^cl"; then
13182                 # this is the normal case where all users were deregistered
13183                 # make sure no new records are added when no users are present
13184                 local last_rec1=$(changelog_users $SINGLEMDS |
13185                                   awk '/^current.index:/ { print $NF }')
13186                 touch $DIR/$tdir/chloe
13187                 local last_rec2=$(changelog_users $SINGLEMDS |
13188                                   awk '/^current.index:/ { print $NF }')
13189                 echo "verify changelogs are off: $last_rec1 == $last_rec2"
13190                 [ $last_rec1 == $last_rec2 ] || error "changelogs not off"
13191         else
13192                 # any changelog users must be leftovers from a previous test
13193                 changelog_users $SINGLEMDS
13194                 echo "other changelog users; can't verify off"
13195         fi
13196 }
13197 run_test 160a "changelog sanity"
13198
13199 test_160b() { # LU-3587
13200         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13201         remote_mds_nodsh && skip "remote MDS with nodsh"
13202         [ $MDS1_VERSION -ge $(version_code 2.2.0) ] ||
13203                 skip "Need MDS version at least 2.2.0"
13204
13205         changelog_register || error "changelog_register failed"
13206         local cl_user="${CL_USERS[$SINGLEMDS]%% *}"
13207         changelog_users $SINGLEMDS | grep -q $cl_user ||
13208                 error "User '$cl_user' not found in changelog_users"
13209
13210         local longname1=$(str_repeat a 255)
13211         local longname2=$(str_repeat b 255)
13212
13213         cd $DIR
13214         echo "creating very long named file"
13215         touch $longname1 || error "create of '$longname1' failed"
13216         echo "renaming very long named file"
13217         mv $longname1 $longname2
13218
13219         changelog_dump | grep RENME | tail -n 5
13220         rm -f $longname2
13221 }
13222 run_test 160b "Verify that very long rename doesn't crash in changelog"
13223
13224 test_160c() {
13225         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13226         remote_mds_nodsh && skip "remote MDS with nodsh"
13227
13228         [[ $MDS1_VERSION -gt $(version_code 2.5.57) ]] ||
13229                 [[ $MDS1_VERSION -gt $(version_code 2.5.1) &&
13230                    $MDS1_VERSION -lt $(version_code 2.5.50) ]] ||
13231                 skip "Need MDS version at least 2.5.58 or 2.5.2+"
13232
13233         local rc=0
13234
13235         # Registration step
13236         changelog_register || error "changelog_register failed"
13237
13238         rm -rf $DIR/$tdir
13239         mkdir -p $DIR/$tdir
13240         $MCREATE $DIR/$tdir/foo_160c
13241         changelog_chmask "-TRUNC"
13242         $TRUNCATE $DIR/$tdir/foo_160c 200
13243         changelog_chmask "+TRUNC"
13244         $TRUNCATE $DIR/$tdir/foo_160c 199
13245         changelog_dump | tail -n 5
13246         local truncs=$(changelog_dump | tail -n 5 | grep -c TRUNC)
13247         [ $truncs -eq 1 ] || error "TRUNC changelog mask count $truncs != 1"
13248 }
13249 run_test 160c "verify that changelog log catch the truncate event"
13250
13251 test_160d() {
13252         remote_mds_nodsh && skip "remote MDS with nodsh"
13253         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
13254         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13255         [[ $MDS1_VERSION -ge $(version_code 2.7.60) ]] ||
13256                 skip "Need MDS version at least 2.7.60"
13257
13258         # Registration step
13259         changelog_register || error "changelog_register failed"
13260
13261         mkdir -p $DIR/$tdir/migrate_dir
13262         changelog_clear 0 || error "changelog_clear failed"
13263
13264         $LFS migrate -m 1 $DIR/$tdir/migrate_dir || error "migrate fails"
13265         changelog_dump | tail -n 5
13266         local migrates=$(changelog_dump | grep -c "MIGRT")
13267         [ $migrates -eq 1 ] || error "MIGRATE changelog count $migrates != 1"
13268 }
13269 run_test 160d "verify that changelog log catch the migrate event"
13270
13271 test_160e() {
13272         remote_mds_nodsh && skip "remote MDS with nodsh"
13273
13274         # Create a user
13275         changelog_register || error "changelog_register failed"
13276
13277         # Delete a future user (expect fail)
13278         local MDT0=$(facet_svc $SINGLEMDS)
13279         do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister "cl77"
13280         local rc=$?
13281
13282         if [ $rc -eq 0 ]; then
13283                 error "Deleted non-existant user cl77"
13284         elif [ $rc -ne 2 ]; then
13285                 error "changelog_deregister failed with $rc, expect 2 (ENOENT)"
13286         fi
13287
13288         # Clear to a bad index (1 billion should be safe)
13289         $LFS changelog_clear $MDT0 "${CL_USERS[$SINGLEMDS]%% *}" 1000000000
13290         rc=$?
13291
13292         if [ $rc -eq 0 ]; then
13293                 error "Successfully cleared to invalid CL index"
13294         elif [ $rc -ne 22 ]; then
13295                 error "changelog_clear failed with $rc, expected 22 (EINVAL)"
13296         fi
13297 }
13298 run_test 160e "changelog negative testing (should return errors)"
13299
13300 test_160f() {
13301         remote_mds_nodsh && skip "remote MDS with nodsh" && return
13302         [[ $MDS1_VERSION -ge $(version_code 2.10.56) ]] ||
13303                 skip "Need MDS version at least 2.10.56"
13304
13305         local mdts=$(comma_list $(mdts_nodes))
13306
13307         # Create a user
13308         changelog_register || error "first changelog_register failed"
13309         changelog_register || error "second changelog_register failed"
13310         local cl_users
13311         declare -A cl_user1
13312         declare -A cl_user2
13313         local user_rec1
13314         local user_rec2
13315         local i
13316
13317         # generate some changelog records to accumulate on each MDT
13318         test_mkdir -c $MDSCOUNT $DIR/$tdir || error "test_mkdir $tdir failed"
13319         createmany -m $DIR/$tdir/$tfile $((MDSCOUNT * 2)) ||
13320                 error "create $DIR/$tdir/$tfile failed"
13321
13322         # check changelogs have been generated
13323         local nbcl=$(changelog_dump | wc -l)
13324         [[ $nbcl -eq 0 ]] && error "no changelogs found"
13325
13326         for param in "changelog_max_idle_time=10" \
13327                      "changelog_gc=1" \
13328                      "changelog_min_gc_interval=2" \
13329                      "changelog_min_free_cat_entries=3"; do
13330                 local MDT0=$(facet_svc $SINGLEMDS)
13331                 local var="${param%=*}"
13332                 local old=$(do_facet mds1 "$LCTL get_param -n mdd.$MDT0.$var")
13333
13334                 stack_trap "do_nodes $mdts $LCTL set_param mdd.*.$var=$old" EXIT
13335                 do_nodes $mdts $LCTL set_param mdd.*.$param
13336         done
13337
13338         # force cl_user2 to be idle (1st part)
13339         sleep 9
13340
13341         # simulate changelog catalog almost full
13342         #define OBD_FAIL_CAT_FREE_RECORDS       0x1313
13343         do_nodes $mdts $LCTL set_param fail_loc=0x1313 fail_val=3
13344
13345         for i in $(seq $MDSCOUNT); do
13346                 cl_users=(${CL_USERS[mds$i]})
13347                 cl_user1[mds$i]="${cl_users[0]}"
13348                 cl_user2[mds$i]="${cl_users[1]}"
13349
13350                 [ -n "${cl_user1[mds$i]}" ] ||
13351                         error "mds$i: no user registered"
13352                 [ -n "${cl_user2[mds$i]}" ] ||
13353                         error "mds$i: only ${cl_user2[mds$i]} is registered"
13354
13355                 user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13356                 [ -n "$user_rec1" ] ||
13357                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13358                 __changelog_clear mds$i ${cl_user1[mds$i]} +2
13359                 user_rec2=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13360                 [ -n "$user_rec2" ] ||
13361                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13362                 echo "mds$i: verifying user ${cl_user1[mds$i]} clear: " \
13363                      "$user_rec1 + 2 == $user_rec2"
13364                 [ $((user_rec1 + 2)) == $user_rec2 ] ||
13365                         error "mds$i: user ${cl_user1[mds$i]} index expected " \
13366                               "$user_rec1 + 2, but is $user_rec2"
13367                 user_rec2=$(changelog_user_rec mds$i ${cl_user2[mds$i]})
13368                 [ -n "$user_rec2" ] ||
13369                         error "mds$i: User ${cl_user2[mds$i]} not registered"
13370                 [ $user_rec1 == $user_rec2 ] ||
13371                         error "mds$i: user ${cl_user2[mds$i]} index expected " \
13372                               "$user_rec1, but is $user_rec2"
13373         done
13374
13375         # force cl_user2 to be idle (2nd part) and to reach
13376         # changelog_max_idle_time
13377         sleep 2
13378
13379         # generate one more changelog to trigger fail_loc
13380         createmany -m $DIR/$tdir/${tfile}bis $((MDSCOUNT * 2)) ||
13381                 error "create $DIR/$tdir/${tfile}bis failed"
13382
13383         # ensure gc thread is done
13384         for i in $(mdts_nodes); do
13385                 wait_update $i \
13386                         "ps -e -o comm= | grep chlg_gc_thread" "" 20 ||
13387                         error "$i: GC-thread not done"
13388         done
13389
13390         local first_rec
13391         for i in $(seq $MDSCOUNT); do
13392                 # check cl_user1 still registered
13393                 changelog_users mds$i | grep -q "${cl_user1[mds$i]}" ||
13394                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13395                 # check cl_user2 unregistered
13396                 changelog_users mds$i | grep -q "${cl_user2[mds$i]}" &&
13397                         error "mds$i: User ${cl_user2[mds$i]} still registered"
13398
13399                 # check changelogs are present and starting at $user_rec1 + 1
13400                 user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13401                 [ -n "$user_rec1" ] ||
13402                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13403                 first_rec=$($LFS changelog $(facet_svc mds$i) |
13404                             awk '{ print $1; exit; }')
13405
13406                 echo "mds$i: verifying first index $user_rec1 + 1 == $first_rec"
13407                 [ $((user_rec1 + 1)) == $first_rec ] ||
13408                         error "mds$i: first index should be $user_rec1 + 1, " \
13409                               "but is $first_rec"
13410         done
13411 }
13412 run_test 160f "changelog garbage collect (timestamped users)"
13413
13414 test_160g() {
13415         remote_mds_nodsh && skip "remote MDS with nodsh"
13416         [[ $MDS1_VERSION -ge $(version_code 2.10.56) ]] ||
13417                 skip "Need MDS version at least 2.10.56"
13418
13419         local mdts=$(comma_list $(mdts_nodes))
13420
13421         #define OBD_FAIL_TIME_IN_CHLOG_USER     0x1314
13422         do_nodes $mdts $LCTL set_param fail_loc=0x1314
13423
13424         # Create a user
13425         changelog_register || error "first changelog_register failed"
13426         changelog_register || error "second changelog_register failed"
13427         local cl_users
13428         declare -A cl_user1
13429         declare -A cl_user2
13430         local user_rec1
13431         local user_rec2
13432         local i
13433
13434         # generate some changelog records to accumulate on each MDT
13435         test_mkdir -c $MDSCOUNT $DIR/$tdir || error "mkdir $tdir failed"
13436         createmany -m $DIR/$tdir/$tfile $((MDSCOUNT * 2)) ||
13437                 error "create $DIR/$tdir/$tfile failed"
13438
13439         # check changelogs have been generated
13440         local nbcl=$(changelog_dump | wc -l)
13441         [[ $nbcl -eq 0 ]] && error "no changelogs found"
13442
13443         # reduce the max_idle_indexes value to make sure we exceed it
13444         max_ndx=$((nbcl / 2 - 1))
13445
13446         for param in "changelog_max_idle_indexes=$max_ndx" \
13447                      "changelog_gc=1" \
13448                      "changelog_min_gc_interval=2" \
13449                      "changelog_min_free_cat_entries=3"; do
13450                 local MDT0=$(facet_svc $SINGLEMDS)
13451                 local var="${param%=*}"
13452                 local old=$(do_facet mds1 "$LCTL get_param -n mdd.$MDT0.$var")
13453
13454                 stack_trap "do_nodes $mdts $LCTL set_param mdd.*.$var=$old" EXIT
13455                 do_nodes $mdts $LCTL set_param mdd.*.$param ||
13456                         error "unable to set mdd.*.$param"
13457         done
13458
13459         # simulate changelog catalog almost full
13460         #define OBD_FAIL_CAT_FREE_RECORDS       0x1313
13461         do_nodes $mdts $LCTL set_param fail_loc=0x1313 fail_val=3
13462
13463         for i in $(seq $MDSCOUNT); do
13464                 cl_users=(${CL_USERS[mds$i]})
13465                 cl_user1[mds$i]="${cl_users[0]}"
13466                 cl_user2[mds$i]="${cl_users[1]}"
13467
13468                 [ -n "${cl_user1[mds$i]}" ] ||
13469                         error "mds$i: no user registered"
13470                 [ -n "${cl_user2[mds$i]}" ] ||
13471                         error "mds$i: only ${cl_user1[mds$i]} is registered"
13472
13473                 user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13474                 [ -n "$user_rec1" ] ||
13475                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13476                 __changelog_clear mds$i ${cl_user1[mds$i]} +2
13477                 user_rec2=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13478                 [ -n "$user_rec2" ] ||
13479                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13480                 echo "mds$i: verifying user ${cl_user1[mds$i]} clear: " \
13481                      "$user_rec1 + 2 == $user_rec2"
13482                 [ $((user_rec1 + 2)) == $user_rec2 ] ||
13483                         error "mds$i: user ${cl_user1[mds$i]} index expected " \
13484                               "$user_rec1 + 2, but is $user_rec2"
13485                 user_rec2=$(changelog_user_rec mds$i ${cl_user2[mds$i]})
13486                 [ -n "$user_rec2" ] ||
13487                         error "mds$i: User ${cl_user2[mds$i]} not registered"
13488                 [ $user_rec1 == $user_rec2 ] ||
13489                         error "mds$i: user ${cl_user2[mds$i]} index expected " \
13490                               "$user_rec1, but is $user_rec2"
13491         done
13492
13493         # ensure we are past the previous changelog_min_gc_interval set above
13494         sleep 2
13495
13496         # generate one more changelog to trigger fail_loc
13497         createmany -m $DIR/$tdir/${tfile}bis $((MDSCOUNT * 2)) ||
13498                 error "create $DIR/$tdir/${tfile}bis failed"
13499
13500         # ensure gc thread is done
13501         for i in $(mdts_nodes); do
13502                 wait_update $i \
13503                         "ps -e -o comm= | grep chlg_gc_thread" "" 20 ||
13504                         error "$i: GC-thread not done"
13505         done
13506
13507         local first_rec
13508         for i in $(seq $MDSCOUNT); do
13509                 # check cl_user1 still registered
13510                 changelog_users mds$i | grep -q "${cl_user1[mds$i]}" ||
13511                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13512                 # check cl_user2 unregistered
13513                 changelog_users mds$i | grep -q "${cl_user2[mds$i]}" &&
13514                         error "mds$i: User ${cl_user2[mds$i]} still registered"
13515
13516                 # check changelogs are present and starting at $user_rec1 + 1
13517                 user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13518                 [ -n "$user_rec1" ] ||
13519                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13520                 first_rec=$($LFS changelog $(facet_svc mds$i) |
13521                             awk '{ print $1; exit; }')
13522
13523                 echo "mds$i: verifying first index $user_rec1 + 1 == $first_rec"
13524                 [ $((user_rec1 + 1)) == $first_rec ] ||
13525                         error "mds$i: first index should be $user_rec1 + 1, " \
13526                               "but is $first_rec"
13527         done
13528 }
13529 run_test 160g "changelog garbage collect (old users)"
13530
13531 test_160h() {
13532         remote_mds_nodsh && skip "remote MDS with nodsh" && return
13533         [[ $MDS1_VERSION -ge $(version_code 2.10.56) ]] ||
13534                 skip "Need MDS version at least 2.10.56"
13535
13536         local mdts=$(comma_list $(mdts_nodes))
13537
13538         # Create a user
13539         changelog_register || error "first changelog_register failed"
13540         changelog_register || error "second changelog_register failed"
13541         local cl_users
13542         declare -A cl_user1
13543         declare -A cl_user2
13544         local user_rec1
13545         local user_rec2
13546         local i
13547
13548         # generate some changelog records to accumulate on each MDT
13549         test_mkdir -c $MDSCOUNT $DIR/$tdir || error "test_mkdir $tdir failed"
13550         createmany -m $DIR/$tdir/$tfile $((MDSCOUNT * 2)) ||
13551                 error "create $DIR/$tdir/$tfile failed"
13552
13553         # check changelogs have been generated
13554         local nbcl=$(changelog_dump | wc -l)
13555         [[ $nbcl -eq 0 ]] && error "no changelogs found"
13556
13557         for param in "changelog_max_idle_time=10" \
13558                      "changelog_gc=1" \
13559                      "changelog_min_gc_interval=2"; do
13560                 local MDT0=$(facet_svc $SINGLEMDS)
13561                 local var="${param%=*}"
13562                 local old=$(do_facet mds1 "$LCTL get_param -n mdd.$MDT0.$var")
13563
13564                 stack_trap "do_nodes $mdts $LCTL set_param mdd.*.$var=$old" EXIT
13565                 do_nodes $mdts $LCTL set_param mdd.*.$param
13566         done
13567
13568         # force cl_user2 to be idle (1st part)
13569         sleep 9
13570
13571         for i in $(seq $MDSCOUNT); do
13572                 cl_users=(${CL_USERS[mds$i]})
13573                 cl_user1[mds$i]="${cl_users[0]}"
13574                 cl_user2[mds$i]="${cl_users[1]}"
13575
13576                 [ -n "${cl_user1[mds$i]}" ] ||
13577                         error "mds$i: no user registered"
13578                 [ -n "${cl_user2[mds$i]}" ] ||
13579                         error "mds$i: only ${cl_user2[mds$i]} is registered"
13580
13581                 user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13582                 [ -n "$user_rec1" ] ||
13583                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13584                 __changelog_clear mds$i ${cl_user1[mds$i]} +2
13585                 user_rec2=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13586                 [ -n "$user_rec2" ] ||
13587                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13588                 echo "mds$i: verifying user ${cl_user1[mds$i]} clear: " \
13589                      "$user_rec1 + 2 == $user_rec2"
13590                 [ $((user_rec1 + 2)) == $user_rec2 ] ||
13591                         error "mds$i: user ${cl_user1[mds$i]} index expected " \
13592                               "$user_rec1 + 2, but is $user_rec2"
13593                 user_rec2=$(changelog_user_rec mds$i ${cl_user2[mds$i]})
13594                 [ -n "$user_rec2" ] ||
13595                         error "mds$i: User ${cl_user2[mds$i]} not registered"
13596                 [ $user_rec1 == $user_rec2 ] ||
13597                         error "mds$i: user ${cl_user2[mds$i]} index expected " \
13598                               "$user_rec1, but is $user_rec2"
13599         done
13600
13601         # force cl_user2 to be idle (2nd part) and to reach
13602         # changelog_max_idle_time
13603         sleep 2
13604
13605         # force each GC-thread start and block then
13606         # one per MDT/MDD, set fail_val accordingly
13607         #define OBD_FAIL_FORCE_GC_THREAD 0x1316
13608         do_nodes $mdts $LCTL set_param fail_loc=0x1316
13609
13610         # generate more changelogs to trigger fail_loc
13611         createmany -m $DIR/$tdir/${tfile}bis $((MDSCOUNT * 2)) ||
13612                 error "create $DIR/$tdir/${tfile}bis failed"
13613
13614         # stop MDT to stop GC-thread, should be done in back-ground as it will
13615         # block waiting for the thread to be released and exit
13616         declare -A stop_pids
13617         for i in $(seq $MDSCOUNT); do
13618                 stop mds$i &
13619                 stop_pids[mds$i]=$!
13620         done
13621
13622         for i in $(mdts_nodes); do
13623                 local facet
13624                 local nb=0
13625                 local facets=$(facets_up_on_host $i)
13626
13627                 for facet in ${facets//,/ }; do
13628                         if [[ $facet == mds* ]]; then
13629                                 nb=$((nb + 1))
13630                         fi
13631                 done
13632                 # ensure each MDS's gc threads are still present and all in "R"
13633                 # state (OBD_FAIL_FORCE_GC_THREAD effect!)
13634                 [[ $(do_node $i pgrep chlg_gc_thread | wc -l) -eq $nb ]] ||
13635                         error "$i: expected $nb GC-thread"
13636                 wait_update $i \
13637                         "ps -C chlg_gc_thread -o state --no-headers | uniq" \
13638                         "R" 20 ||
13639                         error "$i: GC-thread not found in R-state"
13640                 # check umounts of each MDT on MDS have reached kthread_stop()
13641                 [[ $(do_node $i pgrep umount | wc -l) -eq $nb ]] ||
13642                         error "$i: expected $nb umount"
13643                 wait_update $i \
13644                         "ps -C umount -o state --no-headers | uniq" "D" 20 ||
13645                         error "$i: umount not found in D-state"
13646         done
13647
13648         # release all GC-threads
13649         do_nodes $mdts $LCTL set_param fail_loc=0
13650
13651         # wait for MDT stop to complete
13652         for i in $(seq $MDSCOUNT); do
13653                 wait ${stop_pids[mds$i]} || error "mds$i: stop failed"
13654         done
13655
13656         # XXX
13657         # may try to check if any orphan changelog records are present
13658         # via ldiskfs/zfs and llog_reader...
13659
13660         # re-start/mount MDTs
13661         for i in $(seq $MDSCOUNT); do
13662                 start mds$i $(mdsdevname $i) $MDS_MOUNT_OPTS ||
13663                         error "Fail to start mds$i"
13664         done
13665
13666         local first_rec
13667         for i in $(seq $MDSCOUNT); do
13668                 # check cl_user1 still registered
13669                 changelog_users mds$i | grep -q "${cl_user1[mds$i]}" ||
13670                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13671                 # check cl_user2 unregistered
13672                 changelog_users mds$i | grep -q "${cl_user2[mds$i]}" &&
13673                         error "mds$i: User ${cl_user2[mds$i]} still registered"
13674
13675                 # check changelogs are present and starting at $user_rec1 + 1
13676                 user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13677                 [ -n "$user_rec1" ] ||
13678                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13679                 first_rec=$($LFS changelog $(facet_svc mds$i) |
13680                             awk '{ print $1; exit; }')
13681
13682                 echo "mds$i: verifying first index $user_rec1 + 1 == $first_rec"
13683                 [ $((user_rec1 + 1)) == $first_rec ] ||
13684                         error "mds$i: first index should be $user_rec1 + 1, " \
13685                               "but is $first_rec"
13686         done
13687 }
13688 run_test 160h "changelog gc thread stop upon umount, orphan records delete " \
13689               "during mount"
13690
13691 test_160i() {
13692
13693         local mdts=$(comma_list $(mdts_nodes))
13694
13695         changelog_register || error "first changelog_register failed"
13696
13697         # generate some changelog records to accumulate on each MDT
13698         test_mkdir -c $MDSCOUNT $DIR/$tdir || error "mkdir $tdir failed"
13699         createmany -m $DIR/$tdir/$tfile $((MDSCOUNT * 2)) ||
13700                 error "create $DIR/$tdir/$tfile failed"
13701
13702         # check changelogs have been generated
13703         local nbcl=$(changelog_dump | wc -l)
13704         [[ $nbcl -eq 0 ]] && error "no changelogs found"
13705
13706         # simulate race between register and unregister
13707         # XXX as fail_loc is set per-MDS, with DNE configs the race
13708         # simulation will only occur for one MDT per MDS and for the
13709         # others the normal race scenario will take place
13710         #define CFS_FAIL_CHLOG_USER_REG_UNREG_RACE          0x1315
13711         do_nodes $mdts $LCTL set_param fail_loc=0x10001315
13712         do_nodes $mdts $LCTL set_param fail_val=1
13713
13714         # unregister 1st user
13715         changelog_deregister &
13716         local pid1=$!
13717         # wait some time for deregister work to reach race rdv
13718         sleep 2
13719         # register 2nd user
13720         changelog_register || error "2nd user register failed"
13721
13722         wait $pid1 || error "1st user deregister failed"
13723
13724         local i
13725         local last_rec
13726         declare -A LAST_REC
13727         for i in $(seq $MDSCOUNT); do
13728                 if changelog_users mds$i | grep "^cl"; then
13729                         # make sure new records are added with one user present
13730                         LAST_REC[mds$i]=$(changelog_users $SINGLEMDS |
13731                                           awk '/^current.index:/ { print $NF }')
13732                 else
13733                         error "mds$i has no user registered"
13734                 fi
13735         done
13736
13737         # generate more changelog records to accumulate on each MDT
13738         createmany -m $DIR/$tdir/${tfile}bis $((MDSCOUNT * 2)) ||
13739                 error "create $DIR/$tdir/${tfile}bis failed"
13740
13741         for i in $(seq $MDSCOUNT); do
13742                 last_rec=$(changelog_users $SINGLEMDS |
13743                            awk '/^current.index:/ { print $NF }')
13744                 echo "verify changelogs are on: $last_rec != ${LAST_REC[mds$i]}"
13745                 [ $last_rec != ${LAST_REC[mds$i]} ] ||
13746                         error "changelogs are off on mds$i"
13747         done
13748 }
13749 run_test 160i "changelog user register/unregister race"
13750
13751 test_161a() {
13752         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13753
13754         test_mkdir -c1 $DIR/$tdir
13755         cp /etc/hosts $DIR/$tdir/$tfile
13756         test_mkdir -c1 $DIR/$tdir/foo1
13757         test_mkdir -c1 $DIR/$tdir/foo2
13758         ln $DIR/$tdir/$tfile $DIR/$tdir/foo1/sofia
13759         ln $DIR/$tdir/$tfile $DIR/$tdir/foo2/zachary
13760         ln $DIR/$tdir/$tfile $DIR/$tdir/foo1/luna
13761         ln $DIR/$tdir/$tfile $DIR/$tdir/foo2/thor
13762         local FID=$($LFS path2fid $DIR/$tdir/$tfile | tr -d '[]')
13763         if [ "$($LFS fid2path $DIR $FID | wc -l)" != "5" ]; then
13764                 $LFS fid2path $DIR $FID
13765                 error "bad link ea"
13766         fi
13767         # middle
13768         rm $DIR/$tdir/foo2/zachary
13769         # last
13770         rm $DIR/$tdir/foo2/thor
13771         # first
13772         rm $DIR/$tdir/$tfile
13773         # rename
13774         mv $DIR/$tdir/foo1/sofia $DIR/$tdir/foo2/maggie
13775         [ "$($LFS fid2path $FSNAME --link 1 $FID)" != "$tdir/foo2/maggie" ] &&
13776                 { $LFS fid2path $DIR $FID; error "bad link rename"; }
13777         rm $DIR/$tdir/foo2/maggie
13778
13779         # overflow the EA
13780         local longname=$tfile.avg_len_is_thirty_two_
13781         stack_trap "unlinkmany $DIR/$tdir/foo2/$longname 1000 || \
13782                 error_noexit 'failed to unlink many hardlinks'" EXIT
13783         createmany -l$DIR/$tdir/foo1/luna $DIR/$tdir/foo2/$longname 1000 ||
13784                 error "failed to hardlink many files"
13785         links=$($LFS fid2path $DIR $FID | wc -l)
13786         echo -n "${links}/1000 links in link EA"
13787         [[ $links -gt 60 ]] || error "expected at least 60 links in link EA"
13788 }
13789 run_test 161a "link ea sanity"
13790
13791 test_161b() {
13792         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13793         [ $MDSCOUNT -lt 2 ] && skip_env "skipping remote directory test"
13794
13795         local MDTIDX=1
13796         local remote_dir=$DIR/$tdir/remote_dir
13797
13798         mkdir -p $DIR/$tdir
13799         $LFS mkdir -i $MDTIDX $remote_dir ||
13800                 error "create remote directory failed"
13801
13802         cp /etc/hosts $remote_dir/$tfile
13803         mkdir -p $remote_dir/foo1
13804         mkdir -p $remote_dir/foo2
13805         ln $remote_dir/$tfile $remote_dir/foo1/sofia
13806         ln $remote_dir/$tfile $remote_dir/foo2/zachary
13807         ln $remote_dir/$tfile $remote_dir/foo1/luna
13808         ln $remote_dir/$tfile $remote_dir/foo2/thor
13809
13810         local FID=$($LFS path2fid $remote_dir/$tfile | tr -d '[' |
13811                      tr -d ']')
13812         if [ "$($LFS fid2path $DIR $FID | wc -l)" != "5" ]; then
13813                 $LFS fid2path $DIR $FID
13814                 error "bad link ea"
13815         fi
13816         # middle
13817         rm $remote_dir/foo2/zachary
13818         # last
13819         rm $remote_dir/foo2/thor
13820         # first
13821         rm $remote_dir/$tfile
13822         # rename
13823         mv $remote_dir/foo1/sofia $remote_dir/foo2/maggie
13824         local link_path=$($LFS fid2path $FSNAME --link 1 $FID)
13825         if [ "$DIR/$link_path" != "$remote_dir/foo2/maggie" ]; then
13826                 $LFS fid2path $DIR $FID
13827                 error "bad link rename"
13828         fi
13829         rm $remote_dir/foo2/maggie
13830
13831         # overflow the EA
13832         local longname=filename_avg_len_is_thirty_two_
13833         createmany -l$remote_dir/foo1/luna $remote_dir/foo2/$longname 1000 ||
13834                 error "failed to hardlink many files"
13835         links=$($LFS fid2path $DIR $FID | wc -l)
13836         echo -n "${links}/1000 links in link EA"
13837         [[ ${links} -gt 60 ]] ||
13838                 error "expected at least 60 links in link EA"
13839         unlinkmany $remote_dir/foo2/$longname 1000 ||
13840         error "failed to unlink many hardlinks"
13841 }
13842 run_test 161b "link ea sanity under remote directory"
13843
13844 test_161c() {
13845         remote_mds_nodsh && skip "remote MDS with nodsh"
13846         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13847         [[ $MDS1_VERSION -lt $(version_code 2.1.5) ]] &&
13848                 skip "Need MDS version at least 2.1.5"
13849
13850         # define CLF_RENAME_LAST 0x0001
13851         # rename overwrite a target having nlink = 1 (changelog flag 0x1)
13852         changelog_register || error "changelog_register failed"
13853
13854         rm -rf $DIR/$tdir
13855         test_mkdir -i $((MDSCOUNT - 1)) $DIR/$tdir
13856         touch $DIR/$tdir/foo_161c
13857         touch $DIR/$tdir/bar_161c
13858         mv -f $DIR/$tdir/foo_161c $DIR/$tdir/bar_161c
13859         changelog_dump | grep RENME | tail -n 5
13860         local flags=$(changelog_dump | grep "RENME.*bar_161c" | cut -f5 -d' ')
13861         changelog_clear 0 || error "changelog_clear failed"
13862         if [ x$flags != "x0x1" ]; then
13863                 error "flag $flags is not 0x1"
13864         fi
13865
13866         echo "rename overwrite target with nlink = 1, changelog flags=$flags"
13867         # rename overwrite a target having nlink > 1 (changelog flag 0x0)
13868         touch $DIR/$tdir/foo_161c
13869         touch $DIR/$tdir/bar_161c
13870         ln $DIR/$tdir/bar_161c $DIR/$tdir/foobar_161c
13871         mv -f $DIR/$tdir/foo_161c $DIR/$tdir/bar_161c
13872         changelog_dump | grep RENME | tail -n 5
13873         flags=$(changelog_dump | grep "RENME.*bar_161c" | cut -f5 -d' ')
13874         changelog_clear 0 || error "changelog_clear failed"
13875         if [ x$flags != "x0x0" ]; then
13876                 error "flag $flags is not 0x0"
13877         fi
13878         echo "rename overwrite a target having nlink > 1," \
13879                 "changelog record has flags of $flags"
13880
13881         # rename doesn't overwrite a target (changelog flag 0x0)
13882         touch $DIR/$tdir/foo_161c
13883         mv -f $DIR/$tdir/foo_161c $DIR/$tdir/foo2_161c
13884         changelog_dump | grep RENME | tail -n 5
13885         flags=$(changelog_dump | grep RENME | tail -1 | cut -f5 -d' ')
13886         changelog_clear 0 || error "changelog_clear failed"
13887         if [ x$flags != "x0x0" ]; then
13888                 error "flag $flags is not 0x0"
13889         fi
13890         echo "rename doesn't overwrite a target," \
13891                 "changelog record has flags of $flags"
13892
13893         # define CLF_UNLINK_LAST 0x0001
13894         # unlink a file having nlink = 1 (changelog flag 0x1)
13895         rm -f $DIR/$tdir/foo2_161c
13896         changelog_dump | grep UNLNK | tail -n 5
13897         flags=$(changelog_dump | grep UNLNK | tail -1 | cut -f5 -d' ')
13898         changelog_clear 0 || error "changelog_clear failed"
13899         if [ x$flags != "x0x1" ]; then
13900                 error "flag $flags is not 0x1"
13901         fi
13902         echo "unlink a file having nlink = 1," \
13903                 "changelog record has flags of $flags"
13904
13905         # unlink a file having nlink > 1 (changelog flag 0x0)
13906         ln -f $DIR/$tdir/bar_161c $DIR/$tdir/foobar_161c
13907         rm -f $DIR/$tdir/foobar_161c
13908         changelog_dump | grep UNLNK | tail -n 5
13909         flags=$(changelog_dump | grep UNLNK | tail -1 | cut -f5 -d' ')
13910         changelog_clear 0 || error "changelog_clear failed"
13911         if [ x$flags != "x0x0" ]; then
13912                 error "flag $flags is not 0x0"
13913         fi
13914         echo "unlink a file having nlink > 1, changelog record flags '$flags'"
13915 }
13916 run_test 161c "check CL_RENME[UNLINK] changelog record flags"
13917
13918 test_161d() {
13919         remote_mds_nodsh && skip "remote MDS with nodsh"
13920         [ -n "$FILESET" ] && skip "Not functional for FILESET set"
13921
13922         local pid
13923         local fid
13924
13925         changelog_register || error "changelog_register failed"
13926
13927         # work in a standalone dir to avoid locking on $DIR/$MOUNT to
13928         # interfer with $MOUNT/.lustre/fid/ access
13929         mkdir $DIR/$tdir
13930         [[ $? -eq 0 ]] || error "mkdir failed"
13931
13932         #define OBD_FAIL_LLITE_CREATE_NODE_PAUSE 0x140c | OBD_FAIL_ONCE
13933         $LCTL set_param fail_loc=0x8000140c
13934         # 5s pause
13935         $LCTL set_param fail_val=5
13936
13937         # create file
13938         echo foofoo > $DIR/$tdir/$tfile &
13939         pid=$!
13940
13941         # wait for create to be delayed
13942         sleep 2
13943
13944         ps -p $pid
13945         [[ $? -eq 0 ]] || error "create should be blocked"
13946
13947         local tempfile="$(mktemp --tmpdir $tfile.XXXXXX)"
13948         stack_trap "rm -f $tempfile"
13949         fid=$(changelog_extract_field "CREAT" "$tfile" "t=")
13950         cat $MOUNT/.lustre/fid/$fid 2>/dev/null >$tempfile || error "cat failed"
13951         # some delay may occur during ChangeLog publishing and file read just
13952         # above, that could allow file write to happen finally
13953         [[ -s $tempfile ]] && echo "file should be empty"
13954
13955         $LCTL set_param fail_loc=0
13956
13957         wait $pid
13958         [[ $? -eq 0 ]] || error "create failed"
13959 }
13960 run_test 161d "create with concurrent .lustre/fid access"
13961
13962 check_path() {
13963         local expected="$1"
13964         shift
13965         local fid="$2"
13966
13967         local path
13968         path=$($LFS fid2path "$@")
13969         local rc=$?
13970
13971         if [ $rc -ne 0 ]; then
13972                 error "path looked up of '$expected' failed: rc=$rc"
13973         elif [ "$path" != "$expected" ]; then
13974                 error "path looked up '$path' instead of '$expected'"
13975         else
13976                 echo "FID '$fid' resolves to path '$path' as expected"
13977         fi
13978 }
13979
13980 test_162a() { # was test_162
13981         test_mkdir -p -c1 $DIR/$tdir/d2
13982         touch $DIR/$tdir/d2/$tfile
13983         touch $DIR/$tdir/d2/x1
13984         touch $DIR/$tdir/d2/x2
13985         test_mkdir -p -c1 $DIR/$tdir/d2/a/b/c
13986         test_mkdir -p -c1 $DIR/$tdir/d2/p/q/r
13987         # regular file
13988         local fid=$($LFS path2fid $DIR/$tdir/d2/$tfile | tr -d '[]')
13989         check_path "$tdir/d2/$tfile" $FSNAME "$fid" --link 0
13990
13991         # softlink
13992         ln -s $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/p/q/r/slink
13993         fid=$($LFS path2fid $DIR/$tdir/d2/p/q/r/slink | tr -d '[]')
13994         check_path "$tdir/d2/p/q/r/slink" $FSNAME "$fid" --link 0
13995
13996         # softlink to wrong file
13997         ln -s /this/is/garbage $DIR/$tdir/d2/p/q/r/slink.wrong
13998         fid=$($LFS path2fid $DIR/$tdir/d2/p/q/r/slink.wrong | tr -d '[]')
13999         check_path "$tdir/d2/p/q/r/slink.wrong" $FSNAME "$fid" --link 0
14000
14001         # hardlink
14002         ln $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/p/q/r/hlink
14003         mv $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/a/b/c/new_file
14004         fid=$($LFS path2fid $DIR/$tdir/d2/a/b/c/new_file | tr -d '[]')
14005         # fid2path dir/fsname should both work
14006         check_path "$tdir/d2/a/b/c/new_file" $FSNAME "$fid" --link 1
14007         check_path "$DIR/$tdir/d2/p/q/r/hlink" $DIR "$fid" --link 0
14008
14009         # hardlink count: check that there are 2 links
14010         local nlinks=$($LFS fid2path $DIR "$fid" | wc -l)
14011         [ $nlinks -eq 2 ] || error "expect 2 links, found $nlinks"
14012
14013         # hardlink indexing: remove the first link
14014         rm $DIR/$tdir/d2/p/q/r/hlink
14015         check_path "$tdir/d2/a/b/c/new_file" $FSNAME $fid --link 0
14016 }
14017 run_test 162a "path lookup sanity"
14018
14019 test_162b() {
14020         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14021         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
14022
14023         mkdir $DIR/$tdir
14024         $LFS setdirstripe -i0 -c$MDSCOUNT -H all_char $DIR/$tdir/striped_dir ||
14025                                 error "create striped dir failed"
14026
14027         local FID=$($LFS getdirstripe $DIR/$tdir/striped_dir |
14028                                         tail -n 1 | awk '{print $2}')
14029         stat $MOUNT/.lustre/fid/$FID && error "sub_stripe can be accessed"
14030
14031         touch $DIR/$tdir/striped_dir/f{0..4} || error "touch f0..4 failed"
14032         mkdir $DIR/$tdir/striped_dir/d{0..4} || error "mkdir d0..4 failed"
14033
14034         # regular file
14035         for ((i=0;i<5;i++)); do
14036                 FID=$($LFS path2fid $DIR/$tdir/striped_dir/f$i | tr -d '[]') ||
14037                         error "get fid for f$i failed"
14038                 check_path "$tdir/striped_dir/f$i" $FSNAME $FID --link 0
14039
14040                 FID=$($LFS path2fid $DIR/$tdir/striped_dir/d$i | tr -d '[]') ||
14041                         error "get fid for d$i failed"
14042                 check_path "$tdir/striped_dir/d$i" $FSNAME $FID --link 0
14043         done
14044
14045         return 0
14046 }
14047 run_test 162b "striped directory path lookup sanity"
14048
14049 # LU-4239: Verify fid2path works with paths 100 or more directories deep
14050 test_162c() {
14051         [[ $MDS1_VERSION -lt $(version_code 2.7.51) ]] &&
14052                 skip "Need MDS version at least 2.7.51"
14053
14054         local lpath=$tdir.local
14055         local rpath=$tdir.remote
14056
14057         test_mkdir $DIR/$lpath
14058         test_mkdir $DIR/$rpath
14059
14060         for ((i = 0; i <= 101; i++)); do
14061                 lpath="$lpath/$i"
14062                 mkdir $DIR/$lpath
14063                 FID=$($LFS path2fid $DIR/$lpath | tr -d '[]') ||
14064                         error "get fid for local directory $DIR/$lpath failed"
14065                 check_path "$DIR/$lpath" $MOUNT $FID --link 0
14066
14067                 rpath="$rpath/$i"
14068                 test_mkdir $DIR/$rpath
14069                 FID=$($LFS path2fid $DIR/$rpath | tr -d '[]') ||
14070                         error "get fid for remote directory $DIR/$rpath failed"
14071                 check_path "$DIR/$rpath" $MOUNT $FID --link 0
14072         done
14073
14074         return 0
14075 }
14076 run_test 162c "fid2path works with paths 100 or more directories deep"
14077
14078 test_169() {
14079         # do directio so as not to populate the page cache
14080         log "creating a 10 Mb file"
14081         $MULTIOP $DIR/$tfile oO_CREAT:O_DIRECT:O_RDWR:w$((10*1048576))c || error "multiop failed while creating a file"
14082         log "starting reads"
14083         dd if=$DIR/$tfile of=/dev/null bs=4096 &
14084         log "truncating the file"
14085         $MULTIOP $DIR/$tfile oO_TRUNC:c || error "multiop failed while truncating the file"
14086         log "killing dd"
14087         kill %+ || true # reads might have finished
14088         echo "wait until dd is finished"
14089         wait
14090         log "removing the temporary file"
14091         rm -rf $DIR/$tfile || error "tmp file removal failed"
14092 }
14093 run_test 169 "parallel read and truncate should not deadlock"
14094
14095 test_170() {
14096         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14097
14098         $LCTL clear     # bug 18514
14099         $LCTL debug_daemon start $TMP/${tfile}_log_good
14100         touch $DIR/$tfile
14101         $LCTL debug_daemon stop
14102         sed -e "s/^...../a/g" $TMP/${tfile}_log_good > $TMP/${tfile}_log_bad ||
14103                 error "sed failed to read log_good"
14104
14105         $LCTL debug_daemon start $TMP/${tfile}_log_good
14106         rm -rf $DIR/$tfile
14107         $LCTL debug_daemon stop
14108
14109         $LCTL df $TMP/${tfile}_log_bad > $TMP/${tfile}_log_bad.out 2>&1 ||
14110                error "lctl df log_bad failed"
14111
14112         local bad_line=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $9}')
14113         local good_line1=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $5}')
14114
14115         $LCTL df $TMP/${tfile}_log_good > $TMP/${tfile}_log_good.out 2>&1
14116         local good_line2=$(tail -n 1 $TMP/${tfile}_log_good.out | awk '{print $5}')
14117
14118         [ "$bad_line" ] && [ "$good_line1" ] && [ "$good_line2" ] ||
14119                 error "bad_line good_line1 good_line2 are empty"
14120
14121         cat $TMP/${tfile}_log_good >> $TMP/${tfile}_logs_corrupt
14122         cat $TMP/${tfile}_log_bad >> $TMP/${tfile}_logs_corrupt
14123         cat $TMP/${tfile}_log_good >> $TMP/${tfile}_logs_corrupt
14124
14125         $LCTL df $TMP/${tfile}_logs_corrupt > $TMP/${tfile}_log_bad.out 2>&1
14126         local bad_line_new=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $9}')
14127         local good_line_new=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $5}')
14128
14129         [ "$bad_line_new" ] && [ "$good_line_new" ] ||
14130                 error "bad_line_new good_line_new are empty"
14131
14132         local expected_good=$((good_line1 + good_line2*2))
14133
14134         rm -f $TMP/${tfile}*
14135         # LU-231, short malformed line may not be counted into bad lines
14136         if [ $bad_line -ne $bad_line_new ] &&
14137                    [ $bad_line -ne $((bad_line_new - 1)) ]; then
14138                 error "expected $bad_line bad lines, but got $bad_line_new"
14139                 return 1
14140         fi
14141
14142         if [ $expected_good -ne $good_line_new ]; then
14143                 error "expected $expected_good good lines, but got $good_line_new"
14144                 return 2
14145         fi
14146         true
14147 }
14148 run_test 170 "test lctl df to handle corrupted log ====================="
14149
14150 test_171() { # bug20592
14151         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14152
14153         #define OBD_FAIL_PTLRPC_DUMP_LOG         0x50e
14154         $LCTL set_param fail_loc=0x50e
14155         $LCTL set_param fail_val=3000
14156         multiop_bg_pause $DIR/$tfile O_s || true
14157         local MULTIPID=$!
14158         kill -USR1 $MULTIPID
14159         # cause log dump
14160         sleep 3
14161         wait $MULTIPID
14162         if dmesg | grep "recursive fault"; then
14163                 error "caught a recursive fault"
14164         fi
14165         $LCTL set_param fail_loc=0
14166         true
14167 }
14168 run_test 171 "test libcfs_debug_dumplog_thread stuck in do_exit() ======"
14169
14170 # it would be good to share it with obdfilter-survey/iokit-libecho code
14171 setup_obdecho_osc () {
14172         local rc=0
14173         local ost_nid=$1
14174         local obdfilter_name=$2
14175         echo "Creating new osc for $obdfilter_name on $ost_nid"
14176         # make sure we can find loopback nid
14177         $LCTL add_uuid $ost_nid $ost_nid >/dev/null 2>&1
14178
14179         [ $rc -eq 0 ] && { $LCTL attach osc ${obdfilter_name}_osc     \
14180                            ${obdfilter_name}_osc_UUID || rc=2; }
14181         [ $rc -eq 0 ] && { $LCTL --device ${obdfilter_name}_osc setup \
14182                            ${obdfilter_name}_UUID  $ost_nid || rc=3; }
14183         return $rc
14184 }
14185
14186 cleanup_obdecho_osc () {
14187         local obdfilter_name=$1
14188         $LCTL --device ${obdfilter_name}_osc cleanup >/dev/null
14189         $LCTL --device ${obdfilter_name}_osc detach  >/dev/null
14190         return 0
14191 }
14192
14193 obdecho_test() {
14194         local OBD=$1
14195         local node=$2
14196         local pages=${3:-64}
14197         local rc=0
14198         local id
14199
14200         local count=10
14201         local obd_size=$(get_obd_size $node $OBD)
14202         local page_size=$(get_page_size $node)
14203         if [[ -n "$obd_size" ]]; then
14204                 local new_count=$((obd_size / (pages * page_size / 1024)))
14205                 [[ $new_count -ge $count ]] || count=$new_count
14206         fi
14207
14208         do_facet $node "$LCTL attach echo_client ec ec_uuid" || rc=1
14209         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec setup $OBD" ||
14210                            rc=2; }
14211         if [ $rc -eq 0 ]; then
14212             id=$(do_facet $node "$LCTL --device ec create 1"  | awk '/object id/ {print $6}')
14213             [ ${PIPESTATUS[0]} -eq 0 -a -n "$id" ] || rc=3
14214         fi
14215         echo "New object id is $id"
14216         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec getattr $id" ||
14217                            rc=4; }
14218         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec "                 \
14219                            "test_brw $count w v $pages $id" || rc=4; }
14220         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec destroy $id 1" ||
14221                            rc=4; }
14222         [ $rc -eq 0 ] || [ $rc -gt 2 ] &&
14223                 { do_facet $node "$LCTL --device ec cleanup" || rc=5; }
14224         [ $rc -eq 0 ] || [ $rc -gt 1 ] &&
14225                 { do_facet $node "$LCTL --device ec detach" || rc=6; }
14226         [ $rc -ne 0 ] && echo "obecho_create_test failed: $rc"
14227         return $rc
14228 }
14229
14230 test_180a() {
14231         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14232
14233         if ! module_loaded obdecho; then
14234                 load_module obdecho/obdecho &&
14235                         stack_trap "rmmod obdecho" EXIT ||
14236                         error "unable to load obdecho on client"
14237         fi
14238
14239         local osc=$($LCTL dl | grep -v mdt | awk '$3 == "osc" {print $4; exit}')
14240         local host=$($LCTL get_param -n osc.$osc.import |
14241                      awk '/current_connection:/ { print $2 }' )
14242         local target=$($LCTL get_param -n osc.$osc.import |
14243                        awk '/target:/ { print $2 }' )
14244         target=${target%_UUID}
14245
14246         if [ -n "$target" ]; then
14247                 setup_obdecho_osc $host $target &&
14248                         stack_trap "cleanup_obdecho_osc $target" EXIT ||
14249                         { error "obdecho setup failed with $?"; return; }
14250
14251                 obdecho_test ${target}_osc client ||
14252                         error "obdecho_test failed on ${target}_osc"
14253         else
14254                 $LCTL get_param osc.$osc.import
14255                 error "there is no osc.$osc.import target"
14256         fi
14257 }
14258 run_test 180a "test obdecho on osc"
14259
14260 test_180b() {
14261         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14262         remote_ost_nodsh && skip "remote OST with nodsh"
14263
14264         do_rpc_nodes $(facet_active_host ost1) load_module obdecho/obdecho &&
14265                 stack_trap "do_facet ost1 rmmod obdecho" EXIT ||
14266                 error "failed to load module obdecho"
14267
14268         local target=$(do_facet ost1 $LCTL dl |
14269                        awk '/obdfilter/ { print $4; exit; }')
14270
14271         if [ -n "$target" ]; then
14272                 obdecho_test $target ost1 || error "obdecho_test failed with $?"
14273         else
14274                 do_facet ost1 $LCTL dl
14275                 error "there is no obdfilter target on ost1"
14276         fi
14277 }
14278 run_test 180b "test obdecho directly on obdfilter"
14279
14280 test_180c() { # LU-2598
14281         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14282         remote_ost_nodsh && skip "remote OST with nodsh"
14283         [[ $MDS1_VERSION -lt $(version_code 2.4.0) ]] &&
14284                 skip "Need MDS version at least 2.4.0"
14285
14286         do_rpc_nodes $(facet_active_host ost1) load_module obdecho/obdecho &&
14287                 stack_trap "do_facet ost1 rmmod obdecho" EXIT ||
14288                 error "failed to load module obdecho"
14289
14290         local target=$(do_facet ost1 $LCTL dl |
14291                        awk '/obdfilter/ { print $4; exit; }')
14292
14293         if [ -n "$target" ]; then
14294                 local pages=16384 # 64MB bulk I/O RPC size
14295
14296                 obdecho_test "$target" ost1 "$pages" ||
14297                         error "obdecho_test with pages=$pages failed with $?"
14298         else
14299                 do_facet ost1 $LCTL dl
14300                 error "there is no obdfilter target on ost1"
14301         fi
14302 }
14303 run_test 180c "test huge bulk I/O size on obdfilter, don't LASSERT"
14304
14305 test_181() { # bug 22177
14306         test_mkdir $DIR/$tdir
14307         # create enough files to index the directory
14308         createmany -o $DIR/$tdir/foobar 4000
14309         # print attributes for debug purpose
14310         lsattr -d .
14311         # open dir
14312         multiop_bg_pause $DIR/$tdir D_Sc || return 1
14313         MULTIPID=$!
14314         # remove the files & current working dir
14315         unlinkmany $DIR/$tdir/foobar 4000
14316         rmdir $DIR/$tdir
14317         kill -USR1 $MULTIPID
14318         wait $MULTIPID
14319         stat $DIR/$tdir && error "open-unlinked dir was not removed!"
14320         return 0
14321 }
14322 run_test 181 "Test open-unlinked dir ========================"
14323
14324 test_182() {
14325         local fcount=1000
14326         local tcount=10
14327
14328         mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
14329
14330         $LCTL set_param mdc.*.rpc_stats=clear
14331
14332         for (( i = 0; i < $tcount; i++ )) ; do
14333                 mkdir $DIR/$tdir/$i
14334         done
14335
14336         for (( i = 0; i < $tcount; i++ )) ; do
14337                 createmany -o $DIR/$tdir/$i/f- $fcount &
14338         done
14339         wait
14340
14341         for (( i = 0; i < $tcount; i++ )) ; do
14342                 unlinkmany $DIR/$tdir/$i/f- $fcount &
14343         done
14344         wait
14345
14346         $LCTL get_param mdc.*.rpc_stats
14347
14348         rm -rf $DIR/$tdir
14349 }
14350 run_test 182 "Test parallel modify metadata operations ================"
14351
14352 test_183() { # LU-2275
14353         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14354         remote_mds_nodsh && skip "remote MDS with nodsh"
14355         [[ $MDS1_VERSION -lt $(version_code 2.3.56) ]] &&
14356                 skip "Need MDS version at least 2.3.56"
14357
14358         mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
14359         echo aaa > $DIR/$tdir/$tfile
14360
14361 #define OBD_FAIL_MDS_NEGATIVE_POSITIVE  0x148
14362         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x148
14363
14364         ls -l $DIR/$tdir && error "ls succeeded, should have failed"
14365         cat $DIR/$tdir/$tfile && error "cat succeeded, should have failed"
14366
14367         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
14368
14369         # Flush negative dentry cache
14370         touch $DIR/$tdir/$tfile
14371
14372         # We are not checking for any leaked references here, they'll
14373         # become evident next time we do cleanup with module unload.
14374         rm -rf $DIR/$tdir
14375 }
14376 run_test 183 "No crash or request leak in case of strange dispositions ========"
14377
14378 # test suite 184 is for LU-2016, LU-2017
14379 test_184a() {
14380         check_swap_layouts_support
14381
14382         dir0=$DIR/$tdir/$testnum
14383         test_mkdir -p -c1 $dir0
14384         ref1=/etc/passwd
14385         ref2=/etc/group
14386         file1=$dir0/f1
14387         file2=$dir0/f2
14388         $LFS setstripe -c1 $file1
14389         cp $ref1 $file1
14390         $LFS setstripe -c2 $file2
14391         cp $ref2 $file2
14392         gen1=$($LFS getstripe -g $file1)
14393         gen2=$($LFS getstripe -g $file2)
14394
14395         $LFS swap_layouts $file1 $file2 || error "swap of file layout failed"
14396         gen=$($LFS getstripe -g $file1)
14397         [[ $gen1 != $gen ]] ||
14398                 "Layout generation on $file1 does not change"
14399         gen=$($LFS getstripe -g $file2)
14400         [[ $gen2 != $gen ]] ||
14401                 "Layout generation on $file2 does not change"
14402
14403         cmp $ref1 $file2 || error "content compare failed ($ref1 != $file2)"
14404         cmp $ref2 $file1 || error "content compare failed ($ref2 != $file1)"
14405
14406         lfsck_verify_pfid $file1 $file2 || error "PFID are not transferred"
14407 }
14408 run_test 184a "Basic layout swap"
14409
14410 test_184b() {
14411         check_swap_layouts_support
14412
14413         dir0=$DIR/$tdir/$testnum
14414         mkdir -p $dir0 || error "creating dir $dir0"
14415         file1=$dir0/f1
14416         file2=$dir0/f2
14417         file3=$dir0/f3
14418         dir1=$dir0/d1
14419         dir2=$dir0/d2
14420         mkdir $dir1 $dir2
14421         $LFS setstripe -c1 $file1
14422         $LFS setstripe -c2 $file2
14423         $LFS setstripe -c1 $file3
14424         chown $RUNAS_ID $file3
14425         gen1=$($LFS getstripe -g $file1)
14426         gen2=$($LFS getstripe -g $file2)
14427
14428         $LFS swap_layouts $dir1 $dir2 &&
14429                 error "swap of directories layouts should fail"
14430         $LFS swap_layouts $dir1 $file1 &&
14431                 error "swap of directory and file layouts should fail"
14432         $RUNAS $LFS swap_layouts $file1 $file2 &&
14433                 error "swap of file we cannot write should fail"
14434         $LFS swap_layouts $file1 $file3 &&
14435                 error "swap of file with different owner should fail"
14436         /bin/true # to clear error code
14437 }
14438 run_test 184b "Forbidden layout swap (will generate errors)"
14439
14440 test_184c() {
14441         local cmpn_arg=$(cmp -n 2>&1 | grep "invalid option")
14442         [ -n "$cmpn_arg" ] && skip_env "cmp does not support -n"
14443         check_swap_layouts_support
14444
14445         local dir0=$DIR/$tdir/$testnum
14446         mkdir -p $dir0 || error "creating dir $dir0"
14447
14448         local ref1=$dir0/ref1
14449         local ref2=$dir0/ref2
14450         local file1=$dir0/file1
14451         local file2=$dir0/file2
14452         # create a file large enough for the concurrent test
14453         dd if=/dev/urandom of=$ref1 bs=1M count=$((RANDOM % 50 + 20))
14454         dd if=/dev/urandom of=$ref2 bs=1M count=$((RANDOM % 50 + 20))
14455         echo "ref file size: ref1($(stat -c %s $ref1))," \
14456              "ref2($(stat -c %s $ref2))"
14457
14458         cp $ref2 $file2
14459         dd if=$ref1 of=$file1 bs=16k &
14460         local DD_PID=$!
14461
14462         # Make sure dd starts to copy file
14463         while [ ! -f $file1 ]; do sleep 0.1; done
14464
14465         $LFS swap_layouts $file1 $file2
14466         local rc=$?
14467         wait $DD_PID
14468         [[ $? == 0 ]] || error "concurrent write on $file1 failed"
14469         [[ $rc == 0 ]] || error "swap of $file1 and $file2 failed"
14470
14471         # how many bytes copied before swapping layout
14472         local copied=$(stat -c %s $file2)
14473         local remaining=$(stat -c %s $ref1)
14474         remaining=$((remaining - copied))
14475         echo "Copied $copied bytes before swapping layout..."
14476
14477         cmp -n $copied $file1 $ref2 | grep differ &&
14478                 error "Content mismatch [0, $copied) of ref2 and file1"
14479         cmp -n $copied $file2 $ref1 ||
14480                 error "Content mismatch [0, $copied) of ref1 and file2"
14481         cmp -i $copied:$copied -n $remaining $file1 $ref1 ||
14482                 error "Content mismatch [$copied, EOF) of ref1 and file1"
14483
14484         # clean up
14485         rm -f $ref1 $ref2 $file1 $file2
14486 }
14487 run_test 184c "Concurrent write and layout swap"
14488
14489 test_184d() {
14490         check_swap_layouts_support
14491         [ -z "$(which getfattr 2>/dev/null)" ] &&
14492                 skip_env "no getfattr command"
14493
14494         local file1=$DIR/$tdir/$tfile-1
14495         local file2=$DIR/$tdir/$tfile-2
14496         local file3=$DIR/$tdir/$tfile-3
14497         local lovea1
14498         local lovea2
14499
14500         mkdir -p $DIR/$tdir
14501         touch $file1 || error "create $file1 failed"
14502         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE $file2 ||
14503                 error "create $file2 failed"
14504         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE $file3 ||
14505                 error "create $file3 failed"
14506         lovea1=$(get_layout_param $file1)
14507
14508         $LFS swap_layouts $file2 $file3 ||
14509                 error "swap $file2 $file3 layouts failed"
14510         $LFS swap_layouts $file1 $file2 ||
14511                 error "swap $file1 $file2 layouts failed"
14512
14513         lovea2=$(get_layout_param $file2)
14514         echo "$lovea1"
14515         echo "$lovea2"
14516         [ "$lovea1" == "$lovea2" ] || error "lovea $lovea1 != $lovea2"
14517
14518         lovea1=$(getfattr -n trusted.lov $file1 | grep ^trusted)
14519         [[ -z "$lovea1" ]] || error "$file1 shouldn't have lovea"
14520 }
14521 run_test 184d "allow stripeless layouts swap"
14522
14523 test_184e() {
14524         [[ $MDS1_VERSION -ge $(version_code 2.6.94) ]] ||
14525                 skip "Need MDS version at least 2.6.94"
14526         check_swap_layouts_support
14527         [ -z "$(which getfattr 2>/dev/null)" ] &&
14528                 skip_env "no getfattr command"
14529
14530         local file1=$DIR/$tdir/$tfile-1
14531         local file2=$DIR/$tdir/$tfile-2
14532         local file3=$DIR/$tdir/$tfile-3
14533         local lovea
14534
14535         mkdir -p $DIR/$tdir
14536         touch $file1 || error "create $file1 failed"
14537         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE $file2 ||
14538                 error "create $file2 failed"
14539         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE $file3 ||
14540                 error "create $file3 failed"
14541
14542         $LFS swap_layouts $file1 $file2 ||
14543                 error "swap $file1 $file2 layouts failed"
14544
14545         lovea=$(getfattr -n trusted.lov $file1 | grep ^trusted)
14546         [[ -z "$lovea" ]] || error "$file1 shouldn't have lovea"
14547
14548         echo 123 > $file1 || error "Should be able to write into $file1"
14549
14550         $LFS swap_layouts $file1 $file3 ||
14551                 error "swap $file1 $file3 layouts failed"
14552
14553         echo 123 > $file1 || error "Should be able to write into $file1"
14554
14555         rm -rf $file1 $file2 $file3
14556 }
14557 run_test 184e "Recreate layout after stripeless layout swaps"
14558
14559 test_184f() {
14560         # Create a file with name longer than sizeof(struct stat) ==
14561         # 144 to see if we can get chars from the file name to appear
14562         # in the returned striping. Note that 'f' == 0x66.
14563         local file=$(for ((i = 0; i < 200; i++)); do echo -n f; done)
14564
14565         mkdir -p $DIR/$tdir
14566         mcreate $DIR/$tdir/$file
14567         if lfs find --stripe-count 0x6666 $DIR/$tdir | grep $file; then
14568                 error "IOC_MDC_GETFILEINFO returned garbage striping"
14569         fi
14570 }
14571 run_test 184f "IOC_MDC_GETFILEINFO for files with long names but no striping"
14572
14573 test_185() { # LU-2441
14574         # LU-3553 - no volatile file support in old servers
14575         [[ $MDS1_VERSION -ge $(version_code 2.3.60) ]] ||
14576                 skip "Need MDS version at least 2.3.60"
14577
14578         mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
14579         touch $DIR/$tdir/spoo
14580         local mtime1=$(stat -c "%Y" $DIR/$tdir)
14581         local fid=$($MULTIOP $DIR/$tdir VFw4096c) ||
14582                 error "cannot create/write a volatile file"
14583         [ "$FILESET" == "" ] &&
14584         $CHECKSTAT -t file $MOUNT/.lustre/fid/$fid 2>/dev/null &&
14585                 error "FID is still valid after close"
14586
14587         multiop_bg_pause $DIR/$tdir vVw4096_c
14588         local multi_pid=$!
14589
14590         local OLD_IFS=$IFS
14591         IFS=":"
14592         local fidv=($fid)
14593         IFS=$OLD_IFS
14594         # assume that the next FID for this client is sequential, since stdout
14595         # is unfortunately eaten by multiop_bg_pause
14596         local n=$((${fidv[1]} + 1))
14597         local next_fid="${fidv[0]}:$(printf "0x%x" $n):${fidv[2]}"
14598         if [ "$FILESET" == "" ]; then
14599                 $CHECKSTAT -t file $MOUNT/.lustre/fid/$next_fid ||
14600                         error "FID is missing before close"
14601         fi
14602         kill -USR1 $multi_pid
14603         # 1 second delay, so if mtime change we will see it
14604         sleep 1
14605         local mtime2=$(stat -c "%Y" $DIR/$tdir)
14606         [[ $mtime1 == $mtime2 ]] || error "mtime has changed"
14607 }
14608 run_test 185 "Volatile file support"
14609
14610 function create_check_volatile() {
14611         local idx=$1
14612         local tgt
14613
14614         $MULTIOP $MOUNT/.lustre/fid V${idx}Fw4096_c >&/tmp/${tfile}.fid &
14615         local PID=$!
14616         sleep 1
14617         local FID=$(cat /tmp/${tfile}.fid)
14618         [ "$FID" == "" ] && error "can't get FID for volatile"
14619         $CHECKSTAT -t file $MOUNT/.lustre/fid/$FID || error "can't stat $FID"
14620         tgt=$($LFS getstripe -m $MOUNT/.lustre/fid/$FID)
14621         [ "$tgt" != "$idx" ] && error "wrong MDS $tgt, expected $idx"
14622         kill -USR1 $PID
14623         wait
14624         sleep 1
14625         cancel_lru_locks mdc # flush opencache
14626         $CHECKSTAT -t file $MOUNT/.lustre/fid/$FID && error "can stat $FID"
14627         return 0
14628 }
14629
14630 test_185a(){
14631         # LU-12516 - volatile creation via .lustre
14632         [[ $MDS1_VERSION -ge $(version_code 2.12.55) ]] ||
14633                 skip "Need MDS version at least 2.3.55"
14634
14635         create_check_volatile 0
14636         [ $MDSCOUNT -lt 2 ] && return 0
14637
14638         # DNE case
14639         create_check_volatile 1
14640
14641         return 0
14642 }
14643 run_test 185a "Volatile file creation in .lustre/fid/"
14644
14645 test_187a() {
14646         remote_mds_nodsh && skip "remote MDS with nodsh"
14647         [ $MDS1_VERSION -lt $(version_code 2.3.0) ] &&
14648                 skip "Need MDS version at least 2.3.0"
14649
14650         local dir0=$DIR/$tdir/$testnum
14651         mkdir -p $dir0 || error "creating dir $dir0"
14652
14653         local file=$dir0/file1
14654         dd if=/dev/urandom of=$file count=10 bs=1M conv=fsync
14655         local dv1=$($LFS data_version $file)
14656         dd if=/dev/urandom of=$file seek=10 count=1 bs=1M conv=fsync
14657         local dv2=$($LFS data_version $file)
14658         [[ $dv1 != $dv2 ]] ||
14659                 error "data version did not change on write $dv1 == $dv2"
14660
14661         # clean up
14662         rm -f $file1
14663 }
14664 run_test 187a "Test data version change"
14665
14666 test_187b() {
14667         remote_mds_nodsh && skip "remote MDS with nodsh"
14668         [ $MDS1_VERSION -lt $(version_code 2.3.0) ] &&
14669                 skip "Need MDS version at least 2.3.0"
14670
14671         local dir0=$DIR/$tdir/$testnum
14672         mkdir -p $dir0 || error "creating dir $dir0"
14673
14674         declare -a DV=$($MULTIOP $dir0 Vw1000xYw1000xY | cut -f3 -d" ")
14675         [[ ${DV[0]} != ${DV[1]} ]] ||
14676                 error "data version did not change on write"\
14677                       " ${DV[0]} == ${DV[1]}"
14678
14679         # clean up
14680         rm -f $file1
14681 }
14682 run_test 187b "Test data version change on volatile file"
14683
14684 test_200() {
14685         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14686         remote_mgs_nodsh && skip "remote MGS with nodsh"
14687         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
14688
14689         local POOL=${POOL:-cea1}
14690         local POOL_ROOT=${POOL_ROOT:-$DIR/d200.pools}
14691         local POOL_DIR_NAME=${POOL_DIR_NAME:-dir_tst}
14692         # Pool OST targets
14693         local first_ost=0
14694         local last_ost=$(($OSTCOUNT - 1))
14695         local ost_step=2
14696         local ost_list=$(seq $first_ost $ost_step $last_ost)
14697         local ost_range="$first_ost $last_ost $ost_step"
14698         local test_path=$POOL_ROOT/$POOL_DIR_NAME
14699         local file_dir=$POOL_ROOT/file_tst
14700         local subdir=$test_path/subdir
14701         local rc=0
14702
14703         if ! combined_mgs_mds ; then
14704                 mount_mgs_client
14705         fi
14706
14707         while : ; do
14708                 # former test_200a test_200b
14709                 pool_add $POOL                          || { rc=$? ; break; }
14710                 pool_add_targets  $POOL $ost_range      || { rc=$? ; break; }
14711                 # former test_200c test_200d
14712                 mkdir -p $test_path
14713                 pool_set_dir      $POOL $test_path      || { rc=$? ; break; }
14714                 pool_check_dir    $POOL $test_path      || { rc=$? ; break; }
14715                 mkdir -p $subdir
14716                 pool_check_dir    $POOL $subdir         || { rc=$? ; break; }
14717                 pool_dir_rel_path $POOL $POOL_DIR_NAME $POOL_ROOT \
14718                                                         || { rc=$? ; break; }
14719                 # former test_200e test_200f
14720                 local files=$((OSTCOUNT*3))
14721                 pool_alloc_files  $POOL $test_path $files "$ost_list" \
14722                                                         || { rc=$? ; break; }
14723                 pool_create_files $POOL $file_dir $files "$ost_list" \
14724                                                         || { rc=$? ; break; }
14725                 # former test_200g test_200h
14726                 pool_lfs_df $POOL                       || { rc=$? ; break; }
14727                 pool_file_rel_path $POOL $test_path     || { rc=$? ; break; }
14728
14729                 # former test_201a test_201b test_201c
14730                 pool_remove_first_target $POOL          || { rc=$? ; break; }
14731
14732                 local f=$test_path/$tfile
14733                 pool_remove_all_targets $POOL $f        || { rc=$? ; break; }
14734                 pool_remove $POOL $f                    || { rc=$? ; break; }
14735                 break
14736         done
14737
14738         destroy_test_pools
14739
14740         if ! combined_mgs_mds ; then
14741                 umount_mgs_client
14742         fi
14743         return $rc
14744 }
14745 run_test 200 "OST pools"
14746
14747 # usage: default_attr <count | size | offset>
14748 default_attr() {
14749         $LCTL get_param -n lov.$FSNAME-clilov-\*.stripe${1}
14750 }
14751
14752 # usage: check_default_stripe_attr
14753 check_default_stripe_attr() {
14754         ACTUAL=$($LFS getstripe $* $DIR/$tdir)
14755         case $1 in
14756         --stripe-count|-c)
14757                 [ -n "$2" ] && EXPECTED=0 || EXPECTED=$(default_attr count);;
14758         --stripe-size|-S)
14759                 [ -n "$2" ] && EXPECTED=0 || EXPECTED=$(default_attr size);;
14760         --stripe-index|-i)
14761                 EXPECTED=-1;;
14762         *)
14763                 error "unknown getstripe attr '$1'"
14764         esac
14765
14766         [ $ACTUAL == $EXPECTED ] ||
14767                 error "$DIR/$tdir has $1 '$ACTUAL', not '$EXPECTED'"
14768 }
14769
14770 test_204a() {
14771         test_mkdir $DIR/$tdir
14772         $LFS setstripe --stripe-count 0 --stripe-size 0 --stripe-index -1 $DIR/$tdir
14773
14774         check_default_stripe_attr --stripe-count
14775         check_default_stripe_attr --stripe-size
14776         check_default_stripe_attr --stripe-index
14777 }
14778 run_test 204a "Print default stripe attributes"
14779
14780 test_204b() {
14781         test_mkdir $DIR/$tdir
14782         $LFS setstripe --stripe-count 1 $DIR/$tdir
14783
14784         check_default_stripe_attr --stripe-size
14785         check_default_stripe_attr --stripe-index
14786 }
14787 run_test 204b "Print default stripe size and offset"
14788
14789 test_204c() {
14790         test_mkdir $DIR/$tdir
14791         $LFS setstripe --stripe-size 65536 $DIR/$tdir
14792
14793         check_default_stripe_attr --stripe-count
14794         check_default_stripe_attr --stripe-index
14795 }
14796 run_test 204c "Print default stripe count and offset"
14797
14798 test_204d() {
14799         test_mkdir $DIR/$tdir
14800         $LFS setstripe --stripe-index 0 $DIR/$tdir
14801
14802         check_default_stripe_attr --stripe-count
14803         check_default_stripe_attr --stripe-size
14804 }
14805 run_test 204d "Print default stripe count and size"
14806
14807 test_204e() {
14808         test_mkdir $DIR/$tdir
14809         $LFS setstripe -d $DIR/$tdir
14810
14811         check_default_stripe_attr --stripe-count --raw
14812         check_default_stripe_attr --stripe-size --raw
14813         check_default_stripe_attr --stripe-index --raw
14814 }
14815 run_test 204e "Print raw stripe attributes"
14816
14817 test_204f() {
14818         test_mkdir $DIR/$tdir
14819         $LFS setstripe --stripe-count 1 $DIR/$tdir
14820
14821         check_default_stripe_attr --stripe-size --raw
14822         check_default_stripe_attr --stripe-index --raw
14823 }
14824 run_test 204f "Print raw stripe size and offset"
14825
14826 test_204g() {
14827         test_mkdir $DIR/$tdir
14828         $LFS setstripe --stripe-size 65536 $DIR/$tdir
14829
14830         check_default_stripe_attr --stripe-count --raw
14831         check_default_stripe_attr --stripe-index --raw
14832 }
14833 run_test 204g "Print raw stripe count and offset"
14834
14835 test_204h() {
14836         test_mkdir $DIR/$tdir
14837         $LFS setstripe --stripe-index 0 $DIR/$tdir
14838
14839         check_default_stripe_attr --stripe-count --raw
14840         check_default_stripe_attr --stripe-size --raw
14841 }
14842 run_test 204h "Print raw stripe count and size"
14843
14844 # Figure out which job scheduler is being used, if any,
14845 # or use a fake one
14846 if [ -n "$SLURM_JOB_ID" ]; then # SLURM
14847         JOBENV=SLURM_JOB_ID
14848 elif [ -n "$LSB_JOBID" ]; then # Load Sharing Facility
14849         JOBENV=LSB_JOBID
14850 elif [ -n "$PBS_JOBID" ]; then # PBS/Maui/Moab
14851         JOBENV=PBS_JOBID
14852 elif [ -n "$LOADL_STEPID" ]; then # LoadLeveller
14853         JOBENV=LOADL_STEP_ID
14854 elif [ -n "$JOB_ID" ]; then # Sun Grid Engine
14855         JOBENV=JOB_ID
14856 else
14857         $LCTL list_param jobid_name > /dev/null 2>&1
14858         if [ $? -eq 0 ]; then
14859                 JOBENV=nodelocal
14860         else
14861                 JOBENV=FAKE_JOBID
14862         fi
14863 fi
14864 LUSTRE_JOBID_SIZE=31 # plus NUL terminator
14865
14866 verify_jobstats() {
14867         local cmd=($1)
14868         shift
14869         local facets="$@"
14870
14871 # we don't really need to clear the stats for this test to work, since each
14872 # command has a unique jobid, but it makes debugging easier if needed.
14873 #       for facet in $facets; do
14874 #               local dev=$(convert_facet2label $facet)
14875 #               # clear old jobstats
14876 #               do_facet $facet lctl set_param *.$dev.job_stats="clear"
14877 #       done
14878
14879         # use a new JobID for each test, or we might see an old one
14880         [ "$JOBENV" = "FAKE_JOBID" ] &&
14881                 FAKE_JOBID=id.$testnum.$(basename ${cmd[0]}).$RANDOM
14882
14883         JOBVAL=${!JOBENV:0:$LUSTRE_JOBID_SIZE}
14884
14885         [ "$JOBENV" = "nodelocal" ] && {
14886                 FAKE_JOBID=id.$testnum.%e.$RANDOM
14887                 $LCTL set_param jobid_name=$FAKE_JOBID
14888                 JOBVAL=${FAKE_JOBID/\%e/$(basename ${cmd[0]})}
14889         }
14890
14891         log "Test: ${cmd[*]}"
14892         log "Using JobID environment $($LCTL get_param -n jobid_var)=$JOBVAL"
14893
14894         if [ $JOBENV = "FAKE_JOBID" ]; then
14895                 FAKE_JOBID=$JOBVAL ${cmd[*]}
14896         else
14897                 ${cmd[*]}
14898         fi
14899
14900         # all files are created on OST0000
14901         for facet in $facets; do
14902                 local stats="*.$(convert_facet2label $facet).job_stats"
14903
14904                 # strip out libtool wrappers for in-tree executables
14905                 if [ $(do_facet $facet lctl get_param $stats |
14906                        sed -e 's/\.lt-/./' | grep -c $JOBVAL) -ne 1 ]; then
14907                         do_facet $facet lctl get_param $stats
14908                         error "No jobstats for $JOBVAL found on $facet::$stats"
14909                 fi
14910         done
14911 }
14912
14913 jobstats_set() {
14914         local new_jobenv=$1
14915
14916         set_persistent_param_and_check client "jobid_var" \
14917                 "$FSNAME.sys.jobid_var" $new_jobenv
14918 }
14919
14920 test_205() { # Job stats
14921         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14922         [[ $MDS1_VERSION -ge $(version_code 2.7.1) ]] ||
14923                 skip "Need MDS version with at least 2.7.1"
14924         remote_mgs_nodsh && skip "remote MGS with nodsh"
14925         remote_mds_nodsh && skip "remote MDS with nodsh"
14926         remote_ost_nodsh && skip "remote OST with nodsh"
14927         [ -z "$(lctl get_param -n mdc.*.connect_flags | grep jobstats)" ] &&
14928                 skip "Server doesn't support jobstats"
14929         [[ $JOBID_VAR = disable ]] && skip_env "jobstats is disabled"
14930
14931         local old_jobenv=$($LCTL get_param -n jobid_var)
14932         [ $old_jobenv != $JOBENV ] && jobstats_set $JOBENV
14933
14934         if [[ $PERM_CMD == *"set_param -P"* ]]; then
14935                 stack_trap "do_facet mgs $PERM_CMD jobid_var=$old_jobenv" EXIT
14936         else
14937                 stack_trap "do_facet mgs $PERM_CMD \
14938                         $FSNAME.sys.jobid_var=$old_jobenv" EXIT
14939         fi
14940         changelog_register
14941
14942         local old_interval=$(do_facet $SINGLEMDS lctl get_param -n \
14943                                 mdt.*.job_cleanup_interval | head -n 1)
14944         local new_interval=5
14945         do_facet $SINGLEMDS \
14946                 $LCTL set_param mdt.*.job_cleanup_interval=$new_interval
14947         stack_trap "do_facet $SINGLEMDS \
14948                 $LCTL set_param mdt.*.job_cleanup_interval=$old_interval" EXIT
14949         local start=$SECONDS
14950
14951         local cmd
14952         # mkdir
14953         cmd="mkdir $DIR/$tdir"
14954         verify_jobstats "$cmd" "$SINGLEMDS"
14955         # rmdir
14956         cmd="rmdir $DIR/$tdir"
14957         verify_jobstats "$cmd" "$SINGLEMDS"
14958         # mkdir on secondary MDT
14959         if [ $MDSCOUNT -gt 1 ]; then
14960                 cmd="lfs mkdir -i 1 $DIR/$tdir.remote"
14961                 verify_jobstats "$cmd" "mds2"
14962         fi
14963         # mknod
14964         cmd="mknod $DIR/$tfile c 1 3"
14965         verify_jobstats "$cmd" "$SINGLEMDS"
14966         # unlink
14967         cmd="rm -f $DIR/$tfile"
14968         verify_jobstats "$cmd" "$SINGLEMDS"
14969         # create all files on OST0000 so verify_jobstats can find OST stats
14970         # open & close
14971         cmd="$LFS setstripe -i 0 -c 1 $DIR/$tfile"
14972         verify_jobstats "$cmd" "$SINGLEMDS"
14973         # setattr
14974         cmd="touch $DIR/$tfile"
14975         verify_jobstats "$cmd" "$SINGLEMDS ost1"
14976         # write
14977         cmd="dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 oflag=sync"
14978         verify_jobstats "$cmd" "ost1"
14979         # read
14980         cancel_lru_locks osc
14981         cmd="dd if=$DIR/$tfile of=/dev/null bs=1M count=1 iflag=direct"
14982         verify_jobstats "$cmd" "ost1"
14983         # truncate
14984         cmd="$TRUNCATE $DIR/$tfile 0"
14985         verify_jobstats "$cmd" "$SINGLEMDS ost1"
14986         # rename
14987         cmd="mv -f $DIR/$tfile $DIR/$tdir.rename"
14988         verify_jobstats "$cmd" "$SINGLEMDS"
14989         # jobstats expiry - sleep until old stats should be expired
14990         local left=$((new_interval + 5 - (SECONDS - start)))
14991         [ $left -ge 0 ] && wait_update_facet $SINGLEMDS \
14992                 "lctl get_param *.*.job_stats | grep -c 'job_id.*mkdir'" \
14993                         "0" $left
14994         cmd="mkdir $DIR/$tdir.expire"
14995         verify_jobstats "$cmd" "$SINGLEMDS"
14996         [ $(do_facet $SINGLEMDS lctl get_param *.*.job_stats |
14997             grep -c "job_id.*mkdir") -gt 1 ] && error "old jobstats not expired"
14998
14999         # Ensure that jobid are present in changelog (if supported by MDS)
15000         if [ $MDS1_VERSION -ge $(version_code 2.6.52) ];then
15001                 changelog_dump | tail -10
15002                 jobids=$(changelog_dump | tail -9 | grep -c "j=")
15003                 [ $jobids -eq 9 ] ||
15004                         error "Wrong changelog jobid count $jobids != 9"
15005
15006                 # LU-5862
15007                 JOBENV="disable"
15008                 jobstats_set $JOBENV
15009                 touch $DIR/$tfile
15010                 changelog_dump | grep $tfile
15011                 jobids=$(changelog_dump | grep $tfile | tail -1 | grep -c "j=")
15012                 [ $jobids -eq 0 ] ||
15013                         error "Unexpected jobids when jobid_var=$JOBENV"
15014         fi
15015
15016         lctl set_param jobid_var=USER jobid_name="S.%j.%e.%u.%h.E"
15017         JOBENV="JOBCOMPLEX"
15018         JOBCOMPLEX="S.$USER.touch.$(id -u).$(hostname).E"
15019
15020         verify_jobstats "touch $DIR/$tfile" $SINGLEMDS
15021 }
15022 run_test 205 "Verify job stats"
15023
15024 # LU-1480, LU-1773 and LU-1657
15025 test_206() {
15026         mkdir -p $DIR/$tdir
15027         $LFS setstripe -c -1 $DIR/$tdir
15028 #define OBD_FAIL_LOV_INIT 0x1403
15029         $LCTL set_param fail_loc=0xa0001403
15030         $LCTL set_param fail_val=1
15031         touch $DIR/$tdir/$tfile || true
15032 }
15033 run_test 206 "fail lov_init_raid0() doesn't lbug"
15034
15035 test_207a() {
15036         dd if=/dev/zero of=$DIR/$tfile bs=4k count=$((RANDOM%10+1))
15037         local fsz=`stat -c %s $DIR/$tfile`
15038         cancel_lru_locks mdc
15039
15040         # do not return layout in getattr intent
15041 #define OBD_FAIL_MDS_NO_LL_GETATTR 0x170
15042         $LCTL set_param fail_loc=0x170
15043         local sz=`stat -c %s $DIR/$tfile`
15044
15045         [ $fsz -eq $sz ] || error "file size expected $fsz, actual $sz"
15046
15047         rm -rf $DIR/$tfile
15048 }
15049 run_test 207a "can refresh layout at glimpse"
15050
15051 test_207b() {
15052         dd if=/dev/zero of=$DIR/$tfile bs=4k count=$((RANDOM%10+1))
15053         local cksum=`md5sum $DIR/$tfile`
15054         local fsz=`stat -c %s $DIR/$tfile`
15055         cancel_lru_locks mdc
15056         cancel_lru_locks osc
15057
15058         # do not return layout in getattr intent
15059 #define OBD_FAIL_MDS_NO_LL_OPEN 0x171
15060         $LCTL set_param fail_loc=0x171
15061
15062         # it will refresh layout after the file is opened but before read issues
15063         echo checksum is "$cksum"
15064         echo "$cksum" |md5sum -c --quiet || error "file differs"
15065
15066         rm -rf $DIR/$tfile
15067 }
15068 run_test 207b "can refresh layout at open"
15069
15070 test_208() {
15071         # FIXME: in this test suite, only RD lease is used. This is okay
15072         # for now as only exclusive open is supported. After generic lease
15073         # is done, this test suite should be revised. - Jinshan
15074
15075         remote_mds_nodsh && skip "remote MDS with nodsh"
15076         [[ $MDS1_VERSION -ge $(version_code 2.4.52) ]] ||
15077                 skip "Need MDS version at least 2.4.52"
15078
15079         echo "==== test 1: verify get lease work"
15080         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:eRE+eU || error "get lease error"
15081
15082         echo "==== test 2: verify lease can be broken by upcoming open"
15083         $MULTIOP $DIR/$tfile oO_RDONLY:eR_E-eUc &
15084         local PID=$!
15085         sleep 1
15086
15087         $MULTIOP $DIR/$tfile oO_RDONLY:c
15088         kill -USR1 $PID && wait $PID || error "break lease error"
15089
15090         echo "==== test 3: verify lease can't be granted if an open already exists"
15091         $MULTIOP $DIR/$tfile oO_RDONLY:_c &
15092         local PID=$!
15093         sleep 1
15094
15095         $MULTIOP $DIR/$tfile oO_RDONLY:eReUc && error "apply lease should fail"
15096         kill -USR1 $PID && wait $PID || error "open file error"
15097
15098         echo "==== test 4: lease can sustain over recovery"
15099         $MULTIOP $DIR/$tfile oO_RDONLY:eR_E+eUc &
15100         PID=$!
15101         sleep 1
15102
15103         fail mds1
15104
15105         kill -USR1 $PID && wait $PID || error "lease broken over recovery"
15106
15107         echo "==== test 5: lease broken can't be regained by replay"
15108         $MULTIOP $DIR/$tfile oO_RDONLY:eR_E-eUc &
15109         PID=$!
15110         sleep 1
15111
15112         # open file to break lease and then recovery
15113         $MULTIOP $DIR/$tfile oO_RDWR:c || error "open file error"
15114         fail mds1
15115
15116         kill -USR1 $PID && wait $PID || error "lease not broken over recovery"
15117
15118         rm -f $DIR/$tfile
15119 }
15120 run_test 208 "Exclusive open"
15121
15122 test_209() {
15123         [ -z "$(lctl get_param -n mdc.*.connect_flags | grep disp_stripe)" ] &&
15124                 skip_env "must have disp_stripe"
15125
15126         touch $DIR/$tfile
15127         sync; sleep 5; sync;
15128
15129         echo 3 > /proc/sys/vm/drop_caches
15130         req_before=$(awk '/ptlrpc_cache / { print $2 }' /proc/slabinfo)
15131
15132         # open/close 500 times
15133         for i in $(seq 500); do
15134                 cat $DIR/$tfile
15135         done
15136
15137         echo 3 > /proc/sys/vm/drop_caches
15138         req_after=$(awk '/ptlrpc_cache / { print $2 }' /proc/slabinfo)
15139
15140         echo "before: $req_before, after: $req_after"
15141         [ $((req_after - req_before)) -ge 300 ] &&
15142                 error "open/close requests are not freed"
15143         return 0
15144 }
15145 run_test 209 "read-only open/close requests should be freed promptly"
15146
15147 test_212() {
15148         size=`date +%s`
15149         size=$((size % 8192 + 1))
15150         dd if=/dev/urandom of=$DIR/f212 bs=1k count=$size
15151         sendfile $DIR/f212 $DIR/f212.xyz || error "sendfile wrong"
15152         rm -f $DIR/f212 $DIR/f212.xyz
15153 }
15154 run_test 212 "Sendfile test ============================================"
15155
15156 test_213() {
15157         dd if=/dev/zero of=$DIR/$tfile bs=4k count=4
15158         cancel_lru_locks osc
15159         lctl set_param fail_loc=0x8000040f
15160         # generate a read lock
15161         cat $DIR/$tfile > /dev/null
15162         # write to the file, it will try to cancel the above read lock.
15163         cat /etc/hosts >> $DIR/$tfile
15164 }
15165 run_test 213 "OSC lock completion and cancel race don't crash - bug 18829"
15166
15167 test_214() { # for bug 20133
15168         mkdir -p $DIR/$tdir/d214c || error "mkdir $DIR/$tdir/d214c failed"
15169         for (( i=0; i < 340; i++ )) ; do
15170                 touch $DIR/$tdir/d214c/a$i
15171         done
15172
15173         ls -l $DIR/$tdir || error "ls -l $DIR/d214p failed"
15174         mv $DIR/$tdir/d214c $DIR/ || error "mv $DIR/d214p/d214c $DIR/ failed"
15175         ls $DIR/d214c || error "ls $DIR/d214c failed"
15176         rm -rf $DIR/$tdir || error "rm -rf $DIR/d214* failed"
15177         rm -rf $DIR/d214* || error "rm -rf $DIR/d214* failed"
15178 }
15179 run_test 214 "hash-indexed directory test - bug 20133"
15180
15181 # having "abc" as 1st arg, creates $TMP/lnet_abc.out and $TMP/lnet_abc.sys
15182 create_lnet_proc_files() {
15183         lctl get_param -n $1 >$TMP/lnet_$1.sys || error "cannot read lnet.$1"
15184 }
15185
15186 # counterpart of create_lnet_proc_files
15187 remove_lnet_proc_files() {
15188         rm -f $TMP/lnet_$1.sys
15189 }
15190
15191 # uses 1st arg as trailing part of filename, 2nd arg as description for reports,
15192 # 3rd arg as regexp for body
15193 check_lnet_proc_stats() {
15194         local l=$(cat "$TMP/lnet_$1" |wc -l)
15195         [ $l = 1 ] || (cat "$TMP/lnet_$1" && error "$2 is not of 1 line: $l")
15196
15197         grep -E "$3" "$TMP/lnet_$1" || (cat "$TMP/lnet_$1" && error "$2 misformatted")
15198 }
15199
15200 # uses 1st arg as trailing part of filename, 2nd arg as description for reports,
15201 # 3rd arg as regexp for body, 4th arg as regexp for 1st line, 5th arg is
15202 # optional and can be regexp for 2nd line (lnet.routes case)
15203 check_lnet_proc_entry() {
15204         local blp=2          # blp stands for 'position of 1st line of body'
15205         [ -z "$5" ] || blp=3 # lnet.routes case
15206
15207         local l=$(cat "$TMP/lnet_$1" |wc -l)
15208         # subtracting one from $blp because the body can be empty
15209         [ "$l" -ge "$(($blp - 1))" ] || (cat "$TMP/lnet_$1" && error "$2 is too short: $l")
15210
15211         sed -n '1 p' "$TMP/lnet_$1" |grep -E "$4" >/dev/null ||
15212                 (cat "$TMP/lnet_$1" && error "1st line of $2 misformatted")
15213
15214         [ "$5" = "" ] || sed -n '2 p' "$TMP/lnet_$1" |grep -E "$5" >/dev/null ||
15215                 (cat "$TMP/lnet_$1" && error "2nd line of $2 misformatted")
15216
15217         # bail out if any unexpected line happened
15218         sed -n "$blp p" "$TMP/lnet_$1" | grep -Ev "$3"
15219         [ "$?" != 0 ] || error "$2 misformatted"
15220 }
15221
15222 test_215() { # for bugs 18102, 21079, 21517
15223         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15224
15225         local N='(0|[1-9][0-9]*)'       # non-negative numeric
15226         local P='[1-9][0-9]*'           # positive numeric
15227         local I='(0|-?[1-9][0-9]*|NA)'  # any numeric (0 | >0 | <0) or NA if no value
15228         local NET='[a-z][a-z0-9]*'      # LNET net like o2ib2
15229         local ADDR='[0-9.]+'            # LNET addr like 10.0.0.1
15230         local NID="$ADDR@$NET"          # LNET nid like 10.0.0.1@o2ib2
15231
15232         local L1 # regexp for 1st line
15233         local L2 # regexp for 2nd line (optional)
15234         local BR # regexp for the rest (body)
15235
15236         # lnet.stats should look as 11 space-separated non-negative numerics
15237         BR="^$N $N $N $N $N $N $N $N $N $N $N$"
15238         create_lnet_proc_files "stats"
15239         check_lnet_proc_stats "stats.sys" "lnet.stats" "$BR"
15240         remove_lnet_proc_files "stats"
15241
15242         # lnet.routes should look like this:
15243         # Routing disabled/enabled
15244         # net hops priority state router
15245         # where net is a string like tcp0, hops > 0, priority >= 0,
15246         # state is up/down,
15247         # router is a string like 192.168.1.1@tcp2
15248         L1="^Routing (disabled|enabled)$"
15249         L2="^net +hops +priority +state +router$"
15250         BR="^$NET +$N +(0|1) +(up|down) +$NID$"
15251         create_lnet_proc_files "routes"
15252         check_lnet_proc_entry "routes.sys" "lnet.routes" "$BR" "$L1" "$L2"
15253         remove_lnet_proc_files "routes"
15254
15255         # lnet.routers should look like this:
15256         # ref rtr_ref alive_cnt state last_ping ping_sent deadline down_ni router
15257         # where ref > 0, rtr_ref > 0, alive_cnt >= 0, state is up/down,
15258         # last_ping >= 0, ping_sent is boolean (0/1), deadline and down_ni are
15259         # numeric (0 or >0 or <0), router is a string like 192.168.1.1@tcp2
15260         L1="^ref +rtr_ref +alive +router$"
15261         BR="^$P +$P +(up|down) +$NID$"
15262         create_lnet_proc_files "routers"
15263         check_lnet_proc_entry "routers.sys" "lnet.routers" "$BR" "$L1"
15264         remove_lnet_proc_files "routers"
15265
15266         # lnet.peers should look like this:
15267         # nid refs state last max rtr min tx min queue
15268         # where nid is a string like 192.168.1.1@tcp2, refs > 0,
15269         # state is up/down/NA, max >= 0. last, rtr, min, tx, min are
15270         # numeric (0 or >0 or <0), queue >= 0.
15271         L1="^nid +refs +state +last +max +rtr +min +tx +min +queue$"
15272         BR="^$NID +$P +(up|down|NA) +$I +$N +$I +$I +$I +$I +$N$"
15273         create_lnet_proc_files "peers"
15274         check_lnet_proc_entry "peers.sys" "lnet.peers" "$BR" "$L1"
15275         remove_lnet_proc_files "peers"
15276
15277         # lnet.buffers  should look like this:
15278         # pages count credits min
15279         # where pages >=0, count >=0, credits and min are numeric (0 or >0 or <0)
15280         L1="^pages +count +credits +min$"
15281         BR="^ +$N +$N +$I +$I$"
15282         create_lnet_proc_files "buffers"
15283         check_lnet_proc_entry "buffers.sys" "lnet.buffers" "$BR" "$L1"
15284         remove_lnet_proc_files "buffers"
15285
15286         # lnet.nis should look like this:
15287         # nid status alive refs peer rtr max tx min
15288         # where nid is a string like 192.168.1.1@tcp2, status is up/down,
15289         # alive is numeric (0 or >0 or <0), refs >= 0, peer >= 0,
15290         # rtr >= 0, max >=0, tx and min are numeric (0 or >0 or <0).
15291         L1="^nid +status +alive +refs +peer +rtr +max +tx +min$"
15292         BR="^$NID +(up|down) +$I +$N +$N +$N +$N +$I +$I$"
15293         create_lnet_proc_files "nis"
15294         check_lnet_proc_entry "nis.sys" "lnet.nis" "$BR" "$L1"
15295         remove_lnet_proc_files "nis"
15296
15297         # can we successfully write to lnet.stats?
15298         lctl set_param -n stats=0 || error "cannot write to lnet.stats"
15299 }
15300 run_test 215 "lnet exists and has proper content - bugs 18102, 21079, 21517"
15301
15302 test_216() { # bug 20317
15303         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15304         remote_ost_nodsh && skip "remote OST with nodsh"
15305
15306         local node
15307         local facets=$(get_facets OST)
15308         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
15309
15310         save_lustre_params client "osc.*.contention_seconds" > $p
15311         save_lustre_params $facets \
15312                 "ldlm.namespaces.filter-*.max_nolock_bytes" >> $p
15313         save_lustre_params $facets \
15314                 "ldlm.namespaces.filter-*.contended_locks" >> $p
15315         save_lustre_params $facets \
15316                 "ldlm.namespaces.filter-*.contention_seconds" >> $p
15317         clear_stats osc.*.osc_stats
15318
15319         # agressive lockless i/o settings
15320         do_nodes $(comma_list $(osts_nodes)) \
15321                 "lctl set_param -n ldlm.namespaces.*.max_nolock_bytes=2000000 \
15322                         ldlm.namespaces.filter-*.contended_locks=0 \
15323                         ldlm.namespaces.filter-*.contention_seconds=60"
15324         lctl set_param -n osc.*.contention_seconds=60
15325
15326         $DIRECTIO write $DIR/$tfile 0 10 4096
15327         $CHECKSTAT -s 40960 $DIR/$tfile
15328
15329         # disable lockless i/o
15330         do_nodes $(comma_list $(osts_nodes)) \
15331                 "lctl set_param -n ldlm.namespaces.filter-*.max_nolock_bytes=0 \
15332                         ldlm.namespaces.filter-*.contended_locks=32 \
15333                         ldlm.namespaces.filter-*.contention_seconds=0"
15334         lctl set_param -n osc.*.contention_seconds=0
15335         clear_stats osc.*.osc_stats
15336
15337         dd if=/dev/zero of=$DIR/$tfile count=0
15338         $CHECKSTAT -s 0 $DIR/$tfile
15339
15340         restore_lustre_params <$p
15341         rm -f $p
15342         rm $DIR/$tfile
15343 }
15344 run_test 216 "check lockless direct write updates file size and kms correctly"
15345
15346 test_217() { # bug 22430
15347         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15348
15349         local node
15350         local nid
15351
15352         for node in $(nodes_list); do
15353                 nid=$(host_nids_address $node $NETTYPE)
15354                 if [[ $nid = *-* ]] ; then
15355                         echo "lctl ping $(h2nettype $nid)"
15356                         lctl ping $(h2nettype $nid)
15357                 else
15358                         echo "skipping $node (no hyphen detected)"
15359                 fi
15360         done
15361 }
15362 run_test 217 "check lctl ping for hostnames with hiphen ('-')"
15363
15364 test_218() {
15365        # do directio so as not to populate the page cache
15366        log "creating a 10 Mb file"
15367        $MULTIOP $DIR/$tfile oO_CREAT:O_DIRECT:O_RDWR:w$((10*1048576))c || error "multiop failed while creating a file"
15368        log "starting reads"
15369        dd if=$DIR/$tfile of=/dev/null bs=4096 &
15370        log "truncating the file"
15371        $MULTIOP $DIR/$tfile oO_TRUNC:c || error "multiop failed while truncating the file"
15372        log "killing dd"
15373        kill %+ || true # reads might have finished
15374        echo "wait until dd is finished"
15375        wait
15376        log "removing the temporary file"
15377        rm -rf $DIR/$tfile || error "tmp file removal failed"
15378 }
15379 run_test 218 "parallel read and truncate should not deadlock"
15380
15381 test_219() {
15382         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15383
15384         # write one partial page
15385         dd if=/dev/zero of=$DIR/$tfile bs=1024 count=1
15386         # set no grant so vvp_io_commit_write will do sync write
15387         $LCTL set_param fail_loc=0x411
15388         # write a full page at the end of file
15389         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 seek=1 conv=notrunc
15390
15391         $LCTL set_param fail_loc=0
15392         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 seek=3
15393         $LCTL set_param fail_loc=0x411
15394         dd if=/dev/zero of=$DIR/$tfile bs=1024 count=1 seek=2 conv=notrunc
15395
15396         # LU-4201
15397         dd if=/dev/zero of=$DIR/$tfile-2 bs=1024 count=1
15398         $CHECKSTAT -s 1024 $DIR/$tfile-2 || error "checkstat wrong size"
15399 }
15400 run_test 219 "LU-394: Write partial won't cause uncontiguous pages vec at LND"
15401
15402 test_220() { #LU-325
15403         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15404         remote_ost_nodsh && skip "remote OST with nodsh"
15405         remote_mds_nodsh && skip "remote MDS with nodsh"
15406         remote_mgs_nodsh && skip "remote MGS with nodsh"
15407
15408         local OSTIDX=0
15409
15410         # create on MDT0000 so the last_id and next_id are correct
15411         mkdir $DIR/$tdir
15412         local OST=$($LFS df $DIR | awk '/OST:'$OSTIDX'/ { print $1 }')
15413         OST=${OST%_UUID}
15414
15415         # on the mdt's osc
15416         local mdtosc_proc1=$(get_mdtosc_proc_path $SINGLEMDS $OST)
15417         local last_id=$(do_facet $SINGLEMDS lctl get_param -n \
15418                         osp.$mdtosc_proc1.prealloc_last_id)
15419         local next_id=$(do_facet $SINGLEMDS lctl get_param -n \
15420                         osp.$mdtosc_proc1.prealloc_next_id)
15421
15422         $LFS df -i
15423
15424         if ! combined_mgs_mds ; then
15425                 mount_mgs_client
15426         fi
15427
15428         do_facet ost$((OSTIDX + 1)) lctl set_param fail_val=-1
15429         #define OBD_FAIL_OST_ENOINO              0x229
15430         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=0x229
15431         create_pool $FSNAME.$TESTNAME || return 1
15432         do_facet mgs $LCTL pool_add $FSNAME.$TESTNAME $OST || return 2
15433
15434         $LFS setstripe $DIR/$tdir -i $OSTIDX -c 1 -p $FSNAME.$TESTNAME
15435
15436         MDSOBJS=$((last_id - next_id))
15437         echo "preallocated objects on MDS is $MDSOBJS" "($last_id - $next_id)"
15438
15439         blocks=$($LFS df $MOUNT | awk '($1 == '$OSTIDX') { print $4 }')
15440         echo "OST still has $count kbytes free"
15441
15442         echo "create $MDSOBJS files @next_id..."
15443         createmany -o $DIR/$tdir/f $MDSOBJS || return 3
15444
15445         local last_id2=$(do_facet mds${MDSIDX} lctl get_param -n \
15446                         osp.$mdtosc_proc1.prealloc_last_id)
15447         local next_id2=$(do_facet mds${MDSIDX} lctl get_param -n \
15448                         osp.$mdtosc_proc1.prealloc_next_id)
15449
15450         echo "after creation, last_id=$last_id2, next_id=$next_id2"
15451         $LFS df -i
15452
15453         echo "cleanup..."
15454
15455         do_facet ost$((OSTIDX + 1)) lctl set_param fail_val=0
15456         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=0
15457
15458         do_facet mgs $LCTL pool_remove $FSNAME.$TESTNAME $OST ||
15459                 error "$LCTL pool_remove $FSNAME.$TESTNAME $OST failed"
15460         do_facet mgs $LCTL pool_destroy $FSNAME.$TESTNAME ||
15461                 error "$LCTL pool_destroy $FSNAME.$TESTNAME failed"
15462         echo "unlink $MDSOBJS files @$next_id..."
15463         unlinkmany $DIR/$tdir/f $MDSOBJS || error "unlinkmany failed"
15464
15465         if ! combined_mgs_mds ; then
15466                 umount_mgs_client
15467         fi
15468 }
15469 run_test 220 "preallocated MDS objects still used if ENOSPC from OST"
15470
15471 test_221() {
15472         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15473
15474         dd if=`which date` of=$MOUNT/date oflag=sync
15475         chmod +x $MOUNT/date
15476
15477         #define OBD_FAIL_LLITE_FAULT_TRUNC_RACE  0x1401
15478         $LCTL set_param fail_loc=0x80001401
15479
15480         $MOUNT/date > /dev/null
15481         rm -f $MOUNT/date
15482 }
15483 run_test 221 "make sure fault and truncate race to not cause OOM"
15484
15485 test_222a () {
15486         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15487
15488         rm -rf $DIR/$tdir
15489         test_mkdir $DIR/$tdir
15490         $LFS setstripe -c 1 -i 0 $DIR/$tdir
15491         createmany -o $DIR/$tdir/$tfile 10
15492         cancel_lru_locks mdc
15493         cancel_lru_locks osc
15494         #define OBD_FAIL_LDLM_AGL_DELAY           0x31a
15495         $LCTL set_param fail_loc=0x31a
15496         ls -l $DIR/$tdir > /dev/null || error "AGL for ls failed"
15497         $LCTL set_param fail_loc=0
15498         rm -r $DIR/$tdir
15499 }
15500 run_test 222a "AGL for ls should not trigger CLIO lock failure"
15501
15502 test_222b () {
15503         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15504
15505         rm -rf $DIR/$tdir
15506         test_mkdir $DIR/$tdir
15507         $LFS setstripe -c 1 -i 0 $DIR/$tdir
15508         createmany -o $DIR/$tdir/$tfile 10
15509         cancel_lru_locks mdc
15510         cancel_lru_locks osc
15511         #define OBD_FAIL_LDLM_AGL_DELAY           0x31a
15512         $LCTL set_param fail_loc=0x31a
15513         rm -r $DIR/$tdir || error "AGL for rmdir failed"
15514         $LCTL set_param fail_loc=0
15515 }
15516 run_test 222b "AGL for rmdir should not trigger CLIO lock failure"
15517
15518 test_223 () {
15519         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15520
15521         rm -rf $DIR/$tdir
15522         test_mkdir $DIR/$tdir
15523         $LFS setstripe -c 1 -i 0 $DIR/$tdir
15524         createmany -o $DIR/$tdir/$tfile 10
15525         cancel_lru_locks mdc
15526         cancel_lru_locks osc
15527         #define OBD_FAIL_LDLM_AGL_NOLOCK          0x31b
15528         $LCTL set_param fail_loc=0x31b
15529         ls -l $DIR/$tdir > /dev/null || error "reenqueue failed"
15530         $LCTL set_param fail_loc=0
15531         rm -r $DIR/$tdir
15532 }
15533 run_test 223 "osc reenqueue if without AGL lock granted ======================="
15534
15535 test_224a() { # LU-1039, MRP-303
15536         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15537
15538         #define OBD_FAIL_PTLRPC_CLIENT_BULK_CB   0x508
15539         $LCTL set_param fail_loc=0x508
15540         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 conv=fsync
15541         $LCTL set_param fail_loc=0
15542         df $DIR
15543 }
15544 run_test 224a "Don't panic on bulk IO failure"
15545
15546 test_224b() { # LU-1039, MRP-303
15547         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15548
15549         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1
15550         cancel_lru_locks osc
15551         #define OBD_FAIL_PTLRPC_CLIENT_BULK_CB2   0x515
15552         $LCTL set_param fail_loc=0x515
15553         dd of=/dev/null if=$DIR/$tfile bs=4096 count=1
15554         $LCTL set_param fail_loc=0
15555         df $DIR
15556 }
15557 run_test 224b "Don't panic on bulk IO failure"
15558
15559 test_224c() { # LU-6441
15560         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15561         remote_mds_nodsh && skip "remote MDS with nodsh"
15562
15563         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
15564         save_writethrough $p
15565         set_cache writethrough on
15566
15567         local pages_per_rpc=$($LCTL get_param \
15568                                 osc.*.max_pages_per_rpc)
15569         local at_max=$($LCTL get_param -n at_max)
15570         local timeout=$($LCTL get_param -n timeout)
15571         local test_at="at_max"
15572         local param_at="$FSNAME.sys.at_max"
15573         local test_timeout="timeout"
15574         local param_timeout="$FSNAME.sys.timeout"
15575
15576         $LCTL set_param -n osc.*.max_pages_per_rpc=1024
15577
15578         set_persistent_param_and_check client "$test_at" "$param_at" 0
15579         set_persistent_param_and_check client "$test_timeout" "$param_timeout" 5
15580
15581         #define OBD_FAIL_PTLRPC_CLIENT_BULK_CB3 0x520
15582         do_facet ost1 "$LCTL set_param fail_loc=0x520"
15583         $LFS setstripe -c 1 -i 0 $DIR/$tfile
15584         dd if=/dev/zero of=$DIR/$tfile bs=8MB count=1
15585         sync
15586         do_facet ost1 "$LCTL set_param fail_loc=0"
15587
15588         set_persistent_param_and_check client "$test_at" "$param_at" $at_max
15589         set_persistent_param_and_check client "$test_timeout" "$param_timeout" \
15590                 $timeout
15591
15592         $LCTL set_param -n $pages_per_rpc
15593         restore_lustre_params < $p
15594         rm -f $p
15595 }
15596 run_test 224c "Don't hang if one of md lost during large bulk RPC"
15597
15598 MDSSURVEY=${MDSSURVEY:-$(which mds-survey 2>/dev/null || true)}
15599 test_225a () {
15600         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15601         if [ -z ${MDSSURVEY} ]; then
15602                 skip_env "mds-survey not found"
15603         fi
15604         [ $MDS1_VERSION -ge $(version_code 2.2.51) ] ||
15605                 skip "Need MDS version at least 2.2.51"
15606
15607         local mds=$(facet_host $SINGLEMDS)
15608         local target=$(do_nodes $mds 'lctl dl' |
15609                        awk '{ if ($2 == "UP" && $3 == "mdt") { print $4 }}')
15610
15611         local cmd1="file_count=1000 thrhi=4"
15612         local cmd2="dir_count=2 layer=mdd stripe_count=0"
15613         local cmd3="rslt_loc=${TMP} targets=\"$mds:$target\" $MDSSURVEY"
15614         local cmd="$cmd1 $cmd2 $cmd3"
15615
15616         rm -f ${TMP}/mds_survey*
15617         echo + $cmd
15618         eval $cmd || error "mds-survey with zero-stripe failed"
15619         cat ${TMP}/mds_survey*
15620         rm -f ${TMP}/mds_survey*
15621 }
15622 run_test 225a "Metadata survey sanity with zero-stripe"
15623
15624 test_225b () {
15625         if [ -z ${MDSSURVEY} ]; then
15626                 skip_env "mds-survey not found"
15627         fi
15628         [ $MDS1_VERSION -ge $(version_code 2.2.51) ] ||
15629                 skip "Need MDS version at least 2.2.51"
15630         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15631         remote_mds_nodsh && skip "remote MDS with nodsh"
15632         if [ $($LCTL dl | grep -c osc) -eq 0 ]; then
15633                 skip_env "Need to mount OST to test"
15634         fi
15635
15636         local mds=$(facet_host $SINGLEMDS)
15637         local target=$(do_nodes $mds 'lctl dl' |
15638                        awk '{ if ($2 == "UP" && $3 == "mdt") { print $4 }}')
15639
15640         local cmd1="file_count=1000 thrhi=4"
15641         local cmd2="dir_count=2 layer=mdd stripe_count=1"
15642         local cmd3="rslt_loc=${TMP} targets=\"$mds:$target\" $MDSSURVEY"
15643         local cmd="$cmd1 $cmd2 $cmd3"
15644
15645         rm -f ${TMP}/mds_survey*
15646         echo + $cmd
15647         eval $cmd || error "mds-survey with stripe_count failed"
15648         cat ${TMP}/mds_survey*
15649         rm -f ${TMP}/mds_survey*
15650 }
15651 run_test 225b "Metadata survey sanity with stripe_count = 1"
15652
15653 mcreate_path2fid () {
15654         local mode=$1
15655         local major=$2
15656         local minor=$3
15657         local name=$4
15658         local desc=$5
15659         local path=$DIR/$tdir/$name
15660         local fid
15661         local rc
15662         local fid_path
15663
15664         $MCREATE --mode=$1 --major=$2 --minor=$3 $path ||
15665                 error "cannot create $desc"
15666
15667         fid=$($LFS path2fid $path | tr -d '[' | tr -d ']')
15668         rc=$?
15669         [ $rc -ne 0 ] && error "cannot get fid of a $desc"
15670
15671         fid_path=$($LFS fid2path $MOUNT $fid)
15672         rc=$?
15673         [ $rc -ne 0 ] && error "cannot get path of $desc by $DIR $path $fid"
15674
15675         [ "$path" == "$fid_path" ] ||
15676                 error "fid2path returned $fid_path, expected $path"
15677
15678         echo "pass with $path and $fid"
15679 }
15680
15681 test_226a () {
15682         rm -rf $DIR/$tdir
15683         mkdir -p $DIR/$tdir
15684
15685         mcreate_path2fid 0010666 0 0 fifo "FIFO"
15686         mcreate_path2fid 0020666 1 3 null "character special file (null)"
15687         mcreate_path2fid 0020666 1 255 none "character special file (no device)"
15688         mcreate_path2fid 0040666 0 0 dir "directory"
15689         mcreate_path2fid 0060666 7 0 loop0 "block special file (loop)"
15690         mcreate_path2fid 0100666 0 0 file "regular file"
15691         mcreate_path2fid 0120666 0 0 link "symbolic link"
15692         mcreate_path2fid 0140666 0 0 sock "socket"
15693 }
15694 run_test 226a "call path2fid and fid2path on files of all type"
15695
15696 test_226b () {
15697         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
15698
15699         local MDTIDX=1
15700
15701         rm -rf $DIR/$tdir
15702         mkdir -p $DIR/$tdir
15703         $LFS setdirstripe -i $MDTIDX $DIR/$tdir/remote_dir ||
15704                 error "create remote directory failed"
15705         mcreate_path2fid 0010666 0 0 "remote_dir/fifo" "FIFO"
15706         mcreate_path2fid 0020666 1 3 "remote_dir/null" \
15707                                 "character special file (null)"
15708         mcreate_path2fid 0020666 1 255 "remote_dir/none" \
15709                                 "character special file (no device)"
15710         mcreate_path2fid 0040666 0 0 "remote_dir/dir" "directory"
15711         mcreate_path2fid 0060666 7 0 "remote_dir/loop0" \
15712                                 "block special file (loop)"
15713         mcreate_path2fid 0100666 0 0 "remote_dir/file" "regular file"
15714         mcreate_path2fid 0120666 0 0 "remote_dir/link" "symbolic link"
15715         mcreate_path2fid 0140666 0 0 "remote_dir/sock" "socket"
15716 }
15717 run_test 226b "call path2fid and fid2path on files of all type under remote dir"
15718
15719 # LU-1299 Executing or running ldd on a truncated executable does not
15720 # cause an out-of-memory condition.
15721 test_227() {
15722         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15723         [ -z "$(which ldd)" ] && skip_env "should have ldd tool"
15724
15725         dd if=$(which date) of=$MOUNT/date bs=1k count=1
15726         chmod +x $MOUNT/date
15727
15728         $MOUNT/date > /dev/null
15729         ldd $MOUNT/date > /dev/null
15730         rm -f $MOUNT/date
15731 }
15732 run_test 227 "running truncated executable does not cause OOM"
15733
15734 # LU-1512 try to reuse idle OI blocks
15735 test_228a() {
15736         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15737         remote_mds_nodsh && skip "remote MDS with nodsh"
15738         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip_env "ldiskfs only test"
15739
15740         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
15741         local myDIR=$DIR/$tdir
15742
15743         mkdir -p $myDIR
15744         #define OBD_FAIL_SEQ_EXHAUST             0x1002
15745         $LCTL set_param fail_loc=0x80001002
15746         createmany -o $myDIR/t- 10000
15747         $LCTL set_param fail_loc=0
15748         # The guard is current the largest FID holder
15749         touch $myDIR/guard
15750         local SEQ=$($LFS path2fid $myDIR/guard | awk -F ':' '{print $1}' |
15751                     tr -d '[')
15752         local IDX=$(($SEQ % 64))
15753
15754         do_facet $SINGLEMDS sync
15755         # Make sure journal flushed.
15756         sleep 6
15757         local blk1=$(do_facet $SINGLEMDS \
15758                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
15759                      grep Blockcount | awk '{print $4}')
15760
15761         # Remove old files, some OI blocks will become idle.
15762         unlinkmany $myDIR/t- 10000
15763         # Create new files, idle OI blocks should be reused.
15764         createmany -o $myDIR/t- 2000
15765         do_facet $SINGLEMDS sync
15766         # Make sure journal flushed.
15767         sleep 6
15768         local blk2=$(do_facet $SINGLEMDS \
15769                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
15770                      grep Blockcount | awk '{print $4}')
15771
15772         [ $blk1 == $blk2 ] || error "old blk1=$blk1, new blk2=$blk2, unmatched!"
15773 }
15774 run_test 228a "try to reuse idle OI blocks"
15775
15776 test_228b() {
15777         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15778         remote_mds_nodsh && skip "remote MDS with nodsh"
15779         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip_env "ldiskfs only test"
15780
15781         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
15782         local myDIR=$DIR/$tdir
15783
15784         mkdir -p $myDIR
15785         #define OBD_FAIL_SEQ_EXHAUST             0x1002
15786         $LCTL set_param fail_loc=0x80001002
15787         createmany -o $myDIR/t- 10000
15788         $LCTL set_param fail_loc=0
15789         # The guard is current the largest FID holder
15790         touch $myDIR/guard
15791         local SEQ=$($LFS path2fid $myDIR/guard | awk -F ':' '{print $1}' |
15792                     tr -d '[')
15793         local IDX=$(($SEQ % 64))
15794
15795         do_facet $SINGLEMDS sync
15796         # Make sure journal flushed.
15797         sleep 6
15798         local blk1=$(do_facet $SINGLEMDS \
15799                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
15800                      grep Blockcount | awk '{print $4}')
15801
15802         # Remove old files, some OI blocks will become idle.
15803         unlinkmany $myDIR/t- 10000
15804
15805         # stop the MDT
15806         stop $SINGLEMDS || error "Fail to stop MDT."
15807         # remount the MDT
15808         start $SINGLEMDS $MDT_DEV $MDS_MOUNT_OPTS || error "Fail to start MDT."
15809
15810         df $MOUNT || error "Fail to df."
15811         # Create new files, idle OI blocks should be reused.
15812         createmany -o $myDIR/t- 2000
15813         do_facet $SINGLEMDS sync
15814         # Make sure journal flushed.
15815         sleep 6
15816         local blk2=$(do_facet $SINGLEMDS \
15817                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
15818                      grep Blockcount | awk '{print $4}')
15819
15820         [ $blk1 == $blk2 ] || error "old blk1=$blk1, new blk2=$blk2, unmatched!"
15821 }
15822 run_test 228b "idle OI blocks can be reused after MDT restart"
15823
15824 #LU-1881
15825 test_228c() {
15826         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15827         remote_mds_nodsh && skip "remote MDS with nodsh"
15828         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip_env "ldiskfs only test"
15829
15830         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
15831         local myDIR=$DIR/$tdir
15832
15833         mkdir -p $myDIR
15834         #define OBD_FAIL_SEQ_EXHAUST             0x1002
15835         $LCTL set_param fail_loc=0x80001002
15836         # 20000 files can guarantee there are index nodes in the OI file
15837         createmany -o $myDIR/t- 20000
15838         $LCTL set_param fail_loc=0
15839         # The guard is current the largest FID holder
15840         touch $myDIR/guard
15841         local SEQ=$($LFS path2fid $myDIR/guard | awk -F ':' '{print $1}' |
15842                     tr -d '[')
15843         local IDX=$(($SEQ % 64))
15844
15845         do_facet $SINGLEMDS sync
15846         # Make sure journal flushed.
15847         sleep 6
15848         local blk1=$(do_facet $SINGLEMDS \
15849                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
15850                      grep Blockcount | awk '{print $4}')
15851
15852         # Remove old files, some OI blocks will become idle.
15853         unlinkmany $myDIR/t- 20000
15854         rm -f $myDIR/guard
15855         # The OI file should become empty now
15856
15857         # Create new files, idle OI blocks should be reused.
15858         createmany -o $myDIR/t- 2000
15859         do_facet $SINGLEMDS sync
15860         # Make sure journal flushed.
15861         sleep 6
15862         local blk2=$(do_facet $SINGLEMDS \
15863                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
15864                      grep Blockcount | awk '{print $4}')
15865
15866         [ $blk1 == $blk2 ] || error "old blk1=$blk1, new blk2=$blk2, unmatched!"
15867 }
15868 run_test 228c "NOT shrink the last entry in OI index node to recycle idle leaf"
15869
15870 test_229() { # LU-2482, LU-3448
15871         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15872         [ $OSTCOUNT -lt 2 ] && skip_env "needs >= 2 OSTs"
15873         [ $MDS1_VERSION -lt $(version_code 2.4.53) ] &&
15874                 skip "No HSM $(lustre_build_version $SINGLEMDS) MDS < 2.4.53"
15875
15876         rm -f $DIR/$tfile
15877
15878         # Create a file with a released layout and stripe count 2.
15879         $MULTIOP $DIR/$tfile H2c ||
15880                 error "failed to create file with released layout"
15881
15882         $LFS getstripe -v $DIR/$tfile
15883
15884         local pattern=$($LFS getstripe -L $DIR/$tfile)
15885         [ X"$pattern" = X"released" ] || error "pattern error ($pattern)"
15886
15887         local stripe_count=$($LFS getstripe -c $DIR/$tfile) ||
15888                 error "getstripe"
15889         [ $stripe_count -eq 2 ] || error "stripe count not 2 ($stripe_count)"
15890         stat $DIR/$tfile || error "failed to stat released file"
15891
15892         chown $RUNAS_ID $DIR/$tfile ||
15893                 error "chown $RUNAS_ID $DIR/$tfile failed"
15894
15895         chgrp $RUNAS_ID $DIR/$tfile ||
15896                 error "chgrp $RUNAS_ID $DIR/$tfile failed"
15897
15898         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
15899         rm $DIR/$tfile || error "failed to remove released file"
15900 }
15901 run_test 229 "getstripe/stat/rm/attr changes work on released files"
15902
15903 test_230a() {
15904         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15905         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
15906         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
15907                 skip "Need MDS version at least 2.11.52"
15908
15909         local MDTIDX=1
15910
15911         test_mkdir $DIR/$tdir
15912         test_mkdir -i0 -c1 $DIR/$tdir/test_230_local
15913         local mdt_idx=$($LFS getstripe -m $DIR/$tdir/test_230_local)
15914         [ $mdt_idx -ne 0 ] &&
15915                 error "create local directory on wrong MDT $mdt_idx"
15916
15917         $LFS mkdir -i $MDTIDX $DIR/$tdir/test_230 ||
15918                         error "create remote directory failed"
15919         local mdt_idx=$($LFS getstripe -m $DIR/$tdir/test_230)
15920         [ $mdt_idx -ne $MDTIDX ] &&
15921                 error "create remote directory on wrong MDT $mdt_idx"
15922
15923         createmany -o $DIR/$tdir/test_230/t- 10 ||
15924                 error "create files on remote directory failed"
15925         mdt_idx=$($LFS getstripe -m $DIR/$tdir/test_230/t-0)
15926         [ $mdt_idx -ne $MDTIDX ] && error "create files on wrong MDT $mdt_idx"
15927         rm -r $DIR/$tdir || error "unlink remote directory failed"
15928 }
15929 run_test 230a "Create remote directory and files under the remote directory"
15930
15931 test_230b() {
15932         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15933         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
15934         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
15935                 skip "Need MDS version at least 2.11.52"
15936
15937         local MDTIDX=1
15938         local mdt_index
15939         local i
15940         local file
15941         local pid
15942         local stripe_count
15943         local migrate_dir=$DIR/$tdir/migrate_dir
15944         local other_dir=$DIR/$tdir/other_dir
15945
15946         test_mkdir $DIR/$tdir
15947         test_mkdir -i0 -c1 $migrate_dir
15948         test_mkdir -i0 -c1 $other_dir
15949         for ((i=0; i<10; i++)); do
15950                 mkdir -p $migrate_dir/dir_${i}
15951                 createmany -o $migrate_dir/dir_${i}/f 10 ||
15952                         error "create files under remote dir failed $i"
15953         done
15954
15955         cp /etc/passwd $migrate_dir/$tfile
15956         cp /etc/passwd $other_dir/$tfile
15957         chattr +SAD $migrate_dir
15958         chattr +SAD $migrate_dir/$tfile
15959
15960         local old_dir_flag=$(lsattr -a $migrate_dir | awk '/\/\.$/ {print $1}')
15961         local old_file_flag=$(lsattr $migrate_dir/$tfile | awk '{print $1}')
15962         local old_dir_mode=$(stat -c%f $migrate_dir)
15963         local old_file_mode=$(stat -c%f $migrate_dir/$tfile)
15964
15965         mkdir -p $migrate_dir/dir_default_stripe2
15966         $LFS setstripe -c 2 $migrate_dir/dir_default_stripe2
15967         $LFS setstripe -c 2 $migrate_dir/${tfile}_stripe2
15968
15969         mkdir -p $other_dir
15970         ln $migrate_dir/$tfile $other_dir/luna
15971         ln $migrate_dir/$tfile $migrate_dir/sofia
15972         ln $other_dir/$tfile $migrate_dir/david
15973         ln -s $migrate_dir/$tfile $other_dir/zachary
15974         ln -s $migrate_dir/$tfile $migrate_dir/${tfile}_ln
15975         ln -s $other_dir/$tfile $migrate_dir/${tfile}_ln_other
15976
15977         $LFS migrate -m $MDTIDX $migrate_dir ||
15978                 error "fails on migrating remote dir to MDT1"
15979
15980         echo "migratate to MDT1, then checking.."
15981         for ((i = 0; i < 10; i++)); do
15982                 for file in $(find $migrate_dir/dir_${i}); do
15983                         mdt_index=$($LFS getstripe -m $file)
15984                         [ $mdt_index == $MDTIDX ] ||
15985                                 error "$file is not on MDT${MDTIDX}"
15986                 done
15987         done
15988
15989         # the multiple link file should still in MDT0
15990         mdt_index=$($LFS getstripe -m $migrate_dir/$tfile)
15991         [ $mdt_index == 0 ] ||
15992                 error "$file is not on MDT${MDTIDX}"
15993
15994         local new_dir_flag=$(lsattr -a $migrate_dir | awk '/\/\.$/ {print $1}')
15995         [ "$old_dir_flag" = "$new_dir_flag" ] ||
15996                 error " expect $old_dir_flag get $new_dir_flag"
15997
15998         local new_file_flag=$(lsattr $migrate_dir/$tfile | awk '{print $1}')
15999         [ "$old_file_flag" = "$new_file_flag" ] ||
16000                 error " expect $old_file_flag get $new_file_flag"
16001
16002         local new_dir_mode=$(stat -c%f $migrate_dir)
16003         [ "$old_dir_mode" = "$new_dir_mode" ] ||
16004                 error "expect mode $old_dir_mode get $new_dir_mode"
16005
16006         local new_file_mode=$(stat -c%f $migrate_dir/$tfile)
16007         [ "$old_file_mode" = "$new_file_mode" ] ||
16008                 error "expect mode $old_file_mode get $new_file_mode"
16009
16010         diff /etc/passwd $migrate_dir/$tfile ||
16011                 error "$tfile different after migration"
16012
16013         diff /etc/passwd $other_dir/luna ||
16014                 error "luna different after migration"
16015
16016         diff /etc/passwd $migrate_dir/sofia ||
16017                 error "sofia different after migration"
16018
16019         diff /etc/passwd $migrate_dir/david ||
16020                 error "david different after migration"
16021
16022         diff /etc/passwd $other_dir/zachary ||
16023                 error "zachary different after migration"
16024
16025         diff /etc/passwd $migrate_dir/${tfile}_ln ||
16026                 error "${tfile}_ln different after migration"
16027
16028         diff /etc/passwd $migrate_dir/${tfile}_ln_other ||
16029                 error "${tfile}_ln_other different after migration"
16030
16031         stripe_count=$($LFS getstripe -c $migrate_dir/dir_default_stripe2)
16032         [ $stripe_count = 2 ] ||
16033                 error "dir strpe_count $d != 2 after migration."
16034
16035         stripe_count=$($LFS getstripe -c $migrate_dir/${tfile}_stripe2)
16036         [ $stripe_count = 2 ] ||
16037                 error "file strpe_count $d != 2 after migration."
16038
16039         #migrate back to MDT0
16040         MDTIDX=0
16041
16042         $LFS migrate -m $MDTIDX $migrate_dir ||
16043                 error "fails on migrating remote dir to MDT0"
16044
16045         echo "migrate back to MDT0, checking.."
16046         for file in $(find $migrate_dir); do
16047                 mdt_index=$($LFS getstripe -m $file)
16048                 [ $mdt_index == $MDTIDX ] ||
16049                         error "$file is not on MDT${MDTIDX}"
16050         done
16051
16052         local new_dir_flag=$(lsattr -a $migrate_dir | awk '/\/\.$/ {print $1}')
16053         [ "$old_dir_flag" = "$new_dir_flag" ] ||
16054                 error " expect $old_dir_flag get $new_dir_flag"
16055
16056         local new_file_flag=$(lsattr $migrate_dir/$tfile | awk '{print $1}')
16057         [ "$old_file_flag" = "$new_file_flag" ] ||
16058                 error " expect $old_file_flag get $new_file_flag"
16059
16060         local new_dir_mode=$(stat -c%f $migrate_dir)
16061         [ "$old_dir_mode" = "$new_dir_mode" ] ||
16062                 error "expect mode $old_dir_mode get $new_dir_mode"
16063
16064         local new_file_mode=$(stat -c%f $migrate_dir/$tfile)
16065         [ "$old_file_mode" = "$new_file_mode" ] ||
16066                 error "expect mode $old_file_mode get $new_file_mode"
16067
16068         diff /etc/passwd ${migrate_dir}/$tfile ||
16069                 error "$tfile different after migration"
16070
16071         diff /etc/passwd ${other_dir}/luna ||
16072                 error "luna different after migration"
16073
16074         diff /etc/passwd ${migrate_dir}/sofia ||
16075                 error "sofia different after migration"
16076
16077         diff /etc/passwd ${other_dir}/zachary ||
16078                 error "zachary different after migration"
16079
16080         diff /etc/passwd $migrate_dir/${tfile}_ln ||
16081                 error "${tfile}_ln different after migration"
16082
16083         diff /etc/passwd $migrate_dir/${tfile}_ln_other ||
16084                 error "${tfile}_ln_other different after migration"
16085
16086         stripe_count=$($LFS getstripe -c ${migrate_dir}/dir_default_stripe2)
16087         [ $stripe_count = 2 ] ||
16088                 error "dir strpe_count $d != 2 after migration."
16089
16090         stripe_count=$($LFS getstripe -c ${migrate_dir}/${tfile}_stripe2)
16091         [ $stripe_count = 2 ] ||
16092                 error "file strpe_count $d != 2 after migration."
16093
16094         rm -rf $DIR/$tdir || error "rm dir failed after migration"
16095 }
16096 run_test 230b "migrate directory"
16097
16098 test_230c() {
16099         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16100         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16101         remote_mds_nodsh && skip "remote MDS with nodsh"
16102         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16103                 skip "Need MDS version at least 2.11.52"
16104
16105         local MDTIDX=1
16106         local total=3
16107         local mdt_index
16108         local file
16109         local migrate_dir=$DIR/$tdir/migrate_dir
16110
16111         #If migrating directory fails in the middle, all entries of
16112         #the directory is still accessiable.
16113         test_mkdir $DIR/$tdir
16114         test_mkdir -i0 -c1 $migrate_dir
16115         test_mkdir -i1 -c1 $DIR/$tdir/remote_dir
16116         stat $migrate_dir
16117         createmany -o $migrate_dir/f $total ||
16118                 error "create files under ${migrate_dir} failed"
16119
16120         # fail after migrating top dir, and this will fail only once, so the
16121         # first sub file migration will fail (currently f3), others succeed.
16122         #OBD_FAIL_MIGRATE_ENTRIES       0x1801
16123         do_facet mds1 lctl set_param fail_loc=0x1801
16124         local t=$(ls $migrate_dir | wc -l)
16125         $LFS migrate --mdt-index $MDTIDX $migrate_dir &&
16126                 error "migrate should fail"
16127         local u=$(ls $migrate_dir | wc -l)
16128         [ "$u" == "$t" ] || error "$u != $t during migration"
16129
16130         # add new dir/file should succeed
16131         mkdir $migrate_dir/dir ||
16132                 error "mkdir failed under migrating directory"
16133         touch $migrate_dir/file ||
16134                 error "create file failed under migrating directory"
16135
16136         # add file with existing name should fail
16137         for file in $migrate_dir/f*; do
16138                 stat $file > /dev/null || error "stat $file failed"
16139                 $OPENFILE -f O_CREAT:O_EXCL $file &&
16140                         error "open(O_CREAT|O_EXCL) $file should fail"
16141                 $MULTIOP $file m && error "create $file should fail"
16142                 touch $DIR/$tdir/remote_dir/$tfile ||
16143                         error "touch $tfile failed"
16144                 ln $DIR/$tdir/remote_dir/$tfile $file &&
16145                         error "link $file should fail"
16146                 mdt_index=$($LFS getstripe -m $file)
16147                 if [ $mdt_index == 0 ]; then
16148                         # file failed to migrate is not allowed to rename to
16149                         mv $DIR/$tdir/remote_dir/$tfile $file &&
16150                                 error "rename to $file should fail"
16151                 else
16152                         mv $DIR/$tdir/remote_dir/$tfile $file ||
16153                                 error "rename to $file failed"
16154                 fi
16155                 echo hello >> $file || error "write $file failed"
16156         done
16157
16158         # resume migration with different options should fail
16159         $LFS migrate -m 0 $migrate_dir &&
16160                 error "migrate -m 0 $migrate_dir should fail"
16161
16162         $LFS migrate -m $MDTIDX -c 2 $migrate_dir &&
16163                 error "migrate -c 2 $migrate_dir should fail"
16164
16165         # resume migration should succeed
16166         $LFS migrate -m $MDTIDX $migrate_dir ||
16167                 error "migrate $migrate_dir failed"
16168
16169         echo "Finish migration, then checking.."
16170         for file in $(find $migrate_dir); do
16171                 mdt_index=$($LFS getstripe -m $file)
16172                 [ $mdt_index == $MDTIDX ] ||
16173                         error "$file is not on MDT${MDTIDX}"
16174         done
16175
16176         rm -rf $DIR/$tdir || error "rm dir failed after migration"
16177 }
16178 run_test 230c "check directory accessiblity if migration failed"
16179
16180 test_230d() {
16181         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16182         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16183         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16184                 skip "Need MDS version at least 2.11.52"
16185         # LU-11235
16186         [ "$mds1_FSTYPE" == "zfs" ] && skip "skip ZFS backend"
16187
16188         local migrate_dir=$DIR/$tdir/migrate_dir
16189         local old_index
16190         local new_index
16191         local old_count
16192         local new_count
16193         local new_hash
16194         local mdt_index
16195         local i
16196         local j
16197
16198         old_index=$((RANDOM % MDSCOUNT))
16199         old_count=$((MDSCOUNT - old_index))
16200         new_index=$((RANDOM % MDSCOUNT))
16201         new_count=$((MDSCOUNT - new_index))
16202         new_hash="all_char"
16203
16204         [ $old_count -gt 1 ] && old_count=$((old_count - RANDOM % old_count))
16205         [ $new_count -gt 1 ] && new_count=$((new_count - RANDOM % new_count))
16206
16207         test_mkdir $DIR/$tdir
16208         test_mkdir -i $old_index -c $old_count $migrate_dir
16209
16210         for ((i=0; i<100; i++)); do
16211                 test_mkdir -i0 -c1 $migrate_dir/dir_${i}
16212                 createmany -o $migrate_dir/dir_${i}/f 100 ||
16213                         error "create files under remote dir failed $i"
16214         done
16215
16216         echo -n "Migrate from MDT$old_index "
16217         [ $old_count -gt 1 ] && echo -n "... MDT$((old_index + old_count - 1)) "
16218         echo -n "to MDT$new_index"
16219         [ $new_count -gt 1 ] && echo -n " ... MDT$((new_index + new_count - 1))"
16220         echo
16221
16222         echo "$LFS migrate -m$new_index -c$new_count -H $new_hash $migrate_dir"
16223         $LFS migrate -m $new_index -c $new_count -H $new_hash $migrate_dir ||
16224                 error "migrate remote dir error"
16225
16226         echo "Finish migration, then checking.."
16227         for file in $(find $migrate_dir); do
16228                 mdt_index=$($LFS getstripe -m $file)
16229                 if [ $mdt_index -lt $new_index ] ||
16230                    [ $mdt_index -gt $((new_index + new_count - 1)) ]; then
16231                         error "$file is on MDT$mdt_index"
16232                 fi
16233         done
16234
16235         rm -rf $DIR/$tdir || error "rm dir failed after migration"
16236 }
16237 run_test 230d "check migrate big directory"
16238
16239 test_230e() {
16240         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16241         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16242         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16243                 skip "Need MDS version at least 2.11.52"
16244
16245         local i
16246         local j
16247         local a_fid
16248         local b_fid
16249
16250         mkdir -p $DIR/$tdir
16251         mkdir $DIR/$tdir/migrate_dir
16252         mkdir $DIR/$tdir/other_dir
16253         touch $DIR/$tdir/migrate_dir/a
16254         ln $DIR/$tdir/migrate_dir/a $DIR/$tdir/other_dir/b
16255         ls $DIR/$tdir/other_dir
16256
16257         $LFS migrate -m 1 $DIR/$tdir/migrate_dir ||
16258                 error "migrate dir fails"
16259
16260         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir)
16261         [ $mdt_index == 1 ] || error "migrate_dir is not on MDT1"
16262
16263         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir/a)
16264         [ $mdt_index == 0 ] || error "a is not on MDT0"
16265
16266         $LFS migrate -m 1 $DIR/$tdir/other_dir ||
16267                 error "migrate dir fails"
16268
16269         mdt_index=$($LFS getstripe -m $DIR/$tdir/other_dir)
16270         [ $mdt_index == 1 ] || error "other_dir is not on MDT1"
16271
16272         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir/a)
16273         [ $mdt_index == 1 ] || error "a is not on MDT1"
16274
16275         mdt_index=$($LFS getstripe -m $DIR/$tdir/other_dir/b)
16276         [ $mdt_index == 1 ] || error "b is not on MDT1"
16277
16278         a_fid=$($LFS path2fid $DIR/$tdir/migrate_dir/a)
16279         b_fid=$($LFS path2fid $DIR/$tdir/other_dir/b)
16280
16281         [ "$a_fid" = "$b_fid" ] || error "different fid after migration"
16282
16283         rm -rf $DIR/$tdir || error "rm dir failed after migration"
16284 }
16285 run_test 230e "migrate mulitple local link files"
16286
16287 test_230f() {
16288         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16289         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16290         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16291                 skip "Need MDS version at least 2.11.52"
16292
16293         local a_fid
16294         local ln_fid
16295
16296         mkdir -p $DIR/$tdir
16297         mkdir $DIR/$tdir/migrate_dir
16298         $LFS mkdir -i1 $DIR/$tdir/other_dir
16299         touch $DIR/$tdir/migrate_dir/a
16300         ln $DIR/$tdir/migrate_dir/a $DIR/$tdir/other_dir/ln1
16301         ln $DIR/$tdir/migrate_dir/a $DIR/$tdir/other_dir/ln2
16302         ls $DIR/$tdir/other_dir
16303
16304         # a should be migrated to MDT1, since no other links on MDT0
16305         $LFS migrate -m 1 $DIR/$tdir/migrate_dir ||
16306                 error "#1 migrate dir fails"
16307         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir)
16308         [ $mdt_index == 1 ] || error "migrate_dir is not on MDT1"
16309         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir/a)
16310         [ $mdt_index == 1 ] || error "a is not on MDT1"
16311
16312         # a should stay on MDT1, because it is a mulitple link file
16313         $LFS migrate -m 0 $DIR/$tdir/migrate_dir ||
16314                 error "#2 migrate dir fails"
16315         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir/a)
16316         [ $mdt_index == 1 ] || error "a is not on MDT1"
16317
16318         $LFS migrate -m 1 $DIR/$tdir/migrate_dir ||
16319                 error "#3 migrate dir fails"
16320
16321         a_fid=$($LFS path2fid $DIR/$tdir/migrate_dir/a)
16322         ln_fid=$($LFS path2fid $DIR/$tdir/other_dir/ln1)
16323         [ "$a_fid" = "$ln_fid" ] || error "different fid after migrate to MDT1"
16324
16325         rm -rf $DIR/$tdir/other_dir/ln1 || error "unlink ln1 fails"
16326         rm -rf $DIR/$tdir/other_dir/ln2 || error "unlink ln2 fails"
16327
16328         # a should be migrated to MDT0, since no other links on MDT1
16329         $LFS migrate -m 0 $DIR/$tdir/migrate_dir ||
16330                 error "#4 migrate dir fails"
16331         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir/a)
16332         [ $mdt_index == 0 ] || error "a is not on MDT0"
16333
16334         rm -rf $DIR/$tdir || error "rm dir failed after migration"
16335 }
16336 run_test 230f "migrate mulitple remote link files"
16337
16338 test_230g() {
16339         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16340         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16341         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16342                 skip "Need MDS version at least 2.11.52"
16343
16344         mkdir -p $DIR/$tdir/migrate_dir
16345
16346         $LFS migrate -m 1000 $DIR/$tdir/migrate_dir &&
16347                 error "migrating dir to non-exist MDT succeeds"
16348         true
16349 }
16350 run_test 230g "migrate dir to non-exist MDT"
16351
16352 test_230h() {
16353         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16354         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16355         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16356                 skip "Need MDS version at least 2.11.52"
16357
16358         local mdt_index
16359
16360         mkdir -p $DIR/$tdir/migrate_dir
16361
16362         $LFS migrate -m1 $DIR &&
16363                 error "migrating mountpoint1 should fail"
16364
16365         $LFS migrate -m1 $DIR/$tdir/.. &&
16366                 error "migrating mountpoint2 should fail"
16367
16368         # same as mv
16369         $LFS migrate -m1 $DIR/$tdir/migrate_dir/.. &&
16370                 error "migrating $tdir/migrate_dir/.. should fail"
16371
16372         true
16373 }
16374 run_test 230h "migrate .. and root"
16375
16376 test_230i() {
16377         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16378         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16379         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16380                 skip "Need MDS version at least 2.11.52"
16381
16382         mkdir -p $DIR/$tdir/migrate_dir
16383
16384         $LFS migrate -m 1 $DIR/$tdir/migrate_dir/ ||
16385                 error "migration fails with a tailing slash"
16386
16387         $LFS migrate -m 0 $DIR/$tdir/migrate_dir// ||
16388                 error "migration fails with two tailing slashes"
16389 }
16390 run_test 230i "lfs migrate -m tolerates trailing slashes"
16391
16392 test_230j() {
16393         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
16394         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16395                 skip "Need MDS version at least 2.11.52"
16396
16397         $LFS mkdir -m 0 -c 1 $DIR/$tdir || error "mkdir $tdir failed"
16398         $LFS setstripe -E 1M -L mdt $DIR/$tdir/$tfile ||
16399                 error "create $tfile failed"
16400         cat /etc/passwd > $DIR/$tdir/$tfile
16401
16402         $LFS migrate -m 1 $DIR/$tdir
16403
16404         cmp /etc/passwd $DIR/$tdir/$tfile ||
16405                 error "DoM file mismatch after migration"
16406 }
16407 run_test 230j "DoM file data not changed after dir migration"
16408
16409 test_230k() {
16410         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs"
16411         [ $MDS1_VERSION -lt $(version_code 2.11.56) ] &&
16412                 skip "Need MDS version at least 2.11.56"
16413
16414         local total=20
16415         local files_on_starting_mdt=0
16416
16417         $LFS mkdir -i -1 -c 2 $DIR/$tdir || error "mkdir failed"
16418         $LFS getdirstripe $DIR/$tdir
16419         for i in $(seq $total); do
16420                 echo $((i*i - i)) > $DIR/$tdir/$tfile.$i || error "write failed"
16421                 [[ $($LFS getstripe -m $DIR/$tdir/$tfile.$i) -eq 0 ]] &&
16422                         files_on_starting_mdt=$((files_on_starting_mdt + 1))
16423         done
16424
16425         echo "$files_on_starting_mdt files on MDT0"
16426
16427         $LFS migrate -m 1,3 $DIR/$tdir || error "migrate -m 1,3 failed"
16428         $LFS getdirstripe $DIR/$tdir
16429
16430         files_on_starting_mdt=0
16431         for i in $(seq $total); do
16432                 $(echo $((i*i - i)) | cmp $DIR/$tdir/$tfile.$i -) ||
16433                         error "file $tfile.$i mismatch after migration"
16434                 [[ $($LFS getstripe -m $DIR/$tdir/$tfile.$i) -eq 1 ]] &&
16435                         files_on_starting_mdt=$((files_on_starting_mdt + 1))
16436         done
16437
16438         echo "$files_on_starting_mdt files on MDT1 after migration"
16439         [[ $files_on_starting_mdt -eq $total ]] && error "all files on MDT1"
16440
16441         $LFS migrate -m 0 -c 2 $DIR/$tdir || error "migrate -m 0 -c 2 failed"
16442         $LFS getdirstripe $DIR/$tdir
16443
16444         files_on_starting_mdt=0
16445         for i in $(seq $total); do
16446                 $(echo $((i*i - i)) | cmp $DIR/$tdir/$tfile.$i -) ||
16447                         error "file $tfile.$i mismatch after 2nd migration"
16448                 [[ $($LFS getstripe -m $DIR/$tdir/$tfile.$i) -eq 0 ]] &&
16449                         files_on_starting_mdt=$((files_on_starting_mdt + 1))
16450         done
16451
16452         echo "$files_on_starting_mdt files on MDT0 after 2nd migration"
16453         [[ $files_on_starting_mdt -eq $total ]] && error "all files on MDT0"
16454
16455         true
16456 }
16457 run_test 230k "file data not changed after dir migration"
16458
16459 test_230l() {
16460         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
16461         [ $MDS1_VERSION -lt $(version_code 2.11.56) ] &&
16462                 skip "Need MDS version at least 2.11.56"
16463
16464         $LFS mkdir -i 0 -c 1 $DIR/$tdir || error "mkdir failed"
16465         createmany -o $DIR/$tdir/f___________________________________ 1000 ||
16466                 error "create files under remote dir failed $i"
16467         $LFS migrate -m 1 $DIR/$tdir || error "migrate failed"
16468 }
16469 run_test 230l "readdir between MDTs won't crash"
16470
16471 test_231a()
16472 {
16473         # For simplicity this test assumes that max_pages_per_rpc
16474         # is the same across all OSCs
16475         local max_pages=$($LCTL get_param -n osc.*.max_pages_per_rpc | head -n1)
16476         local bulk_size=$((max_pages * PAGE_SIZE))
16477         local brw_size=$(do_facet ost1 $LCTL get_param -n obdfilter.*.brw_size |
16478                                        head -n 1)
16479
16480         mkdir -p $DIR/$tdir
16481         $LFS setstripe -S ${brw_size}M $DIR/$tdir ||
16482                 error "failed to set stripe with -S ${brw_size}M option"
16483
16484         # clear the OSC stats
16485         $LCTL set_param osc.*.stats=0 &>/dev/null
16486         stop_writeback
16487
16488         # Client writes $bulk_size - there must be 1 rpc for $max_pages.
16489         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=$bulk_size count=1 \
16490                 oflag=direct &>/dev/null || error "dd failed"
16491
16492         sync; sleep 1; sync # just to be safe
16493         local nrpcs=$($LCTL get_param osc.*.stats |awk '/ost_write/ {print $2}')
16494         if [ x$nrpcs != "x1" ]; then
16495                 $LCTL get_param osc.*.stats
16496                 error "found $nrpcs ost_write RPCs, not 1 as expected"
16497         fi
16498
16499         start_writeback
16500         # Drop the OSC cache, otherwise we will read from it
16501         cancel_lru_locks osc
16502
16503         # clear the OSC stats
16504         $LCTL set_param osc.*.stats=0 &>/dev/null
16505
16506         # Client reads $bulk_size.
16507         dd if=$DIR/$tdir/$tfile of=/dev/null bs=$bulk_size count=1 \
16508                 iflag=direct &>/dev/null || error "dd failed"
16509
16510         nrpcs=$($LCTL get_param osc.*.stats | awk '/ost_read/ { print $2 }')
16511         if [ x$nrpcs != "x1" ]; then
16512                 $LCTL get_param osc.*.stats
16513                 error "found $nrpcs ost_read RPCs, not 1 as expected"
16514         fi
16515 }
16516 run_test 231a "checking that reading/writing of BRW RPC size results in one RPC"
16517
16518 test_231b() {
16519         mkdir -p $DIR/$tdir
16520         local i
16521         for i in {0..1023}; do
16522                 dd if=/dev/zero of=$DIR/$tdir/$tfile conv=notrunc \
16523                         seek=$((2 * i)) bs=4096 count=1 &>/dev/null ||
16524                         error "dd of=$DIR/$tdir/$tfile seek=$((2 * i)) failed"
16525         done
16526         sync
16527 }
16528 run_test 231b "must not assert on fully utilized OST request buffer"
16529
16530 test_232a() {
16531         mkdir -p $DIR/$tdir
16532         $LFS setstripe -c1 -i0 $DIR/$tdir/$tfile
16533
16534         #define OBD_FAIL_LDLM_OST_LVB            0x31c
16535         do_facet ost1 $LCTL set_param fail_loc=0x31c
16536
16537         # ignore dd failure
16538         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=1 || true
16539
16540         do_facet ost1 $LCTL set_param fail_loc=0
16541         umount_client $MOUNT || error "umount failed"
16542         mount_client $MOUNT || error "mount failed"
16543         stop ost1 || error "cannot stop ost1"
16544         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS || error "cannot start ost1"
16545 }
16546 run_test 232a "failed lock should not block umount"
16547
16548 test_232b() {
16549         [ $MDS1_VERSION -ge $(version_code 2.10.58) ] ||
16550                 skip "Need MDS version at least 2.10.58"
16551
16552         mkdir -p $DIR/$tdir
16553         $LFS setstripe -c1 -i0 $DIR/$tdir/$tfile
16554         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=1
16555         sync
16556         cancel_lru_locks osc
16557
16558         #define OBD_FAIL_LDLM_OST_LVB            0x31c
16559         do_facet ost1 $LCTL set_param fail_loc=0x31c
16560
16561         # ignore failure
16562         $LFS data_version $DIR/$tdir/$tfile || true
16563
16564         do_facet ost1 $LCTL set_param fail_loc=0
16565         umount_client $MOUNT || error "umount failed"
16566         mount_client $MOUNT || error "mount failed"
16567         stop ost1 || error "cannot stop ost1"
16568         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS || error "cannot start ost1"
16569 }
16570 run_test 232b "failed data version lock should not block umount"
16571
16572 test_233a() {
16573         [ $MDS1_VERSION -ge $(version_code 2.3.64) ] ||
16574                 skip "Need MDS version at least 2.3.64"
16575         [ -n "$FILESET" ] && skip_env "SKIP due to FILESET set"
16576
16577         local fid=$($LFS path2fid $MOUNT)
16578
16579         stat $MOUNT/.lustre/fid/$fid > /dev/null ||
16580                 error "cannot access $MOUNT using its FID '$fid'"
16581 }
16582 run_test 233a "checking that OBF of the FS root succeeds"
16583
16584 test_233b() {
16585         [ $MDS1_VERSION -ge $(version_code 2.5.90) ] ||
16586                 skip "Need MDS version at least 2.5.90"
16587         [ -n "$FILESET" ] && skip_env "SKIP due to FILESET set"
16588
16589         local fid=$($LFS path2fid $MOUNT/.lustre)
16590
16591         stat $MOUNT/.lustre/fid/$fid > /dev/null ||
16592                 error "cannot access $MOUNT/.lustre using its FID '$fid'"
16593
16594         fid=$($LFS path2fid $MOUNT/.lustre/fid)
16595         stat $MOUNT/.lustre/fid/$fid > /dev/null ||
16596                 error "cannot access $MOUNT/.lustre/fid using its FID '$fid'"
16597 }
16598 run_test 233b "checking that OBF of the FS .lustre succeeds"
16599
16600 test_234() {
16601         local p="$TMP/sanityN-$TESTNAME.parameters"
16602         save_lustre_params client "llite.*.xattr_cache" > $p
16603         lctl set_param llite.*.xattr_cache 1 ||
16604                 skip_env "xattr cache is not supported"
16605
16606         mkdir -p $DIR/$tdir || error "mkdir failed"
16607         touch $DIR/$tdir/$tfile || error "touch failed"
16608         # OBD_FAIL_LLITE_XATTR_ENOMEM
16609         $LCTL set_param fail_loc=0x1405
16610         getfattr -n user.attr $DIR/$tdir/$tfile &&
16611                 error "getfattr should have failed with ENOMEM"
16612         $LCTL set_param fail_loc=0x0
16613         rm -rf $DIR/$tdir
16614
16615         restore_lustre_params < $p
16616         rm -f $p
16617 }
16618 run_test 234 "xattr cache should not crash on ENOMEM"
16619
16620 test_235() {
16621         [ $MDS1_VERSION -lt $(version_code 2.4.52) ] &&
16622                 skip "Need MDS version at least 2.4.52"
16623
16624         flock_deadlock $DIR/$tfile
16625         local RC=$?
16626         case $RC in
16627                 0)
16628                 ;;
16629                 124) error "process hangs on a deadlock"
16630                 ;;
16631                 *) error "error executing flock_deadlock $DIR/$tfile"
16632                 ;;
16633         esac
16634 }
16635 run_test 235 "LU-1715: flock deadlock detection does not work properly"
16636
16637 #LU-2935
16638 test_236() {
16639         check_swap_layouts_support
16640
16641         local ref1=/etc/passwd
16642         local ref2=/etc/group
16643         local file1=$DIR/$tdir/f1
16644         local file2=$DIR/$tdir/f2
16645
16646         test_mkdir -c1 $DIR/$tdir
16647         $LFS setstripe -c 1 $file1 || error "cannot setstripe on '$file1': rc = $?"
16648         cp $ref1 $file1 || error "cp $ref1 $file1 failed: rc = $?"
16649         $LFS setstripe -c 2 $file2 || error "cannot setstripe on '$file2': rc = $?"
16650         cp $ref2 $file2 || error "cp $ref2 $file2 failed: rc = $?"
16651         local fd=$(free_fd)
16652         local cmd="exec $fd<>$file2"
16653         eval $cmd
16654         rm $file2
16655         $LFS swap_layouts $file1 /proc/self/fd/${fd} ||
16656                 error "cannot swap layouts of '$file1' and /proc/self/fd/${fd}"
16657         cmd="exec $fd>&-"
16658         eval $cmd
16659         cmp $ref2 $file1 || error "content compare failed ($ref2 != $file1)"
16660
16661         #cleanup
16662         rm -rf $DIR/$tdir
16663 }
16664 run_test 236 "Layout swap on open unlinked file"
16665
16666 # LU-4659 linkea consistency
16667 test_238() {
16668         [[ $MDS1_VERSION -gt $(version_code 2.5.57) ]] ||
16669                 [[ $MDS1_VERSION -gt $(version_code 2.5.1) &&
16670                    $MDS1_VERSION -lt $(version_code 2.5.50) ]] ||
16671                 skip "Need MDS version at least 2.5.58 or 2.5.2+"
16672
16673         touch $DIR/$tfile
16674         ln $DIR/$tfile $DIR/$tfile.lnk
16675         touch $DIR/$tfile.new
16676         mv $DIR/$tfile.new $DIR/$tfile
16677         local fid1=$($LFS path2fid $DIR/$tfile)
16678         local fid2=$($LFS path2fid $DIR/$tfile.lnk)
16679         local path1=$($LFS fid2path $FSNAME "$fid1")
16680         [ $tfile == $path1 ] || error "linkea inconsistent: $tfile $fid1 $path1"
16681         local path2=$($LFS fid2path $FSNAME "$fid2")
16682         [ $tfile.lnk == $path2 ] ||
16683                 error "linkea inconsistent: $tfile.lnk $fid2 $path2!"
16684         rm -f $DIR/$tfile*
16685 }
16686 run_test 238 "Verify linkea consistency"
16687
16688 test_239A() { # was test_239
16689         [ $MDS1_VERSION -lt $(version_code 2.5.60) ] &&
16690                 skip "Need MDS version at least 2.5.60"
16691
16692         local list=$(comma_list $(mdts_nodes))
16693
16694         mkdir -p $DIR/$tdir
16695         createmany -o $DIR/$tdir/f- 5000
16696         unlinkmany $DIR/$tdir/f- 5000
16697         [ $MDS1_VERSION -gt $(version_code 2.10.4) ] &&
16698                 do_nodes $list "lctl set_param -n osp.*.force_sync=1"
16699         changes=$(do_nodes $list "lctl get_param -n osp.*MDT*.sync_changes \
16700                         osp.*MDT*.sync_in_flight" | calc_sum)
16701         [ "$changes" -eq 0 ] || error "$changes not synced"
16702 }
16703 run_test 239A "osp_sync test"
16704
16705 test_239a() { #LU-5297
16706         remote_mds_nodsh && skip "remote MDS with nodsh"
16707
16708         touch $DIR/$tfile
16709         #define OBD_FAIL_OSP_CHECK_INVALID_REC     0x2100
16710         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x2100
16711         chgrp $RUNAS_GID $DIR/$tfile
16712         wait_delete_completed
16713 }
16714 run_test 239a "process invalid osp sync record correctly"
16715
16716 test_239b() { #LU-5297
16717         remote_mds_nodsh && skip "remote MDS with nodsh"
16718
16719         touch $DIR/$tfile1
16720         #define OBD_FAIL_OSP_CHECK_ENOMEM     0x2101
16721         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x2101
16722         chgrp $RUNAS_GID $DIR/$tfile1
16723         wait_delete_completed
16724         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
16725         touch $DIR/$tfile2
16726         chgrp $RUNAS_GID $DIR/$tfile2
16727         wait_delete_completed
16728 }
16729 run_test 239b "process osp sync record with ENOMEM error correctly"
16730
16731 test_240() {
16732         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16733         remote_mds_nodsh && skip "remote MDS with nodsh"
16734
16735         mkdir -p $DIR/$tdir
16736
16737         $LFS mkdir -i 0 $DIR/$tdir/d0 ||
16738                 error "failed to mkdir $DIR/$tdir/d0 on MDT0"
16739         $LFS mkdir -i 1 $DIR/$tdir/d0/d1 ||
16740                 error "failed to mkdir $DIR/$tdir/d0/d1 on MDT1"
16741
16742         umount_client $MOUNT || error "umount failed"
16743         #define OBD_FAIL_TGT_DELAY_CONDITIONAL   0x713
16744         do_facet mds2 lctl set_param fail_loc=0x713 fail_val=1
16745         mount_client $MOUNT || error "failed to mount client"
16746
16747         echo "stat $DIR/$tdir/d0/d1, should not fail/ASSERT"
16748         stat $DIR/$tdir/d0/d1 || error "fail to stat $DIR/$tdir/d0/d1"
16749 }
16750 run_test 240 "race between ldlm enqueue and the connection RPC (no ASSERT)"
16751
16752 test_241_bio() {
16753         local count=$1
16754         local bsize=$2
16755
16756         for LOOP in $(seq $count); do
16757                 dd if=$DIR/$tfile of=/dev/null bs=$bsize count=1 2>/dev/null
16758                 cancel_lru_locks $OSC || true
16759         done
16760 }
16761
16762 test_241_dio() {
16763         local count=$1
16764         local bsize=$2
16765
16766         for LOOP in $(seq $1); do
16767                 dd if=$DIR/$tfile of=/dev/null bs=$bsize count=1 iflag=direct \
16768                         2>/dev/null
16769         done
16770 }
16771
16772 test_241a() { # was test_241
16773         local bsize=$PAGE_SIZE
16774
16775         (( bsize < 40960 )) && bsize=40960
16776         dd if=/dev/zero of=$DIR/$tfile count=1 bs=$bsize
16777         ls -la $DIR/$tfile
16778         cancel_lru_locks $OSC
16779         test_241_bio 1000 $bsize &
16780         PID=$!
16781         test_241_dio 1000 $bsize
16782         wait $PID
16783 }
16784 run_test 241a "bio vs dio"
16785
16786 test_241b() {
16787         local bsize=$PAGE_SIZE
16788
16789         (( bsize < 40960 )) && bsize=40960
16790         dd if=/dev/zero of=$DIR/$tfile count=1 bs=$bsize
16791         ls -la $DIR/$tfile
16792         test_241_dio 1000 $bsize &
16793         PID=$!
16794         test_241_dio 1000 $bsize
16795         wait $PID
16796 }
16797 run_test 241b "dio vs dio"
16798
16799 test_242() {
16800         remote_mds_nodsh && skip "remote MDS with nodsh"
16801
16802         mkdir -p $DIR/$tdir
16803         touch $DIR/$tdir/$tfile
16804
16805         #define OBD_FAIL_MDS_READPAGE_PACK      0x105
16806         do_facet mds1 lctl set_param fail_loc=0x105
16807         /bin/ls $DIR/$tdir && error "ls $DIR/$tdir should fail"
16808
16809         do_facet mds1 lctl set_param fail_loc=0
16810         /bin/ls $DIR/$tdir || error "ls $DIR/$tdir failed"
16811 }
16812 run_test 242 "mdt_readpage failure should not cause directory unreadable"
16813
16814 test_243()
16815 {
16816         test_mkdir $DIR/$tdir
16817         group_lock_test -d $DIR/$tdir || error "A group lock test failed"
16818 }
16819 run_test 243 "various group lock tests"
16820
16821 test_244()
16822 {
16823         test_mkdir $DIR/$tdir
16824         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=35
16825         sendfile_grouplock $DIR/$tdir/$tfile || \
16826                 error "sendfile+grouplock failed"
16827         rm -rf $DIR/$tdir
16828 }
16829 run_test 244 "sendfile with group lock tests"
16830
16831 test_245() {
16832         local flagname="multi_mod_rpcs"
16833         local connect_data_name="max_mod_rpcs"
16834         local out
16835
16836         # check if multiple modify RPCs flag is set
16837         out=$($LCTL get_param mdc.$FSNAME-MDT0000-*.import |
16838                 grep "connect_flags:")
16839         echo "$out"
16840
16841         echo "$out" | grep -qw $flagname
16842         if [ $? -ne 0 ]; then
16843                 echo "connect flag $flagname is not set"
16844                 return
16845         fi
16846
16847         # check if multiple modify RPCs data is set
16848         out=$($LCTL get_param mdc.$FSNAME-MDT0000-*.import)
16849         echo "$out"
16850
16851         echo "$out" | grep -qw $connect_data_name ||
16852                 error "import should have connect data $connect_data_name"
16853 }
16854 run_test 245 "check mdc connection flag/data: multiple modify RPCs"
16855
16856 test_246() { # LU-7371
16857         remote_ost_nodsh && skip "remote OST with nodsh"
16858         [ $OST1_VERSION -lt $(version_code 2.7.62) ] &&
16859                 skip "Need OST version >= 2.7.62"
16860
16861         do_facet ost1 $LCTL set_param fail_val=4095
16862 #define OBD_FAIL_OST_READ_SIZE          0x234
16863         do_facet ost1 $LCTL set_param fail_loc=0x234
16864         $LFS setstripe $DIR/$tfile -i 0 -c 1
16865         dd if=/dev/zero of=$DIR/$tfile bs=4095 count=1 > /dev/null 2>&1
16866         cancel_lru_locks $FSNAME-OST0000
16867         dd if=$DIR/$tfile of=/dev/null bs=1048576 || error "Read failed"
16868 }
16869 run_test 246 "Read file of size 4095 should return right length"
16870
16871 cleanup_247() {
16872         local submount=$1
16873
16874         trap 0
16875         umount_client $submount
16876         rmdir $submount
16877 }
16878
16879 test_247a() {
16880         lctl get_param -n mdc.$FSNAME-MDT0000*.import |
16881                 grep -q subtree ||
16882                 skip_env "Fileset feature is not supported"
16883
16884         local submount=${MOUNT}_$tdir
16885
16886         mkdir $MOUNT/$tdir
16887         mkdir -p $submount || error "mkdir $submount failed"
16888         FILESET="$FILESET/$tdir" mount_client $submount ||
16889                 error "mount $submount failed"
16890         trap "cleanup_247 $submount" EXIT
16891         echo foo > $submount/$tfile || error "write $submount/$tfile failed"
16892         [ $(cat $MOUNT/$tdir/$tfile) = "foo" ] ||
16893                 error "read $MOUNT/$tdir/$tfile failed"
16894         cleanup_247 $submount
16895 }
16896 run_test 247a "mount subdir as fileset"
16897
16898 test_247b() {
16899         lctl get_param -n mdc.$FSNAME-MDT0000*.import | grep -q subtree ||
16900                 skip_env "Fileset feature is not supported"
16901
16902         local submount=${MOUNT}_$tdir
16903
16904         rm -rf $MOUNT/$tdir
16905         mkdir -p $submount || error "mkdir $submount failed"
16906         SKIP_FILESET=1
16907         FILESET="$FILESET/$tdir" mount_client $submount &&
16908                 error "mount $submount should fail"
16909         rmdir $submount
16910 }
16911 run_test 247b "mount subdir that dose not exist"
16912
16913 test_247c() {
16914         lctl get_param -n mdc.$FSNAME-MDT0000*.import | grep -q subtree ||
16915                 skip_env "Fileset feature is not supported"
16916
16917         local submount=${MOUNT}_$tdir
16918
16919         mkdir -p $MOUNT/$tdir/dir1
16920         mkdir -p $submount || error "mkdir $submount failed"
16921         trap "cleanup_247 $submount" EXIT
16922         FILESET="$FILESET/$tdir" mount_client $submount ||
16923                 error "mount $submount failed"
16924         local fid=$($LFS path2fid $MOUNT/)
16925         $LFS fid2path $submount $fid && error "fid2path should fail"
16926         cleanup_247 $submount
16927 }
16928 run_test 247c "running fid2path outside root"
16929
16930 test_247d() {
16931         lctl get_param -n mdc.$FSNAME-MDT0000*.import | grep -q subtree ||
16932                 skip "Fileset feature is not supported"
16933
16934         local submount=${MOUNT}_$tdir
16935
16936         mkdir -p $MOUNT/$tdir/dir1
16937         mkdir -p $submount || error "mkdir $submount failed"
16938         FILESET="$FILESET/$tdir" mount_client $submount ||
16939                 error "mount $submount failed"
16940         trap "cleanup_247 $submount" EXIT
16941         local fid=$($LFS path2fid $submount/dir1)
16942         $LFS fid2path $submount $fid || error "fid2path should succeed"
16943         cleanup_247 $submount
16944 }
16945 run_test 247d "running fid2path inside root"
16946
16947 # LU-8037
16948 test_247e() {
16949         lctl get_param -n mdc.$FSNAME-MDT0000*.import |
16950                 grep -q subtree ||
16951                 skip "Fileset feature is not supported"
16952
16953         local submount=${MOUNT}_$tdir
16954
16955         mkdir $MOUNT/$tdir
16956         mkdir -p $submount || error "mkdir $submount failed"
16957         FILESET="$FILESET/.." mount_client $submount &&
16958                 error "mount $submount should fail"
16959         rmdir $submount
16960 }
16961 run_test 247e "mount .. as fileset"
16962
16963 test_248() {
16964         local fast_read_sav=$($LCTL get_param -n llite.*.fast_read 2>/dev/null)
16965         [ -z "$fast_read_sav" ] && skip "no fast read support"
16966
16967         # create a large file for fast read verification
16968         dd if=/dev/zero of=$DIR/$tfile bs=1M count=128 > /dev/null 2>&1
16969
16970         # make sure the file is created correctly
16971         $CHECKSTAT -s $((128*1024*1024)) $DIR/$tfile ||
16972                 { rm -f $DIR/$tfile; skip "file creation error"; }
16973
16974         echo "Test 1: verify that fast read is 4 times faster on cache read"
16975
16976         # small read with fast read enabled
16977         $LCTL set_param -n llite.*.fast_read=1
16978         local t_fast=$(dd if=$DIR/$tfile of=/dev/null bs=4k 2>&1 |
16979                 egrep -o '([[:digit:]\.\,e-]+) s' | cut -d's' -f1 |
16980                 sed -e 's/,/./' -e 's/[eE]+*/\*10\^/')
16981         # small read with fast read disabled
16982         $LCTL set_param -n llite.*.fast_read=0
16983         local t_slow=$(dd if=$DIR/$tfile of=/dev/null bs=4k 2>&1 |
16984                 egrep -o '([[:digit:]\.\,e-]+) s' | cut -d's' -f1 |
16985                 sed -e 's/,/./' -e 's/[eE]+*/\*10\^/')
16986
16987         # verify that fast read is 4 times faster for cache read
16988         [ $(bc <<< "4 * $t_fast < $t_slow") -eq 1 ] ||
16989                 error_not_in_vm "fast read was not 4 times faster: " \
16990                            "$t_fast vs $t_slow"
16991
16992         echo "Test 2: verify the performance between big and small read"
16993         $LCTL set_param -n llite.*.fast_read=1
16994
16995         # 1k non-cache read
16996         cancel_lru_locks osc
16997         local t_1k=$(dd if=$DIR/$tfile of=/dev/null bs=1k 2>&1 |
16998                 egrep -o '([[:digit:]\.\,e-]+) s' | cut -d's' -f1 |
16999                 sed -e 's/,/./' -e 's/[eE]+*/\*10\^/')
17000
17001         # 1M non-cache read
17002         cancel_lru_locks osc
17003         local t_1m=$(dd if=$DIR/$tfile of=/dev/null bs=1k 2>&1 |
17004                 egrep -o '([[:digit:]\.\,e-]+) s' | cut -d's' -f1 |
17005                 sed -e 's/,/./' -e 's/[eE]+*/\*10\^/')
17006
17007         # verify that big IO is not 4 times faster than small IO
17008         [ $(bc <<< "4 * $t_1k >= $t_1m") -eq 1 ] ||
17009                 error_not_in_vm "bigger IO is way too fast: $t_1k vs $t_1m"
17010
17011         $LCTL set_param -n llite.*.fast_read=$fast_read_sav
17012         rm -f $DIR/$tfile
17013 }
17014 run_test 248 "fast read verification"
17015
17016 test_249() { # LU-7890
17017         [ $MDS1_VERSION -lt $(version_code 2.8.53) ] &&
17018                 skip "Need at least version 2.8.54"
17019
17020         rm -f $DIR/$tfile
17021         $LFS setstripe -c 1 $DIR/$tfile
17022         # Offset 2T == 4k * 512M
17023         dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 seek=512M ||
17024                 error "dd to 2T offset failed"
17025 }
17026 run_test 249 "Write above 2T file size"
17027
17028 test_250() {
17029         [ "$(facet_fstype ost$(($($LFS getstripe -i $DIR/$tfile) + 1)))" = "zfs" ] \
17030          && skip "no 16TB file size limit on ZFS"
17031
17032         $LFS setstripe -c 1 $DIR/$tfile
17033         # ldiskfs extent file size limit is (16TB - 4KB - 1) bytes
17034         local size=$((16 * 1024 * 1024 * 1024 * 1024 - 4096 - 1))
17035         $TRUNCATE $DIR/$tfile $size || error "truncate $tfile to $size failed"
17036         dd if=/dev/zero of=$DIR/$tfile bs=10 count=1 oflag=append \
17037                 conv=notrunc,fsync && error "append succeeded"
17038         return 0
17039 }
17040 run_test 250 "Write above 16T limit"
17041
17042 test_251() {
17043         $LFS setstripe -c -1 -S 1048576 $DIR/$tfile
17044
17045         #define OBD_FAIL_LLITE_LOST_LAYOUT 0x1407
17046         #Skip once - writing the first stripe will succeed
17047         $LCTL set_param fail_loc=0xa0001407 fail_val=1
17048         $MULTIOP $DIR/$tfile o:O_RDWR:w2097152c 2>&1 | grep -q "short write" &&
17049                 error "short write happened"
17050
17051         $LCTL set_param fail_loc=0xa0001407 fail_val=1
17052         $MULTIOP $DIR/$tfile or2097152c 2>&1 | grep -q "short read" &&
17053                 error "short read happened"
17054
17055         rm -f $DIR/$tfile
17056 }
17057 run_test 251 "Handling short read and write correctly"
17058
17059 test_252() {
17060         remote_mds_nodsh && skip "remote MDS with nodsh"
17061         remote_ost_nodsh && skip "remote OST with nodsh"
17062         if [ "$ost1_FSTYPE" != ldiskfs ] || [ "$mds1_FSTYPE" != ldiskfs ]; then
17063                 skip_env "ldiskfs only test"
17064         fi
17065
17066         local tgt
17067         local dev
17068         local out
17069         local uuid
17070         local num
17071         local gen
17072
17073         # check lr_reader on OST0000
17074         tgt=ost1
17075         dev=$(facet_device $tgt)
17076         out=$(do_facet $tgt $LR_READER $dev)
17077         [ $? -eq 0 ] || error "$LR_READER failed on target $tgt device $dev"
17078         echo "$out"
17079         uuid=$(echo "$out" | grep -i uuid | awk '{ print $2 }')
17080         [ "$uuid" == "$(ostuuid_from_index 0)" ] ||
17081                 error "Invalid uuid returned by $LR_READER on target $tgt"
17082         echo -e "uuid returned by $LR_READER is '$uuid'\n"
17083
17084         # check lr_reader -c on MDT0000
17085         tgt=mds1
17086         dev=$(facet_device $tgt)
17087         if ! do_facet $tgt $LR_READER -h | grep -q OPTIONS; then
17088                 skip "$LR_READER does not support additional options"
17089         fi
17090         out=$(do_facet $tgt $LR_READER -c $dev)
17091         [ $? -eq 0 ] || error "$LR_READER failed on target $tgt device $dev"
17092         echo "$out"
17093         num=$(echo "$out" | grep -c "mdtlov")
17094         [ "$num" -eq $((MDSCOUNT - 1)) ] ||
17095                 error "Invalid number of mdtlov clients returned by $LR_READER"
17096         echo -e "Number of mdtlov clients returned by $LR_READER is '$num'\n"
17097
17098         # check lr_reader -cr on MDT0000
17099         out=$(do_facet $tgt $LR_READER -cr $dev)
17100         [ $? -eq 0 ] || error "$LR_READER failed on target $tgt device $dev"
17101         echo "$out"
17102         echo "$out" | grep -q "^reply_data:$" ||
17103                 error "$LR_READER should have returned 'reply_data' section"
17104         num=$(echo "$out" | grep -c "client_generation")
17105         echo -e "Number of reply data returned by $LR_READER is '$num'\n"
17106 }
17107 run_test 252 "check lr_reader tool"
17108
17109 test_253() {
17110         [ $PARALLEL == "yes" ] && skip "skip parallel run"
17111         remote_mds_nodsh && skip "remote MDS with nodsh"
17112         remote_mgs_nodsh && skip "remote MGS with nodsh"
17113
17114         local ostidx=0
17115         local rc=0
17116         local ost_name=$(ostname_from_index $ostidx)
17117
17118         # on the mdt's osc
17119         local mdtosc_proc1=$(get_mdtosc_proc_path $SINGLEMDS $ost_name)
17120         do_facet $SINGLEMDS $LCTL get_param -n \
17121                 osp.$mdtosc_proc1.reserved_mb_high ||
17122                 skip  "remote MDS does not support reserved_mb_high"
17123
17124         rm -rf $DIR/$tdir
17125         wait_mds_ost_sync
17126         wait_delete_completed
17127         mkdir $DIR/$tdir
17128
17129         if ! combined_mgs_mds ; then
17130                 mount_mgs_client
17131         fi
17132         pool_add $TESTNAME || error "Pool creation failed"
17133         pool_add_targets $TESTNAME 0 || error "Pool add targets failed"
17134
17135         $LFS setstripe $DIR/$tdir -i $ostidx -c 1 -p $FSNAME.$TESTNAME ||
17136                 error "Setstripe failed"
17137
17138         dd if=/dev/zero of=$DIR/$tdir/$tfile.0 bs=1M count=10
17139
17140         local wms=$(ost_watermarks_set_enospc $tfile $ostidx |
17141                     grep "watermarks")
17142         stack_trap "ost_watermarks_clear_enospc $tfile $ostidx $wms" EXIT
17143
17144         local oa_status=$(do_facet $SINGLEMDS $LCTL get_param -n \
17145                         osp.$mdtosc_proc1.prealloc_status)
17146         echo "prealloc_status $oa_status"
17147
17148         dd if=/dev/zero of=$DIR/$tdir/$tfile.1 bs=1M count=1 &&
17149                 error "File creation should fail"
17150
17151         #object allocation was stopped, but we still able to append files
17152         dd if=/dev/zero of=$DIR/$tdir/$tfile.0 bs=1M seek=6 count=5 \
17153                 oflag=append || error "Append failed"
17154
17155         rm -f $DIR/$tdir/$tfile.0
17156
17157         # For this test, we want to delete the files we created to go out of
17158         # space but leave the watermark, so we remain nearly out of space
17159         ost_watermarks_enospc_delete_files $tfile $ostidx
17160
17161         wait_delete_completed
17162
17163         sleep_maxage
17164
17165         for i in $(seq 10 12); do
17166                 dd if=/dev/zero of=$DIR/$tdir/$tfile.$i bs=1M count=1 \
17167                         2>/dev/null || error "File creation failed after rm"
17168         done
17169
17170         oa_status=$(do_facet $SINGLEMDS $LCTL get_param -n \
17171                         osp.$mdtosc_proc1.prealloc_status)
17172         echo "prealloc_status $oa_status"
17173
17174         if (( oa_status != 0 )); then
17175                 error "Object allocation still disable after rm"
17176         fi
17177
17178         if ! combined_mgs_mds ; then
17179                 umount_mgs_client
17180         fi
17181 }
17182 run_test 253 "Check object allocation limit"
17183
17184 test_254() {
17185         [ $PARALLEL == "yes" ] && skip "skip parallel run"
17186         remote_mds_nodsh && skip "remote MDS with nodsh"
17187         do_facet $SINGLEMDS $LCTL get_param -n mdd.$MDT0.changelog_size ||
17188                 skip "MDS does not support changelog_size"
17189
17190         local cl_user
17191         local MDT0=$(facet_svc $SINGLEMDS)
17192
17193         changelog_register || error "changelog_register failed"
17194
17195         changelog_clear 0 || error "changelog_clear failed"
17196
17197         local size1=$(do_facet $SINGLEMDS \
17198                       $LCTL get_param -n mdd.$MDT0.changelog_size)
17199         echo "Changelog size $size1"
17200
17201         rm -rf $DIR/$tdir
17202         $LFS mkdir -i 0 $DIR/$tdir
17203         # change something
17204         mkdir -p $DIR/$tdir/pics/2008/zachy
17205         touch $DIR/$tdir/pics/2008/zachy/timestamp
17206         cp /etc/hosts $DIR/$tdir/pics/2008/zachy/pic1.jpg
17207         mv $DIR/$tdir/pics/2008/zachy $DIR/$tdir/pics/zach
17208         ln $DIR/$tdir/pics/zach/pic1.jpg $DIR/$tdir/pics/2008/portland.jpg
17209         ln -s $DIR/$tdir/pics/2008/portland.jpg $DIR/$tdir/pics/desktop.jpg
17210         rm $DIR/$tdir/pics/desktop.jpg
17211
17212         local size2=$(do_facet $SINGLEMDS \
17213                       $LCTL get_param -n mdd.$MDT0.changelog_size)
17214         echo "Changelog size after work $size2"
17215
17216         (( $size2 > $size1 )) ||
17217                 error "new Changelog size=$size2 less than old size=$size1"
17218 }
17219 run_test 254 "Check changelog size"
17220
17221 ladvise_no_type()
17222 {
17223         local type=$1
17224         local file=$2
17225
17226         lfs ladvise -a invalid $file 2>&1 | grep "Valid types" |
17227                 awk -F: '{print $2}' | grep $type > /dev/null
17228         if [ $? -ne 0 ]; then
17229                 return 0
17230         fi
17231         return 1
17232 }
17233
17234 ladvise_no_ioctl()
17235 {
17236         local file=$1
17237
17238         lfs ladvise -a willread $file > /dev/null 2>&1
17239         if [ $? -eq 0 ]; then
17240                 return 1
17241         fi
17242
17243         lfs ladvise -a willread $file 2>&1 |
17244                 grep "Inappropriate ioctl for device" > /dev/null
17245         if [ $? -eq 0 ]; then
17246                 return 0
17247         fi
17248         return 1
17249 }
17250
17251 percent() {
17252         bc <<<"scale=2; ($1 - $2) * 100 / $2"
17253 }
17254
17255 # run a random read IO workload
17256 # usage: random_read_iops <filename> <filesize> <iosize>
17257 random_read_iops() {
17258         local file=$1
17259         local fsize=$2
17260         local iosize=${3:-4096}
17261
17262         $READS -f $file -s $fsize -b $iosize -n $((fsize / iosize)) -t 60 |
17263                 sed -e '/^$/d' -e 's#.*s, ##' -e 's#MB/s##'
17264 }
17265
17266 drop_file_oss_cache() {
17267         local file="$1"
17268         local nodes="$2"
17269
17270         $LFS ladvise -a dontneed $file 2>/dev/null ||
17271                 do_nodes $nodes "echo 3 > /proc/sys/vm/drop_caches"
17272 }
17273
17274 ladvise_willread_performance()
17275 {
17276         local repeat=10
17277         local average_origin=0
17278         local average_cache=0
17279         local average_ladvise=0
17280
17281         for ((i = 1; i <= $repeat; i++)); do
17282                 echo "Iter $i/$repeat: reading without willread hint"
17283                 cancel_lru_locks osc
17284                 drop_file_oss_cache $DIR/$tfile $(comma_list $(osts_nodes))
17285                 local speed_origin=$(random_read_iops $DIR/$tfile $size)
17286                 echo "Iter $i/$repeat: uncached speed: $speed_origin"
17287                 average_origin=$(bc <<<"$average_origin + $speed_origin")
17288
17289                 cancel_lru_locks osc
17290                 local speed_cache=$(random_read_iops $DIR/$tfile $size)
17291                 echo "Iter $i/$repeat: OSS cache speed: $speed_cache"
17292                 average_cache=$(bc <<<"$average_cache + $speed_cache")
17293
17294                 cancel_lru_locks osc
17295                 drop_file_oss_cache $DIR/$tfile $(comma_list $(osts_nodes))
17296                 $LFS ladvise -a willread $DIR/$tfile || error "ladvise failed"
17297                 local speed_ladvise=$(random_read_iops $DIR/$tfile $size)
17298                 echo "Iter $i/$repeat: ladvise speed: $speed_ladvise"
17299                 average_ladvise=$(bc <<<"$average_ladvise + $speed_ladvise")
17300         done
17301         average_origin=$(bc <<<"scale=2; $average_origin / $repeat")
17302         average_cache=$(bc <<<"scale=2; $average_cache / $repeat")
17303         average_ladvise=$(bc <<<"scale=2; $average_ladvise / $repeat")
17304
17305         speedup_cache=$(percent $average_cache $average_origin)
17306         speedup_ladvise=$(percent $average_ladvise $average_origin)
17307
17308         echo "Average uncached read: $average_origin"
17309         echo "Average speedup with OSS cached read: " \
17310                 "$average_cache = +$speedup_cache%"
17311         echo "Average speedup with ladvise willread: " \
17312                 "$average_ladvise = +$speedup_ladvise%"
17313
17314         local lowest_speedup=20
17315         if [ ${average_cache%.*} -lt $lowest_speedup ]; then
17316                 echo "Speedup with OSS cached read less than $lowest_speedup%," \
17317                         "got $average_cache%. Skipping ladvise willread check."
17318                 return 0
17319         fi
17320
17321         # the test won't work on ZFS until it supports 'ladvise dontneed', but
17322         # it is still good to run until then to exercise 'ladvise willread'
17323         ! $LFS ladvise -a dontneed $DIR/$tfile &&
17324                 [ "$ost1_FSTYPE" = "zfs" ] &&
17325                 echo "osd-zfs does not support dontneed or drop_caches" &&
17326                 return 0
17327
17328         lowest_speedup=$(bc <<<"scale=2; $average_cache / 2")
17329         [ ${average_ladvise%.*} -gt $lowest_speedup ] ||
17330                 error_not_in_vm "Speedup with willread is less than " \
17331                         "$lowest_speedup%, got $average_ladvise%"
17332 }
17333
17334 test_255a() {
17335         [ $OST1_VERSION -lt $(version_code 2.8.54) ] &&
17336                 skip "lustre < 2.8.54 does not support ladvise "
17337         remote_ost_nodsh && skip "remote OST with nodsh"
17338
17339         lfs setstripe -c -1 -i 0 $DIR/$tfile || error "$tfile failed"
17340
17341         ladvise_no_type willread $DIR/$tfile &&
17342                 skip "willread ladvise is not supported"
17343
17344         ladvise_no_ioctl $DIR/$tfile &&
17345                 skip "ladvise ioctl is not supported"
17346
17347         local size_mb=100
17348         local size=$((size_mb * 1048576))
17349         dd if=/dev/zero of=$DIR/$tfile bs=1048576 count=$size_mb ||
17350                 error "dd to $DIR/$tfile failed"
17351
17352         lfs ladvise -a willread $DIR/$tfile ||
17353                 error "Ladvise failed with no range argument"
17354
17355         lfs ladvise -a willread -s 0 $DIR/$tfile ||
17356                 error "Ladvise failed with no -l or -e argument"
17357
17358         lfs ladvise -a willread -e 1 $DIR/$tfile ||
17359                 error "Ladvise failed with only -e argument"
17360
17361         lfs ladvise -a willread -l 1 $DIR/$tfile ||
17362                 error "Ladvise failed with only -l argument"
17363
17364         lfs ladvise -a willread -s 2 -e 1 $DIR/$tfile &&
17365                 error "End offset should not be smaller than start offset"
17366
17367         lfs ladvise -a willread -s 2 -e 2 $DIR/$tfile &&
17368                 error "End offset should not be equal to start offset"
17369
17370         lfs ladvise -a willread -s $size -l 1 $DIR/$tfile ||
17371                 error "Ladvise failed with overflowing -s argument"
17372
17373         lfs ladvise -a willread -s 1 -e $((size + 1)) $DIR/$tfile ||
17374                 error "Ladvise failed with overflowing -e argument"
17375
17376         lfs ladvise -a willread -s 1 -l $size $DIR/$tfile ||
17377                 error "Ladvise failed with overflowing -l argument"
17378
17379         lfs ladvise -a willread -l 1 -e 2 $DIR/$tfile &&
17380                 error "Ladvise succeeded with conflicting -l and -e arguments"
17381
17382         echo "Synchronous ladvise should wait"
17383         local delay=4
17384 #define OBD_FAIL_OST_LADVISE_PAUSE       0x237
17385         do_nodes $(comma_list $(osts_nodes)) \
17386                 $LCTL set_param fail_val=$delay fail_loc=0x237
17387
17388         local start_ts=$SECONDS
17389         lfs ladvise -a willread $DIR/$tfile ||
17390                 error "Ladvise failed with no range argument"
17391         local end_ts=$SECONDS
17392         local inteval_ts=$((end_ts - start_ts))
17393
17394         if [ $inteval_ts -lt $(($delay - 1)) ]; then
17395                 error "Synchronous advice didn't wait reply"
17396         fi
17397
17398         echo "Asynchronous ladvise shouldn't wait"
17399         local start_ts=$SECONDS
17400         lfs ladvise -a willread -b $DIR/$tfile ||
17401                 error "Ladvise failed with no range argument"
17402         local end_ts=$SECONDS
17403         local inteval_ts=$((end_ts - start_ts))
17404
17405         if [ $inteval_ts -gt $(($delay / 2)) ]; then
17406                 error "Asynchronous advice blocked"
17407         fi
17408
17409         do_nodes $(comma_list $(osts_nodes)) $LCTL set_param fail_loc=0
17410         ladvise_willread_performance
17411 }
17412 run_test 255a "check 'lfs ladvise -a willread'"
17413
17414 facet_meminfo() {
17415         local facet=$1
17416         local info=$2
17417
17418         do_facet $facet "cat /proc/meminfo | grep ^${info}:" | awk '{print $2}'
17419 }
17420
17421 test_255b() {
17422         [ $OST1_VERSION -lt $(version_code 2.8.54) ] &&
17423                 skip "lustre < 2.8.54 does not support ladvise "
17424         remote_ost_nodsh && skip "remote OST with nodsh"
17425
17426         lfs setstripe -c 1 -i 0 $DIR/$tfile
17427
17428         ladvise_no_type dontneed $DIR/$tfile &&
17429                 skip "dontneed ladvise is not supported"
17430
17431         ladvise_no_ioctl $DIR/$tfile &&
17432                 skip "ladvise ioctl is not supported"
17433
17434         ! $LFS ladvise -a dontneed $DIR/$tfile &&
17435                 [ "$ost1_FSTYPE" = "zfs" ] &&
17436                 skip "zfs-osd does not support 'ladvise dontneed'"
17437
17438         local size_mb=100
17439         local size=$((size_mb * 1048576))
17440         # In order to prevent disturbance of other processes, only check 3/4
17441         # of the memory usage
17442         local kibibytes=$((size_mb * 1024 * 3 / 4))
17443
17444         dd if=/dev/zero of=$DIR/$tfile bs=1048576 count=$size_mb ||
17445                 error "dd to $DIR/$tfile failed"
17446
17447         #force write to complete before dropping OST cache & checking memory
17448         sync
17449
17450         local total=$(facet_meminfo ost1 MemTotal)
17451         echo "Total memory: $total KiB"
17452
17453         do_facet ost1 "sync && echo 3 > /proc/sys/vm/drop_caches"
17454         local before_read=$(facet_meminfo ost1 Cached)
17455         echo "Cache used before read: $before_read KiB"
17456
17457         lfs ladvise -a willread $DIR/$tfile ||
17458                 error "Ladvise willread failed"
17459         local after_read=$(facet_meminfo ost1 Cached)
17460         echo "Cache used after read: $after_read KiB"
17461
17462         lfs ladvise -a dontneed $DIR/$tfile ||
17463                 error "Ladvise dontneed again failed"
17464         local no_read=$(facet_meminfo ost1 Cached)
17465         echo "Cache used after dontneed ladvise: $no_read KiB"
17466
17467         if [ $total -lt $((before_read + kibibytes)) ]; then
17468                 echo "Memory is too small, abort checking"
17469                 return 0
17470         fi
17471
17472         if [ $((before_read + kibibytes)) -gt $after_read ]; then
17473                 error "Ladvise willread should use more memory" \
17474                         "than $kibibytes KiB"
17475         fi
17476
17477         if [ $((no_read + kibibytes)) -gt $after_read ]; then
17478                 error "Ladvise dontneed should release more memory" \
17479                         "than $kibibytes KiB"
17480         fi
17481 }
17482 run_test 255b "check 'lfs ladvise -a dontneed'"
17483
17484 test_255c() {
17485         [ $OST1_VERSION -lt $(version_code 2.10.50) ] &&
17486                 skip "lustre < 2.10.53 does not support lockahead"
17487
17488         local count
17489         local new_count
17490         local difference
17491         local i
17492         local rc
17493
17494         test_mkdir -p $DIR/$tdir
17495         $LFS setstripe -i 0 -c 1 $DIR/$tdir
17496
17497         #test 10 returns only success/failure
17498         i=10
17499         lockahead_test -d $DIR/$tdir -t $i -f $tfile
17500         rc=$?
17501         if [ $rc -eq 255 ]; then
17502                 error "Ladvise test${i} failed, ${rc}"
17503         fi
17504
17505         #test 11 counts lock enqueue requests, all others count new locks
17506         i=11
17507         count=$(do_facet ost1 \
17508                 $LCTL get_param -n ost.OSS.ost.stats)
17509         count=$(echo "$count" | grep ldlm_extent_enqueue | awk '{ print $2 }')
17510
17511         lockahead_test -d $DIR/$tdir -t $i -f $tfile
17512         rc=$?
17513         if [ $rc -eq 255 ]; then
17514                 error "Ladvise test${i} failed, ${rc}"
17515         fi
17516
17517         new_count=$(do_facet ost1 \
17518                 $LCTL get_param -n ost.OSS.ost.stats)
17519         new_count=$(echo "$new_count" | grep ldlm_extent_enqueue | \
17520                    awk '{ print $2 }')
17521
17522         difference="$((new_count - count))"
17523         if [ $difference -ne $rc ]; then
17524                 error "Ladvise test${i}, bad enqueue count, returned " \
17525                       "${rc}, actual ${difference}"
17526         fi
17527
17528         for i in $(seq 12 21); do
17529                 # If we do not do this, we run the risk of having too many
17530                 # locks and starting lock cancellation while we are checking
17531                 # lock counts.
17532                 cancel_lru_locks osc
17533
17534                 count=$($LCTL get_param -n \
17535                        ldlm.namespaces.$FSNAME-OST0000*osc-[-0-9a-f]*.lock_unused_count)
17536
17537                 lockahead_test -d $DIR/$tdir -t $i -f $tfile
17538                 rc=$?
17539                 if [ $rc -eq 255 ]; then
17540                         error "Ladvise test ${i} failed, ${rc}"
17541                 fi
17542
17543                 new_count=$($LCTL get_param -n \
17544                        ldlm.namespaces.$FSNAME-OST0000*osc-[-0-9a-f]*.lock_unused_count)
17545                 difference="$((new_count - count))"
17546
17547                 # Test 15 output is divided by 100 to map down to valid return
17548                 if [ $i -eq 15 ]; then
17549                         rc="$((rc * 100))"
17550                 fi
17551
17552                 if [ $difference -ne $rc ]; then
17553                         error "Ladvise test ${i}, bad lock count, returned " \
17554                               "${rc}, actual ${difference}"
17555                 fi
17556         done
17557
17558         #test 22 returns only success/failure
17559         i=22
17560         lockahead_test -d $DIR/$tdir -t $i -f $tfile
17561         rc=$?
17562         if [ $rc -eq 255 ]; then
17563                 error "Ladvise test${i} failed, ${rc}"
17564         fi
17565 }
17566 run_test 255c "suite of ladvise lockahead tests"
17567
17568 test_256() {
17569         [ $PARALLEL == "yes" ] && skip "skip parallel run"
17570         remote_mds_nodsh && skip "remote MDS with nodsh"
17571         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip "ldiskfs only test"
17572         changelog_users $SINGLEMDS | grep "^cl" &&
17573                 skip "active changelog user"
17574
17575         local cl_user
17576         local cat_sl
17577         local mdt_dev
17578
17579         mdt_dev=$(mdsdevname 1)
17580         echo $mdt_dev
17581
17582         changelog_register || error "changelog_register failed"
17583
17584         rm -rf $DIR/$tdir
17585         mkdir -p $DIR/$tdir
17586
17587         changelog_clear 0 || error "changelog_clear failed"
17588
17589         # change something
17590         touch $DIR/$tdir/{1..10}
17591
17592         # stop the MDT
17593         stop $SINGLEMDS || error "Fail to stop MDT"
17594
17595         # remount the MDT
17596
17597         start $SINGLEMDS $mdt_dev $MDS_MOUNT_OPTS || error "Fail to start MDT"
17598
17599         #after mount new plainllog is used
17600         touch $DIR/$tdir/{11..19}
17601         local tmpfile="$(mktemp --tmpdir -u $tfile.XXXXXX)"
17602         stack_trap "rm -f $tmpfile"
17603         cat_sl=$(do_facet $SINGLEMDS "sync; \
17604                  $DEBUGFS -c -R 'dump changelog_catalog $tmpfile' $mdt_dev; \
17605                  llog_reader $tmpfile | grep -c type=1064553b")
17606         do_facet $SINGLEMDS llog_reader $tmpfile
17607
17608         [ $cat_sl != 2 ] && error "Changelog catalog has $cat_sl != 2 slots"
17609
17610         changelog_clear 0 || error "changelog_clear failed"
17611
17612         cat_sl=$(do_facet $SINGLEMDS "sync; \
17613                  $DEBUGFS -c -R 'dump changelog_catalog $tmpfile' $mdt_dev; \
17614                  llog_reader $tmpfile | grep -c type=1064553b")
17615
17616         if (( cat_sl == 2 )); then
17617                 error "Empty plain llog was not deleted from changelog catalog"
17618         elif (( cat_sl != 1 )); then
17619                 error "Active plain llog shouldn't be deleted from catalog"
17620         fi
17621 }
17622 run_test 256 "Check llog delete for empty and not full state"
17623
17624 test_257() {
17625         remote_mds_nodsh && skip "remote MDS with nodsh"
17626         [[ $MDS1_VERSION -lt $(version_code 2.8.55) ]] &&
17627                 skip "Need MDS version at least 2.8.55"
17628
17629         test_mkdir $DIR/$tdir
17630
17631         setfattr -n trusted.name1 -v value1 $DIR/$tdir ||
17632                 error "setfattr -n trusted.name1=value1 $DIR/$tdir failed"
17633         stat $DIR/$tdir
17634
17635 #define OBD_FAIL_MDS_XATTR_REP                  0x161
17636         local mdtidx=$($LFS getstripe -m $DIR/$tdir)
17637         local facet=mds$((mdtidx + 1))
17638         set_nodes_failloc $(facet_active_host $facet) 0x80000161
17639         getfattr -n trusted.name1 $DIR/$tdir 2> /dev/null
17640
17641         stop $facet || error "stop MDS failed"
17642         start $facet $(mdsdevname $((mdtidx + 1))) $MDS_MOUNT_OPTS ||
17643                 error "start MDS fail"
17644         wait_recovery_complete $facet
17645 }
17646 run_test 257 "xattr locks are not lost"
17647
17648 # Verify we take the i_mutex when security requires it
17649 test_258a() {
17650 #define OBD_FAIL_IMUTEX_SEC 0x141c
17651         $LCTL set_param fail_loc=0x141c
17652         touch $DIR/$tfile
17653         chmod u+s $DIR/$tfile
17654         chmod a+rwx $DIR/$tfile
17655         $RUNAS dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 oflag=append
17656         RC=$?
17657         if [ $RC -ne 0 ]; then
17658                 error "error, failed to take i_mutex, rc=$?"
17659         fi
17660         rm -f $DIR/$tfile
17661 }
17662 run_test 258a "verify i_mutex security behavior when suid attributes is set"
17663
17664 # Verify we do NOT take the i_mutex in the normal case
17665 test_258b() {
17666 #define OBD_FAIL_IMUTEX_NOSEC 0x141d
17667         $LCTL set_param fail_loc=0x141d
17668         touch $DIR/$tfile
17669         chmod a+rwx $DIR
17670         chmod a+rw $DIR/$tfile
17671         $RUNAS dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 oflag=append
17672         RC=$?
17673         if [ $RC -ne 0 ]; then
17674                 error "error, took i_mutex unnecessarily, rc=$?"
17675         fi
17676         rm -f $DIR/$tfile
17677
17678 }
17679 run_test 258b "verify i_mutex security behavior"
17680
17681 test_259() {
17682         local file=$DIR/$tfile
17683         local before
17684         local after
17685
17686         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip "ldiskfs only test"
17687
17688         stack_trap "rm -f $file" EXIT
17689
17690         wait_delete_completed
17691         before=$(do_facet ost1 "$LCTL get_param -n osd-*.*OST0000.kbytesfree")
17692         echo "before: $before"
17693
17694         $LFS setstripe -i 0 -c 1 $file
17695         dd if=/dev/zero of=$file bs=1M count=10 || error "couldn't write"
17696         sync_all_data
17697         after=$(do_facet ost1 "$LCTL get_param -n osd-*.*OST0000.kbytesfree")
17698         echo "after write: $after"
17699
17700 #define OBD_FAIL_OSD_FAIL_AT_TRUNCATE          0x2301
17701         do_facet ost1 $LCTL set_param fail_loc=0x2301
17702         $TRUNCATE $file 0
17703         after=$(do_facet ost1 "$LCTL get_param -n osd-*.*OST0000.kbytesfree")
17704         echo "after truncate: $after"
17705
17706         stop ost1
17707         do_facet ost1 $LCTL set_param fail_loc=0
17708         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS || error "cannot start ost1"
17709         sleep 2
17710         after=$(do_facet ost1 "$LCTL get_param -n osd-*.*OST0000.kbytesfree")
17711         echo "after restart: $after"
17712         [ $((after - before)) -ge $(fs_log_size ost1) ] &&
17713                 error "missing truncate?"
17714
17715         return 0
17716 }
17717 run_test 259 "crash at delayed truncate"
17718
17719 test_260() {
17720 #define OBD_FAIL_MDC_CLOSE               0x806
17721         $LCTL set_param fail_loc=0x80000806
17722         touch $DIR/$tfile
17723
17724 }
17725 run_test 260 "Check mdc_close fail"
17726
17727 ### Data-on-MDT sanity tests ###
17728 test_270a() {
17729         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
17730                 skip "Need MDS version at least 2.10.55 for DoM"
17731
17732         # create DoM file
17733         local dom=$DIR/$tdir/dom_file
17734         local tmp=$DIR/$tdir/tmp_file
17735
17736         mkdir -p $DIR/$tdir
17737
17738         # basic checks for DoM component creation
17739         $LFS setstripe -E 1024K -E 2048K -L mdt $dom 2>/dev/null &&
17740                 error "Can set MDT layout to non-first entry"
17741
17742         $LFS setstripe -E 1024K -L mdt -E 2048K -L mdt $dom 2>/dev/null &&
17743                 error "Can define multiple entries as MDT layout"
17744
17745         $LFS setstripe -E 1M -L mdt $dom || error "Can't create DoM layout"
17746
17747         [ $($LFS getstripe -L $dom) == "mdt" ] || error "bad pattern"
17748         [ $($LFS getstripe -c $dom) == 0 ] || error "bad stripe count"
17749         [ $($LFS getstripe -S $dom) == 1048576 ] || error "bad stripe size"
17750
17751         local mdtidx=$($LFS getstripe -m $dom)
17752         local mdtname=MDT$(printf %04x $mdtidx)
17753         local facet=mds$((mdtidx + 1))
17754         local space_check=1
17755
17756         # Skip free space checks with ZFS
17757         [ "$(facet_fstype $facet)" == "zfs" ] && space_check=0
17758
17759         # write
17760         sync
17761         local size_tmp=$((65536 * 3))
17762         local mdtfree1=$(do_facet $facet \
17763                          lctl get_param -n osd*.*$mdtname.kbytesfree)
17764
17765         dd if=/dev/urandom of=$tmp bs=1024 count=$((size_tmp / 1024))
17766         # check also direct IO along write
17767         # IO size must be a multiple of PAGE_SIZE on all platforms (ARM=64KB)
17768         dd if=$tmp of=$dom bs=65536 count=$((size_tmp / 65536)) oflag=direct
17769         sync
17770         cmp $tmp $dom || error "file data is different"
17771         [ $(stat -c%s $dom) == $size_tmp ] ||
17772                 error "bad size after write: $(stat -c%s $dom) != $size_tmp"
17773         if [ $space_check == 1 ]; then
17774                 local mdtfree2=$(do_facet $facet \
17775                                  lctl get_param -n osd*.*$mdtname.kbytesfree)
17776
17777                 # increase in usage from by $size_tmp
17778                 [ $(($mdtfree1 - $mdtfree2)) -ge $((size_tmp / 1024)) ] ||
17779                         error "MDT free space wrong after write: " \
17780                               "$mdtfree1 >= $mdtfree2 + $size_tmp/1024"
17781         fi
17782
17783         # truncate
17784         local size_dom=10000
17785
17786         $TRUNCATE $dom $size_dom
17787         [ $(stat -c%s $dom) == $size_dom ] ||
17788                 error "bad size after truncate: $(stat -c%s $dom) != $size_dom"
17789         if [ $space_check == 1 ]; then
17790                 mdtfree1=$(do_facet $facet \
17791                                 lctl get_param -n osd*.*$mdtname.kbytesfree)
17792                 # decrease in usage from $size_tmp to new $size_dom
17793                 [ $(($mdtfree1 - $mdtfree2)) -ge \
17794                   $(((size_tmp - size_dom) / 1024)) ] ||
17795                         error "MDT free space is wrong after truncate: " \
17796                               "$mdtfree1 >= $mdtfree2 + ($size_tmp - $size_dom) / 1024"
17797         fi
17798
17799         # append
17800         cat $tmp >> $dom
17801         sync
17802         size_dom=$((size_dom + size_tmp))
17803         [ $(stat -c%s $dom) == $size_dom ] ||
17804                 error "bad size after append: $(stat -c%s $dom) != $size_dom"
17805         if [ $space_check == 1 ]; then
17806                 mdtfree2=$(do_facet $facet \
17807                                 lctl get_param -n osd*.*$mdtname.kbytesfree)
17808                 # increase in usage by $size_tmp from previous
17809                 [ $(($mdtfree1 - $mdtfree2)) -ge $((size_tmp / 1024)) ] ||
17810                         error "MDT free space is wrong after append: " \
17811                               "$mdtfree1 >= $mdtfree2 + $size_tmp/1024"
17812         fi
17813
17814         # delete
17815         rm $dom
17816         if [ $space_check == 1 ]; then
17817                 mdtfree1=$(do_facet $facet \
17818                                 lctl get_param -n osd*.*$mdtname.kbytesfree)
17819                 # decrease in usage by $size_dom from previous
17820                 [ $(($mdtfree1 - $mdtfree2)) -ge $((size_dom / 1024)) ] ||
17821                         error "MDT free space is wrong after removal: " \
17822                               "$mdtfree1 >= $mdtfree2 + $size_dom/1024"
17823         fi
17824
17825         # combined striping
17826         $LFS setstripe -E 1024K -L mdt -E EOF $dom ||
17827                 error "Can't create DoM + OST striping"
17828
17829         size_tmp=2031616 # must be a multiple of PAGE_SIZE=65536 on ARM
17830         dd if=/dev/urandom of=$tmp bs=1024 count=$((size_tmp / 1024))
17831         # check also direct IO along write
17832         dd if=$tmp of=$dom bs=65536 count=$((size_tmp / 65536)) oflag=direct
17833         sync
17834         cmp $tmp $dom || error "file data is different"
17835         [ $(stat -c%s $dom) == $size_tmp ] ||
17836                 error "bad size after write: $(stat -c%s $dom) != $size_tmp"
17837         rm $dom $tmp
17838
17839         return 0
17840 }
17841 run_test 270a "DoM: basic functionality tests"
17842
17843 test_270b() {
17844         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
17845                 skip "Need MDS version at least 2.10.55"
17846
17847         local dom=$DIR/$tdir/dom_file
17848         local max_size=1048576
17849
17850         mkdir -p $DIR/$tdir
17851         $LFS setstripe -E $max_size -L mdt $dom
17852
17853         # truncate over the limit
17854         $TRUNCATE $dom $(($max_size + 1)) &&
17855                 error "successful truncate over the maximum size"
17856         # write over the limit
17857         dd if=/dev/zero of=$dom bs=$max_size seek=1 count=1 &&
17858                 error "successful write over the maximum size"
17859         # append over the limit
17860         dd if=/dev/zero of=$dom bs=$(($max_size - 3)) count=1
17861         echo "12345" >> $dom && error "successful append over the maximum size"
17862         rm $dom
17863
17864         return 0
17865 }
17866 run_test 270b "DoM: maximum size overflow checks for DoM-only file"
17867
17868 test_270c() {
17869         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
17870                 skip "Need MDS version at least 2.10.55"
17871
17872         mkdir -p $DIR/$tdir
17873         $LFS setstripe -E 1024K -L mdt $DIR/$tdir
17874
17875         # check files inherit DoM EA
17876         touch $DIR/$tdir/first
17877         [ $($LFS getstripe -L $DIR/$tdir/first) == "mdt" ] ||
17878                 error "bad pattern"
17879         [ $($LFS getstripe -c $DIR/$tdir/first) == 0 ] ||
17880                 error "bad stripe count"
17881         [ $($LFS getstripe -S $DIR/$tdir/first) == 1048576 ] ||
17882                 error "bad stripe size"
17883
17884         # check directory inherits DoM EA and uses it as default
17885         mkdir $DIR/$tdir/subdir
17886         touch $DIR/$tdir/subdir/second
17887         [ $($LFS getstripe -L $DIR/$tdir/subdir/second) == "mdt" ] ||
17888                 error "bad pattern in sub-directory"
17889         [ $($LFS getstripe -c $DIR/$tdir/subdir/second) == 0 ] ||
17890                 error "bad stripe count in sub-directory"
17891         [ $($LFS getstripe -S $DIR/$tdir/subdir/second) == 1048576 ] ||
17892                 error "bad stripe size in sub-directory"
17893         return 0
17894 }
17895 run_test 270c "DoM: DoM EA inheritance tests"
17896
17897 test_270d() {
17898         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
17899                 skip "Need MDS version at least 2.10.55"
17900
17901         mkdir -p $DIR/$tdir
17902         $LFS setstripe -E 1024K -L mdt $DIR/$tdir
17903
17904         # inherit default DoM striping
17905         mkdir $DIR/$tdir/subdir
17906         touch $DIR/$tdir/subdir/f1
17907
17908         # change default directory striping
17909         $LFS setstripe -c 1 $DIR/$tdir/subdir
17910         touch $DIR/$tdir/subdir/f2
17911         [ $($LFS getstripe -c $DIR/$tdir/subdir/f2) == 1 ] ||
17912                 error "wrong default striping in file 2"
17913         [ $($LFS getstripe -L $DIR/$tdir/subdir/f2) == "raid0" ] ||
17914                 error "bad pattern in file 2"
17915         return 0
17916 }
17917 run_test 270d "DoM: change striping from DoM to RAID0"
17918
17919 test_270e() {
17920         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
17921                 skip "Need MDS version at least 2.10.55"
17922
17923         mkdir -p $DIR/$tdir/dom
17924         mkdir -p $DIR/$tdir/norm
17925         DOMFILES=20
17926         NORMFILES=10
17927         $LFS setstripe -E 1M -L mdt $DIR/$tdir/dom
17928         $LFS setstripe -i 0 -S 2M $DIR/$tdir/norm
17929
17930         createmany -o $DIR/$tdir/dom/dom- $DOMFILES
17931         createmany -o $DIR/$tdir/norm/norm- $NORMFILES
17932
17933         # find DoM files by layout
17934         NUM=$($LFS find -L mdt -type f $DIR/$tdir 2>/dev/null | wc -l)
17935         [ $NUM -eq  $DOMFILES ] ||
17936                 error "lfs find -L: found $NUM, expected $DOMFILES"
17937         echo "Test 1: lfs find 20 DOM files by layout: OK"
17938
17939         # there should be 1 dir with default DOM striping
17940         NUM=$($LFS find -L mdt -type d $DIR/$tdir 2>/dev/null | wc -l)
17941         [ $NUM -eq  1 ] ||
17942                 error "lfs find -L: found $NUM, expected 1 dir"
17943         echo "Test 2: lfs find 1 DOM dir by layout: OK"
17944
17945         # find DoM files by stripe size
17946         NUM=$($LFS find -S -1200K -type f $DIR/$tdir 2>/dev/null | wc -l)
17947         [ $NUM -eq  $DOMFILES ] ||
17948                 error "lfs find -S: found $NUM, expected $DOMFILES"
17949         echo "Test 4: lfs find 20 DOM files by stripe size: OK"
17950
17951         # find files by stripe offset except DoM files
17952         NUM=$($LFS find -i 0 -type f $DIR/$tdir 2>/dev/null | wc -l)
17953         [ $NUM -eq  $NORMFILES ] ||
17954                 error "lfs find -i: found $NUM, expected $NORMFILES"
17955         echo "Test 5: lfs find no DOM files by stripe index: OK"
17956         return 0
17957 }
17958 run_test 270e "DoM: lfs find with DoM files test"
17959
17960 test_270f() {
17961         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
17962                 skip "Need MDS version at least 2.10.55"
17963
17964         local mdtname=${FSNAME}-MDT0000-mdtlov
17965         local dom=$DIR/$tdir/dom_file
17966         local dom_limit_saved=$(do_facet mds1 $LCTL get_param -n \
17967                                                 lod.$mdtname.dom_stripesize)
17968         local dom_limit=131072
17969
17970         do_facet mds1 $LCTL set_param -n lod.$mdtname.dom_stripesize=$dom_limit
17971         local dom_current=$(do_facet mds1 $LCTL get_param -n \
17972                                                 lod.$mdtname.dom_stripesize)
17973         [ ${dom_limit} -eq ${dom_current} ] ||
17974                 error "Cannot change per-MDT DoM stripe limit to $dom_limit"
17975
17976         $LFS mkdir -i 0 -c 1 $DIR/$tdir
17977         $LFS setstripe -d $DIR/$tdir
17978         $LFS setstripe -E $dom_limit -L mdt $DIR/$tdir ||
17979                 error "Can't set directory default striping"
17980
17981         # exceed maximum stripe size
17982         $LFS setstripe -E $((dom_limit * 2)) -L mdt $dom ||
17983                 error "Can't create file with $((dom_limit * 2)) DoM stripe"
17984         [ $($LFS getstripe -S $dom) -eq $((dom_limit * 2)) ] &&
17985                 error "Able to create DoM component size more than LOD limit"
17986
17987         do_facet mds1 $LCTL set_param -n lod.$mdtname.dom_stripesize=0
17988         dom_current=$(do_facet mds1 $LCTL get_param -n \
17989                                                 lod.$mdtname.dom_stripesize)
17990         [ 0 -eq ${dom_current} ] ||
17991                 error "Can't set zero DoM stripe limit"
17992         rm $dom
17993
17994         # attempt to create DoM file on server with disabled DoM should
17995         # remove DoM entry from layout and be succeed
17996         $LFS setstripe -E $dom_limit -L mdt -E -1 $dom ||
17997                 error "Can't create DoM file (DoM is disabled)"
17998         [ $($LFS getstripe -L $dom) == "mdt" ] &&
17999                 error "File has DoM component while DoM is disabled"
18000         rm $dom
18001
18002         # attempt to create DoM file with only DoM stripe should return error
18003         $LFS setstripe -E $dom_limit -L mdt $dom &&
18004                 error "Able to create DoM-only file while DoM is disabled"
18005
18006         # too low values to be aligned with smallest stripe size 64K
18007         do_facet mds1 $LCTL set_param -n lod.$mdtname.dom_stripesize=30000
18008         dom_current=$(do_facet mds1 $LCTL get_param -n \
18009                                                 lod.$mdtname.dom_stripesize)
18010         [ 30000 -eq ${dom_current} ] &&
18011                 error "Can set too small DoM stripe limit"
18012
18013         # 64K is a minimal stripe size in Lustre, expect limit of that size
18014         [ 65536 -eq ${dom_current} ] ||
18015                 error "Limit is not set to 64K but ${dom_current}"
18016
18017         do_facet mds1 $LCTL set_param -n lod.$mdtname.dom_stripesize=2147483648
18018         dom_current=$(do_facet mds1 $LCTL get_param -n \
18019                                                 lod.$mdtname.dom_stripesize)
18020         echo $dom_current
18021         [ 2147483648 -eq ${dom_current} ] &&
18022                 error "Can set too large DoM stripe limit"
18023
18024         do_facet mds1 $LCTL set_param -n \
18025                                 lod.$mdtname.dom_stripesize=$((dom_limit * 2))
18026         $LFS setstripe -E $((dom_limit * 2)) -L mdt $dom ||
18027                 error "Can't create DoM component size after limit change"
18028         do_facet mds1 $LCTL set_param -n \
18029                                 lod.$mdtname.dom_stripesize=$((dom_limit / 2))
18030         $LFS setstripe -E $dom_limit -L mdt ${dom}_big ||
18031                 error "Can't create DoM file after limit decrease"
18032         [ $($LFS getstripe -S ${dom}_big) -eq $((dom_limit / 2)) ] ||
18033                 error "Can create big DoM component after limit decrease"
18034         touch ${dom}_def ||
18035                 error "Can't create file with old default layout"
18036
18037         do_facet mds1 $LCTL set_param -n lod.*.dom_stripesize=$dom_limit_saved
18038         return 0
18039 }
18040 run_test 270f "DoM: maximum DoM stripe size checks"
18041
18042 test_271a() {
18043         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18044                 skip "Need MDS version at least 2.10.55"
18045
18046         local dom=$DIR/$tdir/dom
18047
18048         mkdir -p $DIR/$tdir
18049
18050         $LFS setstripe -E 1024K -L mdt $dom
18051
18052         lctl set_param -n mdc.*.stats=clear
18053         dd if=/dev/zero of=$dom bs=4096 count=1 || return 1
18054         cat $dom > /dev/null
18055         local reads=$(lctl get_param -n mdc.*.stats | grep -c ost_read)
18056         [ $reads -eq 0 ] || error "Unexpected $reads READ RPCs"
18057         ls $dom
18058         rm -f $dom
18059 }
18060 run_test 271a "DoM: data is cached for read after write"
18061
18062 test_271b() {
18063         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18064                 skip "Need MDS version at least 2.10.55"
18065
18066         local dom=$DIR/$tdir/dom
18067
18068         mkdir -p $DIR/$tdir
18069
18070         $LFS setstripe -E 1024K -L mdt -E EOF $dom
18071
18072         lctl set_param -n mdc.*.stats=clear
18073         dd if=/dev/zero of=$dom bs=4096 count=1 || return 1
18074         cancel_lru_locks mdc
18075         $CHECKSTAT -t file -s 4096 $dom || error "stat #1 fails"
18076         # second stat to check size is cached on client
18077         $CHECKSTAT -t file -s 4096 $dom || error "stat #2 fails"
18078         local gls=$(lctl get_param -n mdc.*.stats | grep -c ldlm_glimpse)
18079         [ $gls -eq 0 ] || error "Unexpected $gls glimpse RPCs"
18080         rm -f $dom
18081 }
18082 run_test 271b "DoM: no glimpse RPC for stat (DoM only file)"
18083
18084 test_271ba() {
18085         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18086                 skip "Need MDS version at least 2.10.55"
18087
18088         local dom=$DIR/$tdir/dom
18089
18090         mkdir -p $DIR/$tdir
18091
18092         $LFS setstripe -E 1024K -L mdt -E EOF $dom
18093
18094         lctl set_param -n mdc.*.stats=clear
18095         lctl set_param -n osc.*.stats=clear
18096         dd if=/dev/zero of=$dom bs=2048K count=1 || return 1
18097         cancel_lru_locks mdc
18098         $CHECKSTAT -t file -s 2097152 $dom || error "stat"
18099         # second stat to check size is cached on client
18100         $CHECKSTAT -t file -s 2097152 $dom || error "stat"
18101         local gls=$(lctl get_param -n mdc.*.stats | grep -c ldlm_glimpse)
18102         [ $gls == 0 ] || error "Unexpected $gls glimpse RPCs"
18103         local gls=$(lctl get_param -n osc.*.stats | grep -c ldlm_glimpse)
18104         [ $gls == 0 ] || error "Unexpected $gls OSC glimpse RPCs"
18105         rm -f $dom
18106 }
18107 run_test 271ba "DoM: no glimpse RPC for stat (combined file)"
18108
18109
18110 get_mdc_stats() {
18111         local mdtidx=$1
18112         local param=$2
18113         local mdt=MDT$(printf %04x $mdtidx)
18114
18115         if [ -z $param ]; then
18116                 lctl get_param -n mdc.*$mdt*.stats
18117         else
18118                 lctl get_param -n mdc.*$mdt*.stats | awk "/$param/"'{print $2}'
18119         fi
18120 }
18121
18122 test_271c() {
18123         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18124                 skip "Need MDS version at least 2.10.55"
18125
18126         local dom=$DIR/$tdir/dom
18127
18128         mkdir -p $DIR/$tdir
18129
18130         $LFS setstripe -E 1024K -L mdt $DIR/$tdir
18131
18132         local mdtidx=$($LFS getstripe -m $DIR/$tdir)
18133         local facet=mds$((mdtidx + 1))
18134
18135         cancel_lru_locks mdc
18136         do_facet $facet lctl set_param -n mdt.*.dom_lock=0
18137         createmany -o $dom 1000
18138         lctl set_param -n mdc.*.stats=clear
18139         smalliomany -w $dom 1000 200
18140         get_mdc_stats $mdtidx
18141         local enq=$(get_mdc_stats $mdtidx ldlm_ibits_enqueue)
18142         # Each file has 1 open, 1 IO enqueues, total 2000
18143         # but now we have also +1 getxattr for security.capability, total 3000
18144         [ $enq -ge 2000 ] || error "Too few enqueues $enq, expected > 2000"
18145         unlinkmany $dom 1000
18146
18147         cancel_lru_locks mdc
18148         do_facet $facet lctl set_param -n mdt.*.dom_lock=1
18149         createmany -o $dom 1000
18150         lctl set_param -n mdc.*.stats=clear
18151         smalliomany -w $dom 1000 200
18152         local enq_2=$(get_mdc_stats $mdtidx ldlm_ibits_enqueue)
18153         # Expect to see reduced amount of RPCs by 1000 due to single enqueue
18154         # for OPEN and IO lock.
18155         [ $((enq - enq_2)) -ge 1000 ] ||
18156                 error "Too many enqueues $enq_2, expected about $((enq - 1000))"
18157         unlinkmany $dom 1000
18158         return 0
18159 }
18160 run_test 271c "DoM: IO lock at open saves enqueue RPCs"
18161
18162 cleanup_271def_tests() {
18163         trap 0
18164         rm -f $1
18165 }
18166
18167 test_271d() {
18168         [ $MDS1_VERSION -lt $(version_code 2.10.57) ] &&
18169                 skip "Need MDS version at least 2.10.57"
18170
18171         local dom=$DIR/$tdir/dom
18172         local tmp=$TMP/$tfile
18173         trap "cleanup_271def_tests $tmp" EXIT
18174
18175         mkdir -p $DIR/$tdir
18176
18177         $LFS setstripe -E 1024K -L mdt $DIR/$tdir
18178
18179         local mdtidx=$($LFS getstripe --mdt-index $DIR/$tdir)
18180
18181         cancel_lru_locks mdc
18182         dd if=/dev/urandom of=$tmp bs=1000 count=1
18183         dd if=$tmp of=$dom bs=1000 count=1
18184         cancel_lru_locks mdc
18185
18186         cat /etc/hosts >> $tmp
18187         lctl set_param -n mdc.*.stats=clear
18188
18189         # append data to the same file it should update local page
18190         echo "Append to the same page"
18191         cat /etc/hosts >> $dom
18192         local num=$(get_mdc_stats $mdtidx ost_read)
18193         local ra=$(get_mdc_stats $mdtidx req_active)
18194         local rw=$(get_mdc_stats $mdtidx req_waittime)
18195
18196         [ -z $num ] || error "$num READ RPC occured"
18197         [ $ra == $rw ] || error "$((ra - rw)) resend occured"
18198         echo "... DONE"
18199
18200         # compare content
18201         cmp $tmp $dom || error "file miscompare"
18202
18203         cancel_lru_locks mdc
18204         lctl set_param -n mdc.*.stats=clear
18205
18206         echo "Open and read file"
18207         cat $dom > /dev/null
18208         local num=$(get_mdc_stats $mdtidx ost_read)
18209         local ra=$(get_mdc_stats $mdtidx req_active)
18210         local rw=$(get_mdc_stats $mdtidx req_waittime)
18211
18212         [ -z $num ] || error "$num READ RPC occured"
18213         [ $ra == $rw ] || error "$((ra - rw)) resend occured"
18214         echo "... DONE"
18215
18216         # compare content
18217         cmp $tmp $dom || error "file miscompare"
18218
18219         return 0
18220 }
18221 run_test 271d "DoM: read on open (1K file in reply buffer)"
18222
18223 test_271f() {
18224         [ $MDS1_VERSION -lt $(version_code 2.10.57) ] &&
18225                 skip "Need MDS version at least 2.10.57"
18226
18227         local dom=$DIR/$tdir/dom
18228         local tmp=$TMP/$tfile
18229         trap "cleanup_271def_tests $tmp" EXIT
18230
18231         mkdir -p $DIR/$tdir
18232
18233         $LFS setstripe -E 1024K -L mdt $DIR/$tdir
18234
18235         local mdtidx=$($LFS getstripe --mdt-index $DIR/$tdir)
18236
18237         cancel_lru_locks mdc
18238         dd if=/dev/urandom of=$tmp bs=200000 count=1
18239         dd if=$tmp of=$dom bs=200000 count=1
18240         cancel_lru_locks mdc
18241         cat /etc/hosts >> $tmp
18242         lctl set_param -n mdc.*.stats=clear
18243
18244         echo "Append to the same page"
18245         cat /etc/hosts >> $dom
18246         local num=$(get_mdc_stats $mdtidx ost_read)
18247         local ra=$(get_mdc_stats $mdtidx req_active)
18248         local rw=$(get_mdc_stats $mdtidx req_waittime)
18249
18250         [ -z $num ] || error "$num READ RPC occured"
18251         [ $ra == $rw ] || error "$((ra - rw)) resend occured"
18252         echo "... DONE"
18253
18254         # compare content
18255         cmp $tmp $dom || error "file miscompare"
18256
18257         cancel_lru_locks mdc
18258         lctl set_param -n mdc.*.stats=clear
18259
18260         echo "Open and read file"
18261         cat $dom > /dev/null
18262         local num=$(get_mdc_stats $mdtidx ost_read)
18263         local ra=$(get_mdc_stats $mdtidx req_active)
18264         local rw=$(get_mdc_stats $mdtidx req_waittime)
18265
18266         [ $num -eq 1 ] || error "expect 1 READ RPC, $num occured"
18267         [ $ra == $rw ] || error "$((ra - rw)) resend occured"
18268         echo "... DONE"
18269
18270         # compare content
18271         cmp $tmp $dom || error "file miscompare"
18272
18273         return 0
18274 }
18275 run_test 271f "DoM: read on open (200K file and read tail)"
18276
18277 test_271g() {
18278         [[ $($LCTL get_param mdc.*.import) =~ async_discard ]] ||
18279                 skip "Skipping due to old client or server version"
18280
18281         $LFS setstripe -E 1024K -L mdt -E EOF $DIR1/$tfile
18282         # to get layout
18283         $CHECKSTAT -t file $DIR1/$tfile
18284
18285         $MULTIOP $DIR1/$tfile Ow40960_w4096c &
18286         MULTIOP_PID=$!
18287         sleep 1
18288         #define OBD_FAIL_LDLM_CANCEL_BL_CB_RACE
18289         $LCTL set_param fail_loc=0x80000314
18290         rm $DIR1/$tfile || error "Unlink fails"
18291         RC=$?
18292         kill -USR1 $MULTIOP_PID && wait $MULTIOP_PID || error "multiop failure"
18293         [ $RC -eq 0 ] || error "Failed write to stale object"
18294 }
18295 run_test 271g "Discard DoM data vs client flush race"
18296
18297 test_272a() {
18298         [ $MDS1_VERSION -lt $(version_code 2.11.50) ] &&
18299                 skip "Need MDS version at least 2.11.50"
18300
18301         local dom=$DIR/$tdir/dom
18302         mkdir -p $DIR/$tdir
18303
18304         $LFS setstripe -E 256K -L mdt -E -1 -c1 $dom
18305         dd if=/dev/urandom of=$dom bs=512K count=1 ||
18306                 error "failed to write data into $dom"
18307         local old_md5=$(md5sum $dom)
18308
18309         $LFS migrate -E 256K -L mdt -E -1 -c2 $dom ||
18310                 error "failed to migrate to the same DoM component"
18311
18312         local new_md5=$(md5sum $dom)
18313
18314         [ "$old_md5" == "$new_md5" ] ||
18315                 error "md5sum differ: $old_md5, $new_md5"
18316
18317         [ $($LFS getstripe -c $dom) -eq 2 ] ||
18318                 error "migrate stripe count bad: $(LFS getstripe -c $dom) != 2"
18319 }
18320 run_test 272a "DoM migration: new layout with the same DOM component"
18321
18322 test_272b() {
18323         [ $MDS1_VERSION -lt $(version_code 2.11.50) ] &&
18324                 skip "Need MDS version at least 2.11.50"
18325
18326         local dom=$DIR/$tdir/dom
18327         mkdir -p $DIR/$tdir
18328         $LFS setstripe -E 1M -L mdt -E -1 -c1 $dom
18329
18330         local mdtidx=$($LFS getstripe -m $dom)
18331         local mdtname=MDT$(printf %04x $mdtidx)
18332         local facet=mds$((mdtidx + 1))
18333
18334         local mdtfree1=$(do_facet $facet \
18335                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18336         dd if=/dev/urandom of=$dom bs=2M count=1 ||
18337                 error "failed to write data into $dom"
18338         local old_md5=$(md5sum $dom)
18339         cancel_lru_locks mdc
18340         local mdtfree1=$(do_facet $facet \
18341                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18342
18343         $LFS migrate -c2 $dom ||
18344                 error "failed to migrate to the new composite layout"
18345         [ $($LFS getstripe -L $dom) == 'mdt' ] &&
18346                 error "MDT stripe was not removed"
18347
18348         cancel_lru_locks mdc
18349         local new_md5=$(md5sum $dom)
18350         [ "$old_md5" != "$new_md5" ] &&
18351                 error "$old_md5 != $new_md5"
18352
18353         # Skip free space checks with ZFS
18354         if [ "$(facet_fstype $facet)" != "zfs" ]; then
18355                 local mdtfree2=$(do_facet $facet \
18356                                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18357                 [ $mdtfree2 -gt $mdtfree1 ] ||
18358                         error "MDT space is not freed after migration"
18359         fi
18360         return 0
18361 }
18362 run_test 272b "DoM migration: DOM file to the OST-striped file (plain)"
18363
18364 test_272c() {
18365         [ $MDS1_VERSION -lt $(version_code 2.11.50) ] &&
18366                 skip "Need MDS version at least 2.11.50"
18367
18368         local dom=$DIR/$tdir/$tfile
18369         mkdir -p $DIR/$tdir
18370         $LFS setstripe -E 1M -L mdt -E -1 -c1 $dom
18371
18372         local mdtidx=$($LFS getstripe -m $dom)
18373         local mdtname=MDT$(printf %04x $mdtidx)
18374         local facet=mds$((mdtidx + 1))
18375
18376         dd if=/dev/urandom of=$dom bs=2M count=1 oflag=direct ||
18377                 error "failed to write data into $dom"
18378         local old_md5=$(md5sum $dom)
18379         cancel_lru_locks mdc
18380         local mdtfree1=$(do_facet $facet \
18381                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18382
18383         $LFS migrate -E 2M -c1 -E -1 -c2 $dom ||
18384                 error "failed to migrate to the new composite layout"
18385         [ $($LFS getstripe -L $dom) == 'mdt' ] &&
18386                 error "MDT stripe was not removed"
18387
18388         cancel_lru_locks mdc
18389         local new_md5=$(md5sum $dom)
18390         [ "$old_md5" != "$new_md5" ] &&
18391                 error "$old_md5 != $new_md5"
18392
18393         # Skip free space checks with ZFS
18394         if [ "$(facet_fstype $facet)" != "zfs" ]; then
18395                 local mdtfree2=$(do_facet $facet \
18396                                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18397                 [ $mdtfree2 -gt $mdtfree1 ] ||
18398                         error "MDS space is not freed after migration"
18399         fi
18400         return 0
18401 }
18402 run_test 272c "DoM migration: DOM file to the OST-striped file (composite)"
18403
18404 test_273a() {
18405         [ $MDS1_VERSION -lt $(version_code 2.11.50) ] &&
18406                 skip "Need MDS version at least 2.11.50"
18407
18408         # Layout swap cannot be done if either file has DOM component,
18409         # this will never be supported, migration should be used instead
18410
18411         local dom=$DIR/$tdir/$tfile
18412         mkdir -p $DIR/$tdir
18413
18414         $LFS setstripe -c2 ${dom}_plain
18415         $LFS setstripe -E 1M -L mdt -E -1 -c2 ${dom}_dom
18416         $LFS swap_layouts ${dom}_plain ${dom}_dom &&
18417                 error "can swap layout with DoM component"
18418         $LFS swap_layouts ${dom}_dom ${dom}_plain &&
18419                 error "can swap layout with DoM component"
18420
18421         $LFS setstripe -E 1M -c1 -E -1 -c2 ${dom}_comp
18422         $LFS swap_layouts ${dom}_comp ${dom}_dom &&
18423                 error "can swap layout with DoM component"
18424         $LFS swap_layouts ${dom}_dom ${dom}_comp &&
18425                 error "can swap layout with DoM component"
18426         return 0
18427 }
18428 run_test 273a "DoM: layout swapping should fail with DOM"
18429
18430 test_275() {
18431         remote_ost_nodsh && skip "remote OST with nodsh"
18432         [ $OST1_VERSION -lt $(version_code 2.10.57) ] &&
18433                 skip "Need OST version >= 2.10.57"
18434
18435         local file=$DIR/$tfile
18436         local oss
18437
18438         oss=$(comma_list $(osts_nodes))
18439
18440         dd if=/dev/urandom of=$file bs=1M count=2 ||
18441                 error "failed to create a file"
18442         cancel_lru_locks osc
18443
18444         #lock 1
18445         dd if=$file of=/dev/null bs=1M count=1 iflag=direct ||
18446                 error "failed to read a file"
18447
18448 #define OBD_FAIL_LDLM_PAUSE_CANCEL2      0x31f
18449         $LCTL set_param fail_loc=0x8000031f
18450
18451         cancel_lru_locks osc &
18452         sleep 1
18453
18454 #define OBD_FAIL_LDLM_PROLONG_PAUSE      0x32b
18455         do_nodes $oss $LCTL set_param fail_loc=0x8000032b
18456         #IO takes another lock, but matches the PENDING one
18457         #and places it to the IO RPC
18458         dd if=$file of=/dev/null bs=1M count=1 iflag=direct ||
18459                 error "failed to read a file with PENDING lock"
18460 }
18461 run_test 275 "Read on a canceled duplicate lock"
18462
18463 test_276() {
18464         remote_ost_nodsh && skip "remote OST with nodsh"
18465         local pid
18466
18467         do_facet ost1 "(while true; do \
18468                 $LCTL get_param obdfilter.*.filesfree > /dev/null 2>&1; \
18469                 done) & pid=\\\$!; echo \\\$pid > $TMP/sanity_276_pid" &
18470         pid=$!
18471
18472         for LOOP in $(seq 20); do
18473                 stop ost1
18474                 start ost1 $(ostdevname 1) $OST_MOUNT_OPTS
18475         done
18476         kill -9 $pid
18477         do_facet ost1 "pid=\\\$(cat $TMP/sanity_276_pid); kill -9 \\\$pid; \
18478                 rm $TMP/sanity_276_pid"
18479 }
18480 run_test 276 "Race between mount and obd_statfs"
18481
18482 test_277() {
18483         $LCTL set_param ldlm.namespaces.*.lru_size=0
18484         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1
18485         local cached_mb=$($LCTL get_param llite.*.max_cached_mb |
18486                         grep ^used_mb | awk '{print $2}')
18487         [ $cached_mb -eq 1 ] || error "expected mb 1 got $cached_mb"
18488         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 \
18489                 oflag=direct conv=notrunc
18490         cached_mb=$($LCTL get_param llite.*.max_cached_mb |
18491                         grep ^used_mb | awk '{print $2}')
18492         [ $cached_mb -eq 0 ] || error "expected mb 0 got $cached_mb"
18493 }
18494 run_test 277 "Direct IO shall drop page cache"
18495
18496 test_278() {
18497         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
18498         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
18499         [[ "$(facet_host mds1)" != "$(facet_host mds2)" ]] &&
18500                 skip "needs the same host for mdt1 mdt2" && return
18501
18502         local pid1
18503         local pid2
18504
18505 #define OBD_FAIL_OBD_STOP_MDS_RACE     0x60b
18506         do_facet mds2 $LCTL set_param fail_loc=0x8000060c
18507         stop mds2 &
18508         pid2=$!
18509
18510         stop mds1
18511
18512         echo "Starting MDTs"
18513         start mds1 $(mdsdevname 1) $MDS_MOUNT_OPTS
18514         wait $pid2
18515 #For the error assertion will happen. lu_env_get_key(..., &mdt_thread_key)
18516 #will return NULL
18517         do_facet mds2 $LCTL set_param fail_loc=0
18518
18519         start mds2 $(mdsdevname 2) $MDS_MOUNT_OPTS
18520 }
18521 run_test 278 "Race starting MDS between MDTs stop/start"
18522
18523 cleanup_test_300() {
18524         trap 0
18525         umask $SAVE_UMASK
18526 }
18527 test_striped_dir() {
18528         local mdt_index=$1
18529         local stripe_count
18530         local stripe_index
18531
18532         mkdir -p $DIR/$tdir
18533
18534         SAVE_UMASK=$(umask)
18535         trap cleanup_test_300 RETURN EXIT
18536
18537         $LFS setdirstripe -i $mdt_index -c 2 -H all_char -o 755 \
18538                                                 $DIR/$tdir/striped_dir ||
18539                 error "set striped dir error"
18540
18541         local mode=$(stat -c%a $DIR/$tdir/striped_dir)
18542         [ "$mode" = "755" ] || error "expect 755 got $mode"
18543
18544         $LFS getdirstripe $DIR/$tdir/striped_dir > /dev/null 2>&1 ||
18545                 error "getdirstripe failed"
18546         stripe_count=$($LFS getdirstripe -c $DIR/$tdir/striped_dir)
18547         if [ "$stripe_count" != "2" ]; then
18548                 error "1:stripe_count is $stripe_count, expect 2"
18549         fi
18550         stripe_count=$($LFS getdirstripe -T $DIR/$tdir/striped_dir)
18551         if [ "$stripe_count" != "2" ]; then
18552                 error "2:stripe_count is $stripe_count, expect 2"
18553         fi
18554
18555         stripe_index=$($LFS getdirstripe -i $DIR/$tdir/striped_dir)
18556         if [ "$stripe_index" != "$mdt_index" ]; then
18557                 error "stripe_index is $stripe_index, expect $mdt_index"
18558         fi
18559
18560         [ $(stat -c%h $DIR/$tdir/striped_dir) == '2' ] ||
18561                 error "nlink error after create striped dir"
18562
18563         mkdir $DIR/$tdir/striped_dir/a
18564         mkdir $DIR/$tdir/striped_dir/b
18565
18566         stat $DIR/$tdir/striped_dir/a ||
18567                 error "create dir under striped dir failed"
18568         stat $DIR/$tdir/striped_dir/b ||
18569                 error "create dir under striped dir failed"
18570
18571         [ $(stat -c%h $DIR/$tdir/striped_dir) == '4' ] ||
18572                 error "nlink error after mkdir"
18573
18574         rmdir $DIR/$tdir/striped_dir/a
18575         [ $(stat -c%h $DIR/$tdir/striped_dir) == '3' ] ||
18576                 error "nlink error after rmdir"
18577
18578         rmdir $DIR/$tdir/striped_dir/b
18579         [ $(stat -c%h $DIR/$tdir/striped_dir) == '2' ] ||
18580                 error "nlink error after rmdir"
18581
18582         chattr +i $DIR/$tdir/striped_dir
18583         createmany -o $DIR/$tdir/striped_dir/f 10 &&
18584                 error "immutable flags not working under striped dir!"
18585         chattr -i $DIR/$tdir/striped_dir
18586
18587         rmdir $DIR/$tdir/striped_dir ||
18588                 error "rmdir striped dir error"
18589
18590         cleanup_test_300
18591
18592         true
18593 }
18594
18595 test_300a() {
18596         [ $MDS1_VERSION -lt $(version_code 2.7.0) ] &&
18597                 skip "skipped for lustre < 2.7.0"
18598         [ $PARALLEL == "yes" ] && skip "skip parallel run"
18599         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
18600
18601         test_striped_dir 0 || error "failed on striped dir on MDT0"
18602         test_striped_dir 1 || error "failed on striped dir on MDT0"
18603 }
18604 run_test 300a "basic striped dir sanity test"
18605
18606 test_300b() {
18607         [ $MDS1_VERSION -lt $(version_code 2.7.0) ] &&
18608                 skip "skipped for lustre < 2.7.0"
18609         [ $PARALLEL == "yes" ] && skip "skip parallel run"
18610         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
18611
18612         local i
18613         local mtime1
18614         local mtime2
18615         local mtime3
18616
18617         test_mkdir $DIR/$tdir || error "mkdir fail"
18618         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir ||
18619                 error "set striped dir error"
18620         for i in {0..9}; do
18621                 mtime1=$(stat -c %Y $DIR/$tdir/striped_dir)
18622                 sleep 1
18623                 touch $DIR/$tdir/striped_dir/file_$i || error "touch error $i"
18624                 mtime2=$(stat -c %Y $DIR/$tdir/striped_dir)
18625                 [ $mtime1 -eq $mtime2 ] && error "mtime unchanged after create"
18626                 sleep 1
18627                 rm -f $DIR/$tdir/striped_dir/file_$i || error "unlink error $i"
18628                 mtime3=$(stat -c %Y $DIR/$tdir/striped_dir)
18629                 [ $mtime2 -eq $mtime3 ] && error "mtime unchanged after unlink"
18630         done
18631         true
18632 }
18633 run_test 300b "check ctime/mtime for striped dir"
18634
18635 test_300c() {
18636         [ $MDS1_VERSION -lt $(version_code 2.7.0) ] &&
18637                 skip "skipped for lustre < 2.7.0"
18638         [ $PARALLEL == "yes" ] && skip "skip parallel run"
18639         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
18640
18641         local file_count
18642
18643         mkdir -p $DIR/$tdir
18644         $LFS setdirstripe -i 0 -c 2 $DIR/$tdir/striped_dir ||
18645                 error "set striped dir error"
18646
18647         chown $RUNAS_ID:$RUNAS_GID $DIR/$tdir/striped_dir ||
18648                 error "chown striped dir failed"
18649
18650         $RUNAS createmany -o $DIR/$tdir/striped_dir/f 5000 ||
18651                 error "create 5k files failed"
18652
18653         file_count=$(ls $DIR/$tdir/striped_dir | wc -l)
18654
18655         [ "$file_count" = 5000 ] || error "file count $file_count != 5000"
18656
18657         rm -rf $DIR/$tdir
18658 }
18659 run_test 300c "chown && check ls under striped directory"
18660
18661 test_300d() {
18662         [ $MDS1_VERSION -lt $(version_code 2.7.0) ] &&
18663                 skip "skipped for lustre < 2.7.0"
18664         [ $PARALLEL == "yes" ] && skip "skip parallel run"
18665         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
18666
18667         local stripe_count
18668         local file
18669
18670         mkdir -p $DIR/$tdir
18671         $LFS setstripe -c 2 $DIR/$tdir
18672
18673         #local striped directory
18674         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir ||
18675                 error "set striped dir error"
18676         createmany -o $DIR/$tdir/striped_dir/f 10 ||
18677                 error "create 10 files failed"
18678
18679         #remote striped directory
18680         $LFS setdirstripe -i 1 -c 2 $DIR/$tdir/remote_striped_dir ||
18681                 error "set striped dir error"
18682         createmany -o $DIR/$tdir/remote_striped_dir/f 10 ||
18683                 error "create 10 files failed"
18684
18685         for file in $(find $DIR/$tdir); do
18686                 stripe_count=$($LFS getstripe -c $file)
18687                 [ $stripe_count -eq 2 ] ||
18688                         error "wrong stripe $stripe_count for $file"
18689         done
18690
18691         rm -rf $DIR/$tdir
18692 }
18693 run_test 300d "check default stripe under striped directory"
18694
18695 test_300e() {
18696         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
18697                 skip "Need MDS version at least 2.7.55"
18698         [ $PARALLEL == "yes" ] && skip "skip parallel run"
18699         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
18700
18701         local stripe_count
18702         local file
18703
18704         mkdir -p $DIR/$tdir
18705
18706         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir ||
18707                 error "set striped dir error"
18708
18709         touch $DIR/$tdir/striped_dir/a
18710         touch $DIR/$tdir/striped_dir/b
18711         touch $DIR/$tdir/striped_dir/c
18712
18713         mkdir $DIR/$tdir/striped_dir/dir_a
18714         mkdir $DIR/$tdir/striped_dir/dir_b
18715         mkdir $DIR/$tdir/striped_dir/dir_c
18716
18717         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir/stp_a ||
18718                 error "set striped adir under striped dir error"
18719
18720         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir/stp_b ||
18721                 error "set striped bdir under striped dir error"
18722
18723         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir/stp_c ||
18724                 error "set striped cdir under striped dir error"
18725
18726         mrename $DIR/$tdir/striped_dir/dir_a $DIR/$tdir/striped_dir/dir_b ||
18727                 error "rename dir under striped dir fails"
18728
18729         mrename $DIR/$tdir/striped_dir/stp_a $DIR/$tdir/striped_dir/stp_b ||
18730                 error "rename dir under different stripes fails"
18731
18732         mrename $DIR/$tdir/striped_dir/a $DIR/$tdir/striped_dir/c ||
18733                 error "rename file under striped dir should succeed"
18734
18735         mrename $DIR/$tdir/striped_dir/dir_b $DIR/$tdir/striped_dir/dir_c ||
18736                 error "rename dir under striped dir should succeed"
18737
18738         rm -rf $DIR/$tdir
18739 }
18740 run_test 300e "check rename under striped directory"
18741
18742 test_300f() {
18743         [ $PARALLEL == "yes" ] && skip "skip parallel run"
18744         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
18745         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
18746                 skip "Need MDS version at least 2.7.55"
18747
18748         local stripe_count
18749         local file
18750
18751         rm -rf $DIR/$tdir
18752         mkdir -p $DIR/$tdir
18753
18754         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir ||
18755                 error "set striped dir error"
18756
18757         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir1 ||
18758                 error "set striped dir error"
18759
18760         touch $DIR/$tdir/striped_dir/a
18761         mkdir $DIR/$tdir/striped_dir/dir_a
18762         $LFS setdirstripe -i 0 -c 2 $DIR/$tdir/striped_dir/stp_a ||
18763                 error "create striped dir under striped dir fails"
18764
18765         touch $DIR/$tdir/striped_dir1/b
18766         mkdir $DIR/$tdir/striped_dir1/dir_b
18767         $LFS setdirstripe -i 0 -c 2 $DIR/$tdir/striped_dir/stp_b ||
18768                 error "create striped dir under striped dir fails"
18769
18770         mrename $DIR/$tdir/striped_dir/dir_a $DIR/$tdir/striped_dir1/dir_b ||
18771                 error "rename dir under different striped dir should fail"
18772
18773         mrename $DIR/$tdir/striped_dir/stp_a $DIR/$tdir/striped_dir1/stp_b ||
18774                 error "rename striped dir under diff striped dir should fail"
18775
18776         mrename $DIR/$tdir/striped_dir/a $DIR/$tdir/striped_dir1/a ||
18777                 error "rename file under diff striped dirs fails"
18778
18779         rm -rf $DIR/$tdir
18780 }
18781 run_test 300f "check rename cross striped directory"
18782
18783 test_300_check_default_striped_dir()
18784 {
18785         local dirname=$1
18786         local default_count=$2
18787         local default_index=$3
18788         local stripe_count
18789         local stripe_index
18790         local dir_stripe_index
18791         local dir
18792
18793         echo "checking $dirname $default_count $default_index"
18794         $LFS setdirstripe -D -c $default_count -i $default_index \
18795                                 -t all_char $DIR/$tdir/$dirname ||
18796                 error "set default stripe on striped dir error"
18797         stripe_count=$($LFS getdirstripe -D -c $DIR/$tdir/$dirname)
18798         [ $stripe_count -eq $default_count ] ||
18799                 error "expect $default_count get $stripe_count for $dirname"
18800
18801         stripe_index=$($LFS getdirstripe -D -i $DIR/$tdir/$dirname)
18802         [ $stripe_index -eq $default_index ] ||
18803                 error "expect $default_index get $stripe_index for $dirname"
18804
18805         mkdir $DIR/$tdir/$dirname/{test1,test2,test3,test4} ||
18806                                                 error "create dirs failed"
18807
18808         createmany -o $DIR/$tdir/$dirname/f- 10 || error "create files failed"
18809         unlinkmany $DIR/$tdir/$dirname/f- 10    || error "unlink files failed"
18810         for dir in $(find $DIR/$tdir/$dirname/*); do
18811                 stripe_count=$($LFS getdirstripe -c $dir)
18812                 [ $stripe_count -eq $default_count ] ||
18813                 [ $stripe_count -eq 0 ] || [ $default_count -eq 1 ] ||
18814                 error "stripe count $default_count != $stripe_count for $dir"
18815
18816                 stripe_index=$($LFS getdirstripe -i $dir)
18817                 [ $default_index -eq -1 ] ||
18818                         [ $stripe_index -eq $default_index ] ||
18819                         error "$stripe_index != $default_index for $dir"
18820
18821                 #check default stripe
18822                 stripe_count=$($LFS getdirstripe -D -c $dir)
18823                 [ $stripe_count -eq $default_count ] ||
18824                 error "default count $default_count != $stripe_count for $dir"
18825
18826                 stripe_index=$($LFS getdirstripe -D -i $dir)
18827                 [ $stripe_index -eq $default_index ] ||
18828                 error "default index $default_index != $stripe_index for $dir"
18829         done
18830         rmdir $DIR/$tdir/$dirname/* || error "rmdir failed"
18831 }
18832
18833 test_300g() {
18834         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
18835         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
18836                 skip "Need MDS version at least 2.7.55"
18837
18838         local dir
18839         local stripe_count
18840         local stripe_index
18841
18842         mkdir $DIR/$tdir
18843         mkdir $DIR/$tdir/normal_dir
18844
18845         #Checking when client cache stripe index
18846         $LFS setdirstripe -c$MDSCOUNT $DIR/$tdir/striped_dir
18847         $LFS setdirstripe -D -i1 $DIR/$tdir/striped_dir ||
18848                 error "create striped_dir failed"
18849
18850         $LFS setdirstripe -i0 $DIR/$tdir/striped_dir/dir0 ||
18851                 error "create dir0 fails"
18852         stripe_index=$($LFS getdirstripe -i $DIR/$tdir/striped_dir/dir0)
18853         [ $stripe_index -eq 0 ] ||
18854                 error "dir0 expect index 0 got $stripe_index"
18855
18856         mkdir $DIR/$tdir/striped_dir/dir1 ||
18857                 error "create dir1 fails"
18858         stripe_index=$($LFS getdirstripe -i $DIR/$tdir/striped_dir/dir1)
18859         [ $stripe_index -eq 1 ] ||
18860                 error "dir1 expect index 1 got $stripe_index"
18861
18862         #check default stripe count/stripe index
18863         test_300_check_default_striped_dir normal_dir $MDSCOUNT 1
18864         test_300_check_default_striped_dir normal_dir 1 0
18865         test_300_check_default_striped_dir normal_dir 2 1
18866         test_300_check_default_striped_dir normal_dir 2 -1
18867
18868         #delete default stripe information
18869         echo "delete default stripeEA"
18870         $LFS setdirstripe -d $DIR/$tdir/normal_dir ||
18871                 error "set default stripe on striped dir error"
18872
18873         mkdir -p $DIR/$tdir/normal_dir/{test1,test2,test3,test4}
18874         for dir in $(find $DIR/$tdir/normal_dir/*); do
18875                 stripe_count=$($LFS getdirstripe -c $dir)
18876                 [ $stripe_count -eq 0 ] ||
18877                         error "expect 1 get $stripe_count for $dir"
18878                 stripe_index=$($LFS getdirstripe -i $dir)
18879                 [ $stripe_index -eq 0 ] ||
18880                         error "expect 0 get $stripe_index for $dir"
18881         done
18882 }
18883 run_test 300g "check default striped directory for normal directory"
18884
18885 test_300h() {
18886         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
18887         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
18888                 skip "Need MDS version at least 2.7.55"
18889
18890         local dir
18891         local stripe_count
18892
18893         mkdir $DIR/$tdir
18894         $LFS setdirstripe -i0 -c$MDSCOUNT -H all_char $DIR/$tdir/striped_dir ||
18895                 error "set striped dir error"
18896
18897         test_300_check_default_striped_dir striped_dir $MDSCOUNT 1
18898         test_300_check_default_striped_dir striped_dir 1 0
18899         test_300_check_default_striped_dir striped_dir 2 1
18900         test_300_check_default_striped_dir striped_dir 2 -1
18901
18902         #delete default stripe information
18903         $LFS setdirstripe -d $DIR/$tdir/striped_dir ||
18904                 error "set default stripe on striped dir error"
18905
18906         mkdir -p $DIR/$tdir/striped_dir/{test1,test2,test3,test4}
18907         for dir in $(find $DIR/$tdir/striped_dir/*); do
18908                 stripe_count=$($LFS getdirstripe -c $dir)
18909                 [ $stripe_count -eq 0 ] ||
18910                         error "expect 1 get $stripe_count for $dir"
18911         done
18912 }
18913 run_test 300h "check default striped directory for striped directory"
18914
18915 test_300i() {
18916         [ $PARALLEL == "yes" ] && skip "skip parallel run"
18917         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
18918         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
18919                 skip "Need MDS version at least 2.7.55"
18920
18921         local stripe_count
18922         local file
18923
18924         mkdir $DIR/$tdir
18925
18926         $LFS setdirstripe -i 0 -c$MDSCOUNT -H all_char $DIR/$tdir/striped_dir ||
18927                 error "set striped dir error"
18928
18929         createmany -o $DIR/$tdir/striped_dir/f- 10 ||
18930                 error "create files under striped dir failed"
18931
18932         $LFS setdirstripe -i0 -c$MDSCOUNT -H all_char $DIR/$tdir/hashdir ||
18933                 error "set striped hashdir error"
18934
18935         $LFS setdirstripe -i0 -c$MDSCOUNT -H all_char $DIR/$tdir/hashdir/d0 ||
18936                 error "create dir0 under hash dir failed"
18937         $LFS setdirstripe -i0 -c$MDSCOUNT -H fnv_1a_64 $DIR/$tdir/hashdir/d1 ||
18938                 error "create dir1 under hash dir failed"
18939
18940         # unfortunately, we need to umount to clear dir layout cache for now
18941         # once we fully implement dir layout, we can drop this
18942         umount_client $MOUNT || error "umount failed"
18943         mount_client $MOUNT || error "mount failed"
18944
18945         $LFS find -H fnv_1a_64 $DIR/$tdir/hashdir
18946         local dircnt=$($LFS find -H fnv_1a_64 $DIR/$tdir/hashdir | wc -l)
18947         [ $dircnt -eq 1 ] || error "lfs find striped dir got:$dircnt,except:1"
18948
18949         #set the stripe to be unknown hash type
18950         #define OBD_FAIL_UNKNOWN_LMV_STRIPE     0x1901
18951         $LCTL set_param fail_loc=0x1901
18952         for ((i = 0; i < 10; i++)); do
18953                 $CHECKSTAT -t file $DIR/$tdir/striped_dir/f-$i ||
18954                         error "stat f-$i failed"
18955                 rm $DIR/$tdir/striped_dir/f-$i || error "unlink f-$i failed"
18956         done
18957
18958         touch $DIR/$tdir/striped_dir/f0 &&
18959                 error "create under striped dir with unknown hash should fail"
18960
18961         $LCTL set_param fail_loc=0
18962
18963         umount_client $MOUNT || error "umount failed"
18964         mount_client $MOUNT || error "mount failed"
18965
18966         return 0
18967 }
18968 run_test 300i "client handle unknown hash type striped directory"
18969
18970 test_300j() {
18971         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
18972         [ $PARALLEL == "yes" ] && skip "skip parallel run"
18973         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
18974                 skip "Need MDS version at least 2.7.55"
18975
18976         local stripe_count
18977         local file
18978
18979         mkdir $DIR/$tdir
18980
18981         #define OBD_FAIL_SPLIT_UPDATE_REC       0x1702
18982         $LCTL set_param fail_loc=0x1702
18983         $LFS setdirstripe -i 0 -c$MDSCOUNT -H all_char $DIR/$tdir/striped_dir ||
18984                 error "set striped dir error"
18985
18986         createmany -o $DIR/$tdir/striped_dir/f- 10 ||
18987                 error "create files under striped dir failed"
18988
18989         $LCTL set_param fail_loc=0
18990
18991         rm -rf $DIR/$tdir || error "unlink striped dir fails"
18992
18993         return 0
18994 }
18995 run_test 300j "test large update record"
18996
18997 test_300k() {
18998         [ $PARALLEL == "yes" ] && skip "skip parallel run"
18999         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19000         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19001                 skip "Need MDS version at least 2.7.55"
19002
19003         # this test needs a huge transaction
19004         local kb
19005         kb=$(do_facet $SINGLEMDS lctl get_param -n osd*.lustre-MDT0000.kbytestotal)
19006         [ $kb -lt $((1024*1024)) ] && skip "too small mds: $kb"
19007
19008         local stripe_count
19009         local file
19010
19011         mkdir $DIR/$tdir
19012
19013         #define OBD_FAIL_LARGE_STRIPE   0x1703
19014         $LCTL set_param fail_loc=0x1703
19015         $LFS setdirstripe -i 0 -c192 $DIR/$tdir/striped_dir ||
19016                 error "set striped dir error"
19017         $LCTL set_param fail_loc=0
19018
19019         $LFS getdirstripe $DIR/$tdir/striped_dir ||
19020                 error "getstripeddir fails"
19021         rm -rf $DIR/$tdir/striped_dir ||
19022                 error "unlink striped dir fails"
19023
19024         return 0
19025 }
19026 run_test 300k "test large striped directory"
19027
19028 test_300l() {
19029         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19030         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19031         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19032                 skip "Need MDS version at least 2.7.55"
19033
19034         local stripe_index
19035
19036         test_mkdir -p $DIR/$tdir/striped_dir
19037         chown $RUNAS_ID $DIR/$tdir/striped_dir ||
19038                         error "chown $RUNAS_ID failed"
19039         $LFS setdirstripe -i 1 -D $DIR/$tdir/striped_dir ||
19040                 error "set default striped dir failed"
19041
19042         #define OBD_FAIL_MDS_STALE_DIR_LAYOUT    0x158
19043         $LCTL set_param fail_loc=0x80000158
19044         $RUNAS mkdir $DIR/$tdir/striped_dir/test_dir || error "create dir fails"
19045
19046         stripe_index=$($LFS getdirstripe -i $DIR/$tdir/striped_dir/test_dir)
19047         [ $stripe_index -eq 1 ] ||
19048                 error "expect 1 get $stripe_index for $dir"
19049 }
19050 run_test 300l "non-root user to create dir under striped dir with stale layout"
19051
19052 test_300m() {
19053         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19054         [ $MDSCOUNT -ge 2 ] && skip_env "Only for single MDT"
19055         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19056                 skip "Need MDS version at least 2.7.55"
19057
19058         mkdir -p $DIR/$tdir/striped_dir
19059         $LFS setdirstripe -D -c 1 $DIR/$tdir/striped_dir ||
19060                 error "set default stripes dir error"
19061
19062         mkdir $DIR/$tdir/striped_dir/a || error "mkdir a fails"
19063
19064         stripe_count=$($LFS getdirstripe -c $DIR/$tdir/striped_dir/a)
19065         [ $stripe_count -eq 0 ] ||
19066                         error "expect 0 get $stripe_count for a"
19067
19068         $LFS setdirstripe -D -c 2 $DIR/$tdir/striped_dir ||
19069                 error "set default stripes dir error"
19070
19071         mkdir $DIR/$tdir/striped_dir/b || error "mkdir b fails"
19072
19073         stripe_count=$($LFS getdirstripe -c $DIR/$tdir/striped_dir/b)
19074         [ $stripe_count -eq 0 ] ||
19075                         error "expect 0 get $stripe_count for b"
19076
19077         $LFS setdirstripe -D -c1 -i2 $DIR/$tdir/striped_dir ||
19078                 error "set default stripes dir error"
19079
19080         mkdir $DIR/$tdir/striped_dir/c &&
19081                 error "default stripe_index is invalid, mkdir c should fails"
19082
19083         rm -rf $DIR/$tdir || error "rmdir fails"
19084 }
19085 run_test 300m "setstriped directory on single MDT FS"
19086
19087 cleanup_300n() {
19088         local list=$(comma_list $(mdts_nodes))
19089
19090         trap 0
19091         do_nodes $list $LCTL set_param -n mdt.*.enable_remote_dir_gid=0
19092 }
19093
19094 test_300n() {
19095         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19096         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19097         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19098                 skip "Need MDS version at least 2.7.55"
19099         remote_mds_nodsh && skip "remote MDS with nodsh"
19100
19101         local stripe_index
19102         local list=$(comma_list $(mdts_nodes))
19103
19104         trap cleanup_300n RETURN EXIT
19105         mkdir -p $DIR/$tdir
19106         chmod 777 $DIR/$tdir
19107         $RUNAS $LFS setdirstripe -i0 -c$MDSCOUNT \
19108                                 $DIR/$tdir/striped_dir > /dev/null 2>&1 &&
19109                 error "create striped dir succeeds with gid=0"
19110
19111         do_nodes $list $LCTL set_param -n mdt.*.enable_remote_dir_gid=-1
19112         $RUNAS $LFS setdirstripe -i0 -c$MDSCOUNT $DIR/$tdir/striped_dir ||
19113                 error "create striped dir fails with gid=-1"
19114
19115         do_nodes $list $LCTL set_param -n mdt.*.enable_remote_dir_gid=0
19116         $RUNAS $LFS setdirstripe -i 1 -c$MDSCOUNT -D \
19117                                 $DIR/$tdir/striped_dir > /dev/null 2>&1 &&
19118                 error "set default striped dir succeeds with gid=0"
19119
19120
19121         do_nodes $list $LCTL set_param -n mdt.*.enable_remote_dir_gid=-1
19122         $RUNAS $LFS setdirstripe -i 1 -c$MDSCOUNT -D $DIR/$tdir/striped_dir ||
19123                 error "set default striped dir fails with gid=-1"
19124
19125
19126         do_nodes $list $LCTL set_param -n mdt.*.enable_remote_dir_gid=0
19127         $RUNAS mkdir $DIR/$tdir/striped_dir/test_dir ||
19128                                         error "create test_dir fails"
19129         $RUNAS mkdir $DIR/$tdir/striped_dir/test_dir1 ||
19130                                         error "create test_dir1 fails"
19131         $RUNAS mkdir $DIR/$tdir/striped_dir/test_dir2 ||
19132                                         error "create test_dir2 fails"
19133         cleanup_300n
19134 }
19135 run_test 300n "non-root user to create dir under striped dir with default EA"
19136
19137 test_300o() {
19138         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19139         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19140         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19141                 skip "Need MDS version at least 2.7.55"
19142
19143         local numfree1
19144         local numfree2
19145
19146         mkdir -p $DIR/$tdir
19147
19148         numfree1=$(lctl get_param -n mdc.*MDT0000*.filesfree)
19149         numfree2=$(lctl get_param -n mdc.*MDT0001*.filesfree)
19150         if [ $numfree1 -lt 66000 ] || [ $numfree2 -lt 66000 ]; then
19151                 skip "not enough free inodes $numfree1 $numfree2"
19152         fi
19153
19154         numfree1=$(lctl get_param -n mdc.*MDT0000-mdc-*.kbytesfree)
19155         numfree2=$(lctl get_param -n mdc.*MDT0001-mdc-*.kbytesfree)
19156         if [ $numfree1 -lt 300000 ] || [ $numfree2 -lt 300000 ]; then
19157                 skip "not enough free space $numfree1 $numfree2"
19158         fi
19159
19160         $LFS setdirstripe -c2 $DIR/$tdir/striped_dir ||
19161                 error "setdirstripe fails"
19162
19163         createmany -d $DIR/$tdir/striped_dir/d 131000 ||
19164                 error "create dirs fails"
19165
19166         $LCTL set_param ldlm.namespaces.*mdc-*.lru_size=0
19167         ls $DIR/$tdir/striped_dir > /dev/null ||
19168                 error "ls striped dir fails"
19169         unlinkmany -d $DIR/$tdir/striped_dir/d 131000 ||
19170                 error "unlink big striped dir fails"
19171 }
19172 run_test 300o "unlink big sub stripe(> 65000 subdirs)"
19173
19174 test_300p() {
19175         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19176         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19177         remote_mds_nodsh && skip "remote MDS with nodsh"
19178
19179         mkdir -p $DIR/$tdir
19180
19181         #define OBD_FAIL_OUT_ENOSPC     0x1704
19182         do_facet mds2 lctl set_param fail_loc=0x80001704
19183         $LFS setdirstripe -i 0 -c2 $DIR/$tdir/bad_striped_dir > /dev/null 2>&1 \
19184                  && error "create striped directory should fail"
19185
19186         [ -e $DIR/$tdir/bad_striped_dir ] && error "striped dir exists"
19187
19188         $LFS setdirstripe -c2 $DIR/$tdir/bad_striped_dir
19189         true
19190 }
19191 run_test 300p "create striped directory without space"
19192
19193 test_300q() {
19194         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19195         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19196
19197         local fd=$(free_fd)
19198         local cmd="exec $fd<$tdir"
19199         cd $DIR
19200         $LFS mkdir -c $MDSCOUNT $tdir || error "create $tdir fails"
19201         eval $cmd
19202         cmd="exec $fd<&-"
19203         trap "eval $cmd" EXIT
19204         cd $tdir || error "cd $tdir fails"
19205         rmdir  ../$tdir || error "rmdir $tdir fails"
19206         mkdir local_dir && error "create dir succeeds"
19207         $LFS setdirstripe -i1 remote_dir && error "create remote dir succeeds"
19208         eval $cmd
19209         return 0
19210 }
19211 run_test 300q "create remote directory under orphan directory"
19212
19213 test_300r() {
19214         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.7.55) ] &&
19215                 skip "Need MDS version at least 2.7.55" && return
19216         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
19217
19218         mkdir $DIR/$tdir
19219
19220         $LFS setdirstripe -i 0 -c -1 $DIR/$tdir/striped_dir ||
19221                 error "set striped dir error"
19222
19223         $LFS getdirstripe $DIR/$tdir/striped_dir ||
19224                 error "getstripeddir fails"
19225
19226         local stripe_count
19227         stripe_count=$($LFS getdirstripe $DIR/$tdir/striped_dir |
19228                       awk '/lmv_stripe_count:/ { print $2 }')
19229
19230         [ $MDSCOUNT -ne $stripe_count ] &&
19231                 error "wrong stripe count $stripe_count expected $MDSCOUNT"
19232
19233         rm -rf $DIR/$tdir/striped_dir ||
19234                 error "unlink striped dir fails"
19235 }
19236 run_test 300r "test -1 striped directory"
19237
19238 prepare_remote_file() {
19239         mkdir $DIR/$tdir/src_dir ||
19240                 error "create remote source failed"
19241
19242         cp /etc/hosts $DIR/$tdir/src_dir/a ||
19243                  error "cp to remote source failed"
19244         touch $DIR/$tdir/src_dir/a
19245
19246         $LFS mkdir -i 1 $DIR/$tdir/tgt_dir ||
19247                 error "create remote target dir failed"
19248
19249         touch $DIR/$tdir/tgt_dir/b
19250
19251         mrename $DIR/$tdir/src_dir/a $DIR/$tdir/tgt_dir/b ||
19252                 error "rename dir cross MDT failed!"
19253
19254         $CHECKSTAT -t file $DIR/$tdir/src_dir/a &&
19255                 error "src_child still exists after rename"
19256
19257         $CHECKSTAT -t file $DIR/$tdir/tgt_dir/b ||
19258                 error "missing file(a) after rename"
19259
19260         diff /etc/hosts $DIR/$tdir/tgt_dir/b ||
19261                 error "diff after rename"
19262 }
19263
19264 test_310a() {
19265         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 4 MDTs"
19266         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19267
19268         local remote_file=$DIR/$tdir/tgt_dir/b
19269
19270         mkdir -p $DIR/$tdir
19271
19272         prepare_remote_file || error "prepare remote file failed"
19273
19274         #open-unlink file
19275         $OPENUNLINK $remote_file $remote_file ||
19276                 error "openunlink $remote_file failed"
19277         $CHECKSTAT -a $remote_file || error "$remote_file exists"
19278 }
19279 run_test 310a "open unlink remote file"
19280
19281 test_310b() {
19282         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 4 MDTs"
19283         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19284
19285         local remote_file=$DIR/$tdir/tgt_dir/b
19286
19287         mkdir -p $DIR/$tdir
19288
19289         prepare_remote_file || error "prepare remote file failed"
19290
19291         ln $remote_file $DIR/$tfile || error "link failed for remote file"
19292         $MULTIOP $DIR/$tfile Ouc || error "mulitop failed"
19293         $CHECKSTAT -t file $remote_file || error "check file failed"
19294 }
19295 run_test 310b "unlink remote file with multiple links while open"
19296
19297 test_310c() {
19298         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19299         [[ $MDSCOUNT -lt 4 ]] && skip_env "needs >= 4 MDTs"
19300
19301         local remote_file=$DIR/$tdir/tgt_dir/b
19302
19303         mkdir -p $DIR/$tdir
19304
19305         prepare_remote_file || error "prepare remote file failed"
19306
19307         ln $remote_file $DIR/$tfile || error "link failed for remote file"
19308         multiop_bg_pause $remote_file O_uc ||
19309                         error "mulitop failed for remote file"
19310         MULTIPID=$!
19311         $MULTIOP $DIR/$tfile Ouc
19312         kill -USR1 $MULTIPID
19313         wait $MULTIPID
19314 }
19315 run_test 310c "open-unlink remote file with multiple links"
19316
19317 #LU-4825
19318 test_311() {
19319         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19320         [ $OSTCOUNT -lt 2 ] && skip "needs >= 2 OSTs"
19321         [ $MDS1_VERSION -lt $(version_code 2.8.54) ] &&
19322                 skip "lustre < 2.8.54 does not contain LU-4825 fix"
19323         remote_mds_nodsh && skip "remote MDS with nodsh"
19324
19325         local old_iused=$($LFS df -i | grep OST0000 | awk '{ print $3 }')
19326         local mdts=$(comma_list $(mdts_nodes))
19327
19328         mkdir -p $DIR/$tdir
19329         $LFS setstripe -i 0 -c 1 $DIR/$tdir
19330         createmany -o $DIR/$tdir/$tfile. 1000
19331
19332         # statfs data is not real time, let's just calculate it
19333         old_iused=$((old_iused + 1000))
19334
19335         local count=$(do_facet $SINGLEMDS "$LCTL get_param -n \
19336                         osp.*OST0000*MDT0000.create_count")
19337         local max_count=$(do_facet $SINGLEMDS "$LCTL get_param -n \
19338                                 osp.*OST0000*MDT0000.max_create_count")
19339         do_nodes $mdts "$LCTL set_param -n osp.*OST0000*.max_create_count=0"
19340
19341         $LFS setstripe -i 0 $DIR/$tdir/$tfile || error "setstripe failed"
19342         local index=$($LFS getstripe -i $DIR/$tdir/$tfile)
19343         [ $index -ne 0 ] || error "$tfile stripe index is 0"
19344
19345         unlinkmany $DIR/$tdir/$tfile. 1000
19346
19347         do_nodes $mdts "$LCTL set_param -n \
19348                         osp.*OST0000*.max_create_count=$max_count"
19349         [ $MDS1_VERSION -lt $(version_code 2.12.51) ] &&
19350                 do_nodes $mdts "$LCTL set_param -n \
19351                                 osp.*OST0000*.create_count=$count"
19352         do_nodes $mdts "$LCTL get_param osp.*OST0000*.create_count" |
19353                         grep "=0" && error "create_count is zero"
19354
19355         local new_iused
19356         for i in $(seq 120); do
19357                 new_iused=$($LFS df -i | grep OST0000 | awk '{ print $3 }')
19358                 # system may be too busy to destroy all objs in time, use
19359                 # a somewhat small value to not fail autotest
19360                 [ $((old_iused - new_iused)) -gt 400 ] && break
19361                 sleep 1
19362         done
19363
19364         echo "waited $i sec, old Iused $old_iused, new Iused $new_iused"
19365         [ $((old_iused - new_iused)) -gt 400 ] ||
19366                 error "objs not destroyed after unlink"
19367 }
19368 run_test 311 "disable OSP precreate, and unlink should destroy objs"
19369
19370 zfs_oid_to_objid()
19371 {
19372         local ost=$1
19373         local objid=$2
19374
19375         local vdevdir=$(dirname $(facet_vdevice $ost))
19376         local cmd="$ZDB -e -p $vdevdir -ddddd $(facet_device $ost)"
19377         local zfs_zapid=$(do_facet $ost $cmd |
19378                           grep -w "/O/0/d$((objid%32))" -C 5 |
19379                           awk '/Object/{getline; print $1}')
19380         local zfs_objid=$(do_facet $ost $cmd $zfs_zapid |
19381                           awk "/$objid = /"'{printf $3}')
19382
19383         echo $zfs_objid
19384 }
19385
19386 zfs_object_blksz() {
19387         local ost=$1
19388         local objid=$2
19389
19390         local vdevdir=$(dirname $(facet_vdevice $ost))
19391         local cmd="$ZDB -e -p $vdevdir -dddd $(facet_device $ost)"
19392         local blksz=$(do_facet $ost $cmd $objid |
19393                       awk '/dblk/{getline; printf $4}')
19394
19395         case "${blksz: -1}" in
19396                 k|K) blksz=$((${blksz:0:$((${#blksz} - 1))}*1024)) ;;
19397                 m|M) blksz=$((${blksz:0:$((${#blksz} - 1))}*1024*1024)) ;;
19398                 *) ;;
19399         esac
19400
19401         echo $blksz
19402 }
19403
19404 test_312() { # LU-4856
19405         remote_ost_nodsh && skip "remote OST with nodsh"
19406         [ "$ost1_FSTYPE" = "zfs" ] ||
19407                 skip_env "the test only applies to zfs"
19408
19409         local max_blksz=$(do_facet ost1 \
19410                           $ZFS get -p recordsize $(facet_device ost1) |
19411                           awk '!/VALUE/{print $3}')
19412
19413         # to make life a little bit easier
19414         $LFS mkdir -c 1 -i 0 $DIR/$tdir
19415         $LFS setstripe -c 1 -i 0 $DIR/$tdir
19416
19417         local tf=$DIR/$tdir/$tfile
19418         touch $tf
19419         local oid=$($LFS getstripe $tf | awk '/obdidx/{getline; print $2}')
19420
19421         # Get ZFS object id
19422         local zfs_objid=$(zfs_oid_to_objid ost1 $oid)
19423         # block size change by sequential overwrite
19424         local bs
19425
19426         for ((bs=$PAGE_SIZE; bs <= max_blksz; bs *= 4)) ; do
19427                 dd if=/dev/zero of=$tf bs=$bs count=1 oflag=sync conv=notrunc
19428
19429                 local blksz=$(zfs_object_blksz ost1 $zfs_objid)
19430                 [ $blksz -eq $bs ] || error "blksz error: $blksz, expected: $bs"
19431         done
19432         rm -f $tf
19433
19434         # block size change by sequential append write
19435         dd if=/dev/zero of=$tf bs=$PAGE_SIZE count=1 oflag=sync conv=notrunc
19436         oid=$($LFS getstripe $tf | awk '/obdidx/{getline; print $2}')
19437         zfs_objid=$(zfs_oid_to_objid ost1 $oid)
19438         local count
19439
19440         for ((count = 1; count < $((max_blksz / PAGE_SIZE)); count *= 2)); do
19441                 dd if=/dev/zero of=$tf bs=$PAGE_SIZE count=$count seek=$count \
19442                         oflag=sync conv=notrunc
19443
19444                 blksz=$(zfs_object_blksz ost1 $zfs_objid)
19445                 [ $blksz -eq $((2 * count * PAGE_SIZE)) ] ||
19446                         error "blksz error, actual $blksz, " \
19447                                 "expected: 2 * $count * $PAGE_SIZE"
19448         done
19449         rm -f $tf
19450
19451         # random write
19452         touch $tf
19453         oid=$($LFS getstripe $tf | awk '/obdidx/{getline; print $2}')
19454         zfs_objid=$(zfs_oid_to_objid ost1 $oid)
19455
19456         dd if=/dev/zero of=$tf bs=1K count=1 oflag=sync conv=notrunc
19457         blksz=$(zfs_object_blksz ost1 $zfs_objid)
19458         [ $blksz -eq $PAGE_SIZE ] ||
19459                 error "blksz error: $blksz, expected: $PAGE_SIZE"
19460
19461         dd if=/dev/zero of=$tf bs=64K count=1 oflag=sync conv=notrunc seek=128
19462         blksz=$(zfs_object_blksz ost1 $zfs_objid)
19463         [ $blksz -eq 65536 ] || error "blksz error: $blksz, expected: 64k"
19464
19465         dd if=/dev/zero of=$tf bs=1M count=1 oflag=sync conv=notrunc
19466         blksz=$(zfs_object_blksz ost1 $zfs_objid)
19467         [ $blksz -eq 65536 ] || error "rewrite error: $blksz, expected: 64k"
19468 }
19469 run_test 312 "make sure ZFS adjusts its block size by write pattern"
19470
19471 test_313() {
19472         remote_ost_nodsh && skip "remote OST with nodsh"
19473
19474         local file=$DIR/$tfile
19475
19476         rm -f $file
19477         $LFS setstripe -c 1 -i 0 $file || error "setstripe failed"
19478
19479         # define OBD_FAIL_TGT_RCVD_EIO           0x720
19480         do_facet ost1 "$LCTL set_param fail_loc=0x720"
19481         dd if=/dev/zero of=$file bs=$PAGE_SIZE oflag=direct count=1 &&
19482                 error "write should failed"
19483         do_facet ost1 "$LCTL set_param fail_loc=0"
19484         rm -f $file
19485 }
19486 run_test 313 "io should fail after last_rcvd update fail"
19487
19488 test_314() {
19489         [ $OSTCOUNT -lt 2 ] && skip "needs >= 2 OSTs"
19490
19491         $LFS setstripe -c 2 -i 0 $DIR/$tfile || error "setstripe failed"
19492         do_facet ost1 "$LCTL set_param fail_loc=0x720"
19493         rm -f $DIR/$tfile
19494         wait_delete_completed
19495         do_facet ost1 "$LCTL set_param fail_loc=0"
19496 }
19497 run_test 314 "OSP shouldn't fail after last_rcvd update failure"
19498
19499 test_315() { # LU-618
19500         [ -f /proc/$$/io ] || skip_env "no IO accounting in kernel"
19501
19502         local file=$DIR/$tfile
19503         rm -f $file
19504
19505         $MULTIOP $file oO_CREAT:O_DIRECT:O_RDWR:w4063232c ||
19506                 error "multiop file write failed"
19507         $MULTIOP $file oO_RDONLY:r4063232_c &
19508         PID=$!
19509
19510         sleep 2
19511
19512         local rbytes=$(awk '/read_bytes/ { print $2 }' /proc/$PID/io)
19513         kill -USR1 $PID
19514
19515         [ $rbytes -gt 4000000 ] || error "read is not accounted ($rbytes)"
19516         rm -f $file
19517 }
19518 run_test 315 "read should be accounted"
19519
19520 test_316() {
19521         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
19522         large_xattr_enabled || skip_env "ea_inode feature disabled"
19523
19524         rm -rf $DIR/$tdir/d
19525         mkdir -p $DIR/$tdir/d
19526         chown nobody $DIR/$tdir/d
19527         touch $DIR/$tdir/d/file
19528
19529         $LFS mv -M1 $DIR/$tdir/d || error "lfs mv failed"
19530 }
19531 run_test 316 "lfs mv"
19532
19533 test_317() {
19534         [ $MDS1_VERSION -lt $(version_code 2.11.53) ] &&
19535                 skip "Need MDS version at least 2.11.53"
19536         if [ "$ost1_FSTYPE" == "zfs" ]; then
19537                 skip "LU-10370: no implementation for ZFS"
19538         fi
19539
19540         local trunc_sz
19541         local grant_blk_size
19542
19543         grant_blk_size=$($LCTL get_param osc.$FSNAME*.import |
19544                         awk '/grant_block_size:/ { print $2; exit; }')
19545         #
19546         # Create File of size 5M. Truncate it to below size's and verify
19547         # blocks count.
19548         #
19549         dd if=/dev/zero of=$DIR/$tfile bs=5M count=1 conv=fsync ||
19550                 error "Create file $DIR/$tfile failed"
19551         stack_trap "rm -f $DIR/$tfile" EXIT
19552
19553         for trunc_sz in 2097152 4097 4000 509 0; do
19554                 $TRUNCATE $DIR/$tfile $trunc_sz ||
19555                         error "truncate $tfile to $trunc_sz failed"
19556                 local sz=$(stat --format=%s $DIR/$tfile)
19557                 local blk=$(stat --format=%b $DIR/$tfile)
19558                 local trunc_blk=$((((trunc_sz + (grant_blk_size - 1) ) /
19559                                      grant_blk_size) * 8))
19560
19561                 if [[ $blk -ne $trunc_blk ]]; then
19562                         $(which stat) $DIR/$tfile
19563                         error "Expected Block $trunc_blk got $blk for $tfile"
19564                 fi
19565
19566                 $CHECKSTAT -s $trunc_sz $DIR/$tfile ||
19567                         error "Expected Size $trunc_sz got $sz for $tfile"
19568         done
19569
19570         #
19571         # sparse file test
19572         # Create file with a hole and write actual two blocks. Block count
19573         # must be 16.
19574         #
19575         dd if=/dev/zero of=$DIR/$tfile bs=$grant_blk_size count=2 seek=5 \
19576                 conv=fsync || error "Create file : $DIR/$tfile"
19577
19578         # Calculate the final truncate size.
19579         trunc_sz=$(($(stat --format=%s $DIR/$tfile) - (grant_blk_size + 1)))
19580
19581         #
19582         # truncate to size $trunc_sz bytes. Strip the last block
19583         # The block count must drop to 8
19584         #
19585         $TRUNCATE $DIR/$tfile $trunc_sz ||
19586                 error "truncate $tfile to $trunc_sz failed"
19587
19588         local trunc_bsz=$((grant_blk_size / $(stat --format=%B $DIR/$tfile)))
19589         sz=$(stat --format=%s $DIR/$tfile)
19590         blk=$(stat --format=%b $DIR/$tfile)
19591
19592         if [[ $blk -ne $trunc_bsz ]]; then
19593                 $(which stat) $DIR/$tfile
19594                 error "Expected Block $trunc_bsz got $blk for $tfile"
19595         fi
19596
19597         $CHECKSTAT -s $trunc_sz $DIR/$tfile ||
19598                 error "Expected Size $trunc_sz got $sz for $tfile"
19599 }
19600 run_test 317 "Verify blocks get correctly update after truncate"
19601
19602 test_318() {
19603         local old_max_active=$($LCTL get_param -n \
19604                             llite.*.max_read_ahead_async_active 2>/dev/null)
19605
19606         $LCTL set_param llite.*.max_read_ahead_async_active=256
19607         local max_active=$($LCTL get_param -n \
19608                            llite.*.max_read_ahead_async_active 2>/dev/null)
19609         [ $max_active -ne 256 ] && error "expected 256 but got $max_active"
19610
19611         # currently reset to 0 is unsupported, leave it 512 for now.
19612         $LCTL set_param llite.*.max_read_ahead_async_active=0 &&
19613                 error "set max_read_ahead_async_active should fail"
19614
19615         $LCTL set_param llite.*.max_read_ahead_async_active=512
19616         max_active=$($LCTL get_param -n \
19617                      llite.*.max_read_ahead_async_active 2>/dev/null)
19618         [ $max_active -eq 512 ] || error "expected 512 but got $max_active"
19619
19620         # restore @max_active
19621         [ $old_max_active -ne 0 ] && $LCTL set_param \
19622                 llite.*.max_read_ahead_async_active=$old_max_active
19623
19624         local old_threshold=$($LCTL get_param -n \
19625                 llite.*.read_ahead_async_file_threshold_mb 2>/dev/null)
19626         local max_per_file_mb=$($LCTL get_param -n \
19627                 llite.*.max_read_ahead_per_file_mb 2>/dev/null)
19628
19629         local invalid=$(($max_per_file_mb + 1))
19630         $LCTL set_param \
19631                 llite.*.read_ahead_async_file_threshold_mb=$invalid\
19632                         && error "set $invalid should fail"
19633
19634         local valid=$(($invalid - 1))
19635         $LCTL set_param \
19636                 llite.*.read_ahead_async_file_threshold_mb=$valid ||
19637                         error "set $valid should succeed"
19638         local threshold=$($LCTL get_param -n \
19639                 llite.*.read_ahead_async_file_threshold_mb 2>/dev/null)
19640         [ $threshold -eq $valid ] || error \
19641                 "expect threshold $valid got $threshold"
19642         $LCTL set_param \
19643                 llite.*.read_ahead_async_file_threshold_mb=$old_threshold
19644 }
19645 run_test 318 "Verify async readahead tunables"
19646
19647 test_319() {
19648         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
19649
19650         local before=$(date +%s)
19651         local evict
19652         local mdir=$DIR/$tdir
19653         local file=$mdir/xxx
19654
19655         $LFS mkdir -i0 $mdir || error "mkdir $mdir fails"
19656         touch $file
19657
19658 #define OBD_FAIL_LDLM_LOCAL_CANCEL_PAUSE 0x32c
19659         $LCTL set_param fail_val=5 fail_loc=0x8000032c
19660         $LFS mv -m1 $file &
19661
19662         sleep 1
19663         dd if=$file of=/dev/null
19664         wait
19665         evict=$($LCTL get_param mdc.$FSNAME-MDT*.state |
19666           awk -F"[ [,]" '/EVICTED ]$/ { if (mx<$5) {mx=$5;} } END { print mx }')
19667
19668         [ -z "$evict" ] || [[ $evict -le $before ]] || error "eviction happened"
19669 }
19670 run_test 319 "lost lease lock on migrate error"
19671
19672 test_fake_rw() {
19673         local read_write=$1
19674         if [ "$read_write" = "write" ]; then
19675                 local dd_cmd="dd if=/dev/zero of=$DIR/$tfile"
19676         elif [ "$read_write" = "read" ]; then
19677                 local dd_cmd="dd of=/dev/null if=$DIR/$tfile"
19678         else
19679                 error "argument error"
19680         fi
19681
19682         # turn off debug for performance testing
19683         local saved_debug=$($LCTL get_param -n debug)
19684         $LCTL set_param debug=0
19685
19686         $LFS setstripe -c 1 -i 0 $DIR/$tfile
19687
19688         # get ost1 size - lustre-OST0000
19689         local ost1_avail_size=$($LFS df | awk /${ost1_svc}/'{ print $4 }')
19690         local blocks=$((ost1_avail_size/2/1024)) # half avail space by megabytes
19691         [ $blocks -gt 1000 ] && blocks=1000 # 1G in maximum
19692
19693         if [ "$read_write" = "read" ]; then
19694                 truncate -s $(expr 1048576 \* $blocks) $DIR/$tfile
19695         fi
19696
19697         local start_time=$(date +%s.%N)
19698         $dd_cmd bs=1M count=$blocks oflag=sync ||
19699                 error "real dd $read_write error"
19700         local duration=$(bc <<< "$(date +%s.%N) - $start_time")
19701
19702         if [ "$read_write" = "write" ]; then
19703                 rm -f $DIR/$tfile
19704         fi
19705
19706         # define OBD_FAIL_OST_FAKE_RW           0x238
19707         do_facet ost1 $LCTL set_param fail_loc=0x238
19708
19709         local start_time=$(date +%s.%N)
19710         $dd_cmd bs=1M count=$blocks oflag=sync ||
19711                 error "fake dd $read_write error"
19712         local duration_fake=$(bc <<< "$(date +%s.%N) - $start_time")
19713
19714         if [ "$read_write" = "write" ]; then
19715                 # verify file size
19716                 cancel_lru_locks osc
19717                 $CHECKSTAT -t file -s $((blocks * 1024 * 1024)) $DIR/$tfile ||
19718                         error "$tfile size not $blocks MB"
19719         fi
19720         do_facet ost1 $LCTL set_param fail_loc=0
19721
19722         echo "fake $read_write $duration_fake vs. normal $read_write" \
19723                 "$duration in seconds"
19724         [ $(bc <<< "$duration_fake < $duration") -eq 1 ] ||
19725                 error_not_in_vm "fake write is slower"
19726
19727         $LCTL set_param -n debug="$saved_debug"
19728         rm -f $DIR/$tfile
19729 }
19730 test_399a() { # LU-7655 for OST fake write
19731         remote_ost_nodsh && skip "remote OST with nodsh"
19732
19733         test_fake_rw write
19734 }
19735 run_test 399a "fake write should not be slower than normal write"
19736
19737 test_399b() { # LU-8726 for OST fake read
19738         remote_ost_nodsh && skip "remote OST with nodsh"
19739         if [ "$ost1_FSTYPE" != "ldiskfs" ]; then
19740                 skip_env "ldiskfs only test"
19741         fi
19742
19743         test_fake_rw read
19744 }
19745 run_test 399b "fake read should not be slower than normal read"
19746
19747 test_400a() { # LU-1606, was conf-sanity test_74
19748         if ! which $CC > /dev/null 2>&1; then
19749                 skip_env "$CC is not installed"
19750         fi
19751
19752         local extra_flags=''
19753         local out=$TMP/$tfile
19754         local prefix=/usr/include/lustre
19755         local prog
19756
19757         if ! [[ -d $prefix ]]; then
19758                 # Assume we're running in tree and fixup the include path.
19759                 extra_flags+=" -I$LUSTRE/../lnet/include/uapi -I$LUSTRE/include/uapi -I$LUSTRE/include"
19760                 extra_flags+=" -L$LUSTRE/utils/.lib"
19761         fi
19762
19763         for prog in $LUSTRE_TESTS_API_DIR/*.c; do
19764                 $CC -Wall -Werror $extra_flags -o $out $prog -llustreapi ||
19765                         error "client api broken"
19766         done
19767         rm -f $out
19768 }
19769 run_test 400a "Lustre client api program can compile and link"
19770
19771 test_400b() { # LU-1606, LU-5011
19772         local header
19773         local out=$TMP/$tfile
19774         local prefix=/usr/include/linux/lustre
19775
19776         # We use a hard coded prefix so that this test will not fail
19777         # when run in tree. There are headers in lustre/include/lustre/
19778         # that are not packaged (like lustre_idl.h) and have more
19779         # complicated include dependencies (like config.h and lnet/types.h).
19780         # Since this test about correct packaging we just skip them when
19781         # they don't exist (see below) rather than try to fixup cppflags.
19782
19783         if ! which $CC > /dev/null 2>&1; then
19784                 skip_env "$CC is not installed"
19785         fi
19786
19787         for header in $prefix/*.h; do
19788                 if ! [[ -f "$header" ]]; then
19789                         continue
19790                 fi
19791
19792                 if [[ "$(basename $header)" == lustre_ioctl.h ]]; then
19793                         continue # lustre_ioctl.h is internal header
19794                 fi
19795
19796                 $CC -Wall -Werror -include $header -c -x c /dev/null -o $out ||
19797                         error "cannot compile '$header'"
19798         done
19799         rm -f $out
19800 }
19801 run_test 400b "packaged headers can be compiled"
19802
19803 test_401a() { #LU-7437
19804         local printf_arg=$(find -printf 2>&1 | grep "unrecognized:")
19805         [ -n "$printf_arg" ] && skip_env "find does not support -printf"
19806
19807         #count the number of parameters by "list_param -R"
19808         local params=$($LCTL list_param -R '*' 2>/dev/null | wc -l)
19809         #count the number of parameters by listing proc files
19810         local proc_dirs=$(eval \ls -d $proc_regexp 2>/dev/null)
19811         echo "proc_dirs='$proc_dirs'"
19812         [ -n "$proc_dirs" ] || error "no proc_dirs on $HOSTNAME"
19813         local procs=$(find -L $proc_dirs -mindepth 1 -printf '%P\n' 2>/dev/null|
19814                       sort -u | wc -l)
19815
19816         [ $params -eq $procs ] ||
19817                 error "found $params parameters vs. $procs proc files"
19818
19819         # test the list_param -D option only returns directories
19820         params=$($LCTL list_param -R -D '*' 2>/dev/null | wc -l)
19821         #count the number of parameters by listing proc directories
19822         procs=$(find -L $proc_dirs -mindepth 1 -type d -printf '%P\n' 2>/dev/null |
19823                 sort -u | wc -l)
19824
19825         [ $params -eq $procs ] ||
19826                 error "found $params parameters vs. $procs proc files"
19827 }
19828 run_test 401a "Verify if 'lctl list_param -R' can list parameters recursively"
19829
19830 test_401b() {
19831         local save=$($LCTL get_param -n jobid_var)
19832         local tmp=testing
19833
19834         $LCTL set_param foo=bar jobid_var=$tmp bar=baz &&
19835                 error "no error returned when setting bad parameters"
19836
19837         local jobid_new=$($LCTL get_param -n foe jobid_var baz)
19838         [[ "$jobid_new" == "$tmp" ]] || error "jobid tmp $jobid_new != $tmp"
19839
19840         $LCTL set_param -n fog=bam jobid_var=$save bat=fog
19841         local jobid_old=$($LCTL get_param -n foe jobid_var bag)
19842         [[ "$jobid_old" == "$save" ]] || error "jobid new $jobid_old != $save"
19843 }
19844 run_test 401b "Verify 'lctl {get,set}_param' continue after error"
19845
19846 test_401c() {
19847         local jobid_var_old=$($LCTL get_param -n jobid_var)
19848         local jobid_var_new
19849
19850         $LCTL set_param jobid_var= &&
19851                 error "no error returned for 'set_param a='"
19852
19853         jobid_var_new=$($LCTL get_param -n jobid_var)
19854         [[ "$jobid_var_old" == "$jobid_var_new" ]] ||
19855                 error "jobid_var was changed by setting without value"
19856
19857         $LCTL set_param jobid_var &&
19858                 error "no error returned for 'set_param a'"
19859
19860         jobid_var_new=$($LCTL get_param -n jobid_var)
19861         [[ "$jobid_var_old" == "$jobid_var_new" ]] ||
19862                 error "jobid_var was changed by setting without value"
19863 }
19864 run_test 401c "Verify 'lctl set_param' without value fails in either format."
19865
19866 test_401d() {
19867         local jobid_var_old=$($LCTL get_param -n jobid_var)
19868         local jobid_var_new
19869         local new_value="foo=bar"
19870
19871         $LCTL set_param jobid_var=$new_value ||
19872                 error "'set_param a=b' did not accept a value containing '='"
19873
19874         jobid_var_new=$($LCTL get_param -n jobid_var)
19875         [[ "$jobid_var_new" == "$new_value" ]] ||
19876                 error "'set_param a=b' failed on a value containing '='"
19877
19878         # Reset the jobid_var to test the other format
19879         $LCTL set_param jobid_var=$jobid_var_old
19880         jobid_var_new=$($LCTL get_param -n jobid_var)
19881         [[ "$jobid_var_new" == "$jobid_var_old" ]] ||
19882                 error "failed to reset jobid_var"
19883
19884         $LCTL set_param jobid_var $new_value ||
19885                 error "'set_param a b' did not accept a value containing '='"
19886
19887         jobid_var_new=$($LCTL get_param -n jobid_var)
19888         [[ "$jobid_var_new" == "$new_value" ]] ||
19889                 error "'set_param a b' failed on a value containing '='"
19890
19891         $LCTL set_param jobid_var $jobid_var_old
19892         jobid_var_new=$($LCTL get_param -n jobid_var)
19893         [[ "$jobid_var_new" == "$jobid_var_old" ]] ||
19894                 error "failed to reset jobid_var"
19895 }
19896 run_test 401d "Verify 'lctl set_param' accepts values containing '='"
19897
19898 test_402() {
19899         [[ $MDS1_VERSION -ge $(version_code 2.7.66) ]] ||
19900         [[ $MDS1_VERSION -ge $(version_code 2.7.18.4) &&
19901                 $MDS1_VERSION -lt $(version_code 2.7.50) ]] ||
19902         [[ $MDS1_VERSION -ge $(version_code 2.7.2) &&
19903                 $MDS1_VERSION -lt $(version_code 2.7.11) ]] ||
19904                 skip "Need MDS version 2.7.2+ or 2.7.18.4+ or 2.7.66+"
19905         remote_mds_nodsh && skip "remote MDS with nodsh"
19906
19907         $LFS setdirstripe -i 0 $DIR/$tdir || error "setdirstripe -i 0 failed"
19908 #define OBD_FAIL_MDS_FLD_LOOKUP 0x15c
19909         do_facet mds1 "lctl set_param fail_loc=0x8000015c"
19910         touch $DIR/$tdir/$tfile && error "touch should fail with ENOENT" ||
19911                 echo "Touch failed - OK"
19912 }
19913 run_test 402 "Return ENOENT to lod_generate_and_set_lovea"
19914
19915 test_403() {
19916         local file1=$DIR/$tfile.1
19917         local file2=$DIR/$tfile.2
19918         local tfile=$TMP/$tfile
19919
19920         rm -f $file1 $file2 $tfile
19921
19922         touch $file1
19923         ln $file1 $file2
19924
19925         # 30 sec OBD_TIMEOUT in ll_getattr()
19926         # right before populating st_nlink
19927         $LCTL set_param fail_loc=0x80001409
19928         stat -c %h $file1 > $tfile &
19929
19930         # create an alias, drop all locks and reclaim the dentry
19931         < $file2
19932         cancel_lru_locks mdc
19933         cancel_lru_locks osc
19934         sysctl -w vm.drop_caches=2
19935
19936         wait
19937
19938         [ $(cat $tfile) -gt 0 ] || error "wrong nlink count: $(cat $tfile)"
19939
19940         rm -f $tfile $file1 $file2
19941 }
19942 run_test 403 "i_nlink should not drop to zero due to aliasing"
19943
19944 test_404() { # LU-6601
19945         [[ $MDS1_VERSION -ge $(version_code 2.8.53) ]] ||
19946                 skip "Need server version newer than 2.8.52"
19947         remote_mds_nodsh && skip "remote MDS with nodsh"
19948
19949         local mosps=$(do_facet $SINGLEMDS $LCTL dl |
19950                 awk '/osp .*-osc-MDT/ { print $4}')
19951
19952         local osp
19953         for osp in $mosps; do
19954                 echo "Deactivate: " $osp
19955                 do_facet $SINGLEMDS $LCTL --device %$osp deactivate
19956                 local stat=$(do_facet $SINGLEMDS $LCTL dl |
19957                         awk -vp=$osp '$4 == p { print $2 }')
19958                 [ $stat = IN ] || {
19959                         do_facet $SINGLEMDS $LCTL dl | grep -w $osp
19960                         error "deactivate error"
19961                 }
19962                 echo "Activate: " $osp
19963                 do_facet $SINGLEMDS $LCTL --device %$osp activate
19964                 local stat=$(do_facet $SINGLEMDS $LCTL dl |
19965                         awk -vp=$osp '$4 == p { print $2 }')
19966                 [ $stat = UP ] || {
19967                         do_facet $SINGLEMDS $LCTL dl | grep -w $osp
19968                         error "activate error"
19969                 }
19970         done
19971 }
19972 run_test 404 "validate manual {de}activated works properly for OSPs"
19973
19974 test_405() {
19975         [ -n "$FILESET" ] && skip "Not functional for FILESET set"
19976         [ $MDS1_VERSION -lt $(version_code 2.6.92) ] ||
19977                 [ $CLIENT_VERSION -lt $(version_code 2.6.99) ] &&
19978                         skip "Layout swap lock is not supported"
19979
19980         check_swap_layouts_support
19981
19982         test_mkdir $DIR/$tdir
19983         swap_lock_test -d $DIR/$tdir ||
19984                 error "One layout swap locked test failed"
19985 }
19986 run_test 405 "Various layout swap lock tests"
19987
19988 test_406() {
19989         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19990         [ $OSTCOUNT -lt 2 ] && skip_env "needs >= 2 OSTs"
19991         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
19992         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19993         [ $MDS1_VERSION -lt $(version_code 2.8.50) ] &&
19994                 skip "Need MDS version at least 2.8.50"
19995
19996         local def_stripe_size=$($LFS getstripe -S $MOUNT)
19997         local test_pool=$TESTNAME
19998
19999         if ! combined_mgs_mds ; then
20000                 mount_mgs_client
20001         fi
20002         pool_add $test_pool || error "pool_add failed"
20003         pool_add_targets $test_pool 0 $(($OSTCOUNT - 1)) 1 ||
20004                 error "pool_add_targets failed"
20005
20006         save_layout_restore_at_exit $MOUNT
20007
20008         # parent set default stripe count only, child will stripe from both
20009         # parent and fs default
20010         $LFS setstripe -c 1 -i 1 -S $((def_stripe_size * 2)) -p $test_pool $MOUNT ||
20011                 error "setstripe $MOUNT failed"
20012         $LFS mkdir -c $MDSCOUNT $DIR/$tdir || error "mkdir $tdir failed"
20013         $LFS setstripe -c $OSTCOUNT $DIR/$tdir || error "setstripe $tdir failed"
20014         for i in $(seq 10); do
20015                 local f=$DIR/$tdir/$tfile.$i
20016                 touch $f || error "touch failed"
20017                 local count=$($LFS getstripe -c $f)
20018                 [ $count -eq $OSTCOUNT ] ||
20019                         error "$f stripe count $count != $OSTCOUNT"
20020                 local offset=$($LFS getstripe -i $f)
20021                 [ $offset -eq 1 ] || error "$f stripe offset $offset != 1"
20022                 local size=$($LFS getstripe -S $f)
20023                 [ $size -eq $((def_stripe_size * 2)) ] ||
20024                         error "$f stripe size $size != $((def_stripe_size * 2))"
20025                 local pool=$($LFS getstripe -p $f)
20026                 [ $pool == $test_pool ] || error "$f pool $pool != $test_pool"
20027         done
20028
20029         # change fs default striping, delete parent default striping, now child
20030         # will stripe from new fs default striping only
20031         $LFS setstripe -c 1 -S $def_stripe_size -i 0 $MOUNT ||
20032                 error "change $MOUNT default stripe failed"
20033         $LFS setstripe -c 0 $DIR/$tdir ||
20034                 error "delete $tdir default stripe failed"
20035         for i in $(seq 11 20); do
20036                 local f=$DIR/$tdir/$tfile.$i
20037                 touch $f || error "touch $f failed"
20038                 local count=$($LFS getstripe -c $f)
20039                 [ $count -eq 1 ] || error "$f stripe count $count != 1"
20040                 local offset=$($LFS getstripe -i $f)
20041                 [ $offset -eq 0 ] || error "$f stripe offset $offset != 0"
20042                 local size=$($LFS getstripe -S $f)
20043                 [ $size -eq $def_stripe_size ] ||
20044                         error "$f stripe size $size != $def_stripe_size"
20045                 local pool=$($LFS getstripe -p $f)
20046                 [ $pool == $test_pool ] || error "$f pool $pool isn't set"
20047         done
20048
20049         unlinkmany $DIR/$tdir/$tfile. 1 20
20050
20051         local f=$DIR/$tdir/$tfile
20052         pool_remove_all_targets $test_pool $f
20053         pool_remove $test_pool $f
20054
20055         if ! combined_mgs_mds ; then
20056                 umount_mgs_client
20057         fi
20058 }
20059 run_test 406 "DNE support fs default striping"
20060
20061 test_407() {
20062         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
20063         [[ $MDS1_VERSION -lt $(version_code 2.8.55) ]] &&
20064                 skip "Need MDS version at least 2.8.55"
20065         remote_mds_nodsh && skip "remote MDS with nodsh"
20066
20067         $LFS mkdir -i 0 -c 1 $DIR/$tdir.0 ||
20068                 error "$LFS mkdir -i 0 -c 1 $tdir.0 failed"
20069         $LFS mkdir -i 1 -c 1 $DIR/$tdir.1 ||
20070                 error "$LFS mkdir -i 1 -c 1 $tdir.1 failed"
20071         touch $DIR/$tdir.0/$tfile.0 || error "touch $tdir.0/$tfile.0 failed"
20072
20073         #define OBD_FAIL_DT_TXN_STOP    0x2019
20074         for idx in $(seq $MDSCOUNT); do
20075                 do_facet mds$idx "lctl set_param fail_loc=0x2019"
20076         done
20077         $LFS mkdir -c 2 $DIR/$tdir && error "$LFS mkdir -c 2 $tdir should fail"
20078         mv $DIR/$tdir.0/$tfile.0 $DIR/$tdir.1/$tfile.1 &&
20079                 error "mv $tdir.0/$tfile.0 $tdir.1/$tfile.1 should fail"
20080         true
20081 }
20082 run_test 407 "transaction fail should cause operation fail"
20083
20084 test_408() {
20085         dd if=/dev/zero of=$DIR/$tfile bs=$PAGE_SIZE count=1 oflag=direct
20086
20087         #define OBD_FAIL_OSC_BRW_PREP_REQ2        0x40a
20088         lctl set_param fail_loc=0x8000040a
20089         # let ll_prepare_partial_page() fail
20090         dd if=/dev/zero of=$DIR/$tfile bs=2048 count=1 conv=notrunc || true
20091
20092         rm -f $DIR/$tfile
20093
20094         # create at least 100 unused inodes so that
20095         # shrink_icache_memory(0) should not return 0
20096         touch $DIR/$tfile-{0..100}
20097         rm -f $DIR/$tfile-{0..100}
20098         sync
20099
20100         echo 2 > /proc/sys/vm/drop_caches
20101 }
20102 run_test 408 "drop_caches should not hang due to page leaks"
20103
20104 test_409()
20105 {
20106         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
20107
20108         mkdir -p $DIR/$tdir || error "(0) Fail to mkdir"
20109         $LFS mkdir -i 1 -c 2 $DIR/$tdir/foo || error "(1) Fail to mkdir"
20110         touch $DIR/$tdir/guard || error "(2) Fail to create"
20111
20112         local PREFIX=$(str_repeat 'A' 128)
20113         echo "Create 1K hard links start at $(date)"
20114         createmany -l $DIR/$tdir/guard $DIR/$tdir/foo/${PREFIX}_ 1000 ||
20115                 error "(3) Fail to hard link"
20116
20117         echo "Links count should be right although linkEA overflow"
20118         stat $DIR/$tdir/guard || error "(4) Fail to stat"
20119         local linkcount=$(stat --format=%h $DIR/$tdir/guard)
20120         [ $linkcount -eq 1001 ] ||
20121                 error "(5) Unexpected hard links count: $linkcount"
20122
20123         echo "List all links start at $(date)"
20124         ls -l $DIR/$tdir/foo > /dev/null ||
20125                 error "(6) Fail to list $DIR/$tdir/foo"
20126
20127         echo "Unlink hard links start at $(date)"
20128         unlinkmany $DIR/$tdir/foo/${PREFIX}_ 1000 ||
20129                 error "(7) Fail to unlink"
20130         echo "Unlink hard links finished at $(date)"
20131 }
20132 run_test 409 "Large amount of cross-MDTs hard links on the same file"
20133
20134 test_410()
20135 {
20136         [[ $CLIENT_VERSION -lt $(version_code 2.9.59) ]] &&
20137                 skip "Need client version at least 2.9.59"
20138
20139         # Create a file, and stat it from the kernel
20140         local testfile=$DIR/$tfile
20141         touch $testfile
20142
20143         local run_id=$RANDOM
20144         local my_ino=$(stat --format "%i" $testfile)
20145
20146         # Try to insert the module. This will always fail as the
20147         # module is designed to not be inserted.
20148         insmod $LUSTRE/tests/kernel/kinode.ko run_id=$run_id fname=$testfile \
20149             &> /dev/null
20150
20151         # Anything but success is a test failure
20152         dmesg | grep -q \
20153             "lustre_kinode_$run_id: inode numbers are identical: $my_ino" ||
20154             error "no inode match"
20155 }
20156 run_test 410 "Test inode number returned from kernel thread"
20157
20158 cleanup_test411_cgroup() {
20159         trap 0
20160         rmdir "$1"
20161 }
20162
20163 test_411() {
20164         local cg_basedir=/sys/fs/cgroup/memory
20165         # LU-9966
20166         test -f "$cg_basedir/memory.kmem.limit_in_bytes" ||
20167                 skip "no setup for cgroup"
20168
20169         dd if=/dev/zero of=$DIR/$tfile bs=1M count=100 conv=fsync ||
20170                 error "test file creation failed"
20171         cancel_lru_locks osc
20172
20173         # Create a very small memory cgroup to force a slab allocation error
20174         local cgdir=$cg_basedir/osc_slab_alloc
20175         mkdir $cgdir || error "cgroup mkdir '$cgdir' failed"
20176         trap "cleanup_test411_cgroup $cgdir" EXIT
20177         echo 2M > $cgdir/memory.kmem.limit_in_bytes
20178         echo 1M > $cgdir/memory.limit_in_bytes
20179
20180         # Should not LBUG, just be killed by oom-killer
20181         # dd will return 0 even allocation failure in some environment.
20182         # So don't check return value
20183         sh -c "echo \$$ > $cgdir/tasks && dd if=$DIR/$tfile of=/dev/null"
20184         cleanup_test411_cgroup $cgdir
20185
20186         return 0
20187 }
20188 run_test 411 "Slab allocation error with cgroup does not LBUG"
20189
20190 test_412() {
20191         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
20192         if [ $(lustre_version_code mds1) -lt $(version_code 2.10.55) ]; then
20193                 skip "Need server version at least 2.10.55"
20194         fi
20195
20196         $LFS mkdir -i $((MDSCOUNT - 1)),$((MDSCOUNT - 2)) $DIR/$tdir ||
20197                 error "mkdir failed"
20198         $LFS getdirstripe $DIR/$tdir
20199         local stripe_index=$($LFS getdirstripe -i $DIR/$tdir)
20200         [ $stripe_index -eq $((MDSCOUNT - 1)) ] ||
20201                 error "expect $((MDSCOUT - 1)) get $stripe_index"
20202         local stripe_count=$($LFS getdirstripe -T $DIR/$tdir)
20203         [ $stripe_count -eq 2 ] ||
20204                 error "expect 2 get $stripe_count"
20205 }
20206 run_test 412 "mkdir on specific MDTs"
20207
20208 test_413a() {
20209         [ $MDSCOUNT -lt 2 ] &&
20210                 skip "We need at least 2 MDTs for this test"
20211
20212         if [ $(lustre_version_code mds1) -lt $(version_code 2.10.55) ]; then
20213                 skip "Need server version at least 2.10.55"
20214         fi
20215
20216         mkdir $DIR/$tdir || error "mkdir failed"
20217
20218         # find MDT that is the most full
20219         local max=$($LFS df | grep MDT |
20220                 awk 'BEGIN { a=0 }
20221                         { sub("%", "", $5)
20222                           if (0+$5 >= a)
20223                           {
20224                                 a = $5
20225                                 b = $6
20226                           }
20227                         }
20228                      END { split(b, c, ":")
20229                            sub("]", "", c[2])
20230                            print c[2]
20231                          }')
20232
20233         for i in $(seq $((MDSCOUNT - 1))); do
20234                 $LFS mkdir -c $i $DIR/$tdir/d$i ||
20235                         error "mkdir d$i failed"
20236                 $LFS getdirstripe $DIR/$tdir/d$i
20237                 local stripe_index=$($LFS getdirstripe -i $DIR/$tdir/d$i)
20238                 [ $stripe_index -ne $max ] ||
20239                         error "don't expect $max"
20240         done
20241 }
20242 run_test 413a "mkdir on less full MDTs"
20243
20244 test_413b() {
20245         [ $MDSCOUNT -lt 2 ] &&
20246                 skip "We need at least 2 MDTs for this test"
20247
20248         [ $MDS1_VERSION -lt $(version_code 2.12.52) ] &&
20249                 skip "Need server version at least 2.12.52"
20250
20251         mkdir $DIR/$tdir || error "mkdir failed"
20252         $LFS setdirstripe -D -i -1 -H space $DIR/$tdir ||
20253                 error "setdirstripe failed"
20254
20255         local qos_prio_free
20256         local qos_threshold_rr
20257         local count
20258
20259         qos_prio_free=$($LCTL get_param -n lmv.*.qos_prio_free | head -n1)
20260         qos_prio_free=${qos_prio_free%%%}
20261         qos_threshold_rr=$($LCTL get_param -n lmv.*.qos_threshold_rr | head -n1)
20262         qos_threshold_rr=${qos_threshold_rr%%%}
20263         qos_maxage=$($LCTL get_param -n lmv.*.qos_maxage)
20264
20265         stack_trap "$LCTL set_param lmv.*.qos_prio_free=$qos_prio_free" EXIT
20266         stack_trap "$LCTL set_param lmv.*.qos_threshold_rr=$qos_threshold_rr" \
20267                 EXIT
20268         stack_trap "$LCTL set_param lmv.*.qos_maxage=$qos_maxage" EXIT
20269
20270         echo "mkdir with roundrobin"
20271
20272         $LCTL set_param lmv.*.qos_threshold_rr=100
20273         for i in $(seq $((100 * MDSCOUNT))); do
20274                 mkdir $DIR/$tdir/subdir$i || error "mkdir subdir$i failed"
20275         done
20276         for i in $(seq $MDSCOUNT); do
20277                 count=$($LFS getdirstripe -i $DIR/$tdir/* | grep ^$((i - 1))$ |
20278                         wc -w)
20279                 echo "$count directories created on MDT$((i - 1))"
20280                 [ $count -eq 100 ] || error "subdirs are not evenly distributed"
20281         done
20282
20283         rm -rf $DIR/$tdir/*
20284
20285         $LCTL set_param lmv.*.qos_threshold_rr=$qos_threshold_rr
20286         # Shorten statfs result age, so that it can be updated in time
20287         $LCTL set_param lmv.*.qos_maxage=1
20288         sleep_maxage
20289
20290         local ffree
20291         local max
20292         local min
20293         local max_index
20294         local min_index
20295
20296         ffree=($(lctl get_param -n mdc.*[mM][dD][cC]-[^M]*.filesfree | uniq))
20297         echo "MDT filesfree available: ${ffree[@]}"
20298         max=${ffree[0]}
20299         min=${ffree[0]}
20300         max_index=0
20301         min_index=0
20302         for ((i = 0; i < ${#ffree[@]}; i++)); do
20303                 if [[ ${ffree[i]} -gt $max ]]; then
20304                         max=${ffree[i]}
20305                         max_index=$i
20306                 fi
20307                 if [[ ${ffree[i]} -lt $min ]]; then
20308                         min=${ffree[i]}
20309                         min_index=$i
20310                 fi
20311         done
20312         echo "Min free files: MDT$min_index: $min"
20313         echo "Max free files: MDT$max_index: $max"
20314
20315         [ $min -eq 0 ] && skip "no free files in MDT$min_index"
20316         [ $min -gt 10000000 ] && skip "too much free files in MDT$min_index"
20317
20318         # Check if we need to generate uneven MDTs
20319         test_mkdir -i $min_index -c 1 -p $DIR/$tdir-MDT$min_index
20320         local threshold=10
20321         local diff=$((max - min))
20322         local diff2=$((diff * 100 / min))
20323
20324         echo -n "Check for uneven MDTs: "
20325         echo -n "diff=$diff files ($diff2%) must be > $threshold% ..."
20326
20327         if [ $diff2 -gt $threshold ]; then
20328                 echo "ok"
20329                 echo "Don't need to fill MDT$min_index"
20330         else
20331                 # generate uneven MDTs, create till 25% diff
20332                 echo "no"
20333                 diff2=$((threshold - diff2))
20334                 diff=$((min * diff2 / 100))
20335                 # 50 sec per 10000 files in vm
20336                 [ $diff -gt 40000 ] && [ "$SLOW" = "no" ] &&
20337                         skip "$diff files to create"
20338                 echo "Fill $diff2% diff in MDT$min_index with $diff files"
20339                 local i
20340                 local value="$(generate_string 1024)"
20341                 for i in $(seq $diff); do
20342                         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE \
20343                                 $DIR/$tdir-MDT$min_index/f$i > /dev/null ||
20344                                 error "create f$i failed"
20345                         setfattr -n user.413b -v $value \
20346                                 $DIR/$tdir-MDT$min_index/f$i ||
20347                                 error "setfattr f$i failed"
20348                 done
20349         fi
20350
20351         min=$((100 *MDSCOUNT))
20352         max=0
20353
20354         echo "mkdir with balanced space usage"
20355         $LCTL set_param lmv.*.qos_prio_free=100
20356         for i in $(seq $((100 * MDSCOUNT))); do
20357                 mkdir $DIR/$tdir/subdir$i || error "mkdir subdir$i failed"
20358         done
20359         for i in $(seq $MDSCOUNT); do
20360                 count=$($LFS getdirstripe -i $DIR/$tdir/* | grep ^$((i - 1))$ |
20361                         wc -w)
20362                 echo "$count directories created on MDT$((i - 1))"
20363                 [ $min -gt $count ] && min=$count
20364                 [ $max -lt $count ] && max=$count
20365         done
20366         [ $((max - min)) -gt $MDSCOUNT ] ||
20367                 error "subdirs shouldn't be evenly distributed"
20368
20369         which getfattr > /dev/null 2>&1 || skip_env "no getfattr command"
20370
20371         $LFS setdirstripe -D -d $DIR/$tdir || error "setdirstripe -d failed"
20372         getfattr -n trusted.dmv $DIR/$tdir && error "default dir layout exists"
20373         true
20374 }
20375 run_test 413b "mkdir with balanced space usage"
20376
20377 test_414() {
20378 #define OBD_FAIL_PTLRPC_BULK_ATTACH      0x521
20379         $LCTL set_param fail_loc=0x80000521
20380         dd if=/dev/zero of=$DIR/$tfile bs=2M count=1 oflag=sync
20381         rm -f $DIR/$tfile
20382 }
20383 run_test 414 "simulate ENOMEM in ptlrpc_register_bulk()"
20384
20385 test_415() {
20386         [ $PARALLEL == "yes" ] && skip "skip parallel run"
20387         [ $(lustre_version_code mds1) -lt $(version_code 2.11.52) ] &&
20388                 skip "Need server version at least 2.11.52"
20389
20390         # LU-11102
20391         local total
20392         local setattr_pid
20393         local start_time
20394         local end_time
20395         local duration
20396
20397         total=500
20398         # this test may be slow on ZFS
20399         [ "$mds1_FSTYPE" == "zfs" ] && total=100
20400
20401         # though this test is designed for striped directory, let's test normal
20402         # directory too since lock is always saved as CoS lock.
20403         test_mkdir $DIR/$tdir || error "mkdir $tdir"
20404         createmany -o $DIR/$tdir/$tfile. $total || error "createmany"
20405
20406         (
20407                 while true; do
20408                         touch $DIR/$tdir
20409                 done
20410         ) &
20411         setattr_pid=$!
20412
20413         start_time=$(date +%s)
20414         for i in $(seq $total); do
20415                 mrename $DIR/$tdir/$tfile.$i $DIR/$tdir/$tfile-new.$i \
20416                         > /dev/null
20417         done
20418         end_time=$(date +%s)
20419         duration=$((end_time - start_time))
20420
20421         kill -9 $setattr_pid
20422
20423         echo "rename $total files took $duration sec"
20424         [ $duration -lt 100 ] || error "rename took $duration sec"
20425 }
20426 run_test 415 "lock revoke is not missing"
20427
20428 test_416() {
20429         [ $(lustre_version_code mds1) -lt $(version_code 2.11.55) ] &&
20430                 skip "Need server version at least 2.11.55"
20431
20432         # define OBD_FAIL_OSD_TXN_START    0x19a
20433         do_facet mds1 lctl set_param fail_loc=0x19a
20434
20435         lfs mkdir -c $MDSCOUNT $DIR/$tdir
20436
20437         true
20438 }
20439 run_test 416 "transaction start failure won't cause system hung"
20440
20441 cleanup_417() {
20442         trap 0
20443         do_nodes $(comma_list $(mdts_nodes)) \
20444                 "$LCTL set_param -n mdt.*MDT*.enable_dir_migration=1"
20445         do_nodes $(comma_list $(mdts_nodes)) \
20446                 "$LCTL set_param -n mdt.*MDT*.enable_remote_dir=1"
20447         do_nodes $(comma_list $(mdts_nodes)) \
20448                 "$LCTL set_param -n mdt.*MDT*.enable_striped_dir=1"
20449 }
20450
20451 test_417() {
20452         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
20453         [[ $MDS1_VERSION -lt $(version_code 2.11.56) ]] &&
20454                 skip "Need MDS version at least 2.11.56"
20455
20456         trap cleanup_417 RETURN EXIT
20457
20458         $LFS mkdir -i 1 $DIR/$tdir.1 || error "create remote dir $tdir.1 failed"
20459         do_nodes $(comma_list $(mdts_nodes)) \
20460                 "$LCTL set_param -n mdt.*MDT*.enable_dir_migration=0"
20461         $LFS migrate -m 0 $DIR/$tdir.1 &&
20462                 error "migrate dir $tdir.1 should fail"
20463
20464         do_nodes $(comma_list $(mdts_nodes)) \
20465                 "$LCTL set_param -n mdt.*MDT*.enable_remote_dir=0"
20466         $LFS mkdir -i 1 $DIR/$tdir.2 &&
20467                 error "create remote dir $tdir.2 should fail"
20468
20469         do_nodes $(comma_list $(mdts_nodes)) \
20470                 "$LCTL set_param -n mdt.*MDT*.enable_striped_dir=0"
20471         $LFS mkdir -c 2 $DIR/$tdir.3 &&
20472                 error "create striped dir $tdir.3 should fail"
20473         true
20474 }
20475 run_test 417 "disable remote dir, striped dir and dir migration"
20476
20477 # Checks that the outputs of df [-i] and lfs df [-i] match
20478 #
20479 # usage: check_lfs_df <blocks | inodes> <mountpoint>
20480 check_lfs_df() {
20481         local dir=$2
20482         local inodes
20483         local df_out
20484         local lfs_df_out
20485         local count
20486         local passed=false
20487
20488         # blocks or inodes
20489         [ "$1" == "blocks" ] && inodes= || inodes="-i"
20490
20491         for count in {1..100}; do
20492                 cancel_lru_locks
20493                 sync; sleep 0.2
20494
20495                 # read the lines of interest
20496                 df_out=($(df -P $inodes $dir | tail -n +2)) ||
20497                         error "df $inodes $dir | tail -n +2 failed"
20498                 lfs_df_out=($($LFS df $inodes $dir | grep summary:)) ||
20499                         error "lfs df $inodes $dir | grep summary: failed"
20500
20501                 # skip first substrings of each output as they are different
20502                 # "<NID>:/<fsname>" for df, "filesystem_summary:" for lfs df
20503                 # compare the two outputs
20504                 passed=true
20505                 for i in {1..5}; do
20506                         [ "${df_out[i]}" != "${lfs_df_out[i]}" ] && passed=false
20507                 done
20508                 $passed && break
20509         done
20510
20511         if ! $passed; then
20512                 df -P $inodes $dir
20513                 echo
20514                 lfs df $inodes $dir
20515                 error "df and lfs df $1 output mismatch: "      \
20516                       "df ${inodes}: ${df_out[*]}, "            \
20517                       "lfs df ${inodes}: ${lfs_df_out[*]}"
20518         fi
20519 }
20520
20521 test_418() {
20522         [ $PARALLEL == "yes" ] && skip "skip parallel run"
20523
20524         local dir=$DIR/$tdir
20525         local numfiles=$((RANDOM % 4096 + 2))
20526         local numblocks=$((RANDOM % 256 + 1))
20527
20528         wait_delete_completed
20529         test_mkdir $dir
20530
20531         # check block output
20532         check_lfs_df blocks $dir
20533         # check inode output
20534         check_lfs_df inodes $dir
20535
20536         # create a single file and retest
20537         echo "Creating a single file and testing"
20538         createmany -o $dir/$tfile- 1 &>/dev/null ||
20539                 error "creating 1 file in $dir failed"
20540         check_lfs_df blocks $dir
20541         check_lfs_df inodes $dir
20542
20543         # create a random number of files
20544         echo "Creating $((numfiles - 1)) files and testing"
20545         createmany -o $dir/$tfile- 1 $((numfiles - 1)) &>/dev/null ||
20546                 error "creating $((numfiles - 1)) files in $dir failed"
20547
20548         # write a random number of blocks to the first test file
20549         echo "Writing $numblocks 4K blocks and testing"
20550         dd if=/dev/urandom of=$dir/${tfile}-0 bs=4K conv=fsync \
20551                 count=$numblocks &>/dev/null ||
20552                 error "dd to $dir/${tfile}-0 failed"
20553
20554         # retest
20555         check_lfs_df blocks $dir
20556         check_lfs_df inodes $dir
20557
20558         unlinkmany $dir/$tfile- $numfiles &>/dev/null ||
20559                 error "unlinking $numfiles files in $dir failed"
20560 }
20561 run_test 418 "df and lfs df outputs match"
20562
20563 test_419()
20564 {
20565         local dir=$DIR/$tdir
20566
20567         mkdir -p $dir
20568         touch $dir/file
20569
20570         cancel_lru_locks mdc
20571
20572         #OBD_FAIL_LLITE_OPEN_BY_NAME    0x1410
20573         $LCTL set_param fail_loc=0x1410
20574         cat $dir/file
20575         $LCTL set_param fail_loc=0
20576         rm -rf $dir
20577 }
20578 run_test 419 "Verify open file by name doesn't crash kernel"
20579
20580 test_420()
20581 {
20582         [[ $MDS1_VERSION -ge $(version_code 2.12.53) ]] ||
20583                 skip "Need MDS version at least 2.12.53"
20584
20585         local SAVE_UMASK=$(umask)
20586         local dir=$DIR/$tdir
20587         local uname=$(getent passwd $RUNAS_ID | cut -d: -f1)
20588
20589         mkdir -p $dir
20590         umask 0000
20591         mkdir -m03777 $dir/testdir
20592         ls -dn $dir/testdir
20593         # Need to remove trailing '.' when SELinux is enabled
20594         local dirperms=$(ls -dn $dir/testdir |
20595                          awk '{ sub(/\.$/, "", $1); print $1}')
20596         [ $dirperms == "drwxrwsrwt" ] ||
20597                 error "incorrect perms on $dir/testdir"
20598
20599         su - $uname -c "PATH=$LUSTRE/tests:\$PATH; \
20600                 openfile -f O_RDONLY:O_CREAT -m 02755 $dir/testdir/testfile"
20601         ls -n $dir/testdir/testfile
20602         local fileperms=$(ls -n $dir/testdir/testfile |
20603                           awk '{ sub(/\.$/, "", $1); print $1}')
20604         [ $fileperms == "-rwxr-xr-x" ] ||
20605                 error "incorrect perms on $dir/testdir/testfile"
20606
20607         umask $SAVE_UMASK
20608 }
20609 run_test 420 "clear SGID bit on non-directories for non-members"
20610
20611 test_421a() {
20612         local cnt
20613         local fid1
20614         local fid2
20615
20616         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
20617                 skip "Need MDS version at least 2.12.54"
20618
20619         test_mkdir $DIR/$tdir
20620         createmany -o $DIR/$tdir/f 3
20621         cnt=$(ls -1 $DIR/$tdir | wc -l)
20622         [ $cnt != 3 ] && error "unexpected #files: $cnt"
20623
20624         fid1=$(lfs path2fid $DIR/$tdir/f1)
20625         fid2=$(lfs path2fid $DIR/$tdir/f2)
20626         $LFS rmfid $DIR $fid1 $fid2 || error "rmfid failed"
20627
20628         stat $DIR/$tdir/f1 && error "f1 still visible on the client"
20629         stat $DIR/$tdir/f2 && error "f2 still visible on the client"
20630
20631         cnt=$(ls -1 $DIR/$tdir | wc -l)
20632         [ $cnt == 1 ] || error "unexpected #files after: $cnt"
20633
20634         rm -f $DIR/$tdir/f3 || error "can't remove f3"
20635         createmany -o $DIR/$tdir/f 3
20636         cnt=$(ls -1 $DIR/$tdir | wc -l)
20637         [ $cnt != 3 ] && error "unexpected #files: $cnt"
20638
20639         fid1=$(lfs path2fid $DIR/$tdir/f1)
20640         fid2=$(lfs path2fid $DIR/$tdir/f2)
20641         echo "remove using fsname $FSNAME"
20642         $LFS rmfid $FSNAME $fid1 $fid2 || error "rmfid with fsname failed"
20643
20644         cnt=$(ls -1 $DIR/$tdir | wc -l)
20645         [ $cnt == 1 ] || error "unexpected #files after: $cnt"
20646 }
20647 run_test 421a "simple rm by fid"
20648
20649 test_421b() {
20650         local cnt
20651         local FID1
20652         local FID2
20653
20654         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
20655                 skip "Need MDS version at least 2.12.54"
20656
20657         test_mkdir $DIR/$tdir
20658         createmany -o $DIR/$tdir/f 3
20659         multiop_bg_pause $DIR/$tdir/f1 o_c || error "multiop failed to start"
20660         MULTIPID=$!
20661
20662         FID1=$(lfs path2fid $DIR/$tdir/f1)
20663         FID2=$(lfs path2fid $DIR/$tdir/f2)
20664         $LFS rmfid $DIR $FID1 $FID2 && error "rmfid didn't fail"
20665
20666         kill -USR1 $MULTIPID
20667         wait
20668
20669         cnt=$(ls $DIR/$tdir | wc -l)
20670         [ $cnt == 2 ] || error "unexpected #files after: $cnt"
20671 }
20672 run_test 421b "rm by fid on open file"
20673
20674 test_421c() {
20675         local cnt
20676         local FIDS
20677
20678         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
20679                 skip "Need MDS version at least 2.12.54"
20680
20681         test_mkdir $DIR/$tdir
20682         createmany -o $DIR/$tdir/f 3
20683         touch $DIR/$tdir/$tfile
20684         createmany -l$DIR/$tdir/$tfile $DIR/$tdir/h 180
20685         cnt=$(ls -1 $DIR/$tdir | wc -l)
20686         [ $cnt != 184 ] && error "unexpected #files: $cnt"
20687
20688         FID1=$(lfs path2fid $DIR/$tdir/$tfile)
20689         $LFS rmfid $DIR $FID1 || error "rmfid failed"
20690
20691         cnt=$(ls $DIR/$tdir | wc -l)
20692         [ $cnt == 3 ] || error "unexpected #files after: $cnt"
20693 }
20694 run_test 421c "rm by fid against hardlinked files"
20695
20696 test_421d() {
20697         local cnt
20698         local FIDS
20699
20700         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
20701                 skip "Need MDS version at least 2.12.54"
20702
20703         test_mkdir $DIR/$tdir
20704         createmany -o $DIR/$tdir/f 4097
20705         cnt=$(ls -1 $DIR/$tdir | wc -l)
20706         [ $cnt != 4097 ] && error "unexpected #files: $cnt"
20707
20708         FIDS=$(lfs path2fid $DIR/$tdir/f* | sed "s/[/][^:]*://g")
20709         $LFS rmfid $DIR $FIDS || error "rmfid failed"
20710
20711         cnt=$(ls $DIR/$tdir | wc -l)
20712         rm -rf $DIR/$tdir
20713         [ $cnt == 0 ] || error "unexpected #files after: $cnt"
20714 }
20715 run_test 421d "rmfid en masse"
20716
20717 test_421e() {
20718         local cnt
20719         local FID
20720
20721         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
20722         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
20723                 skip "Need MDS version at least 2.12.54"
20724
20725         mkdir -p $DIR/$tdir
20726         $LFS setdirstripe -c$MDSCOUNT $DIR/$tdir/striped_dir
20727         createmany -o $DIR/$tdir/striped_dir/f 512
20728         cnt=$(ls -1 $DIR/$tdir/striped_dir | wc -l)
20729         [ $cnt != 512 ] && error "unexpected #files: $cnt"
20730
20731         FIDS=$(lfs path2fid $DIR/$tdir/striped_dir/f* |
20732                 sed "s/[/][^:]*://g")
20733         $LFS rmfid $DIR $FIDS || error "rmfid failed"
20734
20735         cnt=$(ls $DIR/$tdir/striped_dir | wc -l)
20736         rm -rf $DIR/$tdir
20737         [ $cnt == 0 ] || error "unexpected #files after: $cnt"
20738 }
20739 run_test 421e "rmfid in DNE"
20740
20741 test_421f() {
20742         local cnt
20743         local FID
20744
20745         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
20746                 skip "Need MDS version at least 2.12.54"
20747
20748         test_mkdir $DIR/$tdir
20749         touch $DIR/$tdir/f
20750         cnt=$(ls -1 $DIR/$tdir | wc -l)
20751         [ $cnt != 1 ] && error "unexpected #files: $cnt"
20752
20753         FID=$(lfs path2fid $DIR/$tdir/f)
20754         $RUNAS $LFS rmfid $DIR $FID && error "rmfid didn't fail (1)"
20755         # rmfid should fail
20756         cnt=$(ls -1 $DIR/$tdir | wc -l)
20757         [ $cnt != 1 ] && error "unexpected #files after (2): $cnt"
20758
20759         chmod a+rw $DIR/$tdir
20760         ls -la $DIR/$tdir
20761         $RUNAS $LFS rmfid $DIR $FID && error "rmfid didn't fail (2)"
20762         # rmfid should fail
20763         cnt=$(ls -1 $DIR/$tdir | wc -l)
20764         [ $cnt != 1 ] && error "unexpected #files after (3): $cnt"
20765
20766         rm -f $DIR/$tdir/f
20767         $RUNAS touch $DIR/$tdir/f
20768         FID=$(lfs path2fid $DIR/$tdir/f)
20769         echo "rmfid as root"
20770         $LFS rmfid $DIR $FID || error "rmfid as root failed"
20771         cnt=$(ls -1 $DIR/$tdir | wc -l)
20772         [ $cnt == 0 ] || error "unexpected #files after (4): $cnt"
20773
20774         rm -f $DIR/$tdir/f
20775         $RUNAS touch $DIR/$tdir/f
20776         cnt=$(ls -1 $DIR/$tdir | wc -l)
20777         [ $cnt != 1 ] && error "unexpected #files (4): $cnt"
20778         FID=$(lfs path2fid $DIR/$tdir/f)
20779         # rmfid w/o user_fid2path mount option should fail
20780         $RUNAS $LFS rmfid $DIR $FID && error "rmfid didn't fail(3)"
20781         cnt=$(ls -1 $DIR/$tdir | wc -l)
20782         [ $cnt == 1 ] || error "unexpected #files after (5): $cnt"
20783
20784         umount_client $MOUNT || "failed to umount client"
20785         mount_client $MOUNT "$MOUNT_OPTS,user_fid2path" ||
20786                 "failed to mount client'"
20787
20788         $RUNAS $LFS rmfid $DIR $FID || error "rmfid failed"
20789         # rmfid should succeed
20790         cnt=$(ls -1 $DIR/$tdir | wc -l)
20791         [ $cnt == 0 ] || error "unexpected #files after (6): $cnt"
20792
20793         # rmfid shouldn't allow to remove files due to dir's permission
20794         chmod a+rwx $DIR/$tdir
20795         touch $DIR/$tdir/f
20796         ls -la $DIR/$tdir
20797         FID=$(lfs path2fid $DIR/$tdir/f)
20798         $RUNAS $LFS rmfid $DIR $FID && error "rmfid didn't fail"
20799
20800         umount_client $MOUNT || "failed to umount client"
20801         mount_client $MOUNT "$MOUNT_OPTS" ||
20802                 "failed to mount client'"
20803
20804 }
20805 run_test 421f "rmfid checks permissions"
20806
20807 test_421g() {
20808         local cnt
20809         local FIDS
20810
20811         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
20812         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
20813                 skip "Need MDS version at least 2.12.54"
20814
20815         mkdir -p $DIR/$tdir
20816         $LFS setdirstripe -c$MDSCOUNT $DIR/$tdir/striped_dir
20817         createmany -o $DIR/$tdir/striped_dir/f 512
20818         cnt=$(ls -1 $DIR/$tdir/striped_dir | wc -l)
20819         [ $cnt != 512 ] && error "unexpected #files: $cnt"
20820
20821         FIDS=$(lfs path2fid $DIR/$tdir/striped_dir/f* |
20822                 sed "s/[/][^:]*://g")
20823
20824         rm -f $DIR/$tdir/striped_dir/f1*
20825         cnt=$(ls -1 $DIR/$tdir/striped_dir | wc -l)
20826         removed=$((512 - cnt))
20827
20828         # few files have been just removed, so we expect
20829         # rmfid to fail on their fids
20830         errors=$($LFS rmfid $DIR $FIDS 2>&1 | wc -l)
20831         [ $removed != $errors ] && error "$errors != $removed"
20832
20833         cnt=$(ls $DIR/$tdir/striped_dir | wc -l)
20834         rm -rf $DIR/$tdir
20835         [ $cnt == 0 ] || error "unexpected #files after: $cnt"
20836 }
20837 run_test 421g "rmfid to return errors properly"
20838
20839 prep_801() {
20840         [[ $(lustre_version_code mds1) -lt $(version_code 2.9.55) ]] ||
20841         [[ $OST1_VERSION -lt $(version_code 2.9.55) ]] &&
20842                 skip "Need server version at least 2.9.55"
20843
20844         start_full_debug_logging
20845 }
20846
20847 post_801() {
20848         stop_full_debug_logging
20849 }
20850
20851 barrier_stat() {
20852         if [ $MGS_VERSION -le $(version_code 2.10.0) ]; then
20853                 local st=$(do_facet mgs $LCTL barrier_stat $FSNAME |
20854                            awk '/The barrier for/ { print $7 }')
20855                 echo $st
20856         else
20857                 local st=$(do_facet mgs $LCTL barrier_stat -s $FSNAME)
20858                 echo \'$st\'
20859         fi
20860 }
20861
20862 barrier_expired() {
20863         local expired
20864
20865         if [ $MGS_VERSION -le $(version_code 2.10.0) ]; then
20866                 expired=$(do_facet mgs $LCTL barrier_stat $FSNAME |
20867                           awk '/will be expired/ { print $7 }')
20868         else
20869                 expired=$(do_facet mgs $LCTL barrier_stat -t $FSNAME)
20870         fi
20871
20872         echo $expired
20873 }
20874
20875 test_801a() {
20876         prep_801
20877
20878         echo "Start barrier_freeze at: $(date)"
20879         #define OBD_FAIL_BARRIER_DELAY          0x2202
20880         do_facet mgs $LCTL set_param fail_val=5 fail_loc=0x2202
20881         # Do not reduce barrier time - See LU-11873
20882         do_facet mgs $LCTL barrier_freeze $FSNAME 20 &
20883
20884         sleep 2
20885         local b_status=$(barrier_stat)
20886         echo "Got barrier status at: $(date)"
20887         [ "$b_status" = "'freezing_p1'" ] ||
20888                 error "(1) unexpected barrier status $b_status"
20889
20890         do_facet mgs $LCTL set_param fail_val=0 fail_loc=0
20891         wait
20892         b_status=$(barrier_stat)
20893         [ "$b_status" = "'frozen'" ] ||
20894                 error "(2) unexpected barrier status $b_status"
20895
20896         local expired=$(barrier_expired)
20897         echo "sleep $((expired + 3)) seconds, then the barrier will be expired"
20898         sleep $((expired + 3))
20899
20900         b_status=$(barrier_stat)
20901         [ "$b_status" = "'expired'" ] ||
20902                 error "(3) unexpected barrier status $b_status"
20903
20904         # Do not reduce barrier time - See LU-11873
20905         do_facet mgs $LCTL barrier_freeze $FSNAME 20 ||
20906                 error "(4) fail to freeze barrier"
20907
20908         b_status=$(barrier_stat)
20909         [ "$b_status" = "'frozen'" ] ||
20910                 error "(5) unexpected barrier status $b_status"
20911
20912         echo "Start barrier_thaw at: $(date)"
20913         #define OBD_FAIL_BARRIER_DELAY          0x2202
20914         do_facet mgs $LCTL set_param fail_val=5 fail_loc=0x2202
20915         do_facet mgs $LCTL barrier_thaw $FSNAME &
20916
20917         sleep 2
20918         b_status=$(barrier_stat)
20919         echo "Got barrier status at: $(date)"
20920         [ "$b_status" = "'thawing'" ] ||
20921                 error "(6) unexpected barrier status $b_status"
20922
20923         do_facet mgs $LCTL set_param fail_val=0 fail_loc=0
20924         wait
20925         b_status=$(barrier_stat)
20926         [ "$b_status" = "'thawed'" ] ||
20927                 error "(7) unexpected barrier status $b_status"
20928
20929         #define OBD_FAIL_BARRIER_FAILURE        0x2203
20930         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x2203
20931         do_facet mgs $LCTL barrier_freeze $FSNAME
20932
20933         b_status=$(barrier_stat)
20934         [ "$b_status" = "'failed'" ] ||
20935                 error "(8) unexpected barrier status $b_status"
20936
20937         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
20938         do_facet mgs $LCTL barrier_thaw $FSNAME
20939
20940         post_801
20941 }
20942 run_test 801a "write barrier user interfaces and stat machine"
20943
20944 test_801b() {
20945         prep_801
20946
20947         mkdir $DIR/$tdir || error "(1) fail to mkdir"
20948         createmany -d $DIR/$tdir/d 6 || "(2) fail to mkdir"
20949         touch $DIR/$tdir/d2/f10 || error "(3) fail to touch"
20950         touch $DIR/$tdir/d3/f11 || error "(4) fail to touch"
20951         touch $DIR/$tdir/d4/f12 || error "(5) fail to touch"
20952
20953         cancel_lru_locks mdc
20954
20955         # 180 seconds should be long enough
20956         do_facet mgs $LCTL barrier_freeze $FSNAME 180
20957
20958         local b_status=$(barrier_stat)
20959         [ "$b_status" = "'frozen'" ] ||
20960                 error "(6) unexpected barrier status $b_status"
20961
20962         mkdir $DIR/$tdir/d0/d10 &
20963         mkdir_pid=$!
20964
20965         touch $DIR/$tdir/d1/f13 &
20966         touch_pid=$!
20967
20968         ln $DIR/$tdir/d2/f10 $DIR/$tdir/d2/f14 &
20969         ln_pid=$!
20970
20971         mv $DIR/$tdir/d3/f11 $DIR/$tdir/d3/f15 &
20972         mv_pid=$!
20973
20974         rm -f $DIR/$tdir/d4/f12 &
20975         rm_pid=$!
20976
20977         stat $DIR/$tdir/d5 || error "(7) stat should succeed"
20978
20979         # To guarantee taht the 'stat' is not blocked
20980         b_status=$(barrier_stat)
20981         [ "$b_status" = "'frozen'" ] ||
20982                 error "(8) unexpected barrier status $b_status"
20983
20984         # let above commands to run at background
20985         sleep 5
20986
20987         ps -p $mkdir_pid || error "(9) mkdir should be blocked"
20988         ps -p $touch_pid || error "(10) touch should be blocked"
20989         ps -p $ln_pid || error "(11) link should be blocked"
20990         ps -p $mv_pid || error "(12) rename should be blocked"
20991         ps -p $rm_pid || error "(13) unlink should be blocked"
20992
20993         b_status=$(barrier_stat)
20994         [ "$b_status" = "'frozen'" ] ||
20995                 error "(14) unexpected barrier status $b_status"
20996
20997         do_facet mgs $LCTL barrier_thaw $FSNAME
20998         b_status=$(barrier_stat)
20999         [ "$b_status" = "'thawed'" ] ||
21000                 error "(15) unexpected barrier status $b_status"
21001
21002         wait $mkdir_pid || error "(16) mkdir should succeed"
21003         wait $touch_pid || error "(17) touch should succeed"
21004         wait $ln_pid || error "(18) link should succeed"
21005         wait $mv_pid || error "(19) rename should succeed"
21006         wait $rm_pid || error "(20) unlink should succeed"
21007
21008         post_801
21009 }
21010 run_test 801b "modification will be blocked by write barrier"
21011
21012 test_801c() {
21013         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
21014
21015         prep_801
21016
21017         stop mds2 || error "(1) Fail to stop mds2"
21018
21019         do_facet mgs $LCTL barrier_freeze $FSNAME 30
21020
21021         local b_status=$(barrier_stat)
21022         [ "$b_status" = "'expired'" ] || [ "$b_status" = "'failed'" ] || {
21023                 do_facet mgs $LCTL barrier_thaw $FSNAME
21024                 error "(2) unexpected barrier status $b_status"
21025         }
21026
21027         do_facet mgs $LCTL barrier_rescan $FSNAME ||
21028                 error "(3) Fail to rescan barrier bitmap"
21029
21030         # Do not reduce barrier time - See LU-11873
21031         do_facet mgs $LCTL barrier_freeze $FSNAME 20
21032
21033         b_status=$(barrier_stat)
21034         [ "$b_status" = "'frozen'" ] ||
21035                 error "(4) unexpected barrier status $b_status"
21036
21037         do_facet mgs $LCTL barrier_thaw $FSNAME
21038         b_status=$(barrier_stat)
21039         [ "$b_status" = "'thawed'" ] ||
21040                 error "(5) unexpected barrier status $b_status"
21041
21042         local devname=$(mdsdevname 2)
21043
21044         start mds2 $devname $MDS_MOUNT_OPTS || error "(6) Fail to start mds2"
21045
21046         do_facet mgs $LCTL barrier_rescan $FSNAME ||
21047                 error "(7) Fail to rescan barrier bitmap"
21048
21049         post_801
21050 }
21051 run_test 801c "rescan barrier bitmap"
21052
21053 saved_MGS_MOUNT_OPTS=$MGS_MOUNT_OPTS
21054 saved_MDS_MOUNT_OPTS=$MDS_MOUNT_OPTS
21055 saved_OST_MOUNT_OPTS=$OST_MOUNT_OPTS
21056 saved_MOUNT_OPTS=$MOUNT_OPTS
21057
21058 cleanup_802a() {
21059         trap 0
21060
21061         stopall
21062         MGS_MOUNT_OPTS=$saved_MGS_MOUNT_OPTS
21063         MDS_MOUNT_OPTS=$saved_MDS_MOUNT_OPTS
21064         OST_MOUNT_OPTS=$saved_OST_MOUNT_OPTS
21065         MOUNT_OPTS=$saved_MOUNT_OPTS
21066         setupall
21067 }
21068
21069 test_802a() {
21070
21071         [[ $(lustre_version_code mds1) -lt $(version_code 2.9.55) ]] ||
21072         [[ $OST1_VERSION -lt $(version_code 2.9.55) ]] &&
21073                 skip "Need server version at least 2.9.55"
21074
21075         [[ $ENABLE_QUOTA ]] && skip "Quota enabled for read-only test"
21076
21077         mkdir $DIR/$tdir || error "(1) fail to mkdir"
21078
21079         cp $LUSTRE/tests/test-framework.sh $DIR/$tdir/ ||
21080                 error "(2) Fail to copy"
21081
21082         trap cleanup_802a EXIT
21083
21084         # sync by force before remount as readonly
21085         sync; sync_all_data; sleep 3; sync_all_data
21086
21087         stopall
21088
21089         MGS_MOUNT_OPTS=$(csa_add "$MGS_MOUNT_OPTS" -o rdonly_dev)
21090         MDS_MOUNT_OPTS=$(csa_add "$MDS_MOUNT_OPTS" -o rdonly_dev)
21091         OST_MOUNT_OPTS=$(csa_add "$OST_MOUNT_OPTS" -o rdonly_dev)
21092
21093         echo "Mount the server as read only"
21094         setupall server_only || error "(3) Fail to start servers"
21095
21096         echo "Mount client without ro should fail"
21097         mount_client $MOUNT &&
21098                 error "(4) Mount client without 'ro' should fail"
21099
21100         echo "Mount client with ro should succeed"
21101         MOUNT_OPTS=$(csa_add "$MOUNT_OPTS" -o ro)
21102         mount_client $MOUNT ||
21103                 error "(5) Mount client with 'ro' should succeed"
21104
21105         echo "Modify should be refused"
21106         touch $DIR/$tdir/guard && error "(6) Touch should fail under ro mode"
21107
21108         echo "Read should be allowed"
21109         diff $LUSTRE/tests/test-framework.sh $DIR/$tdir/test-framework.sh ||
21110                 error "(7) Read should succeed under ro mode"
21111
21112         cleanup_802a
21113 }
21114 run_test 802a "simulate readonly device"
21115
21116 test_802b() {
21117         [ $PARALLEL == "yes" ] && skip "skip parallel run"
21118         remote_mds_nodsh && skip "remote MDS with nodsh"
21119
21120         do_facet $SINGLEMDS $LCTL get_param mdt.*.readonly ||
21121                 skip "readonly option not available"
21122
21123         $LFS mkdir -i 0 -c 1 $DIR/$tdir || error "(1) fail to mkdir"
21124
21125         cp $LUSTRE/tests/test-framework.sh $DIR/$tdir/ ||
21126                 error "(2) Fail to copy"
21127
21128         # write back all cached data before setting MDT to readonly
21129         cancel_lru_locks
21130         sync_all_data
21131
21132         do_facet $SINGLEMDS $LCTL set_param mdt.*.readonly=1
21133         stack_trap "do_facet $SINGLEMDS $LCTL set_param mdt.*.readonly=0" EXIT
21134
21135         echo "Modify should be refused"
21136         touch $DIR/$tdir/guard && error "(6) Touch should fail under ro mode"
21137
21138         echo "Read should be allowed"
21139         diff $LUSTRE/tests/test-framework.sh $DIR/$tdir/test-framework.sh ||
21140                 error "(7) Read should succeed under ro mode"
21141
21142         # disable readonly
21143         do_facet $SINGLEMDS $LCTL set_param mdt.*.readonly=0
21144 }
21145 run_test 802b "be able to set MDTs to readonly"
21146
21147 test_803() {
21148         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
21149         [ $MDS1_VERSION -lt $(version_code 2.10.54) ] &&
21150                 skip "MDS needs to be newer than 2.10.54"
21151
21152         mkdir -p $DIR/$tdir
21153         # Create some objects on all MDTs to trigger related logs objects
21154         for idx in $(seq $MDSCOUNT); do
21155                 $LFS mkdir -c $MDSCOUNT -i $((idx % $MDSCOUNT)) \
21156                         $DIR/$tdir/dir${idx} ||
21157                         error "Fail to create $DIR/$tdir/dir${idx}"
21158         done
21159
21160         sync; sleep 3
21161         wait_delete_completed # ensure old test cleanups are finished
21162         echo "before create:"
21163         $LFS df -i $MOUNT
21164         local before_used=$($LFS df -i | grep MDT0000_UUID | awk '{print $3}')
21165
21166         for i in {1..10}; do
21167                 $LFS mkdir -c 1 -i 1 $DIR/$tdir/foo$i ||
21168                         error "Fail to create $DIR/$tdir/foo$i"
21169         done
21170
21171         sync; sleep 3
21172         echo "after create:"
21173         $LFS df -i $MOUNT
21174         local after_used=$($LFS df -i | grep MDT0000_UUID | awk '{print $3}')
21175
21176         # allow for an llog to be cleaned up during the test
21177         [ $after_used -ge $((before_used + 10 - 1)) ] ||
21178                 error "before ($before_used) + 10 > after ($after_used)"
21179
21180         for i in {1..10}; do
21181                 rm -rf $DIR/$tdir/foo$i ||
21182                         error "Fail to remove $DIR/$tdir/foo$i"
21183         done
21184
21185         sleep 3 # avoid MDT return cached statfs
21186         wait_delete_completed
21187         echo "after unlink:"
21188         $LFS df -i $MOUNT
21189         after_used=$($LFS df -i | grep MDT0000_UUID | awk '{print $3}')
21190
21191         # allow for an llog to be created during the test
21192         [ $after_used -le $((before_used + 1)) ] ||
21193                 error "after ($after_used) > before ($before_used) + 1"
21194 }
21195 run_test 803 "verify agent object for remote object"
21196
21197 test_804() {
21198         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
21199         [ $MDS1_VERSION -lt $(version_code 2.10.54) ] &&
21200                 skip "MDS needs to be newer than 2.10.54"
21201         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip_env "ldiskfs only test"
21202
21203         mkdir -p $DIR/$tdir
21204         $LFS mkdir -c 1 -i 1 $DIR/$tdir/dir0 ||
21205                 error "Fail to create $DIR/$tdir/dir0"
21206
21207         local fid=$($LFS path2fid $DIR/$tdir/dir0)
21208         local dev=$(mdsdevname 2)
21209
21210         do_facet mds2 "$DEBUGFS -c -R 'ls /REMOTE_PARENT_DIR' $dev" |
21211                 grep ${fid} || error "NOT found agent entry for dir0"
21212
21213         $LFS mkdir -c $MDSCOUNT -i 0 $DIR/$tdir/dir1 ||
21214                 error "Fail to create $DIR/$tdir/dir1"
21215
21216         touch $DIR/$tdir/dir1/foo0 ||
21217                 error "Fail to create $DIR/$tdir/dir1/foo0"
21218         fid=$($LFS path2fid $DIR/$tdir/dir1/foo0)
21219         local rc=0
21220
21221         for idx in $(seq $MDSCOUNT); do
21222                 dev=$(mdsdevname $idx)
21223                 do_facet mds${idx} \
21224                         "$DEBUGFS -c -R 'ls /REMOTE_PARENT_DIR' $dev" |
21225                         grep ${fid} && rc=$idx
21226         done
21227
21228         mv $DIR/$tdir/dir1/foo0 $DIR/$tdir/dir1/foo1 ||
21229                 error "Fail to rename foo0 to foo1"
21230         if [ $rc -eq 0 ]; then
21231                 for idx in $(seq $MDSCOUNT); do
21232                         dev=$(mdsdevname $idx)
21233                         do_facet mds${idx} \
21234                         "$DEBUGFS -c -R 'ls /REMOTE_PARENT_DIR' $dev" |
21235                         grep ${fid} && rc=$idx
21236                 done
21237         fi
21238
21239         mv $DIR/$tdir/dir1/foo1 $DIR/$tdir/dir1/foo2 ||
21240                 error "Fail to rename foo1 to foo2"
21241         if [ $rc -eq 0 ]; then
21242                 for idx in $(seq $MDSCOUNT); do
21243                         dev=$(mdsdevname $idx)
21244                         do_facet mds${idx} \
21245                         "$DEBUGFS -c -R 'ls /REMOTE_PARENT_DIR' $dev" |
21246                         grep ${fid} && rc=$idx
21247                 done
21248         fi
21249
21250         [ $rc -ne 0 ] || error "NOT found agent entry for foo"
21251
21252         ln $DIR/$tdir/dir1/foo2 $DIR/$tdir/dir0/guard ||
21253                 error "Fail to link to $DIR/$tdir/dir1/foo2"
21254         mv $DIR/$tdir/dir1/foo2 $DIR/$tdir/dir1/foo0 ||
21255                 error "Fail to rename foo2 to foo0"
21256         unlink $DIR/$tdir/dir1/foo0 ||
21257                 error "Fail to unlink $DIR/$tdir/dir1/foo0"
21258         rm -rf $DIR/$tdir/dir0 ||
21259                 error "Fail to rm $DIR/$tdir/dir0"
21260
21261         for idx in $(seq $MDSCOUNT); do
21262                 dev=$(mdsdevname $idx)
21263                 rc=0
21264
21265                 stop mds${idx}
21266                 run_e2fsck $(facet_active_host mds$idx) $dev -n ||
21267                         rc=$?
21268                 start mds${idx} $dev $MDS_MOUNT_OPTS ||
21269                         error "mount mds$idx failed"
21270                 df $MOUNT > /dev/null 2>&1
21271
21272                 # e2fsck should not return error
21273                 [ $rc -eq 0 ] ||
21274                         error "e2fsck detected error on MDT${idx}: rc=$rc"
21275         done
21276 }
21277 run_test 804 "verify agent entry for remote entry"
21278
21279 cleanup_805() {
21280         do_facet $SINGLEMDS zfs set quota=$old $fsset
21281         unlinkmany $DIR/$tdir/f- 1000000
21282         trap 0
21283 }
21284
21285 test_805() {
21286         local zfs_version=$(do_node $SINGLEMDS cat /sys/module/zfs/version)
21287         [ "$mds1_FSTYPE" != "zfs" ] && skip "ZFS specific test"
21288         [ $(version_code $zfs_version) -lt $(version_code 0.7.2) ] &&
21289                 skip "netfree not implemented before 0.7"
21290         [[ $MDS1_VERSION -ge $(version_code 2.10.57) ]] ||
21291                 skip "Need MDS version at least 2.10.57"
21292
21293         local fsset
21294         local freekb
21295         local usedkb
21296         local old
21297         local quota
21298         local pref="osd-zfs.lustre-MDT0000."
21299
21300         # limit available space on MDS dataset to meet nospace issue
21301         # quickly. then ZFS 0.7.2 can use reserved space if asked
21302         # properly (using netfree flag in osd_declare_destroy()
21303         fsset=$(do_facet $SINGLEMDS lctl get_param -n $pref.mntdev)
21304         old=$(do_facet $SINGLEMDS zfs get -H quota $fsset | \
21305                 gawk '{print $3}')
21306         freekb=$(do_facet $SINGLEMDS lctl get_param -n $pref.kbytesfree)
21307         usedkb=$(do_facet $SINGLEMDS lctl get_param -n $pref.kbytestotal)
21308         let "usedkb=usedkb-freekb"
21309         let "freekb=freekb/2"
21310         if let "freekb > 5000"; then
21311                 let "freekb=5000"
21312         fi
21313         do_facet $SINGLEMDS zfs set quota=$(((usedkb+freekb)*1024)) $fsset
21314         trap cleanup_805 EXIT
21315         mkdir $DIR/$tdir
21316         $LFS setstripe -E 1M -L mdt $DIR/$tdir || error "DoM not working"
21317         createmany -m $DIR/$tdir/f- 1000000 && error "ENOSPC wasn't met"
21318         rm -rf $DIR/$tdir || error "not able to remove"
21319         do_facet $SINGLEMDS zfs set quota=$old $fsset
21320         trap 0
21321 }
21322 run_test 805 "ZFS can remove from full fs"
21323
21324 # Size-on-MDS test
21325 check_lsom_data()
21326 {
21327         local file=$1
21328         local size=$($LFS getsom -s $file)
21329         local expect=$(stat -c %s $file)
21330
21331         [[ $size == $expect ]] ||
21332                 error "$file expected size: $expect, got: $size"
21333
21334         local blocks=$($LFS getsom -b $file)
21335         expect=$(stat -c %b $file)
21336         [[ $blocks == $expect ]] ||
21337                 error "$file expected blocks: $expect, got: $blocks"
21338 }
21339
21340 check_lsom_size()
21341 {
21342         local size=$($LFS getsom -s $1)
21343         local expect=$2
21344
21345         [[ $size == $expect ]] ||
21346                 error "$file expected size: $expect, got: $size"
21347 }
21348
21349 test_806() {
21350         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
21351                 skip "Need MDS version at least 2.11.52"
21352
21353         local bs=1048576
21354
21355         touch $DIR/$tfile || error "touch $tfile failed"
21356
21357         local save="$TMP/$TESTSUITE-$TESTNAME.parameters"
21358         save_lustre_params client "llite.*.xattr_cache" > $save
21359         lctl set_param llite.*.xattr_cache=0
21360         stack_trap "restore_lustre_params < $save; rm -f $save" EXIT
21361
21362         # single-threaded write
21363         echo "Test SOM for single-threaded write"
21364         dd if=/dev/zero of=$DIR/$tfile bs=$bs count=1 ||
21365                 error "write $tfile failed"
21366         check_lsom_size $DIR/$tfile $bs
21367
21368         local num=32
21369         local size=$(($num * $bs))
21370         local offset=0
21371         local i
21372
21373         echo "Test SOM for single client multi-threaded($num) write"
21374         $TRUNCATE $DIR/$tfile 0
21375         for ((i = 0; i < $num; i++)); do
21376                 $MULTIOP $DIR/$tfile Oz${offset}w${bs}c &
21377                 local pids[$i]=$!
21378                 offset=$((offset + $bs))
21379         done
21380         for (( i=0; i < $num; i++ )); do
21381                 wait ${pids[$i]}
21382         done
21383         check_lsom_size $DIR/$tfile $size
21384
21385         $TRUNCATE $DIR/$tfile 0
21386         for ((i = 0; i < $num; i++)); do
21387                 offset=$((offset - $bs))
21388                 $MULTIOP $DIR/$tfile Oz${offset}w${bs}c &
21389                 local pids[$i]=$!
21390         done
21391         for (( i=0; i < $num; i++ )); do
21392                 wait ${pids[$i]}
21393         done
21394         check_lsom_size $DIR/$tfile $size
21395
21396         # multi-client wirtes
21397         num=$(get_node_count ${CLIENTS//,/ })
21398         size=$(($num * $bs))
21399         offset=0
21400         i=0
21401
21402         echo "Test SOM for multi-client ($num) writes"
21403         $TRUNCATE $DIR/$tfile 0
21404         for client in ${CLIENTS//,/ }; do
21405                 do_node $client $MULTIOP $DIR/$tfile Oz${offset}w${bs}c &
21406                 local pids[$i]=$!
21407                 i=$((i + 1))
21408                 offset=$((offset + $bs))
21409         done
21410         for (( i=0; i < $num; i++ )); do
21411                 wait ${pids[$i]}
21412         done
21413         check_lsom_size $DIR/$tfile $offset
21414
21415         i=0
21416         $TRUNCATE $DIR/$tfile 0
21417         for client in ${CLIENTS//,/ }; do
21418                 offset=$((offset - $bs))
21419                 do_node $client $MULTIOP $DIR/$tfile Oz${offset}w${bs}c &
21420                 local pids[$i]=$!
21421                 i=$((i + 1))
21422         done
21423         for (( i=0; i < $num; i++ )); do
21424                 wait ${pids[$i]}
21425         done
21426         check_lsom_size $DIR/$tfile $size
21427
21428         # verify truncate
21429         echo "Test SOM for truncate"
21430         $TRUNCATE $DIR/$tfile 1048576
21431         check_lsom_size $DIR/$tfile 1048576
21432         $TRUNCATE $DIR/$tfile 1234
21433         check_lsom_size $DIR/$tfile 1234
21434
21435         # verify SOM blocks count
21436         echo "Verify SOM block count"
21437         $TRUNCATE $DIR/$tfile 0
21438         $MULTIOP $DIR/$tfile oO_TRUNC:O_RDWR:w1048576YSc ||
21439                 error "failed to write file $tfile"
21440         check_lsom_data $DIR/$tfile
21441 }
21442 run_test 806 "Verify Lazy Size on MDS"
21443
21444 test_807() {
21445         [ -n "$FILESET" ] && skip "Not functional for FILESET set"
21446         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
21447                 skip "Need MDS version at least 2.11.52"
21448
21449         # Registration step
21450         changelog_register || error "changelog_register failed"
21451         local cl_user="${CL_USERS[$SINGLEMDS]%% *}"
21452         changelog_users $SINGLEMDS | grep -q $cl_user ||
21453                 error "User $cl_user not found in changelog_users"
21454
21455         local save="$TMP/$TESTSUITE-$TESTNAME.parameters"
21456         save_lustre_params client "llite.*.xattr_cache" > $save
21457         lctl set_param llite.*.xattr_cache=0
21458         stack_trap "restore_lustre_params < $save; rm -f $save" EXIT
21459
21460         rm -rf $DIR/$tdir || error "rm $tdir failed"
21461         mkdir -p $DIR/$tdir || error "mkdir $tdir failed"
21462         touch $DIR/$tdir/trunc || error "touch $tdir/trunc failed"
21463         $TRUNCATE $DIR/$tdir/trunc 1024 || error "truncate $tdir/trunc failed"
21464         $TRUNCATE $DIR/$tdir/trunc 1048576 ||
21465                 error "truncate $tdir/trunc failed"
21466
21467         local bs=1048576
21468         dd if=/dev/zero of=$DIR/$tdir/single_dd bs=$bs count=1 ||
21469                 error "write $tfile failed"
21470
21471         # multi-client wirtes
21472         local num=$(get_node_count ${CLIENTS//,/ })
21473         local offset=0
21474         local i=0
21475
21476         echo "Test SOM for multi-client ($num) writes"
21477         touch $DIR/$tfile || error "touch $tfile failed"
21478         $TRUNCATE $DIR/$tfile 0
21479         for client in ${CLIENTS//,/ }; do
21480                 do_node $client $MULTIOP $DIR/$tfile Oz${offset}w${bs}c &
21481                 local pids[$i]=$!
21482                 i=$((i + 1))
21483                 offset=$((offset + $bs))
21484         done
21485         for (( i=0; i < $num; i++ )); do
21486                 wait ${pids[$i]}
21487         done
21488
21489         sleep 5
21490         $LSOM_SYNC -u $cl_user -m $FSNAME-MDT0000 $MOUNT
21491         check_lsom_data $DIR/$tdir/trunc
21492         check_lsom_data $DIR/$tdir/single_dd
21493         check_lsom_data $DIR/$tfile
21494
21495         rm -rf $DIR/$tdir
21496         # Deregistration step
21497         changelog_deregister || error "changelog_deregister failed"
21498 }
21499 run_test 807 "verify LSOM syncing tool"
21500
21501 check_som_nologged()
21502 {
21503         local lines=$($LFS changelog $FSNAME-MDT0000 |
21504                 grep 'x=trusted.som' | wc -l)
21505         [ $lines -ne 0 ] && error "trusted.som xattr is logged in Changelogs"
21506 }
21507
21508 test_808() {
21509         [ $MDS1_VERSION -lt $(version_code 2.11.55) ] &&
21510                 skip "Need MDS version at least 2.11.55"
21511
21512         # Registration step
21513         changelog_register || error "changelog_register failed"
21514
21515         touch $DIR/$tfile || error "touch $tfile failed"
21516         check_som_nologged
21517
21518         dd if=/dev/zero of=$DIR/$tfile bs=1048576 count=1 ||
21519                 error "write $tfile failed"
21520         check_som_nologged
21521
21522         $TRUNCATE $DIR/$tfile 1234
21523         check_som_nologged
21524
21525         $TRUNCATE $DIR/$tfile 1048576
21526         check_som_nologged
21527
21528         # Deregistration step
21529         changelog_deregister || error "changelog_deregister failed"
21530 }
21531 run_test 808 "Check trusted.som xattr not logged in Changelogs"
21532
21533 check_som_nodata()
21534 {
21535         $LFS getsom $1
21536         [[ $? -eq 61 ]] || error "DoM-only file $1 has SOM xattr"
21537 }
21538
21539 test_809() {
21540         [ $MDS1_VERSION -lt $(version_code 2.11.56) ] &&
21541                 skip "Need MDS version at least 2.11.56"
21542
21543         $LFS setstripe -E 1M -L mdt $DIR/$tfile ||
21544                 error "failed to create DoM-only file $DIR/$tfile"
21545         touch $DIR/$tfile || error "touch $tfile failed"
21546         check_som_nodata $DIR/$tfile
21547
21548         dd if=/dev/zero of=$DIR/$tfile bs=2048 count=1 ||
21549                 error "write $tfile failed"
21550         check_som_nodata $DIR/$tfile
21551
21552         $TRUNCATE $DIR/$tfile 1234
21553         check_som_nodata $DIR/$tfile
21554
21555         $TRUNCATE $DIR/$tfile 4097
21556         check_som_nodata $DIR/$file
21557 }
21558 run_test 809 "Verify no SOM xattr store for DoM-only files"
21559
21560 test_810() {
21561         local ORIG
21562         local CSUM
21563
21564         # t10 seem to dislike partial pages
21565         lctl set_param osc.*.checksum_type=adler
21566         lctl set_param fail_loc=0x411
21567         dd if=/dev/urandom of=$DIR/$tfile bs=10240 count=2
21568         ORIG=$(md5sum $DIR/$tfile)
21569         lctl set_param ldlm.namespaces.*osc*.lru_size=clear
21570         CSUM=$(md5sum $DIR/$tfile)
21571         set_checksum_type adler
21572         if [ "$ORIG" != "$CSUM" ]; then
21573                 error "$ORIG != $CSUM"
21574         fi
21575 }
21576 run_test 810 "partial page writes on ZFS (LU-11663)"
21577
21578 test_811() {
21579         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.11.56) ] &&
21580                 skip "Need MDS version at least 2.11.56"
21581
21582         #define OBD_FAIL_MDS_ORPHAN_DELETE      0x165
21583         do_facet mds1 $LCTL set_param fail_loc=0x165
21584         $MULTIOP $DIR/$tfile Ouc || error "multiop failed"
21585
21586         stop mds1
21587         start mds1 $(mdsdevname 1) $MDS_MOUNT_OPTS
21588
21589         sleep 5
21590         [[ $(do_facet mds1 pgrep orph_.*-MDD | wc -l) -eq 0 ]] ||
21591                 error "MDD orphan cleanup thread not quit"
21592 }
21593 run_test 811 "orphan name stub can be cleaned up in startup"
21594
21595 test_812() {
21596         [ $OST1_VERSION -lt $(version_code 2.12.51) ] &&
21597                 skip "OST < 2.12.51 doesn't support this fail_loc"
21598         [ "$SHARED_KEY" = true ] &&
21599                 skip "OSC connections never go IDLE with Shared-Keys enabled"
21600
21601         $LFS setstripe -c 1 -i 0 $DIR/$tfile
21602         # ensure ost1 is connected
21603         stat $DIR/$tfile >/dev/null || error "can't stat"
21604         wait_osc_import_state client ost1 FULL
21605         # no locks, no reqs to let the connection idle
21606         cancel_lru_locks osc
21607
21608         # delay OST_DISCONNECT on OST1 to put OSC into intermediate state
21609 #define OBD_FAIL_OST_DISCONNECT_DELAY    0x245
21610         do_facet ost1 "$LCTL set_param fail_loc=0x245 fail_val=8"
21611         wait_osc_import_state client ost1 CONNECTING
21612         do_facet ost1 "$LCTL set_param fail_loc=0 fail_val=0"
21613
21614         stat $DIR/$tfile >/dev/null || error "can't stat file"
21615 }
21616 run_test 812 "do not drop reqs generated when imp is going to idle (LU-11951)"
21617
21618 test_813() {
21619         local file_heat_sav=$($LCTL get_param -n llite.*.file_heat 2>/dev/null)
21620         [ -z "$file_heat_sav" ] && skip "no file heat support"
21621
21622         local readsample
21623         local writesample
21624         local readbyte
21625         local writebyte
21626         local readsample1
21627         local writesample1
21628         local readbyte1
21629         local writebyte1
21630
21631         local period_second=$($LCTL get_param -n llite.*.heat_period_second)
21632         local decay_pct=$($LCTL get_param -n llite.*.heat_decay_percentage)
21633
21634         $LCTL set_param -n llite.*.file_heat=1
21635         echo "Turn on file heat"
21636         echo "Period second: $period_second, Decay percentage: $decay_pct"
21637
21638         echo "QQQQ" > $DIR/$tfile
21639         echo "QQQQ" > $DIR/$tfile
21640         echo "QQQQ" > $DIR/$tfile
21641         cat $DIR/$tfile > /dev/null
21642         cat $DIR/$tfile > /dev/null
21643         cat $DIR/$tfile > /dev/null
21644         cat $DIR/$tfile > /dev/null
21645
21646         local out=$($LFS heat_get $DIR/$tfile)
21647
21648         $LFS heat_get $DIR/$tfile
21649         readsample=$(echo "$out" | grep 'readsample' | awk '{ print $2 }')
21650         writesample=$(echo "$out" | grep 'writesample' | awk '{ print $2 }')
21651         readbyte=$(echo "$out" | grep 'readbyte' | awk '{ print $2 }')
21652         writebyte=$(echo "$out" | grep 'writebyte' | awk '{ print $2 }')
21653
21654         [ $readsample -le 4 ] || error "read sample ($readsample) is wrong"
21655         [ $writesample -le 3 ] || error "write sample ($writesample) is wrong"
21656         [ $readbyte -le 20 ] || error "read bytes ($readbyte) is wrong"
21657         [ $writebyte -le 15 ] || error "write bytes ($writebyte) is wrong"
21658
21659         sleep $((period_second + 3))
21660         echo "Sleep $((period_second + 3)) seconds..."
21661         # The recursion formula to calculate the heat of the file f is as
21662         # follow:
21663         # Hi+1(f) = (1-P)*Hi(f)+ P*Ci
21664         # Where Hi is the heat value in the period between time points i*I and
21665         # (i+1)*I; Ci is the access count in the period; the symbol P refers
21666         # to the weight of Ci.
21667         out=$($LFS heat_get $DIR/$tfile)
21668         $LFS heat_get $DIR/$tfile
21669         readsample=$(echo "$out" | grep 'readsample' | awk '{ print $2 }')
21670         writesample=$(echo "$out" | grep 'writesample' | awk '{ print $2 }')
21671         readbyte=$(echo "$out" | grep 'readbyte' | awk '{ print $2 }')
21672         writebyte=$(echo "$out" | grep 'writebyte' | awk '{ print $2 }')
21673
21674         [ $(bc <<< "$readsample <= 4 * $decay_pct / 100") -eq 1 ] ||
21675                 error "read sample ($readsample) is wrong"
21676         [ $(bc <<< "$writesample <= 3 * $decay_pct / 100") -eq 1 ] ||
21677                 error "write sample ($writesample) is wrong"
21678         [ $(bc <<< "$readbyte <= 20 * $decay_pct / 100") -eq 1 ] ||
21679                 error "read bytes ($readbyte) is wrong"
21680         [ $(bc <<< "$writebyte <= 15 * $decay_pct / 100") -eq 1 ] ||
21681                 error "write bytes ($writebyte) is wrong"
21682
21683         echo "QQQQ" > $DIR/$tfile
21684         echo "QQQQ" > $DIR/$tfile
21685         echo "QQQQ" > $DIR/$tfile
21686         cat $DIR/$tfile > /dev/null
21687         cat $DIR/$tfile > /dev/null
21688         cat $DIR/$tfile > /dev/null
21689         cat $DIR/$tfile > /dev/null
21690
21691         sleep $((period_second + 3))
21692         echo "Sleep $((period_second + 3)) seconds..."
21693
21694         out=$($LFS heat_get $DIR/$tfile)
21695         $LFS heat_get $DIR/$tfile
21696         readsample1=$(echo "$out" | grep 'readsample' | awk '{ print $2 }')
21697         writesample1=$(echo "$out" | grep 'writesample' | awk '{ print $2 }')
21698         readbyte1=$(echo "$out" | grep 'readbyte' | awk '{ print $2 }')
21699         writebyte1=$(echo "$out" | grep 'writebyte' | awk '{ print $2 }')
21700
21701         [ $(bc <<< "$readsample1 <= ($readsample * (100 - $decay_pct) + \
21702                 4 * $decay_pct) / 100") -eq 1 ] ||
21703                 error "read sample ($readsample1) is wrong"
21704         [ $(bc <<< "$writesample1 <= ($writesample * (100 - $decay_pct) + \
21705                 3 * $decay_pct) / 100") -eq 1 ] ||
21706                 error "write sample ($writesample1) is wrong"
21707         [ $(bc <<< "$readbyte1 <= ($readbyte * (100 - $decay_pct) + \
21708                 20 * $decay_pct) / 100") -eq 1 ] ||
21709                 error "read bytes ($readbyte1) is wrong"
21710         [ $(bc <<< "$writebyte1 <= ($writebyte * (100 - $decay_pct) + \
21711                 15 * $decay_pct) / 100") -eq 1 ] ||
21712                 error "write bytes ($writebyte1) is wrong"
21713
21714         echo "Turn off file heat for the file $DIR/$tfile"
21715         $LFS heat_set -o $DIR/$tfile
21716
21717         echo "QQQQ" > $DIR/$tfile
21718         echo "QQQQ" > $DIR/$tfile
21719         echo "QQQQ" > $DIR/$tfile
21720         cat $DIR/$tfile > /dev/null
21721         cat $DIR/$tfile > /dev/null
21722         cat $DIR/$tfile > /dev/null
21723         cat $DIR/$tfile > /dev/null
21724
21725         out=$($LFS heat_get $DIR/$tfile)
21726         $LFS heat_get $DIR/$tfile
21727         readsample=$(echo "$out" | grep 'readsample' | awk '{ print $2 }')
21728         writesample=$(echo "$out" | grep 'writesample' | awk '{ print $2 }')
21729         readbyte=$(echo "$out" | grep 'readbyte' | awk '{ print $2 }')
21730         writebyte=$(echo "$out" | grep 'writebyte' | awk '{ print $2 }')
21731
21732         [ $readsample -eq 0 ] || error "read sample ($readsample) is wrong"
21733         [ $writesample -eq 0 ] || error "write sample ($writesample) is wrong"
21734         [ $readbyte -eq 0 ] || error "read bytes ($readbyte) is wrong"
21735         [ $writebyte -eq 0 ] || error "write bytes ($writebyte) is wrong"
21736
21737         echo "Trun on file heat for the file $DIR/$tfile"
21738         $LFS heat_set -O $DIR/$tfile
21739
21740         echo "QQQQ" > $DIR/$tfile
21741         echo "QQQQ" > $DIR/$tfile
21742         echo "QQQQ" > $DIR/$tfile
21743         cat $DIR/$tfile > /dev/null
21744         cat $DIR/$tfile > /dev/null
21745         cat $DIR/$tfile > /dev/null
21746         cat $DIR/$tfile > /dev/null
21747
21748         out=$($LFS heat_get $DIR/$tfile)
21749         $LFS heat_get $DIR/$tfile
21750         readsample=$(echo "$out" | grep 'readsample' | awk '{ print $2 }')
21751         writesample=$(echo "$out" | grep 'writesample' | awk '{ print $2 }')
21752         readbyte=$(echo "$out" | grep 'readbyte' | awk '{ print $2 }')
21753         writebyte=$(echo "$out" | grep 'writebyte' | awk '{ print $2 }')
21754
21755         [ $readsample -gt 0 ] || error "read sample ($readsample) is wrong"
21756         [ $writesample -gt 0 ] || error "write sample ($writesample) is wrong"
21757         [ $readbyte -gt 0 ] || error "read bytes ($readbyte) is wrong"
21758         [ $writebyte -gt 0 ] || error "write bytes ($writebyte) is wrong"
21759
21760         $LFS heat_set -c $DIR/$tfile
21761         $LCTL set_param -n llite.*.file_heat=0
21762         echo "Turn off file heat support for the Lustre filesystem"
21763
21764         echo "QQQQ" > $DIR/$tfile
21765         echo "QQQQ" > $DIR/$tfile
21766         echo "QQQQ" > $DIR/$tfile
21767         cat $DIR/$tfile > /dev/null
21768         cat $DIR/$tfile > /dev/null
21769         cat $DIR/$tfile > /dev/null
21770         cat $DIR/$tfile > /dev/null
21771
21772         out=$($LFS heat_get $DIR/$tfile)
21773         $LFS heat_get $DIR/$tfile
21774         readsample=$(echo "$out" | grep 'readsample' | awk '{ print $2 }')
21775         writesample=$(echo "$out" | grep 'writesample' | awk '{ print $2 }')
21776         readbyte=$(echo "$out" | grep 'readbyte' | awk '{ print $2 }')
21777         writebyte=$(echo "$out" | grep 'writebyte' | awk '{ print $2 }')
21778
21779         [ $readsample -eq 0 ] || error "read sample ($readsample) is wrong"
21780         [ $writesample -eq 0 ] || error "write sample ($writesample) is wrong"
21781         [ $readbyte -eq 0 ] || error "read bytes ($readbyte) is wrong"
21782         [ $writebyte -eq 0 ] || error "write bytes ($writebyte) is wrong"
21783
21784         $LCTL set_param -n llite.*.file_heat=$file_heat_sav
21785         rm -f $DIR/$tfile
21786 }
21787 run_test 813 "File heat verfication"
21788
21789 test_814()
21790 {
21791         dd of=$DIR/$tfile seek=128 bs=1k < /dev/null
21792         echo -n y >> $DIR/$tfile
21793         cp --sparse=always $DIR/$tfile $DIR/${tfile}.cp || error "copy failed"
21794         diff $DIR/$tfile $DIR/${tfile}.cp || error "files should be same"
21795 }
21796 run_test 814 "sparse cp works as expected (LU-12361)"
21797
21798 test_815()
21799 {
21800         writeme -b 100 $DIR/$tfile || error "write 100 bytes failed"
21801         writeme -b 0 $DIR/$tfile || error "write 0 byte failed"
21802 }
21803 run_test 815 "zero byte tiny write doesn't hang (LU-12382)"
21804
21805 test_816() {
21806         [ "$SHARED_KEY" = true ] &&
21807                 skip "OSC connections never go IDLE with Shared-Keys enabled"
21808
21809         $LFS setstripe -c 1 -i 0 $DIR/$tfile
21810         # ensure ost1 is connected
21811         stat $DIR/$tfile >/dev/null || error "can't stat"
21812         wait_osc_import_state client ost1 FULL
21813         # no locks, no reqs to let the connection idle
21814         cancel_lru_locks osc
21815         lru_resize_disable osc
21816         local before
21817         local now
21818         before=$($LCTL get_param -n \
21819                  ldlm.namespaces.$FSNAME-OST0000-osc-[^M]*.lru_size)
21820
21821         wait_osc_import_state client ost1 IDLE
21822         dd if=/dev/null of=$DIR/$tfile bs=1k count=1 conv=sync
21823         now=$($LCTL get_param -n \
21824               ldlm.namespaces.$FSNAME-OST0000-osc-[^M]*.lru_size)
21825         [ $before == $now ] || error "lru_size changed $before != $now"
21826 }
21827 run_test 816 "do not reset lru_resize on idle reconnect"
21828
21829 cleanup_817() {
21830         umount $tmpdir
21831         exportfs -u localhost:$DIR/nfsexp
21832         rm -rf $DIR/nfsexp
21833 }
21834
21835 test_817() {
21836         systemctl restart nfs-server.service || skip "failed to restart nfsd"
21837
21838         mkdir -p $DIR/nfsexp
21839         exportfs -orw,no_root_squash localhost:$DIR/nfsexp ||
21840                 error "failed to export nfs"
21841
21842         tmpdir=$(mktemp -d /tmp/nfs-XXXXXX)
21843         stack_trap cleanup_817 EXIT
21844
21845         mount -t nfs -orw localhost:$DIR/nfsexp $tmpdir ||
21846                 error "failed to mount nfs to $tmpdir"
21847
21848         cp /bin/true $tmpdir
21849         $DIR/nfsexp/true || error "failed to execute 'true' command"
21850 }
21851 run_test 817 "nfsd won't cache write lock for exec file"
21852
21853 #
21854 # tests that do cleanup/setup should be run at the end
21855 #
21856
21857 test_900() {
21858         [ $PARALLEL == "yes" ] && skip "skip parallel run"
21859         local ls
21860
21861         #define OBD_FAIL_MGC_PAUSE_PROCESS_LOG   0x903
21862         $LCTL set_param fail_loc=0x903
21863
21864         cancel_lru_locks MGC
21865
21866         FAIL_ON_ERROR=true cleanup
21867         FAIL_ON_ERROR=true setup
21868 }
21869 run_test 900 "umount should not race with any mgc requeue thread"
21870
21871 complete $SECONDS
21872 [ -f $EXT2_DEV ] && rm $EXT2_DEV || true
21873 check_and_cleanup_lustre
21874 if [ "$I_MOUNTED" != "yes" ]; then
21875         lctl set_param debug="$OLDDEBUG" 2> /dev/null || true
21876 fi
21877 exit_status