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-4398
  57         ALWAYS_EXCEPT+=" 45       317      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:
  65         ALWAYS_EXCEPT="$ALWAYS_EXCEPT  "
  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 test_27M() {
2832         [[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.12.57) ]] &&
2833                 skip "Need MDS version >= than 2.12.57"
2834         remote_mds_nodsh && skip "remote MDS with nodsh"
2835         [[ $OSTCOUNT -lt 2 ]] && skip_env "need > 1 OST"
2836
2837         test_mkdir $DIR/$tdir
2838
2839         # Set default striping on directory
2840         $LFS setstripe -C 4 $DIR/$tdir
2841
2842         echo 1 > $DIR/$tdir/${tfile}.1
2843         local count=$($LFS getstripe -c $DIR/$tdir/${tfile}.1)
2844         local setcount=4
2845         [ $count -eq $setcount ] ||
2846                 error "(1) stripe count $count, should be $setcount"
2847
2848         # Capture existing append_stripe_count setting for restore
2849         local orig_count=$(do_facet mds1 $LCTL get_param -n mdd.$FSNAME-MDT0000.append_stripe_count)
2850         local mdts=$(comma_list $(mdts_nodes))
2851         stack_trap "do_nodes $mdts $LCTL set_param mdd.*.append_stripe_count=$orig_count" EXIT
2852
2853         local appendcount=$orig_count
2854         echo 1 >> $DIR/$tdir/${tfile}.2_append
2855         count=$($LFS getstripe -c $DIR/$tdir/${tfile}.2_append)
2856         [ $count -eq $appendcount ] ||
2857                 error "(2)stripe count $count, should be $appendcount for append"
2858
2859         # Disable O_APPEND striping, verify it works
2860         do_nodes $mdts $LCTL set_param mdd.*.append_stripe_count=0
2861
2862         # Should now get the default striping, which is 4
2863         setcount=4
2864         echo 1 >> $DIR/$tdir/${tfile}.3_append
2865         count=$($LFS getstripe -c $DIR/$tdir/${tfile}.3_append)
2866         [ $count -eq $setcount ] ||
2867                 error "(3) stripe count $count, should be $setcount"
2868
2869         # Try changing the stripe count for append files
2870         do_nodes $mdts $LCTL set_param mdd.*.append_stripe_count=2
2871
2872         # Append striping is now 2 (directory default is still 4)
2873         appendcount=2
2874         echo 1 >> $DIR/$tdir/${tfile}.4_append
2875         count=$($LFS getstripe -c $DIR/$tdir/${tfile}.4_append)
2876         [ $count -eq $appendcount ] ||
2877                 error "(4) stripe count $count, should be $appendcount for append"
2878
2879         # Test append stripe count of -1
2880         do_nodes $mdts $LCTL set_param mdd.*.append_stripe_count=-1
2881         appendcount=$OSTCOUNT
2882         echo 1 >> $DIR/$tdir/${tfile}.5
2883         count=$($LFS getstripe -c $DIR/$tdir/${tfile}.5)
2884         [ $count -eq $appendcount ] ||
2885                 error "(5) stripe count $count, should be $appendcount for append"
2886
2887         # Set append striping back to default of 1
2888         do_nodes $mdts $LCTL set_param mdd.*.append_stripe_count=1
2889
2890         # Try a new default striping, PFL + DOM
2891         $LFS setstripe -L mdt -E 1M -E -1 -c 2 $DIR/$tdir
2892
2893         # Create normal DOM file, DOM returns stripe count == 0
2894         setcount=0
2895         touch $DIR/$tdir/${tfile}.6
2896         count=$($LFS getstripe -c $DIR/$tdir/${tfile}.6)
2897         [ $count -eq $setcount ] ||
2898                 error "(6) stripe count $count, should be $setcount"
2899
2900         # Show
2901         appendcount=1
2902         echo 1 >> $DIR/$tdir/${tfile}.7_append
2903         count=$($LFS getstripe -c $DIR/$tdir/${tfile}.7_append)
2904         [ $count -eq $appendcount ] ||
2905                 error "(7) stripe count $count, should be $appendcount for append"
2906
2907         # Clean up DOM layout
2908         $LFS setstripe -d $DIR/$tdir
2909
2910         # Now test that append striping works when layout is from root
2911         $LFS setstripe -c 2 $MOUNT
2912         # Make a special directory for this
2913         mkdir $DIR/${tdir}/${tdir}.2
2914         stack_trap "$LFS setstripe -d $MOUNT" EXIT
2915
2916         # Verify for normal file
2917         setcount=2
2918         echo 1 > $DIR/${tdir}/${tdir}.2/${tfile}.8
2919         count=$($LFS getstripe -c $DIR/$tdir/${tdir}.2/${tfile}.8)
2920         [ $count -eq $setcount ] ||
2921                 error "(8) stripe count $count, should be $setcount"
2922
2923         appendcount=1
2924         echo 1 >> $DIR/${tdir}/${tdir}.2/${tfile}.9_append
2925         count=$($LFS getstripe -c $DIR/${tdir}/${tdir}.2/${tfile}.9_append)
2926         [ $count -eq $appendcount ] ||
2927                 error "(9) stripe count $count, should be $appendcount for append"
2928
2929         # Now test O_APPEND striping with pools
2930         do_nodes $mdts $LCTL set_param mdd.*.append_pool="$TESTNAME"
2931         stack_trap "do_nodes $mdts $LCTL set_param mdd.*.append_pool='none'" EXIT
2932
2933         # Create the pool
2934         pool_add $TESTNAME || error "pool creation failed"
2935         pool_add_targets $TESTNAME 0 1 || error "Pool add targets failed"
2936
2937         echo 1 >> $DIR/$tdir/${tfile}.10_append
2938
2939         pool=$($LFS getstripe -p $DIR/$tdir/${tfile}.10_append)
2940         [ "$pool" = "$TESTNAME" ] || error "(10) incorrect pool: $pool"
2941
2942         # Check that count is still correct
2943         appendcount=1
2944         echo 1 >> $DIR/$tdir/${tfile}.11_append
2945         count=$($LFS getstripe -c $DIR/$tdir/${tfile}.11_append)
2946         [ $count -eq $appendcount ] ||
2947                 error "(11) stripe count $count, should be $appendcount for append"
2948
2949         # Disable O_APPEND stripe count, verify pool works separately
2950         do_nodes $mdts $LCTL set_param mdd.*.append_stripe_count=0
2951
2952         echo 1 >> $DIR/$tdir/${tfile}.12_append
2953
2954         pool=$($LFS getstripe -p $DIR/$tdir/${tfile}.12_append)
2955         [ "$pool" = "$TESTNAME" ] || error "(12) incorrect pool: $pool"
2956
2957         # Remove pool setting, verify it's not applied
2958         do_nodes $mdts $LCTL set_param mdd.*.append_pool='none'
2959
2960         echo 1 >> $DIR/$tdir/${tfile}.13_append
2961
2962         pool=$($LFS getstripe -p $DIR/$tdir/${tfile}.13_append)
2963         [ "$pool" = "" ] || error "(13) pool found: $pool"
2964 }
2965 run_test 27M "test O_APPEND striping"
2966
2967 # createtest also checks that device nodes are created and
2968 # then visible correctly (#2091)
2969 test_28() { # bug 2091
2970         test_mkdir $DIR/d28
2971         $CREATETEST $DIR/d28/ct || error "createtest failed"
2972 }
2973 run_test 28 "create/mknod/mkdir with bad file types ============"
2974
2975 test_29() {
2976         [ $PARALLEL == "yes" ] && skip "skip parallel run"
2977
2978         sync; sleep 1; sync # flush out any dirty pages from previous tests
2979         cancel_lru_locks
2980         test_mkdir $DIR/d29
2981         touch $DIR/d29/foo
2982         log 'first d29'
2983         ls -l $DIR/d29
2984
2985         declare -i LOCKCOUNTORIG=0
2986         for lock_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_count); do
2987                 let LOCKCOUNTORIG=$LOCKCOUNTORIG+$lock_count
2988         done
2989         [ $LOCKCOUNTORIG -eq 0 ] && error "No mdc lock count" && return 1
2990
2991         declare -i LOCKUNUSEDCOUNTORIG=0
2992         for unused_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_unused_count); do
2993                 let LOCKUNUSEDCOUNTORIG=$LOCKUNUSEDCOUNTORIG+$unused_count
2994         done
2995
2996         log 'second d29'
2997         ls -l $DIR/d29
2998         log 'done'
2999
3000         declare -i LOCKCOUNTCURRENT=0
3001         for lock_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_count); do
3002                 let LOCKCOUNTCURRENT=$LOCKCOUNTCURRENT+$lock_count
3003         done
3004
3005         declare -i LOCKUNUSEDCOUNTCURRENT=0
3006         for unused_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_unused_count); do
3007                 let LOCKUNUSEDCOUNTCURRENT=$LOCKUNUSEDCOUNTCURRENT+$unused_count
3008         done
3009
3010         if [[ $LOCKCOUNTCURRENT -gt $LOCKCOUNTORIG ]]; then
3011                 $LCTL set_param -n ldlm.dump_namespaces ""
3012                 error "CURRENT: $LOCKCOUNTCURRENT > $LOCKCOUNTORIG"
3013                 $LCTL dk | sort -k4 -t: > $TMP/test_29.dk
3014                 log "dumped log to $TMP/test_29.dk (bug 5793)"
3015                 return 2
3016         fi
3017         if [[ $LOCKUNUSEDCOUNTCURRENT -gt $LOCKUNUSEDCOUNTORIG ]]; then
3018                 error "UNUSED: $LOCKUNUSEDCOUNTCURRENT > $LOCKUNUSEDCOUNTORIG"
3019                 $LCTL dk | sort -k4 -t: > $TMP/test_29.dk
3020                 log "dumped log to $TMP/test_29.dk (bug 5793)"
3021                 return 3
3022         fi
3023 }
3024 run_test 29 "IT_GETATTR regression  ============================"
3025
3026 test_30a() { # was test_30
3027         cp $(which ls) $DIR || cp /bin/ls $DIR
3028         $DIR/ls / || error "Can't execute binary from lustre"
3029         rm $DIR/ls
3030 }
3031 run_test 30a "execute binary from Lustre (execve) =============="
3032
3033 test_30b() {
3034         cp `which ls` $DIR || cp /bin/ls $DIR
3035         chmod go+rx $DIR/ls
3036         $RUNAS $DIR/ls / || error "Can't execute binary from lustre as non-root"
3037         rm $DIR/ls
3038 }
3039 run_test 30b "execute binary from Lustre as non-root ==========="
3040
3041 test_30c() { # b=22376
3042         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3043
3044         cp `which ls` $DIR || cp /bin/ls $DIR
3045         chmod a-rw $DIR/ls
3046         cancel_lru_locks mdc
3047         cancel_lru_locks osc
3048         $RUNAS $DIR/ls / || error "Can't execute binary from lustre"
3049         rm -f $DIR/ls
3050 }
3051 run_test 30c "execute binary from Lustre without read perms ===="
3052
3053 test_31a() {
3054         $OPENUNLINK $DIR/f31 $DIR/f31 || error "openunlink failed"
3055         $CHECKSTAT -a $DIR/f31 || error "$DIR/f31 exists"
3056 }
3057 run_test 31a "open-unlink file =================================="
3058
3059 test_31b() {
3060         touch $DIR/f31 || error "touch $DIR/f31 failed"
3061         ln $DIR/f31 $DIR/f31b || error "ln failed"
3062         $MULTIOP $DIR/f31b Ouc || error "multiop failed"
3063         $CHECKSTAT -t file $DIR/f31 || error "$DIR/f31 not file type"
3064 }
3065 run_test 31b "unlink file with multiple links while open ======="
3066
3067 test_31c() {
3068         touch $DIR/f31 || error "touch $DIR/f31 failed"
3069         ln $DIR/f31 $DIR/f31c || error "ln failed"
3070         multiop_bg_pause $DIR/f31 O_uc ||
3071                 error "multiop_bg_pause for $DIR/f31 failed"
3072         MULTIPID=$!
3073         $MULTIOP $DIR/f31c Ouc
3074         kill -USR1 $MULTIPID
3075         wait $MULTIPID
3076 }
3077 run_test 31c "open-unlink file with multiple links ============="
3078
3079 test_31d() {
3080         opendirunlink $DIR/d31d $DIR/d31d || error "opendirunlink failed"
3081         $CHECKSTAT -a $DIR/d31d || error "$DIR/d31d exists"
3082 }
3083 run_test 31d "remove of open directory ========================="
3084
3085 test_31e() { # bug 2904
3086         openfilleddirunlink $DIR/d31e || error "openfilleddirunlink failed"
3087 }
3088 run_test 31e "remove of open non-empty directory ==============="
3089
3090 test_31f() { # bug 4554
3091         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3092
3093         set -vx
3094         test_mkdir $DIR/d31f
3095         $LFS setstripe -S 1048576 -c 1 $DIR/d31f
3096         cp /etc/hosts $DIR/d31f
3097         ls -l $DIR/d31f
3098         $LFS getstripe $DIR/d31f/hosts
3099         multiop_bg_pause $DIR/d31f D_c || return 1
3100         MULTIPID=$!
3101
3102         rm -rv $DIR/d31f || error "first of $DIR/d31f"
3103         test_mkdir $DIR/d31f
3104         $LFS setstripe -S 1048576 -c 1 $DIR/d31f
3105         cp /etc/hosts $DIR/d31f
3106         ls -l $DIR/d31f
3107         $LFS getstripe $DIR/d31f/hosts
3108         multiop_bg_pause $DIR/d31f D_c || return 1
3109         MULTIPID2=$!
3110
3111         kill -USR1 $MULTIPID || error "first opendir $MULTIPID not running"
3112         wait $MULTIPID || error "first opendir $MULTIPID failed"
3113
3114         sleep 6
3115
3116         kill -USR1 $MULTIPID2 || error "second opendir $MULTIPID not running"
3117         wait $MULTIPID2 || error "second opendir $MULTIPID2 failed"
3118         set +vx
3119 }
3120 run_test 31f "remove of open directory with open-unlink file ==="
3121
3122 test_31g() {
3123         echo "-- cross directory link --"
3124         test_mkdir -c1 $DIR/${tdir}ga
3125         test_mkdir -c1 $DIR/${tdir}gb
3126         touch $DIR/${tdir}ga/f
3127         ln $DIR/${tdir}ga/f $DIR/${tdir}gb/g
3128         $CHECKSTAT -t file $DIR/${tdir}ga/f || error "source"
3129         [ `stat -c%h $DIR/${tdir}ga/f` == '2' ] || error "source nlink"
3130         $CHECKSTAT -t file $DIR/${tdir}gb/g || error "target"
3131         [ `stat -c%h $DIR/${tdir}gb/g` == '2' ] || error "target nlink"
3132 }
3133 run_test 31g "cross directory link==============="
3134
3135 test_31h() {
3136         echo "-- cross directory link --"
3137         test_mkdir -c1 $DIR/${tdir}
3138         test_mkdir -c1 $DIR/${tdir}/dir
3139         touch $DIR/${tdir}/f
3140         ln $DIR/${tdir}/f $DIR/${tdir}/dir/g
3141         $CHECKSTAT -t file $DIR/${tdir}/f || error "source"
3142         [ `stat -c%h $DIR/${tdir}/f` == '2' ] || error "source nlink"
3143         $CHECKSTAT -t file $DIR/${tdir}/dir/g || error "target"
3144         [ `stat -c%h $DIR/${tdir}/dir/g` == '2' ] || error "target nlink"
3145 }
3146 run_test 31h "cross directory link under child==============="
3147
3148 test_31i() {
3149         echo "-- cross directory link --"
3150         test_mkdir -c1 $DIR/$tdir
3151         test_mkdir -c1 $DIR/$tdir/dir
3152         touch $DIR/$tdir/dir/f
3153         ln $DIR/$tdir/dir/f $DIR/$tdir/g
3154         $CHECKSTAT -t file $DIR/$tdir/dir/f || error "source"
3155         [ `stat -c%h $DIR/$tdir/dir/f` == '2' ] || error "source nlink"
3156         $CHECKSTAT -t file $DIR/$tdir/g || error "target"
3157         [ `stat -c%h $DIR/$tdir/g` == '2' ] || error "target nlink"
3158 }
3159 run_test 31i "cross directory link under parent==============="
3160
3161 test_31j() {
3162         test_mkdir -c1 -p $DIR/$tdir
3163         test_mkdir -c1 -p $DIR/$tdir/dir1
3164         ln $DIR/$tdir/dir1 $DIR/$tdir/dir2 && error "ln for dir"
3165         link $DIR/$tdir/dir1 $DIR/$tdir/dir3 && error "link for dir"
3166         mlink $DIR/$tdir/dir1 $DIR/$tdir/dir4 && error "mlink for dir"
3167         mlink $DIR/$tdir/dir1 $DIR/$tdir/dir1 && error "mlink to the same dir"
3168         return 0
3169 }
3170 run_test 31j "link for directory==============="
3171
3172 test_31k() {
3173         test_mkdir -c1 -p $DIR/$tdir
3174         touch $DIR/$tdir/s
3175         touch $DIR/$tdir/exist
3176         mlink $DIR/$tdir/s $DIR/$tdir/t || error "mlink"
3177         mlink $DIR/$tdir/s $DIR/$tdir/exist && error "mlink to exist file"
3178         mlink $DIR/$tdir/s $DIR/$tdir/s && error "mlink to the same file"
3179         mlink $DIR/$tdir/s $DIR/$tdir && error "mlink to parent dir"
3180         mlink $DIR/$tdir $DIR/$tdir/s && error "mlink parent dir to target"
3181         mlink $DIR/$tdir/not-exist $DIR/$tdir/foo && error "mlink non-existing to new"
3182         mlink $DIR/$tdir/not-exist $DIR/$tdir/s && error "mlink non-existing to exist"
3183         return 0
3184 }
3185 run_test 31k "link to file: the same, non-existing, dir==============="
3186
3187 test_31m() {
3188         mkdir $DIR/d31m
3189         touch $DIR/d31m/s
3190         mkdir $DIR/d31m2
3191         touch $DIR/d31m2/exist
3192         mlink $DIR/d31m/s $DIR/d31m2/t || error "mlink"
3193         mlink $DIR/d31m/s $DIR/d31m2/exist && error "mlink to exist file"
3194         mlink $DIR/d31m/s $DIR/d31m2 && error "mlink to parent dir"
3195         mlink $DIR/d31m2 $DIR/d31m/s && error "mlink parent dir to target"
3196         mlink $DIR/d31m/not-exist $DIR/d31m2/foo && error "mlink non-existing to new"
3197         mlink $DIR/d31m/not-exist $DIR/d31m2/s && error "mlink non-existing to exist"
3198         return 0
3199 }
3200 run_test 31m "link to file: the same, non-existing, dir==============="
3201
3202 test_31n() {
3203         touch $DIR/$tfile || error "cannot create '$DIR/$tfile'"
3204         nlink=$(stat --format=%h $DIR/$tfile)
3205         [ ${nlink:--1} -eq 1 ] || error "nlink is $nlink, expected 1"
3206         local fd=$(free_fd)
3207         local cmd="exec $fd<$DIR/$tfile"
3208         eval $cmd
3209         cmd="exec $fd<&-"
3210         trap "eval $cmd" EXIT
3211         nlink=$(stat --dereference --format=%h /proc/self/fd/$fd)
3212         [ ${nlink:--1} -eq 1 ] || error "nlink is $nlink, expected 1"
3213         rm $DIR/$tfile || error "cannot remove '$DIR/$tfile'"
3214         nlink=$(stat --dereference --format=%h /proc/self/fd/$fd)
3215         [ ${nlink:--1} -eq 0 ] || error "nlink is $nlink, expected 0"
3216         eval $cmd
3217 }
3218 run_test 31n "check link count of unlinked file"
3219
3220 link_one() {
3221         local tempfile=$(mktemp $1_XXXXXX)
3222         mlink $tempfile $1 2> /dev/null &&
3223                 echo "$BASHPID: link $tempfile to $1 succeeded"
3224         munlink $tempfile
3225 }
3226
3227 test_31o() { # LU-2901
3228         test_mkdir $DIR/$tdir
3229         for LOOP in $(seq 100); do
3230                 rm -f $DIR/$tdir/$tfile*
3231                 for THREAD in $(seq 8); do
3232                         link_one $DIR/$tdir/$tfile.$LOOP &
3233                 done
3234                 wait
3235                 local LINKS=$(ls -1 $DIR/$tdir | grep -c $tfile.$LOOP)
3236                 [[ $LINKS -gt 1 ]] && ls $DIR/$tdir &&
3237                         error "$LINKS duplicate links to $tfile.$LOOP" &&
3238                         break || true
3239         done
3240 }
3241 run_test 31o "duplicate hard links with same filename"
3242
3243 test_31p() {
3244         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
3245
3246         test_mkdir $DIR/$tdir
3247         $LFS setdirstripe -i0 -c2 $DIR/$tdir/striped_dir
3248         $LFS setdirstripe -D -c2 -H all_char $DIR/$tdir/striped_dir
3249
3250         opendirunlink $DIR/$tdir/striped_dir/test1 ||
3251                 error "open unlink test1 failed"
3252         opendirunlink $DIR/$tdir/striped_dir/test2 ||
3253                 error "open unlink test2 failed"
3254
3255         $CHECKSTAT -a $DIR/$tdir/striped_dir/test1 ||
3256                 error "test1 still exists"
3257         $CHECKSTAT -a $DIR/$tdir/striped_dir/test2 ||
3258                 error "test2 still exists"
3259 }
3260 run_test 31p "remove of open striped directory"
3261
3262 cleanup_test32_mount() {
3263         local rc=0
3264         trap 0
3265         local loopdev=$(losetup -a | grep $EXT2_DEV | sed -ne 's/:.*$//p')
3266         $UMOUNT $DIR/$tdir/ext2-mountpoint || rc=$?
3267         losetup -d $loopdev || true
3268         rm -rf $DIR/$tdir
3269         return $rc
3270 }
3271
3272 test_32a() {
3273         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3274
3275         echo "== more mountpoints and symlinks ================="
3276         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3277         trap cleanup_test32_mount EXIT
3278         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3279         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3280                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3281         $CHECKSTAT -t dir $DIR/$tdir/ext2-mountpoint/.. ||
3282                 error "$DIR/$tdir/ext2-mountpoint/.. not dir type"
3283         cleanup_test32_mount
3284 }
3285 run_test 32a "stat d32a/ext2-mountpoint/.. ====================="
3286
3287 test_32b() {
3288         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3289
3290         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3291         trap cleanup_test32_mount EXIT
3292         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3293         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3294                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3295         ls -al $DIR/$tdir/ext2-mountpoint/.. ||
3296                 error "Can't list $DIR/$tdir/ext2-mountpoint/.."
3297         cleanup_test32_mount
3298 }
3299 run_test 32b "open d32b/ext2-mountpoint/.. ====================="
3300
3301 test_32c() {
3302         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3303
3304         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3305         trap cleanup_test32_mount EXIT
3306         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3307         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3308                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3309         test_mkdir -p $DIR/$tdir/d2/test_dir
3310         $CHECKSTAT -t dir $DIR/$tdir/ext2-mountpoint/../d2/test_dir ||
3311                 error "$DIR/$tdir/ext2-mountpoint/../d2/test_dir not dir type"
3312         cleanup_test32_mount
3313 }
3314 run_test 32c "stat d32c/ext2-mountpoint/../d2/test_dir ========="
3315
3316 test_32d() {
3317         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3318
3319         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3320         trap cleanup_test32_mount EXIT
3321         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3322         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3323                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3324         test_mkdir -p $DIR/$tdir/d2/test_dir
3325         ls -al $DIR/$tdir/ext2-mountpoint/../d2/test_dir ||
3326                 error "Can't list $DIR/$tdir/ext2-mountpoint/../d2/test_dir"
3327         cleanup_test32_mount
3328 }
3329 run_test 32d "open d32d/ext2-mountpoint/../d2/test_dir"
3330
3331 test_32e() {
3332         rm -fr $DIR/$tdir
3333         test_mkdir -p $DIR/$tdir/tmp
3334         local tmp_dir=$DIR/$tdir/tmp
3335         ln -s $DIR/$tdir $tmp_dir/symlink11
3336         ln -s $tmp_dir/symlink11 $tmp_dir/../symlink01
3337         $CHECKSTAT -t link $DIR/$tdir/tmp/symlink11 || error "symlink11 bad"
3338         $CHECKSTAT -t link $DIR/$tdir/symlink01 || error "symlink01 bad"
3339 }
3340 run_test 32e "stat d32e/symlink->tmp/symlink->lustre-subdir"
3341
3342 test_32f() {
3343         rm -fr $DIR/$tdir
3344         test_mkdir -p $DIR/$tdir/tmp
3345         local tmp_dir=$DIR/$tdir/tmp
3346         ln -s $DIR/$tdir $tmp_dir/symlink11
3347         ln -s $tmp_dir/symlink11 $tmp_dir/../symlink01
3348         ls $DIR/$tdir/tmp/symlink11  || error "symlink11 bad"
3349         ls $DIR/$tdir/symlink01 || error "symlink01 bad"
3350 }
3351 run_test 32f "open d32f/symlink->tmp/symlink->lustre-subdir"
3352
3353 test_32g() {
3354         local tmp_dir=$DIR/$tdir/tmp
3355         test_mkdir -p $tmp_dir
3356         test_mkdir $DIR/${tdir}2
3357         ln -s $DIR/${tdir}2 $tmp_dir/symlink12
3358         ln -s $tmp_dir/symlink12 $tmp_dir/../symlink02
3359         $CHECKSTAT -t link $tmp_dir/symlink12 || error "symlink12 not a link"
3360         $CHECKSTAT -t link $DIR/$tdir/symlink02 || error "symlink02 not a link"
3361         $CHECKSTAT -t dir -f $tmp_dir/symlink12 || error "symlink12 not a dir"
3362         $CHECKSTAT -t dir -f $DIR/$tdir/symlink02 || error "symlink12 not a dir"
3363 }
3364 run_test 32g "stat d32g/symlink->tmp/symlink->lustre-subdir/${tdir}2"
3365
3366 test_32h() {
3367         rm -fr $DIR/$tdir $DIR/${tdir}2
3368         tmp_dir=$DIR/$tdir/tmp
3369         test_mkdir -p $tmp_dir
3370         test_mkdir $DIR/${tdir}2
3371         ln -s $DIR/${tdir}2 $tmp_dir/symlink12
3372         ln -s $tmp_dir/symlink12 $tmp_dir/../symlink02
3373         ls $tmp_dir/symlink12 || error "listing symlink12"
3374         ls $DIR/$tdir/symlink02  || error "listing symlink02"
3375 }
3376 run_test 32h "open d32h/symlink->tmp/symlink->lustre-subdir/${tdir}2"
3377
3378 test_32i() {
3379         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3380
3381         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3382         trap cleanup_test32_mount EXIT
3383         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3384         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3385                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3386         touch $DIR/$tdir/test_file
3387         $CHECKSTAT -t file $DIR/$tdir/ext2-mountpoint/../test_file ||
3388                 error "$DIR/$tdir/ext2-mountpoint/../test_file not file type"
3389         cleanup_test32_mount
3390 }
3391 run_test 32i "stat d32i/ext2-mountpoint/../test_file ==========="
3392
3393 test_32j() {
3394         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3395
3396         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3397         trap cleanup_test32_mount EXIT
3398         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3399         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3400                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3401         touch $DIR/$tdir/test_file
3402         cat $DIR/$tdir/ext2-mountpoint/../test_file ||
3403                 error "Can't open $DIR/$tdir/ext2-mountpoint/../test_file"
3404         cleanup_test32_mount
3405 }
3406 run_test 32j "open d32j/ext2-mountpoint/../test_file ==========="
3407
3408 test_32k() {
3409         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3410
3411         rm -fr $DIR/$tdir
3412         trap cleanup_test32_mount EXIT
3413         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3414         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3415                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3416         test_mkdir -p $DIR/$tdir/d2
3417         touch $DIR/$tdir/d2/test_file || error "touch failed"
3418         $CHECKSTAT -t file $DIR/$tdir/ext2-mountpoint/../d2/test_file ||
3419                 error "$DIR/$tdir/ext2-mountpoint/../d2/test_file not file type"
3420         cleanup_test32_mount
3421 }
3422 run_test 32k "stat d32k/ext2-mountpoint/../d2/test_file ========"
3423
3424 test_32l() {
3425         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3426
3427         rm -fr $DIR/$tdir
3428         trap cleanup_test32_mount EXIT
3429         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3430         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3431                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3432         test_mkdir -p $DIR/$tdir/d2
3433         touch $DIR/$tdir/d2/test_file || error "touch failed"
3434         cat  $DIR/$tdir/ext2-mountpoint/../d2/test_file ||
3435                 error "Can't open $DIR/$tdir/ext2-mountpoint/../d2/test_file"
3436         cleanup_test32_mount
3437 }
3438 run_test 32l "open d32l/ext2-mountpoint/../d2/test_file ========"
3439
3440 test_32m() {
3441         rm -fr $DIR/d32m
3442         test_mkdir -p $DIR/d32m/tmp
3443         TMP_DIR=$DIR/d32m/tmp
3444         ln -s $DIR $TMP_DIR/symlink11
3445         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
3446         $CHECKSTAT -t link $DIR/d32m/tmp/symlink11 ||
3447                 error "symlink11 not a link"
3448         $CHECKSTAT -t link $DIR/d32m/symlink01 ||
3449                 error "symlink01 not a link"
3450 }
3451 run_test 32m "stat d32m/symlink->tmp/symlink->lustre-root ======"
3452
3453 test_32n() {
3454         rm -fr $DIR/d32n
3455         test_mkdir -p $DIR/d32n/tmp
3456         TMP_DIR=$DIR/d32n/tmp
3457         ln -s $DIR $TMP_DIR/symlink11
3458         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
3459         ls -l $DIR/d32n/tmp/symlink11  || error "listing symlink11"
3460         ls -l $DIR/d32n/symlink01 || error "listing symlink01"
3461 }
3462 run_test 32n "open d32n/symlink->tmp/symlink->lustre-root ======"
3463
3464 test_32o() {
3465         touch $DIR/$tfile
3466         test_mkdir -p $DIR/d32o/tmp
3467         TMP_DIR=$DIR/d32o/tmp
3468         ln -s $DIR/$tfile $TMP_DIR/symlink12
3469         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
3470         $CHECKSTAT -t link $DIR/d32o/tmp/symlink12 ||
3471                 error "symlink12 not a link"
3472         $CHECKSTAT -t link $DIR/d32o/symlink02 || error "symlink02 not a link"
3473         $CHECKSTAT -t file -f $DIR/d32o/tmp/symlink12 ||
3474                 error "$DIR/d32o/tmp/symlink12 not file type"
3475         $CHECKSTAT -t file -f $DIR/d32o/symlink02 ||
3476                 error "$DIR/d32o/symlink02 not file type"
3477 }
3478 run_test 32o "stat d32o/symlink->tmp/symlink->lustre-root/$tfile"
3479
3480 test_32p() {
3481         log 32p_1
3482         rm -fr $DIR/d32p
3483         log 32p_2
3484         rm -f $DIR/$tfile
3485         log 32p_3
3486         touch $DIR/$tfile
3487         log 32p_4
3488         test_mkdir -p $DIR/d32p/tmp
3489         log 32p_5
3490         TMP_DIR=$DIR/d32p/tmp
3491         log 32p_6
3492         ln -s $DIR/$tfile $TMP_DIR/symlink12
3493         log 32p_7
3494         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
3495         log 32p_8
3496         cat $DIR/d32p/tmp/symlink12 ||
3497                 error "Can't open $DIR/d32p/tmp/symlink12"
3498         log 32p_9
3499         cat $DIR/d32p/symlink02 || error "Can't open $DIR/d32p/symlink02"
3500         log 32p_10
3501 }
3502 run_test 32p "open d32p/symlink->tmp/symlink->lustre-root/$tfile"
3503
3504 test_32q() {
3505         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3506
3507         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3508         trap cleanup_test32_mount EXIT
3509         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3510         touch $DIR/$tdir/ext2-mountpoint/under_the_mount || error "touch failed"
3511         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3512                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3513         ls $DIR/$tdir/ext2-mountpoint | grep "\<under_the_mount\>" && error
3514         cleanup_test32_mount
3515 }
3516 run_test 32q "stat follows mountpoints in Lustre (should return error)"
3517
3518 test_32r() {
3519         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3520
3521         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
3522         trap cleanup_test32_mount EXIT
3523         test_mkdir -p $DIR/$tdir/ext2-mountpoint
3524         touch $DIR/$tdir/ext2-mountpoint/under_the_mount || error "touch failed"
3525         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint ||
3526                 error "mount failed for $EXT2_DEV $DIR/$tdir/ext2-mountpoint"
3527         ls $DIR/$tdir/ext2-mountpoint | grep -q under_the_mount && error || true
3528         cleanup_test32_mount
3529 }
3530 run_test 32r "opendir follows mountpoints in Lustre (should return error)"
3531
3532 test_33aa() {
3533         rm -f $DIR/$tfile
3534         touch $DIR/$tfile
3535         chmod 444 $DIR/$tfile
3536         chown $RUNAS_ID $DIR/$tfile
3537         log 33_1
3538         $RUNAS $OPENFILE -f O_RDWR $DIR/$tfile && error || true
3539         log 33_2
3540 }
3541 run_test 33aa "write file with mode 444 (should return error)"
3542
3543 test_33a() {
3544         rm -fr $DIR/$tdir
3545         test_mkdir $DIR/$tdir
3546         chown $RUNAS_ID $DIR/$tdir
3547         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/$tdir/$tfile ||
3548                 error "$RUNAS create $tdir/$tfile failed"
3549         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/$tdir/$tfile &&
3550                 error "open RDWR" || true
3551 }
3552 run_test 33a "test open file(mode=0444) with O_RDWR (should return error)"
3553
3554 test_33b() {
3555         rm -fr $DIR/$tdir
3556         test_mkdir $DIR/$tdir
3557         chown $RUNAS_ID $DIR/$tdir
3558         $RUNAS $OPENFILE -f 1286739555 $DIR/$tdir/$tfile || true
3559 }
3560 run_test 33b "test open file with malformed flags (No panic)"
3561
3562 test_33c() {
3563         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3564         remote_ost_nodsh && skip "remote OST with nodsh"
3565
3566         local ostnum
3567         local ostname
3568         local write_bytes
3569         local all_zeros
3570
3571         all_zeros=:
3572         rm -fr $DIR/$tdir
3573         test_mkdir $DIR/$tdir
3574         # Read: 0, Write: 4, create/destroy: 2/0, stat: 1, punch: 0
3575
3576         sync
3577         for ostnum in $(seq $OSTCOUNT); do
3578                 # test-framework's OST numbering is one-based, while Lustre's
3579                 # is zero-based
3580                 ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
3581                 # Parsing llobdstat's output sucks; we could grep the /proc
3582                 # path, but that's likely to not be as portable as using the
3583                 # llobdstat utility.  So we parse lctl output instead.
3584                 write_bytes=$(do_facet ost$ostnum lctl get_param -n \
3585                         obdfilter/$ostname/stats |
3586                         awk '/^write_bytes/ {print $7}' )
3587                 echo "baseline_write_bytes@$OSTnum/$ostname=$write_bytes"
3588                 if (( ${write_bytes:-0} > 0 ))
3589                 then
3590                         all_zeros=false
3591                         break;
3592                 fi
3593         done
3594
3595         $all_zeros || return 0
3596
3597         # Write four bytes
3598         echo foo > $DIR/$tdir/bar
3599         # Really write them
3600         sync
3601
3602         # Total up write_bytes after writing.  We'd better find non-zeros.
3603         for ostnum in $(seq $OSTCOUNT); do
3604                 ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
3605                 write_bytes=$(do_facet ost$ostnum lctl get_param -n \
3606                         obdfilter/$ostname/stats |
3607                         awk '/^write_bytes/ {print $7}' )
3608                 echo "write_bytes@$OSTnum/$ostname=$write_bytes"
3609                 if (( ${write_bytes:-0} > 0 ))
3610                 then
3611                         all_zeros=false
3612                         break;
3613                 fi
3614         done
3615
3616         if $all_zeros
3617         then
3618                 for ostnum in $(seq $OSTCOUNT); do
3619                         ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
3620                         echo "Check that write_bytes is present in obdfilter/*/stats:"
3621                         do_facet ost$ostnum lctl get_param -n \
3622                                 obdfilter/$ostname/stats
3623                 done
3624                 error "OST not keeping write_bytes stats (b22312)"
3625         fi
3626 }
3627 run_test 33c "test llobdstat and write_bytes"
3628
3629 test_33d() {
3630         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
3631         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3632
3633         local MDTIDX=1
3634         local remote_dir=$DIR/$tdir/remote_dir
3635
3636         test_mkdir $DIR/$tdir
3637         $LFS mkdir -i $MDTIDX $remote_dir ||
3638                 error "create remote directory failed"
3639
3640         touch $remote_dir/$tfile
3641         chmod 444 $remote_dir/$tfile
3642         chown $RUNAS_ID $remote_dir/$tfile
3643
3644         $RUNAS $OPENFILE -f O_RDWR $DIR/$tfile && error || true
3645
3646         chown $RUNAS_ID $remote_dir
3647         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $remote_dir/f33 ||
3648                                         error "create" || true
3649         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $remote_dir/f33 &&
3650                                     error "open RDWR" || true
3651         $RUNAS $OPENFILE -f 1286739555 $remote_dir/f33 || true
3652 }
3653 run_test 33d "openfile with 444 modes and malformed flags under remote dir"
3654
3655 test_33e() {
3656         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
3657
3658         mkdir $DIR/$tdir
3659
3660         $LFS setdirstripe -i0 -c2 $DIR/$tdir/striped_dir
3661         $LFS setdirstripe -i1 -c2 $DIR/$tdir/striped_dir1
3662         mkdir $DIR/$tdir/local_dir
3663
3664         local s0_mode=$(stat -c%f $DIR/$tdir/striped_dir)
3665         local s1_mode=$(stat -c%f $DIR/$tdir/striped_dir1)
3666         local l_mode=$(stat -c%f $DIR/$tdir/local_dir)
3667
3668         [ "$l_mode" = "$s0_mode" -a "$l_mode" = "$s1_mode" ] ||
3669                 error "mkdir $l_mode striped0 $s0_mode striped1 $s1_mode"
3670
3671         rmdir $DIR/$tdir/* || error "rmdir failed"
3672
3673         umask 777
3674         $LFS setdirstripe -i0 -c2 $DIR/$tdir/striped_dir
3675         $LFS setdirstripe -i1 -c2 $DIR/$tdir/striped_dir1
3676         mkdir $DIR/$tdir/local_dir
3677
3678         s0_mode=$(stat -c%f $DIR/$tdir/striped_dir)
3679         s1_mode=$(stat -c%f $DIR/$tdir/striped_dir1)
3680         l_mode=$(stat -c%f $DIR/$tdir/local_dir)
3681
3682         [ "$l_mode" = "$s0_mode" -a "$l_mode" = "$s1_mode" ] ||
3683                 error "mkdir $l_mode striped0 $s0_mode striped1 $s1_mode 777"
3684
3685         rmdir $DIR/$tdir/* || error "rmdir(umask 777) failed"
3686
3687         umask 000
3688         $LFS setdirstripe -i0 -c2 $DIR/$tdir/striped_dir
3689         $LFS setdirstripe -i1 -c2 $DIR/$tdir/striped_dir1
3690         mkdir $DIR/$tdir/local_dir
3691
3692         s0_mode=$(stat -c%f $DIR/$tdir/striped_dir)
3693         s1_mode=$(stat -c%f $DIR/$tdir/striped_dir1)
3694         l_mode=$(stat -c%f $DIR/$tdir/local_dir)
3695
3696         [ "$l_mode" = "$s0_mode" -a "$l_mode" = "$s1_mode" ] ||
3697                 error "mkdir $l_mode striped0 $s0_mode striped1 $s1_mode 0"
3698 }
3699 run_test 33e "mkdir and striped directory should have same mode"
3700
3701 cleanup_33f() {
3702         trap 0
3703         do_facet $SINGLEMDS $LCTL set_param mdt.*.enable_remote_dir_gid=0
3704 }
3705
3706 test_33f() {
3707         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
3708         remote_mds_nodsh && skip "remote MDS with nodsh"
3709
3710         mkdir $DIR/$tdir
3711         chmod go+rwx $DIR/$tdir
3712         do_facet $SINGLEMDS $LCTL set_param mdt.*.enable_remote_dir_gid=-1
3713         trap cleanup_33f EXIT
3714
3715         $RUNAS lfs mkdir -i 0 -c$MDSCOUNT $DIR/$tdir/striped_dir ||
3716                 error "cannot create striped directory"
3717
3718         $RUNAS touch $DIR/$tdir/striped_dir/{0..16} ||
3719                 error "cannot create files in striped directory"
3720
3721         $RUNAS rm $DIR/$tdir/striped_dir/{0..16} ||
3722                 error "cannot remove files in striped directory"
3723
3724         $RUNAS rmdir $DIR/$tdir/striped_dir ||
3725                 error "cannot remove striped directory"
3726
3727         cleanup_33f
3728 }
3729 run_test 33f "nonroot user can create, access, and remove a striped directory"
3730
3731 test_33g() {
3732         mkdir -p $DIR/$tdir/dir2
3733
3734         local err=$($RUNAS mkdir $DIR/$tdir/dir2 2>&1)
3735         echo $err
3736         [[ $err =~ "exists" ]] || error "Not exists error"
3737 }
3738 run_test 33g "nonroot user create already existing root created file"
3739
3740 TEST_34_SIZE=${TEST_34_SIZE:-2000000000000}
3741 test_34a() {
3742         rm -f $DIR/f34
3743         $MCREATE $DIR/f34 || error "mcreate failed"
3744         $LFS getstripe $DIR/f34 2>&1 | grep -q "no stripe info" ||
3745                 error "getstripe failed"
3746         $TRUNCATE $DIR/f34 $TEST_34_SIZE || error "truncate failed"
3747         $LFS getstripe $DIR/f34 2>&1 | grep -q "no stripe info" ||
3748                 error "getstripe failed"
3749         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 ||
3750                 error "Size of $DIR/f34 not equal to $TEST_34_SIZE bytes"
3751 }
3752 run_test 34a "truncate file that has not been opened ==========="
3753
3754 test_34b() {
3755         [ ! -f $DIR/f34 ] && test_34a
3756         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 ||
3757                 error "Size of $DIR/f34 not equal to $TEST_34_SIZE bytes"
3758         $OPENFILE -f O_RDONLY $DIR/f34
3759         $LFS getstripe $DIR/f34 2>&1 | grep -q "no stripe info" ||
3760                 error "getstripe failed"
3761         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 ||
3762                 error "Size of $DIR/f34 not equal to $TEST_34_SIZE bytes"
3763 }
3764 run_test 34b "O_RDONLY opening file doesn't create objects ====="
3765
3766 test_34c() {
3767         [ ! -f $DIR/f34 ] && test_34a
3768         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 ||
3769                 error "Size of $DIR/f34 not equal to $TEST_34_SIZE bytes"
3770         $OPENFILE -f O_RDWR $DIR/f34
3771         $LFS getstripe $DIR/f34 2>&1 | grep -q "no stripe info" &&
3772                 error "$LFS getstripe failed"
3773         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 ||
3774                 error "Size of $DIR/f34 not equal to $TEST_34_SIZE bytes"
3775 }
3776 run_test 34c "O_RDWR opening file-with-size works =============="
3777
3778 test_34d() {
3779         [ ! -f $DIR/f34 ] && test_34a
3780         dd if=/dev/zero of=$DIR/f34 conv=notrunc bs=4k count=1 ||
3781                 error "dd failed"
3782         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 ||
3783                 error "Size of $DIR/f34 not equal to $TEST_34_SIZE bytes"
3784         rm $DIR/f34
3785 }
3786 run_test 34d "write to sparse file ============================="
3787
3788 test_34e() {
3789         rm -f $DIR/f34e
3790         $MCREATE $DIR/f34e || error "mcreate failed"
3791         $TRUNCATE $DIR/f34e 1000 || error "truncate failed"
3792         $CHECKSTAT -s 1000 $DIR/f34e ||
3793                 error "Size of $DIR/f34e not equal to 1000 bytes"
3794         $OPENFILE -f O_RDWR $DIR/f34e
3795         $CHECKSTAT -s 1000 $DIR/f34e ||
3796                 error "Size of $DIR/f34e not equal to 1000 bytes"
3797 }
3798 run_test 34e "create objects, some with size and some without =="
3799
3800 test_34f() { # bug 6242, 6243
3801         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3802
3803         SIZE34F=48000
3804         rm -f $DIR/f34f
3805         $MCREATE $DIR/f34f || error "mcreate failed"
3806         $TRUNCATE $DIR/f34f $SIZE34F || error "truncating $DIR/f3f to $SIZE34F"
3807         dd if=$DIR/f34f of=$TMP/f34f
3808         $CHECKSTAT -s $SIZE34F $TMP/f34f || error "$TMP/f34f not $SIZE34F bytes"
3809         dd if=/dev/zero of=$TMP/f34fzero bs=$SIZE34F count=1
3810         cmp $DIR/f34f $TMP/f34fzero || error "$DIR/f34f not all zero"
3811         cmp $TMP/f34f $TMP/f34fzero || error "$TMP/f34f not all zero"
3812         rm $TMP/f34f $TMP/f34fzero $DIR/f34f
3813 }
3814 run_test 34f "read from a file with no objects until EOF ======="
3815
3816 test_34g() {
3817         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3818
3819         dd if=/dev/zero of=$DIR/$tfile bs=1 count=100 seek=$TEST_34_SIZE ||
3820                 error "dd failed"
3821         $TRUNCATE $DIR/$tfile $((TEST_34_SIZE / 2))|| error "truncate failed"
3822         $CHECKSTAT -s $((TEST_34_SIZE / 2)) $DIR/$tfile ||
3823                 error "Size of $DIR/$tfile not equal to $((TEST_34_SIZE / 2))"
3824         cancel_lru_locks osc
3825         $CHECKSTAT -s $((TEST_34_SIZE / 2)) $DIR/$tfile ||
3826                 error "wrong size after lock cancel"
3827
3828         $TRUNCATE $DIR/$tfile $TEST_34_SIZE || error "truncate failed"
3829         $CHECKSTAT -s $TEST_34_SIZE $DIR/$tfile ||
3830                 error "expanding truncate failed"
3831         cancel_lru_locks osc
3832         $CHECKSTAT -s $TEST_34_SIZE $DIR/$tfile ||
3833                 error "wrong expanded size after lock cancel"
3834 }
3835 run_test 34g "truncate long file ==============================="
3836
3837 test_34h() {
3838         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3839
3840         local gid=10
3841         local sz=1000
3842
3843         dd if=/dev/zero of=$DIR/$tfile bs=1M count=10 || error "dd failed"
3844         sync # Flush the cache so that multiop below does not block on cache
3845              # flush when getting the group lock
3846         $MULTIOP $DIR/$tfile OG${gid}T${sz}g${gid}c &
3847         MULTIPID=$!
3848
3849         # Since just timed wait is not good enough, let's do a sync write
3850         # that way we are sure enough time for a roundtrip + processing
3851         # passed + 2 seconds of extra margin.
3852         dd if=/dev/zero of=$DIR/${tfile}-1 bs=$PAGE_SIZE oflag=direct count=1
3853         rm $DIR/${tfile}-1
3854         sleep 2
3855
3856         if [[ `ps h -o comm -p $MULTIPID` == "multiop" ]]; then
3857                 error "Multiop blocked on ftruncate, pid=$MULTIPID"
3858                 kill -9 $MULTIPID
3859         fi
3860         wait $MULTIPID
3861         local nsz=`stat -c %s $DIR/$tfile`
3862         [[ $nsz == $sz ]] || error "New size wrong $nsz != $sz"
3863 }
3864 run_test 34h "ftruncate file under grouplock should not block"
3865
3866 test_35a() {
3867         cp /bin/sh $DIR/f35a
3868         chmod 444 $DIR/f35a
3869         chown $RUNAS_ID $DIR/f35a
3870         $RUNAS $DIR/f35a && error || true
3871         rm $DIR/f35a
3872 }
3873 run_test 35a "exec file with mode 444 (should return and not leak)"
3874
3875 test_36a() {
3876         rm -f $DIR/f36
3877         utime $DIR/f36 || error "utime failed for MDS"
3878 }
3879 run_test 36a "MDS utime check (mknod, utime)"
3880
3881 test_36b() {
3882         echo "" > $DIR/f36
3883         utime $DIR/f36 || error "utime failed for OST"
3884 }
3885 run_test 36b "OST utime check (open, utime)"
3886
3887 test_36c() {
3888         rm -f $DIR/d36/f36
3889         test_mkdir $DIR/d36
3890         chown $RUNAS_ID $DIR/d36
3891         $RUNAS utime $DIR/d36/f36 || error "utime failed for MDS as non-root"
3892 }
3893 run_test 36c "non-root MDS utime check (mknod, utime)"
3894
3895 test_36d() {
3896         [ ! -d $DIR/d36 ] && test_36c
3897         echo "" > $DIR/d36/f36
3898         $RUNAS utime $DIR/d36/f36 || error "utime failed for OST as non-root"
3899 }
3900 run_test 36d "non-root OST utime check (open, utime)"
3901
3902 test_36e() {
3903         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping"
3904
3905         test_mkdir $DIR/$tdir
3906         touch $DIR/$tdir/$tfile
3907         $RUNAS utime $DIR/$tdir/$tfile &&
3908                 error "utime worked, expected failure" || true
3909 }
3910 run_test 36e "utime on non-owned file (should return error)"
3911
3912 subr_36fh() {
3913         local fl="$1"
3914         local LANG_SAVE=$LANG
3915         local LC_LANG_SAVE=$LC_LANG
3916         export LANG=C LC_LANG=C # for date language
3917
3918         DATESTR="Dec 20  2000"
3919         test_mkdir $DIR/$tdir
3920         lctl set_param fail_loc=$fl
3921         date; date +%s
3922         cp /etc/hosts $DIR/$tdir/$tfile
3923         sync & # write RPC generated with "current" inode timestamp, but delayed
3924         sleep 1
3925         touch --date="$DATESTR" $DIR/$tdir/$tfile # setattr timestamp in past
3926         LS_BEFORE="`ls -l $DIR/$tdir/$tfile`" # old timestamp from client cache
3927         cancel_lru_locks $OSC
3928         LS_AFTER="`ls -l $DIR/$tdir/$tfile`"  # timestamp from OST object
3929         date; date +%s
3930         [ "$LS_BEFORE" != "$LS_AFTER" ] && \
3931                 echo "BEFORE: $LS_BEFORE" && \
3932                 echo "AFTER : $LS_AFTER" && \
3933                 echo "WANT  : $DATESTR" && \
3934                 error "$DIR/$tdir/$tfile timestamps changed" || true
3935
3936         export LANG=$LANG_SAVE LC_LANG=$LC_LANG_SAVE
3937 }
3938
3939 test_36f() {
3940         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3941
3942         #define OBD_FAIL_OST_BRW_PAUSE_BULK 0x214
3943         subr_36fh "0x80000214"
3944 }
3945 run_test 36f "utime on file racing with OST BRW write =========="
3946
3947 test_36g() {
3948         remote_ost_nodsh && skip "remote OST with nodsh"
3949         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3950         [ $MDS1_VERSION -lt $(version_code 2.12.51) ] &&
3951                 skip "Need MDS version at least 2.12.51"
3952
3953         local fmd_max_age
3954         local fmd
3955         local facet="ost1"
3956         local tgt="obdfilter"
3957
3958         [[ $OSC == "mdc" ]] && tgt="mdt" && facet="mds1"
3959
3960         test_mkdir $DIR/$tdir
3961         fmd_max_age=$(do_facet $facet \
3962                 "lctl get_param -n $tgt.*.tgt_fmd_seconds 2> /dev/null | \
3963                 head -n 1")
3964
3965         echo "FMD max age: ${fmd_max_age}s"
3966         touch $DIR/$tdir/$tfile
3967         fmd=$(do_facet $facet "lctl get_param -n $tgt.*.exports.*.fmd_count" |
3968                 gawk '{cnt=cnt+$1}  END{print cnt}')
3969         echo "FMD before: $fmd"
3970         [[ $fmd == 0 ]] &&
3971                 error "FMD wasn't create by touch"
3972         sleep $((fmd_max_age + 12))
3973         fmd=$(do_facet $facet "lctl get_param -n $tgt.*.exports.*.fmd_count" |
3974                 gawk '{cnt=cnt+$1}  END{print cnt}')
3975         echo "FMD after: $fmd"
3976         [[ $fmd == 0 ]] ||
3977                 error "FMD wasn't expired by ping"
3978 }
3979 run_test 36g "FMD cache expiry ====================="
3980
3981 test_36h() {
3982         [ $PARALLEL == "yes" ] && skip "skip parallel run"
3983
3984         #define OBD_FAIL_OST_BRW_PAUSE_BULK2 0x227
3985         subr_36fh "0x80000227"
3986 }
3987 run_test 36h "utime on file racing with OST BRW write =========="
3988
3989 test_36i() {
3990         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
3991
3992         test_mkdir $DIR/$tdir
3993         $LFS setdirstripe -i0 -c$MDSCOUNT $DIR/$tdir/striped_dir
3994
3995         local mtime=$(stat -c%Y $DIR/$tdir/striped_dir)
3996         local new_mtime=$((mtime + 200))
3997
3998         #change Modify time of striped dir
3999         touch -m -d @$new_mtime $DIR/$tdir/striped_dir ||
4000                         error "change mtime failed"
4001
4002         local got=$(stat -c%Y $DIR/$tdir/striped_dir)
4003
4004         [ "$new_mtime" = "$got" ] || error "expect $new_mtime got $got"
4005 }
4006 run_test 36i "change mtime on striped directory"
4007
4008 # test_37 - duplicate with tests 32q 32r
4009
4010 test_38() {
4011         local file=$DIR/$tfile
4012         touch $file
4013         openfile -f O_DIRECTORY $file
4014         local RC=$?
4015         local ENOTDIR=20
4016         [ $RC -eq 0 ] && error "opened file $file with O_DIRECTORY" || true
4017         [ $RC -eq $ENOTDIR ] || error "error $RC should be ENOTDIR ($ENOTDIR)"
4018 }
4019 run_test 38 "open a regular file with O_DIRECTORY should return -ENOTDIR ==="
4020
4021 test_39a() { # was test_39
4022         touch $DIR/$tfile
4023         touch $DIR/${tfile}2
4024 #       ls -l  $DIR/$tfile $DIR/${tfile}2
4025 #       ls -lu  $DIR/$tfile $DIR/${tfile}2
4026 #       ls -lc  $DIR/$tfile $DIR/${tfile}2
4027         sleep 2
4028         $OPENFILE -f O_CREAT:O_TRUNC:O_WRONLY $DIR/${tfile}2
4029         if [ ! $DIR/${tfile}2 -nt $DIR/$tfile ]; then
4030                 echo "mtime"
4031                 ls -l --full-time $DIR/$tfile $DIR/${tfile}2
4032                 echo "atime"
4033                 ls -lu --full-time $DIR/$tfile $DIR/${tfile}2
4034                 echo "ctime"
4035                 ls -lc --full-time $DIR/$tfile $DIR/${tfile}2
4036                 error "O_TRUNC didn't change timestamps"
4037         fi
4038 }
4039 run_test 39a "mtime changed on create"
4040
4041 test_39b() {
4042         test_mkdir -c1 $DIR/$tdir
4043         cp -p /etc/passwd $DIR/$tdir/fopen
4044         cp -p /etc/passwd $DIR/$tdir/flink
4045         cp -p /etc/passwd $DIR/$tdir/funlink
4046         cp -p /etc/passwd $DIR/$tdir/frename
4047         ln $DIR/$tdir/funlink $DIR/$tdir/funlink2
4048
4049         sleep 1
4050         echo "aaaaaa" >> $DIR/$tdir/fopen
4051         echo "aaaaaa" >> $DIR/$tdir/flink
4052         echo "aaaaaa" >> $DIR/$tdir/funlink
4053         echo "aaaaaa" >> $DIR/$tdir/frename
4054
4055         local open_new=`stat -c %Y $DIR/$tdir/fopen`
4056         local link_new=`stat -c %Y $DIR/$tdir/flink`
4057         local unlink_new=`stat -c %Y $DIR/$tdir/funlink`
4058         local rename_new=`stat -c %Y $DIR/$tdir/frename`
4059
4060         cat $DIR/$tdir/fopen > /dev/null
4061         ln $DIR/$tdir/flink $DIR/$tdir/flink2
4062         rm -f $DIR/$tdir/funlink2
4063         mv -f $DIR/$tdir/frename $DIR/$tdir/frename2
4064
4065         for (( i=0; i < 2; i++ )) ; do
4066                 local open_new2=`stat -c %Y $DIR/$tdir/fopen`
4067                 local link_new2=`stat -c %Y $DIR/$tdir/flink`
4068                 local unlink_new2=`stat -c %Y $DIR/$tdir/funlink`
4069                 local rename_new2=`stat -c %Y $DIR/$tdir/frename2`
4070
4071                 [ $open_new2 -eq $open_new ] || error "open file reverses mtime"
4072                 [ $link_new2 -eq $link_new ] || error "link file reverses mtime"
4073                 [ $unlink_new2 -eq $unlink_new ] || error "unlink file reverses mtime"
4074                 [ $rename_new2 -eq $rename_new ] || error "rename file reverses mtime"
4075
4076                 cancel_lru_locks $OSC
4077                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4078         done
4079 }
4080 run_test 39b "mtime change on open, link, unlink, rename  ======"
4081
4082 # this should be set to past
4083 TEST_39_MTIME=`date -d "1 year ago" +%s`
4084
4085 # bug 11063
4086 test_39c() {
4087         touch $DIR1/$tfile
4088         sleep 2
4089         local mtime0=`stat -c %Y $DIR1/$tfile`
4090
4091         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
4092         local mtime1=`stat -c %Y $DIR1/$tfile`
4093         [ "$mtime1" = $TEST_39_MTIME ] || \
4094                 error "mtime is not set to past: $mtime1, should be $TEST_39_MTIME"
4095
4096         local d1=`date +%s`
4097         echo hello >> $DIR1/$tfile
4098         local d2=`date +%s`
4099         local mtime2=`stat -c %Y $DIR1/$tfile`
4100         [ "$mtime2" -ge "$d1" ] && [ "$mtime2" -le "$d2" ] || \
4101                 error "mtime is not updated on write: $d1 <= $mtime2 <= $d2"
4102
4103         mv $DIR1/$tfile $DIR1/$tfile-1
4104
4105         for (( i=0; i < 2; i++ )) ; do
4106                 local mtime3=`stat -c %Y $DIR1/$tfile-1`
4107                 [ "$mtime2" = "$mtime3" ] || \
4108                         error "mtime ($mtime2) changed (to $mtime3) on rename"
4109
4110                 cancel_lru_locks $OSC
4111                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4112         done
4113 }
4114 run_test 39c "mtime change on rename ==========================="
4115
4116 # bug 21114
4117 test_39d() {
4118         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4119
4120         touch $DIR1/$tfile
4121         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
4122
4123         for (( i=0; i < 2; i++ )) ; do
4124                 local mtime=`stat -c %Y $DIR1/$tfile`
4125                 [ $mtime = $TEST_39_MTIME ] || \
4126                         error "mtime($mtime) is not set to $TEST_39_MTIME"
4127
4128                 cancel_lru_locks $OSC
4129                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4130         done
4131 }
4132 run_test 39d "create, utime, stat =============================="
4133
4134 # bug 21114
4135 test_39e() {
4136         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4137
4138         touch $DIR1/$tfile
4139         local mtime1=`stat -c %Y $DIR1/$tfile`
4140
4141         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
4142
4143         for (( i=0; i < 2; i++ )) ; do
4144                 local mtime2=`stat -c %Y $DIR1/$tfile`
4145                 [ $mtime2 = $TEST_39_MTIME ] || \
4146                         error "mtime($mtime2) is not set to $TEST_39_MTIME"
4147
4148                 cancel_lru_locks $OSC
4149                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4150         done
4151 }
4152 run_test 39e "create, stat, utime, stat ========================"
4153
4154 # bug 21114
4155 test_39f() {
4156         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4157
4158         touch $DIR1/$tfile
4159         mtime1=`stat -c %Y $DIR1/$tfile`
4160
4161         sleep 2
4162         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
4163
4164         for (( i=0; i < 2; i++ )) ; do
4165                 local mtime2=`stat -c %Y $DIR1/$tfile`
4166                 [ $mtime2 = $TEST_39_MTIME ] || \
4167                         error "mtime($mtime2) is not set to $TEST_39_MTIME"
4168
4169                 cancel_lru_locks $OSC
4170                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4171         done
4172 }
4173 run_test 39f "create, stat, sleep, utime, stat ================="
4174
4175 # bug 11063
4176 test_39g() {
4177         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4178
4179         echo hello >> $DIR1/$tfile
4180         local mtime1=`stat -c %Y $DIR1/$tfile`
4181
4182         sleep 2
4183         chmod o+r $DIR1/$tfile
4184
4185         for (( i=0; i < 2; i++ )) ; do
4186                 local mtime2=`stat -c %Y $DIR1/$tfile`
4187                 [ "$mtime1" = "$mtime2" ] || \
4188                         error "lost mtime: $mtime2, should be $mtime1"
4189
4190                 cancel_lru_locks $OSC
4191                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4192         done
4193 }
4194 run_test 39g "write, chmod, stat ==============================="
4195
4196 # bug 11063
4197 test_39h() {
4198         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4199
4200         touch $DIR1/$tfile
4201         sleep 1
4202
4203         local d1=`date`
4204         echo hello >> $DIR1/$tfile
4205         local mtime1=`stat -c %Y $DIR1/$tfile`
4206
4207         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
4208         local d2=`date`
4209         if [ "$d1" != "$d2" ]; then
4210                 echo "write and touch not within one second"
4211         else
4212                 for (( i=0; i < 2; i++ )) ; do
4213                         local mtime2=`stat -c %Y $DIR1/$tfile`
4214                         [ "$mtime2" = $TEST_39_MTIME ] || \
4215                                 error "lost mtime: $mtime2, should be $TEST_39_MTIME"
4216
4217                         cancel_lru_locks $OSC
4218                         if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4219                 done
4220         fi
4221 }
4222 run_test 39h "write, utime within one second, stat ============="
4223
4224 test_39i() {
4225         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4226
4227         touch $DIR1/$tfile
4228         sleep 1
4229
4230         echo hello >> $DIR1/$tfile
4231         local mtime1=`stat -c %Y $DIR1/$tfile`
4232
4233         mv $DIR1/$tfile $DIR1/$tfile-1
4234
4235         for (( i=0; i < 2; i++ )) ; do
4236                 local mtime2=`stat -c %Y $DIR1/$tfile-1`
4237
4238                 [ "$mtime1" = "$mtime2" ] || \
4239                         error "lost mtime: $mtime2, should be $mtime1"
4240
4241                 cancel_lru_locks $OSC
4242                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4243         done
4244 }
4245 run_test 39i "write, rename, stat =============================="
4246
4247 test_39j() {
4248         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4249
4250         start_full_debug_logging
4251         touch $DIR1/$tfile
4252         sleep 1
4253
4254         #define OBD_FAIL_OSC_DELAY_SETTIME       0x412
4255         lctl set_param fail_loc=0x80000412
4256         multiop_bg_pause $DIR1/$tfile oO_RDWR:w2097152_c ||
4257                 error "multiop failed"
4258         local multipid=$!
4259         local mtime1=`stat -c %Y $DIR1/$tfile`
4260
4261         mv $DIR1/$tfile $DIR1/$tfile-1
4262
4263         kill -USR1 $multipid
4264         wait $multipid || error "multiop close failed"
4265
4266         for (( i=0; i < 2; i++ )) ; do
4267                 local mtime2=`stat -c %Y $DIR1/$tfile-1`
4268                 [ "$mtime1" = "$mtime2" ] ||
4269                         error "mtime is lost on close: $mtime2, " \
4270                               "should be $mtime1"
4271
4272                 cancel_lru_locks $OSC
4273                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4274         done
4275         lctl set_param fail_loc=0
4276         stop_full_debug_logging
4277 }
4278 run_test 39j "write, rename, close, stat ======================="
4279
4280 test_39k() {
4281         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4282
4283         touch $DIR1/$tfile
4284         sleep 1
4285
4286         multiop_bg_pause $DIR1/$tfile oO_RDWR:w2097152_c || error "multiop failed"
4287         local multipid=$!
4288         local mtime1=`stat -c %Y $DIR1/$tfile`
4289
4290         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
4291
4292         kill -USR1 $multipid
4293         wait $multipid || error "multiop close failed"
4294
4295         for (( i=0; i < 2; i++ )) ; do
4296                 local mtime2=`stat -c %Y $DIR1/$tfile`
4297
4298                 [ "$mtime2" = $TEST_39_MTIME ] || \
4299                         error "mtime is lost on close: $mtime2, should be $TEST_39_MTIME"
4300
4301                 cancel_lru_locks osc
4302                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4303         done
4304 }
4305 run_test 39k "write, utime, close, stat ========================"
4306
4307 # this should be set to future
4308 TEST_39_ATIME=`date -d "1 year" +%s`
4309
4310 test_39l() {
4311         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4312         remote_mds_nodsh && skip "remote MDS with nodsh"
4313
4314         local atime_diff=$(do_facet $SINGLEMDS \
4315                                 lctl get_param -n mdd.*MDT0000*.atime_diff)
4316         rm -rf $DIR/$tdir
4317         mkdir -p $DIR/$tdir
4318
4319         # test setting directory atime to future
4320         touch -a -d @$TEST_39_ATIME $DIR/$tdir
4321         local atime=$(stat -c %X $DIR/$tdir)
4322         [ "$atime" = $TEST_39_ATIME ] ||
4323                 error "atime is not set to future: $atime, $TEST_39_ATIME"
4324
4325         # test setting directory atime from future to now
4326         local now=$(date +%s)
4327         touch -a -d @$now $DIR/$tdir
4328
4329         atime=$(stat -c %X $DIR/$tdir)
4330         [ "$atime" -eq "$now"  ] ||
4331                 error "atime is not updated from future: $atime, $now"
4332
4333         do_facet $SINGLEMDS lctl set_param -n mdd.*MDT0000*.atime_diff=2
4334         sleep 3
4335
4336         # test setting directory atime when now > dir atime + atime_diff
4337         local d1=$(date +%s)
4338         ls $DIR/$tdir
4339         local d2=$(date +%s)
4340         cancel_lru_locks mdc
4341         atime=$(stat -c %X $DIR/$tdir)
4342         [ "$atime" -ge "$d1" -a "$atime" -le "$d2" ] ||
4343                 error "atime is not updated  : $atime, should be $d2"
4344
4345         do_facet $SINGLEMDS lctl set_param -n mdd.*MDT0000*.atime_diff=60
4346         sleep 3
4347
4348         # test not setting directory atime when now < dir atime + atime_diff
4349         ls $DIR/$tdir
4350         cancel_lru_locks mdc
4351         atime=$(stat -c %X $DIR/$tdir)
4352         [ "$atime" -ge "$d1" -a "$atime" -le "$d2" ] ||
4353                 error "atime is updated to $atime, should remain $d1<atime<$d2"
4354
4355         do_facet $SINGLEMDS \
4356                 lctl set_param -n mdd.*MDT0000*.atime_diff=$atime_diff
4357 }
4358 run_test 39l "directory atime update ==========================="
4359
4360 test_39m() {
4361         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4362
4363         touch $DIR1/$tfile
4364         sleep 2
4365         local far_past_mtime=$(date -d "May 29 1953" +%s)
4366         local far_past_atime=$(date -d "Dec 17 1903" +%s)
4367
4368         touch -m -d @$far_past_mtime $DIR1/$tfile
4369         touch -a -d @$far_past_atime $DIR1/$tfile
4370
4371         for (( i=0; i < 2; i++ )) ; do
4372                 local timestamps=$(stat -c "%X %Y" $DIR1/$tfile)
4373                 [ "$timestamps" = "$far_past_atime $far_past_mtime" ] || \
4374                         error "atime or mtime set incorrectly"
4375
4376                 cancel_lru_locks $OSC
4377                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
4378         done
4379 }
4380 run_test 39m "test atime and mtime before 1970"
4381
4382 test_39n() { # LU-3832
4383         remote_mds_nodsh && skip "remote MDS with nodsh"
4384
4385         local atime_diff=$(do_facet $SINGLEMDS \
4386                 lctl get_param -n mdd.*MDT0000*.atime_diff)
4387         local atime0
4388         local atime1
4389         local atime2
4390
4391         do_facet $SINGLEMDS lctl set_param -n mdd.*MDT0000*.atime_diff=1
4392
4393         rm -rf $DIR/$tfile
4394         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 status=noxfer
4395         atime0=$(stat -c %X $DIR/$tfile)
4396
4397         sleep 5
4398         $MULTIOP $DIR/$tfile oO_RDONLY:O_NOATIME:r4096c
4399         atime1=$(stat -c %X $DIR/$tfile)
4400
4401         sleep 5
4402         cancel_lru_locks mdc
4403         cancel_lru_locks osc
4404         $MULTIOP $DIR/$tfile oO_RDONLY:O_NOATIME:r4096c
4405         atime2=$(stat -c %X $DIR/$tfile)
4406
4407         do_facet $SINGLEMDS \
4408                 lctl set_param -n mdd.*MDT0000*.atime_diff=$atime_diff
4409
4410         [ "$atime0" -eq "$atime1" ] || error "atime0 $atime0 != atime1 $atime1"
4411         [ "$atime1" -eq "$atime2" ] || error "atime0 $atime0 != atime1 $atime1"
4412 }
4413 run_test 39n "check that O_NOATIME is honored"
4414
4415 test_39o() {
4416         TESTDIR=$DIR/$tdir/$tfile
4417         [ -e $TESTDIR ] && rm -rf $TESTDIR
4418         mkdir -p $TESTDIR
4419         cd $TESTDIR
4420         links1=2
4421         ls
4422         mkdir a b
4423         ls
4424         links2=$(stat -c %h .)
4425         [ $(($links1 + 2)) != $links2 ] &&
4426                 error "wrong links count $(($links1 + 2)) != $links2"
4427         rmdir b
4428         links3=$(stat -c %h .)
4429         [ $(($links1 + 1)) != $links3 ] &&
4430                 error "wrong links count $links1 != $links3"
4431         return 0
4432 }
4433 run_test 39o "directory cached attributes updated after create"
4434
4435 test_39p() {
4436         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
4437
4438         local MDTIDX=1
4439         TESTDIR=$DIR/$tdir/$tdir
4440         [ -e $TESTDIR ] && rm -rf $TESTDIR
4441         test_mkdir -p $TESTDIR
4442         cd $TESTDIR
4443         links1=2
4444         ls
4445         test_mkdir -i $MDTIDX $TESTDIR/remote_dir1
4446         test_mkdir -i $MDTIDX $TESTDIR/remote_dir2
4447         ls
4448         links2=$(stat -c %h .)
4449         [ $(($links1 + 2)) != $links2 ] &&
4450                 error "wrong links count $(($links1 + 2)) != $links2"
4451         rmdir remote_dir2
4452         links3=$(stat -c %h .)
4453         [ $(($links1 + 1)) != $links3 ] &&
4454                 error "wrong links count $links1 != $links3"
4455         return 0
4456 }
4457 run_test 39p "remote directory cached attributes updated after create ========"
4458
4459
4460 test_39q() { # LU-8041
4461         local testdir=$DIR/$tdir
4462         mkdir -p $testdir
4463         multiop_bg_pause $testdir D_c || error "multiop failed"
4464         local multipid=$!
4465         cancel_lru_locks mdc
4466         kill -USR1 $multipid
4467         local atime=$(stat -c %X $testdir)
4468         [ "$atime" -ne 0 ] || error "atime is zero"
4469 }
4470 run_test 39q "close won't zero out atime"
4471
4472 test_40() {
4473         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1
4474         $RUNAS $OPENFILE -f O_WRONLY:O_TRUNC $DIR/$tfile &&
4475                 error "openfile O_WRONLY:O_TRUNC $tfile failed"
4476         $CHECKSTAT -t file -s 4096 $DIR/$tfile ||
4477                 error "$tfile is not 4096 bytes in size"
4478 }
4479 run_test 40 "failed open(O_TRUNC) doesn't truncate ============="
4480
4481 test_41() {
4482         # bug 1553
4483         small_write $DIR/f41 18
4484 }
4485 run_test 41 "test small file write + fstat ====================="
4486
4487 count_ost_writes() {
4488         lctl get_param -n ${OSC}.*.stats |
4489                 awk -vwrites=0 '/ost_write/ { writes += $2 } \
4490                         END { printf("%0.0f", writes) }'
4491 }
4492
4493 # decent default
4494 WRITEBACK_SAVE=500
4495 DIRTY_RATIO_SAVE=40
4496 MAX_DIRTY_RATIO=50
4497 BG_DIRTY_RATIO_SAVE=10
4498 MAX_BG_DIRTY_RATIO=25
4499
4500 start_writeback() {
4501         trap 0
4502         # in 2.6, restore /proc/sys/vm/dirty_writeback_centisecs,
4503         # dirty_ratio, dirty_background_ratio
4504         if [ -f /proc/sys/vm/dirty_writeback_centisecs ]; then
4505                 sysctl -w vm.dirty_writeback_centisecs=$WRITEBACK_SAVE
4506                 sysctl -w vm.dirty_background_ratio=$BG_DIRTY_RATIO_SAVE
4507                 sysctl -w vm.dirty_ratio=$DIRTY_RATIO_SAVE
4508         else
4509                 # if file not here, we are a 2.4 kernel
4510                 kill -CONT `pidof kupdated`
4511         fi
4512 }
4513
4514 stop_writeback() {
4515         # setup the trap first, so someone cannot exit the test at the
4516         # exact wrong time and mess up a machine
4517         trap start_writeback EXIT
4518         # in 2.6, save and 0 /proc/sys/vm/dirty_writeback_centisecs
4519         if [ -f /proc/sys/vm/dirty_writeback_centisecs ]; then
4520                 WRITEBACK_SAVE=`sysctl -n vm.dirty_writeback_centisecs`
4521                 sysctl -w vm.dirty_writeback_centisecs=0
4522                 sysctl -w vm.dirty_writeback_centisecs=0
4523                 # save and increase /proc/sys/vm/dirty_ratio
4524                 DIRTY_RATIO_SAVE=`sysctl -n vm.dirty_ratio`
4525                 sysctl -w vm.dirty_ratio=$MAX_DIRTY_RATIO
4526                 # save and increase /proc/sys/vm/dirty_background_ratio
4527                 BG_DIRTY_RATIO_SAVE=`sysctl -n vm.dirty_background_ratio`
4528                 sysctl -w vm.dirty_background_ratio=$MAX_BG_DIRTY_RATIO
4529         else
4530                 # if file not here, we are a 2.4 kernel
4531                 kill -STOP `pidof kupdated`
4532         fi
4533 }
4534
4535 # ensure that all stripes have some grant before we test client-side cache
4536 setup_test42() {
4537         for i in `seq -f $DIR/f42-%g 1 $OSTCOUNT`; do
4538                 dd if=/dev/zero of=$i bs=4k count=1
4539                 rm $i
4540         done
4541 }
4542
4543 # Tests 42* verify that our behaviour is correct WRT caching, file closure,
4544 # file truncation, and file removal.
4545 test_42a() {
4546         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4547
4548         setup_test42
4549         cancel_lru_locks $OSC
4550         stop_writeback
4551         sync; sleep 1; sync # just to be safe
4552         BEFOREWRITES=`count_ost_writes`
4553         lctl get_param -n osc.*[oO][sS][cC][_-]*.cur_grant_bytes | grep "[0-9]"
4554         dd if=/dev/zero of=$DIR/f42a bs=1024 count=100
4555         AFTERWRITES=`count_ost_writes`
4556         [ $BEFOREWRITES -eq $AFTERWRITES ] || \
4557                 error "$BEFOREWRITES < $AFTERWRITES"
4558         start_writeback
4559 }
4560 run_test 42a "ensure that we don't flush on close"
4561
4562 test_42b() {
4563         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4564
4565         setup_test42
4566         cancel_lru_locks $OSC
4567         stop_writeback
4568         sync
4569         dd if=/dev/zero of=$DIR/f42b bs=1024 count=100
4570         BEFOREWRITES=$(count_ost_writes)
4571         $MUNLINK $DIR/f42b || error "$MUNLINK $DIR/f42b: $?"
4572         AFTERWRITES=$(count_ost_writes)
4573         if [[ $BEFOREWRITES -lt $AFTERWRITES ]]; then
4574                 error "$BEFOREWRITES < $AFTERWRITES on unlink"
4575         fi
4576         BEFOREWRITES=$(count_ost_writes)
4577         sync || error "sync: $?"
4578         AFTERWRITES=$(count_ost_writes)
4579         if [[ $BEFOREWRITES -lt $AFTERWRITES ]]; then
4580                 error "$BEFOREWRITES < $AFTERWRITES on sync"
4581         fi
4582         dmesg | grep 'error from obd_brw_async' && error 'error writing back'
4583         start_writeback
4584         return 0
4585 }
4586 run_test 42b "test destroy of file with cached dirty data ======"
4587
4588 # if these tests just want to test the effect of truncation,
4589 # they have to be very careful.  consider:
4590 # - the first open gets a {0,EOF}PR lock
4591 # - the first write conflicts and gets a {0, count-1}PW
4592 # - the rest of the writes are under {count,EOF}PW
4593 # - the open for truncate tries to match a {0,EOF}PR
4594 #   for the filesize and cancels the PWs.
4595 # any number of fixes (don't get {0,EOF} on open, match
4596 # composite locks, do smarter file size management) fix
4597 # this, but for now we want these tests to verify that
4598 # the cancellation with truncate intent works, so we
4599 # start the file with a full-file pw lock to match against
4600 # until the truncate.
4601 trunc_test() {
4602         test=$1
4603         file=$DIR/$test
4604         offset=$2
4605         cancel_lru_locks $OSC
4606         stop_writeback
4607         # prime the file with 0,EOF PW to match
4608         touch $file
4609         $TRUNCATE $file 0
4610         sync; sync
4611         # now the real test..
4612         dd if=/dev/zero of=$file bs=1024 count=100
4613         BEFOREWRITES=`count_ost_writes`
4614         $TRUNCATE $file $offset
4615         cancel_lru_locks $OSC
4616         AFTERWRITES=`count_ost_writes`
4617         start_writeback
4618 }
4619
4620 test_42c() {
4621         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4622
4623         trunc_test 42c 1024
4624         [ $BEFOREWRITES -eq $AFTERWRITES ] &&
4625                 error "beforewrites $BEFOREWRITES == afterwrites $AFTERWRITES on truncate"
4626         rm $file
4627 }
4628 run_test 42c "test partial truncate of file with cached dirty data"
4629
4630 test_42d() {
4631         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4632
4633         trunc_test 42d 0
4634         [ $BEFOREWRITES -eq $AFTERWRITES ] ||
4635                 error "beforewrites $BEFOREWRITES != afterwrites $AFTERWRITES on truncate"
4636         rm $file
4637 }
4638 run_test 42d "test complete truncate of file with cached dirty data"
4639
4640 test_42e() { # bug22074
4641         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4642
4643         local TDIR=$DIR/${tdir}e
4644         local pages=16 # hardcoded 16 pages, don't change it.
4645         local files=$((OSTCOUNT * 500)) # hopefully 500 files on each OST
4646         local proc_osc0="osc.${FSNAME}-OST0000-osc-[^MDT]*"
4647         local max_dirty_mb
4648         local warmup_files
4649
4650         test_mkdir $DIR/${tdir}e
4651         $LFS setstripe -c 1 $TDIR
4652         createmany -o $TDIR/f $files
4653
4654         max_dirty_mb=$($LCTL get_param -n $proc_osc0/max_dirty_mb)
4655
4656         # we assume that with $OSTCOUNT files, at least one of them will
4657         # be allocated on OST0.
4658         warmup_files=$((OSTCOUNT * max_dirty_mb))
4659         createmany -o $TDIR/w $warmup_files
4660
4661         # write a large amount of data into one file and sync, to get good
4662         # avail_grant number from OST.
4663         for ((i=0; i<$warmup_files; i++)); do
4664                 idx=$($LFS getstripe -i $TDIR/w$i)
4665                 [ $idx -ne 0 ] && continue
4666                 dd if=/dev/zero of=$TDIR/w$i bs="$max_dirty_mb"M count=1
4667                 break
4668         done
4669         [[ $i -gt $warmup_files ]] && error "OST0 is still cold"
4670         sync
4671         $LCTL get_param $proc_osc0/cur_dirty_bytes
4672         $LCTL get_param $proc_osc0/cur_grant_bytes
4673
4674         # create as much dirty pages as we can while not to trigger the actual
4675         # RPCs directly. but depends on the env, VFS may trigger flush during this
4676         # period, hopefully we are good.
4677         for ((i=0; i<$warmup_files; i++)); do
4678                 idx=$($LFS getstripe -i $TDIR/w$i)
4679                 [ $idx -ne 0 ] && continue
4680                 dd if=/dev/zero of=$TDIR/w$i bs=1M count=1 2>/dev/null
4681         done
4682         $LCTL get_param $proc_osc0/cur_dirty_bytes
4683         $LCTL get_param $proc_osc0/cur_grant_bytes
4684
4685         # perform the real test
4686         $LCTL set_param $proc_osc0/rpc_stats 0
4687         for ((;i<$files; i++)); do
4688                 [ $($LFS getstripe -i $TDIR/f$i) -eq 0 ] || continue
4689                 dd if=/dev/zero of=$TDIR/f$i bs=$PAGE_SIZE count=$pages 2>/dev/null
4690         done
4691         sync
4692         $LCTL get_param $proc_osc0/rpc_stats
4693
4694         local percent=0
4695         local have_ppr=false
4696         $LCTL get_param $proc_osc0/rpc_stats |
4697                 while read PPR RRPC RPCT RCUM BAR WRPC WPCT WCUM; do
4698                         # skip lines until we are at the RPC histogram data
4699                         [ "$PPR" == "pages" ] && have_ppr=true && continue
4700                         $have_ppr || continue
4701
4702                         # we only want the percent stat for < 16 pages
4703                         [[ $(echo $PPR | tr -d ':') -ge $pages ]] && break
4704
4705                         percent=$((percent + WPCT))
4706                         if [[ $percent -gt 15 ]]; then
4707                                 error "less than 16-pages write RPCs" \
4708                                       "$percent% > 15%"
4709                                 break
4710                         fi
4711                 done
4712         rm -rf $TDIR
4713 }
4714 run_test 42e "verify sub-RPC writes are not done synchronously"
4715
4716 test_43A() { # was test_43
4717         test_mkdir $DIR/$tdir
4718         cp -p /bin/ls $DIR/$tdir/$tfile
4719         $MULTIOP $DIR/$tdir/$tfile Ow_c &
4720         pid=$!
4721         # give multiop a chance to open
4722         sleep 1
4723
4724         $DIR/$tdir/$tfile && error "execute $DIR/$tdir/$tfile succeeded" || true
4725         kill -USR1 $pid
4726 }
4727 run_test 43A "execution of file opened for write should return -ETXTBSY"
4728
4729 test_43a() {
4730         test_mkdir $DIR/$tdir
4731         cp -p $(which sleep) $DIR/$tdir/sleep || error "can't copy"
4732         $DIR/$tdir/sleep 60 &
4733         SLEEP_PID=$!
4734         # Make sure exec of $tdir/sleep wins race with truncate
4735         sleep 1
4736         $MULTIOP $DIR/$tdir/sleep Oc && error "expected error, got success"
4737         kill $SLEEP_PID
4738 }
4739 run_test 43a "open(RDWR) of file being executed should return -ETXTBSY"
4740
4741 test_43b() {
4742         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4743
4744         test_mkdir $DIR/$tdir
4745         cp -p $(which sleep) $DIR/$tdir/sleep || error "can't copy"
4746         $DIR/$tdir/sleep 60 &
4747         SLEEP_PID=$!
4748         # Make sure exec of $tdir/sleep wins race with truncate
4749         sleep 1
4750         $TRUNCATE $DIR/$tdir/sleep 0 && error "expected error, got success"
4751         kill $SLEEP_PID
4752 }
4753 run_test 43b "truncate of file being executed should return -ETXTBSY"
4754
4755 test_43c() {
4756         local testdir="$DIR/$tdir"
4757         test_mkdir $testdir
4758         cp $SHELL $testdir/
4759         ( cd $(dirname $SHELL) && md5sum $(basename $SHELL) ) |
4760                 ( cd $testdir && md5sum -c )
4761 }
4762 run_test 43c "md5sum of copy into lustre"
4763
4764 test_44A() { # was test_44
4765         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
4766
4767         dd if=/dev/zero of=$DIR/f1 bs=4k count=1 seek=1023
4768         dd if=$DIR/f1 bs=4k count=1 > /dev/null
4769 }
4770 run_test 44A "zero length read from a sparse stripe"
4771
4772 test_44a() {
4773         local nstripe=$($LCTL lov_getconfig $DIR | grep default_stripe_count: |
4774                 awk '{ print $2 }')
4775         [ -z "$nstripe" ] && skip "can't get stripe info"
4776         [[ $nstripe -gt $OSTCOUNT ]] &&
4777                 skip "Wrong default_stripe_count: $nstripe OSTCOUNT: $OSTCOUNT"
4778
4779         local stride=$($LCTL lov_getconfig $DIR | grep default_stripe_size: |
4780                 awk '{ print $2 }')
4781         if [[ $nstripe -eq 0 || $nstripe -eq -1 ]]; then
4782                 nstripe=$($LCTL lov_getconfig $DIR | grep obd_count: |
4783                         awk '{ print $2 }')
4784         fi
4785
4786         OFFSETS="0 $((stride/2)) $((stride-1))"
4787         for offset in $OFFSETS; do
4788                 for i in $(seq 0 $((nstripe-1))); do
4789                         local GLOBALOFFSETS=""
4790                         # size in Bytes
4791                         local size=$((((i + 2 * $nstripe )*$stride + $offset)))
4792                         local myfn=$DIR/d44a-$size
4793                         echo "--------writing $myfn at $size"
4794                         ll_sparseness_write $myfn $size ||
4795                                 error "ll_sparseness_write"
4796                         GLOBALOFFSETS="$GLOBALOFFSETS $size"
4797                         ll_sparseness_verify $myfn $GLOBALOFFSETS ||
4798                                 error "ll_sparseness_verify $GLOBALOFFSETS"
4799
4800                         for j in $(seq 0 $((nstripe-1))); do
4801                                 # size in Bytes
4802                                 size=$((((j + $nstripe )*$stride + $offset)))
4803                                 ll_sparseness_write $myfn $size ||
4804                                         error "ll_sparseness_write"
4805                                 GLOBALOFFSETS="$GLOBALOFFSETS $size"
4806                         done
4807                         ll_sparseness_verify $myfn $GLOBALOFFSETS ||
4808                                 error "ll_sparseness_verify $GLOBALOFFSETS"
4809                         rm -f $myfn
4810                 done
4811         done
4812 }
4813 run_test 44a "test sparse pwrite ==============================="
4814
4815 dirty_osc_total() {
4816         tot=0
4817         for d in `lctl get_param -n ${OSC}.*.cur_dirty_bytes`; do
4818                 tot=$(($tot + $d))
4819         done
4820         echo $tot
4821 }
4822 do_dirty_record() {
4823         before=`dirty_osc_total`
4824         echo executing "\"$*\""
4825         eval $*
4826         after=`dirty_osc_total`
4827         echo before $before, after $after
4828 }
4829 test_45() {
4830         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4831
4832         f="$DIR/f45"
4833         # Obtain grants from OST if it supports it
4834         echo blah > ${f}_grant
4835         stop_writeback
4836         sync
4837         do_dirty_record "echo blah > $f"
4838         [[ $before -eq $after ]] && error "write wasn't cached"
4839         do_dirty_record "> $f"
4840         [[ $before -gt $after ]] || error "truncate didn't lower dirty count"
4841         do_dirty_record "echo blah > $f"
4842         [[ $before -eq $after ]] && error "write wasn't cached"
4843         do_dirty_record "sync"
4844         [[ $before -gt $after ]] || error "writeback didn't lower dirty count"
4845         do_dirty_record "echo blah > $f"
4846         [[ $before -eq $after ]] && error "write wasn't cached"
4847         do_dirty_record "cancel_lru_locks osc"
4848         [[ $before -gt $after ]] ||
4849                 error "lock cancellation didn't lower dirty count"
4850         start_writeback
4851 }
4852 run_test 45 "osc io page accounting ============================"
4853
4854 # in a 2 stripe file (lov.sh), page 1023 maps to page 511 in its object.  this
4855 # test tickles a bug where re-dirtying a page was failing to be mapped to the
4856 # objects offset and an assert hit when an rpc was built with 1023's mapped
4857 # offset 511 and 511's raw 511 offset. it also found general redirtying bugs.
4858 test_46() {
4859         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4860
4861         f="$DIR/f46"
4862         stop_writeback
4863         sync
4864         dd if=/dev/zero of=$f bs=$PAGE_SIZE seek=511 count=1
4865         sync
4866         dd conv=notrunc if=/dev/zero of=$f bs=$PAGE_SIZE seek=1023 count=1
4867         dd conv=notrunc if=/dev/zero of=$f bs=$PAGE_SIZE seek=511 count=1
4868         sync
4869         start_writeback
4870 }
4871 run_test 46 "dirtying a previously written page ================"
4872
4873 # test_47 is removed "Device nodes check" is moved to test_28
4874
4875 test_48a() { # bug 2399
4876         [ "$mds1_FSTYPE" = "zfs" ] &&
4877         [ $MDS1_VERSION -lt $(version_code 2.3.63) ] &&
4878                 skip "MDS prior to 2.3.63 handle ZFS dir .. incorrectly"
4879
4880         test_mkdir $DIR/$tdir
4881         cd $DIR/$tdir
4882         mv $DIR/$tdir $DIR/$tdir.new || error "move directory failed"
4883         test_mkdir $DIR/$tdir
4884         touch foo || error "'touch foo' failed after recreating cwd"
4885         test_mkdir bar
4886         touch .foo || error "'touch .foo' failed after recreating cwd"
4887         test_mkdir .bar
4888         ls . > /dev/null || error "'ls .' failed after recreating cwd"
4889         ls .. > /dev/null || error "'ls ..' failed after removing cwd"
4890         cd . || error "'cd .' failed after recreating cwd"
4891         mkdir . && error "'mkdir .' worked after recreating cwd"
4892         rmdir . && error "'rmdir .' worked after recreating cwd"
4893         ln -s . baz || error "'ln -s .' failed after recreating cwd"
4894         cd .. || error "'cd ..' failed after recreating cwd"
4895 }
4896 run_test 48a "Access renamed working dir (should return errors)="
4897
4898 test_48b() { # bug 2399
4899         rm -rf $DIR/$tdir
4900         test_mkdir $DIR/$tdir
4901         cd $DIR/$tdir
4902         rmdir $DIR/$tdir || error "remove cwd $DIR/$tdir failed"
4903         touch foo && error "'touch foo' worked after removing cwd"
4904         mkdir foo && error "'mkdir foo' worked after removing cwd"
4905         touch .foo && error "'touch .foo' worked after removing cwd"
4906         mkdir .foo && error "'mkdir .foo' worked after removing cwd"
4907         ls . > /dev/null && error "'ls .' worked after removing cwd"
4908         ls .. > /dev/null || error "'ls ..' failed after removing cwd"
4909         mkdir . && error "'mkdir .' worked after removing cwd"
4910         rmdir . && error "'rmdir .' worked after removing cwd"
4911         ln -s . foo && error "'ln -s .' worked after removing cwd"
4912         cd .. || echo "'cd ..' failed after removing cwd `pwd`"  #bug 3517
4913 }
4914 run_test 48b "Access removed working dir (should return errors)="
4915
4916 test_48c() { # bug 2350
4917         #lctl set_param debug=-1
4918         #set -vx
4919         rm -rf $DIR/$tdir
4920         test_mkdir -p $DIR/$tdir/dir
4921         cd $DIR/$tdir/dir
4922         $TRACE rmdir $DIR/$tdir/dir || error "remove cwd $DIR/$tdir/dir failed"
4923         $TRACE touch foo && error "touch foo worked after removing cwd"
4924         $TRACE mkdir foo && error "'mkdir foo' worked after removing cwd"
4925         touch .foo && error "touch .foo worked after removing cwd"
4926         mkdir .foo && error "mkdir .foo worked after removing cwd"
4927         $TRACE ls . && error "'ls .' worked after removing cwd"
4928         $TRACE ls .. || error "'ls ..' failed after removing cwd"
4929         $TRACE mkdir . && error "'mkdir .' worked after removing cwd"
4930         $TRACE rmdir . && error "'rmdir .' worked after removing cwd"
4931         $TRACE ln -s . foo && error "'ln -s .' worked after removing cwd"
4932         $TRACE cd .. || echo "'cd ..' failed after removing cwd `pwd`" #bug 3415
4933 }
4934 run_test 48c "Access removed working subdir (should return errors)"
4935
4936 test_48d() { # bug 2350
4937         #lctl set_param debug=-1
4938         #set -vx
4939         rm -rf $DIR/$tdir
4940         test_mkdir -p $DIR/$tdir/dir
4941         cd $DIR/$tdir/dir
4942         $TRACE rmdir $DIR/$tdir/dir || error "remove cwd $DIR/$tdir/dir failed"
4943         $TRACE rmdir $DIR/$tdir || error "remove parent $DIR/$tdir failed"
4944         $TRACE touch foo && error "'touch foo' worked after removing parent"
4945         $TRACE mkdir foo && error "mkdir foo worked after removing parent"
4946         touch .foo && error "'touch .foo' worked after removing parent"
4947         mkdir .foo && error "mkdir .foo worked after removing parent"
4948         $TRACE ls . && error "'ls .' worked after removing parent"
4949         $TRACE ls .. && error "'ls ..' worked after removing parent"
4950         $TRACE mkdir . && error "'mkdir .' worked after removing parent"
4951         $TRACE rmdir . && error "'rmdir .' worked after removing parent"
4952         $TRACE ln -s . foo && error "'ln -s .' worked after removing parent"
4953         true
4954 }
4955 run_test 48d "Access removed parent subdir (should return errors)"
4956
4957 test_48e() { # bug 4134
4958         #lctl set_param debug=-1
4959         #set -vx
4960         rm -rf $DIR/$tdir
4961         test_mkdir -p $DIR/$tdir/dir
4962         cd $DIR/$tdir/dir
4963         $TRACE rmdir $DIR/$tdir/dir || error "remove cwd $DIR/$tdir/dir failed"
4964         $TRACE rmdir $DIR/$tdir || error "remove parent $DIR/$tdir failed"
4965         $TRACE touch $DIR/$tdir || error "'touch $DIR/$tdir' failed"
4966         $TRACE chmod +x $DIR/$tdir || error "'chmod +x $DIR/$tdir' failed"
4967         # On a buggy kernel addition of "touch foo" after cd .. will
4968         # produce kernel oops in lookup_hash_it
4969         touch ../foo && error "'cd ..' worked after recreate parent"
4970         cd $DIR
4971         $TRACE rm $DIR/$tdir || error "rm '$DIR/$tdir' failed"
4972 }
4973 run_test 48e "Access to recreated parent subdir (should return errors)"
4974
4975 test_49() { # LU-1030
4976         [ $PARALLEL == "yes" ] && skip "skip parallel run"
4977         remote_ost_nodsh && skip "remote OST with nodsh"
4978
4979         # get ost1 size - lustre-OST0000
4980         ost1_size=$(do_facet ost1 $LFS df | grep ${ost1_svc} |
4981                 awk '{ print $4 }')
4982         # write 800M at maximum
4983         [[ $ost1_size -lt 2 ]] && ost1_size=2
4984         [[ $ost1_size -gt 819200 ]] && ost1_size=819200
4985
4986         $LFS setstripe -c 1 -i 0 $DIR/$tfile
4987         dd if=/dev/zero of=$DIR/$tfile bs=4k count=$((ost1_size >> 2)) &
4988         local dd_pid=$!
4989
4990         # change max_pages_per_rpc while writing the file
4991         local osc1_mppc=osc.$(get_osc_import_name client ost1).max_pages_per_rpc
4992         local orig_mppc=$($LCTL get_param -n $osc1_mppc)
4993         # loop until dd process exits
4994         while ps ax -opid | grep -wq $dd_pid; do
4995                 $LCTL set_param $osc1_mppc=$((RANDOM % 256 + 1))
4996                 sleep $((RANDOM % 5 + 1))
4997         done
4998         # restore original max_pages_per_rpc
4999         $LCTL set_param $osc1_mppc=$orig_mppc
5000         rm $DIR/$tfile || error "rm $DIR/$tfile failed"
5001 }
5002 run_test 49 "Change max_pages_per_rpc won't break osc extent"
5003
5004 test_50() {
5005         # bug 1485
5006         test_mkdir $DIR/$tdir
5007         cd $DIR/$tdir
5008         ls /proc/$$/cwd || error "ls /proc/$$/cwd failed"
5009 }
5010 run_test 50 "special situations: /proc symlinks  ==============="
5011
5012 test_51a() {    # was test_51
5013         # bug 1516 - create an empty entry right after ".." then split dir
5014         test_mkdir -c1 $DIR/$tdir
5015         touch $DIR/$tdir/foo
5016         $MCREATE $DIR/$tdir/bar
5017         rm $DIR/$tdir/foo
5018         createmany -m $DIR/$tdir/longfile 201
5019         FNUM=202
5020         while [[ $(ls -sd $DIR/$tdir | awk '{ print $1 }') -eq 4 ]]; do
5021                 $MCREATE $DIR/$tdir/longfile$FNUM
5022                 FNUM=$(($FNUM + 1))
5023                 echo -n "+"
5024         done
5025         echo
5026         ls -l $DIR/$tdir > /dev/null || error "ls -l $DIR/$tdir failed"
5027 }
5028 run_test 51a "special situations: split htree with empty entry =="
5029
5030 cleanup_print_lfs_df () {
5031         trap 0
5032         $LFS df
5033         $LFS df -i
5034 }
5035
5036 test_51b() {
5037         [ $PARALLEL == "yes" ] && skip "skip parallel run"
5038
5039         local dir=$DIR/$tdir
5040         local nrdirs=$((65536 + 100))
5041
5042         # cleanup the directory
5043         rm -fr $dir
5044
5045         test_mkdir -c1 $dir
5046
5047         $LFS df
5048         $LFS df -i
5049         local mdtidx=$(printf "%04x" $($LFS getstripe -m $dir))
5050         local numfree=$(lctl get_param -n mdc.$FSNAME-MDT$mdtidx*.filesfree)
5051         [[ $numfree -lt $nrdirs ]] &&
5052                 skip "not enough free inodes ($numfree) on MDT$mdtidx"
5053
5054         # need to check free space for the directories as well
5055         local blkfree=$(lctl get_param -n mdc.$FSNAME-MDT$mdtidx*.kbytesavail)
5056         numfree=$(( blkfree / $(fs_inode_ksize) ))
5057         [[ $numfree -lt $nrdirs ]] && skip "not enough blocks ($numfree)"
5058
5059         trap cleanup_print_lfs_df EXIT
5060
5061         # create files
5062         createmany -d $dir/d $nrdirs || {
5063                 unlinkmany $dir/d $nrdirs
5064                 error "failed to create $nrdirs subdirs in MDT$mdtidx:$dir"
5065         }
5066
5067         # really created :
5068         nrdirs=$(ls -U $dir | wc -l)
5069
5070         # unlink all but 100 subdirectories, then check it still works
5071         local left=100
5072         local delete=$((nrdirs - left))
5073
5074         $LFS df
5075         $LFS df -i
5076
5077         # for ldiskfs the nlink count should be 1, but this is OSD specific
5078         # and so this is listed for informational purposes only
5079         echo "nlink before: $(stat -c %h $dir), created before: $nrdirs"
5080         unlinkmany -d $dir/d $delete ||
5081                 error "unlink of first $delete subdirs failed"
5082
5083         echo "nlink between: $(stat -c %h $dir)"
5084         local found=$(ls -U $dir | wc -l)
5085         [ $found -ne $left ] &&
5086                 error "can't find subdirs: found only $found, expected $left"
5087
5088         unlinkmany -d $dir/d $delete $left ||
5089                 error "unlink of second $left subdirs failed"
5090         # regardless of whether the backing filesystem tracks nlink accurately
5091         # or not, the nlink count shouldn't be more than "." and ".." here
5092         local after=$(stat -c %h $dir)
5093         [[ $after -gt 2 ]] && error "nlink after: $after > 2" ||
5094                 echo "nlink after: $after"
5095
5096         cleanup_print_lfs_df
5097 }
5098 run_test 51b "exceed 64k subdirectory nlink limit on create, verify unlink"
5099
5100 test_51d() {
5101         [ $PARALLEL == "yes" ] && skip "skip parallel run"
5102         [[ $OSTCOUNT -lt 3 ]] && skip_env "needs >= 3 OSTs"
5103
5104         test_mkdir $DIR/$tdir
5105         createmany -o $DIR/$tdir/t- 1000
5106         $LFS getstripe $DIR/$tdir > $TMP/$tfile
5107         for N in $(seq 0 $((OSTCOUNT - 1))); do
5108                 OBJS[$N]=$(awk -vobjs=0 '($1 == '$N') { objs += 1 } \
5109                         END { printf("%0.0f", objs) }' $TMP/$tfile)
5110                 OBJS0[$N]=$(grep -A 1 idx $TMP/$tfile | awk -vobjs=0 \
5111                         '($1 == '$N') { objs += 1 } \
5112                         END { printf("%0.0f", objs) }')
5113                 log "OST$N has ${OBJS[$N]} objects, ${OBJS0[$N]} are index 0"
5114         done
5115         unlinkmany $DIR/$tdir/t- 1000
5116
5117         NLAST=0
5118         for N in $(seq 1 $((OSTCOUNT - 1))); do
5119                 [[ ${OBJS[$N]} -lt $((${OBJS[$NLAST]} - 20)) ]] &&
5120                         error "OST $N has less objects vs OST $NLAST" \
5121                               " (${OBJS[$N]} < ${OBJS[$NLAST]}"
5122                 [[ ${OBJS[$N]} -gt $((${OBJS[$NLAST]} + 20)) ]] &&
5123                         error "OST $N has less objects vs OST $NLAST" \
5124                               " (${OBJS[$N]} < ${OBJS[$NLAST]}"
5125
5126                 [[ ${OBJS0[$N]} -lt $((${OBJS0[$NLAST]} - 20)) ]] &&
5127                         error "OST $N has less #0 objects vs OST $NLAST" \
5128                               " (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
5129                 [[ ${OBJS0[$N]} -gt $((${OBJS0[$NLAST]} + 20)) ]] &&
5130                         error "OST $N has less #0 objects vs OST $NLAST" \
5131                               " (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
5132                 NLAST=$N
5133         done
5134         rm -f $TMP/$tfile
5135 }
5136 run_test 51d "check object distribution"
5137
5138 test_51e() {
5139         if [ "$mds1_FSTYPE" != ldiskfs ]; then
5140                 skip_env "ldiskfs only test"
5141         fi
5142
5143         test_mkdir -c1 $DIR/$tdir
5144         test_mkdir -c1 $DIR/$tdir/d0
5145
5146         touch $DIR/$tdir/d0/foo
5147         createmany -l $DIR/$tdir/d0/foo $DIR/$tdir/d0/f- 65001 &&
5148                 error "file exceed 65000 nlink limit!"
5149         unlinkmany $DIR/$tdir/d0/f- 65001
5150         return 0
5151 }
5152 run_test 51e "check file nlink limit"
5153
5154 test_51f() {
5155         test_mkdir $DIR/$tdir
5156
5157         local max=100000
5158         local ulimit_old=$(ulimit -n)
5159         local spare=20 # number of spare fd's for scripts/libraries, etc.
5160         local mdt=$($LFS getstripe -m $DIR/$tdir)
5161         local numfree=$($LFS df -i $DIR/$tdir | awk '/MDT:'$mdt'/ { print $4 }')
5162
5163         echo "MDT$mdt numfree=$numfree, max=$max"
5164         [[ $numfree -gt $max ]] && numfree=$max || numfree=$((numfree * 7 / 8))
5165         if [ $((numfree + spare)) -gt $ulimit_old ]; then
5166                 while ! ulimit -n $((numfree + spare)); do
5167                         numfree=$((numfree * 3 / 4))
5168                 done
5169                 echo "changed ulimit from $ulimit_old to $((numfree + spare))"
5170         else
5171                 echo "left ulimit at $ulimit_old"
5172         fi
5173
5174         createmany -o -k -t 120 $DIR/$tdir/f $numfree || {
5175                 unlinkmany $DIR/$tdir/f $numfree
5176                 error "create+open $numfree files in $DIR/$tdir failed"
5177         }
5178         ulimit -n $ulimit_old
5179
5180         # if createmany exits at 120s there will be fewer than $numfree files
5181         unlinkmany $DIR/$tdir/f $numfree || true
5182 }
5183 run_test 51f "check many open files limit"
5184
5185 test_52a() {
5186         [ -f $DIR/$tdir/foo ] && chattr -a $DIR/$tdir/foo
5187         test_mkdir $DIR/$tdir
5188         touch $DIR/$tdir/foo
5189         chattr +a $DIR/$tdir/foo || error "chattr +a failed"
5190         echo bar >> $DIR/$tdir/foo || error "append bar failed"
5191         cp /etc/hosts $DIR/$tdir/foo && error "cp worked"
5192         rm -f $DIR/$tdir/foo 2>/dev/null && error "rm worked"
5193         link $DIR/$tdir/foo $DIR/$tdir/foo_link 2>/dev/null &&
5194                                         error "link worked"
5195         echo foo >> $DIR/$tdir/foo || error "append foo failed"
5196         mrename $DIR/$tdir/foo $DIR/$tdir/foo_ren && error "rename worked"
5197         lsattr $DIR/$tdir/foo | egrep -q "^-+a[-e]+ $DIR/$tdir/foo" ||
5198                                                      error "lsattr"
5199         chattr -a $DIR/$tdir/foo || error "chattr -a failed"
5200         cp -r $DIR/$tdir $TMP/
5201         rm -fr $DIR/$tdir $TMP/$tdir || error "cleanup rm failed"
5202 }
5203 run_test 52a "append-only flag test (should return errors)"
5204
5205 test_52b() {
5206         [ -f $DIR/$tdir/foo ] && chattr -i $DIR/$tdir/foo
5207         test_mkdir $DIR/$tdir
5208         touch $DIR/$tdir/foo
5209         chattr +i $DIR/$tdir/foo || error "chattr +i failed"
5210         cat test > $DIR/$tdir/foo && error "cat test worked"
5211         cp /etc/hosts $DIR/$tdir/foo && error "cp worked"
5212         rm -f $DIR/$tdir/foo 2>/dev/null && error "rm worked"
5213         link $DIR/$tdir/foo $DIR/$tdir/foo_link 2>/dev/null &&
5214                                         error "link worked"
5215         echo foo >> $DIR/$tdir/foo && error "echo worked"
5216         mrename $DIR/$tdir/foo $DIR/$tdir/foo_ren && error "rename worked"
5217         [ -f $DIR/$tdir/foo ] || error "$tdir/foo is not a file"
5218         [ -f $DIR/$tdir/foo_ren ] && error "$tdir/foo_ren is not a file"
5219         lsattr $DIR/$tdir/foo | egrep -q "^-+i[-e]+ $DIR/$tdir/foo" ||
5220                                                         error "lsattr"
5221         chattr -i $DIR/$tdir/foo || error "chattr failed"
5222
5223         rm -fr $DIR/$tdir || error "unable to remove $DIR/$tdir"
5224 }
5225 run_test 52b "immutable flag test (should return errors) ======="
5226
5227 test_53() {
5228         [ $PARALLEL == "yes" ] && skip "skip parallel run"
5229         remote_mds_nodsh && skip "remote MDS with nodsh"
5230         remote_ost_nodsh && skip "remote OST with nodsh"
5231
5232         local param
5233         local param_seq
5234         local ostname
5235         local mds_last
5236         local mds_last_seq
5237         local ost_last
5238         local ost_last_seq
5239         local ost_last_id
5240         local ostnum
5241         local node
5242         local found=false
5243         local support_last_seq=true
5244
5245         [[ $MDS1_VERSION -ge $(version_code 2.3.60) ]] ||
5246                 support_last_seq=false
5247
5248         # only test MDT0000
5249         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS)
5250         local value
5251         for value in $(do_facet $SINGLEMDS \
5252                        $LCTL get_param osp.$mdtosc.prealloc_last_id) ; do
5253                 param=$(echo ${value[0]} | cut -d "=" -f1)
5254                 ostname=$(echo $param | cut -d "." -f2 | cut -d - -f 1-2)
5255
5256                 if $support_last_seq; then
5257                         param_seq=$(echo $param |
5258                                 sed -e s/prealloc_last_id/prealloc_last_seq/g)
5259                         mds_last_seq=$(do_facet $SINGLEMDS \
5260                                        $LCTL get_param -n $param_seq)
5261                 fi
5262                 mds_last=$(do_facet $SINGLEMDS $LCTL get_param -n $param)
5263
5264                 ostnum=$(index_from_ostuuid ${ostname}_UUID)
5265                 node=$(facet_active_host ost$((ostnum+1)))
5266                 param="obdfilter.$ostname.last_id"
5267                 for ost_last in $(do_node $node $LCTL get_param -n $param) ; do
5268                         echo "$ostname.last_id=$ost_last; MDS.last_id=$mds_last"
5269                         ost_last_id=$ost_last
5270
5271                         if $support_last_seq; then
5272                                 ost_last_id=$(echo $ost_last |
5273                                               awk -F':' '{print $2}' |
5274                                               sed -e "s/^0x//g")
5275                                 ost_last_seq=$(echo $ost_last |
5276                                                awk -F':' '{print $1}')
5277                                 [[ $ost_last_seq = $mds_last_seq ]] || continue
5278                         fi
5279
5280                         if [[ $ost_last_id != $mds_last ]]; then
5281                                 error "$ost_last_id != $mds_last"
5282                         else
5283                                 found=true
5284                                 break
5285                         fi
5286                 done
5287         done
5288         $found || error "can not match last_seq/last_id for $mdtosc"
5289         return 0
5290 }
5291 run_test 53 "verify that MDS and OSTs agree on pre-creation ===="
5292
5293 test_54a() {
5294         perl -MSocket -e ';' || skip "no Socket perl module installed"
5295
5296         $SOCKETSERVER $DIR/socket ||
5297                 error "$SOCKETSERVER $DIR/socket failed: $?"
5298         $SOCKETCLIENT $DIR/socket ||
5299                 error "$SOCKETCLIENT $DIR/socket failed: $?"
5300         $MUNLINK $DIR/socket || error "$MUNLINK $DIR/socket failed: $?"
5301 }
5302 run_test 54a "unix domain socket test =========================="
5303
5304 test_54b() {
5305         f="$DIR/f54b"
5306         mknod $f c 1 3
5307         chmod 0666 $f
5308         dd if=/dev/zero of=$f bs=$PAGE_SIZE count=1
5309 }
5310 run_test 54b "char device works in lustre ======================"
5311
5312 find_loop_dev() {
5313         [ -b /dev/loop/0 ] && LOOPBASE=/dev/loop/
5314         [ -b /dev/loop0 ] && LOOPBASE=/dev/loop
5315         [ -z "$LOOPBASE" ] && echo "/dev/loop/0 and /dev/loop0 gone?" && return
5316
5317         for i in $(seq 3 7); do
5318                 losetup $LOOPBASE$i > /dev/null 2>&1 && continue
5319                 LOOPDEV=$LOOPBASE$i
5320                 LOOPNUM=$i
5321                 break
5322         done
5323 }
5324
5325 cleanup_54c() {
5326         local rc=0
5327         loopdev="$DIR/loop54c"
5328
5329         trap 0
5330         $UMOUNT $DIR/$tdir || rc=$?
5331         losetup -d $loopdev || true
5332         losetup -d $LOOPDEV || true
5333         rm -rf $loopdev $DIR/$tfile $DIR/$tdir
5334         return $rc
5335 }
5336
5337 test_54c() {
5338         [ $PARALLEL == "yes" ] && skip "skip parallel run"
5339
5340         loopdev="$DIR/loop54c"
5341
5342         find_loop_dev
5343         [ -z "$LOOPNUM" ] && skip_env "couldn't find empty loop device"
5344         trap cleanup_54c EXIT
5345         mknod $loopdev b 7 $LOOPNUM
5346         echo "make a loop file system with $DIR/$tfile on $loopdev ($LOOPNUM)."
5347         dd if=/dev/zero of=$DIR/$tfile bs=$PAGE_SIZE seek=1024 count=1 > /dev/null
5348         losetup $loopdev $DIR/$tfile ||
5349                 error "can't set up $loopdev for $DIR/$tfile"
5350         mkfs.ext2 $loopdev || error "mke2fs on $loopdev"
5351         test_mkdir $DIR/$tdir
5352         mount -t ext2 $loopdev $DIR/$tdir ||
5353                 error "error mounting $loopdev on $DIR/$tdir"
5354         dd if=/dev/zero of=$DIR/$tdir/tmp bs=$PAGE_SIZE count=30 ||
5355                 error "dd write"
5356         df $DIR/$tdir
5357         dd if=$DIR/$tdir/tmp of=/dev/zero bs=$PAGE_SIZE count=30 ||
5358                 error "dd read"
5359         cleanup_54c
5360 }
5361 run_test 54c "block device works in lustre ====================="
5362
5363 test_54d() {
5364         f="$DIR/f54d"
5365         string="aaaaaa"
5366         mknod $f p
5367         [ "$string" = $(echo $string > $f | cat $f) ] || error "$f != $string"
5368 }
5369 run_test 54d "fifo device works in lustre ======================"
5370
5371 test_54e() {
5372         f="$DIR/f54e"
5373         string="aaaaaa"
5374         cp -aL /dev/console $f
5375         echo $string > $f || error "echo $string to $f failed"
5376 }
5377 run_test 54e "console/tty device works in lustre ======================"
5378
5379 test_56a() {
5380         local numfiles=3
5381         local dir=$DIR/$tdir
5382
5383         rm -rf $dir
5384         test_mkdir -p $dir/dir
5385         for i in $(seq $numfiles); do
5386                 touch $dir/file$i
5387                 touch $dir/dir/file$i
5388         done
5389
5390         local numcomp=$($LFS getstripe --component-count $dir)
5391
5392         [[ $numcomp == 0 ]] && numcomp=1
5393
5394         # test lfs getstripe with --recursive
5395         local filenum=$($LFS getstripe -r $dir | egrep -c "obdidx|l_ost_idx")
5396
5397         [[ $filenum -eq $((numfiles * 2)) ]] ||
5398                 error "$LFS getstripe -r: found $filenum != $((numfiles * 2))"
5399         filenum=$($LFS getstripe $dir | egrep -c "obdidx|l_ost_idx")
5400         [[ $filenum -eq $numfiles ]] ||
5401                 error "$LFS getstripe $dir: found $filenum, not $numfiles"
5402         echo "$LFS getstripe showed obdidx or l_ost_idx"
5403
5404         # test lfs getstripe with file instead of dir
5405         filenum=$($LFS getstripe $dir/file1 | egrep -c "obdidx|l_ost_idx")
5406         [[ $filenum -eq 1 ]] ||
5407                 error "$LFS getstripe $dir/file1: found $filenum, not 1"
5408         echo "$LFS getstripe file1 passed"
5409
5410         #test lfs getstripe with --verbose
5411         filenum=$($LFS getstripe --verbose $dir | grep -c lmm_magic)
5412         [[ $filenum -eq $((numfiles * numcomp)) ]] ||
5413                 error "$LFS getstripe --verbose $dir: "\
5414                       "got $filenum want $((numfiles * numcomp)) lmm_magic"
5415         [[ $($LFS getstripe $dir | grep -c lmm_magic) -eq 0 ]] ||
5416                 error "$LFS getstripe $dir: showed lmm_magic"
5417
5418         #test lfs getstripe with -v prints lmm_fid
5419         filenum=$($LFS getstripe -v $dir | grep -c lmm_fid)
5420         [[ $filenum -eq $((numfiles * numcomp)) ]] ||
5421                 error "$LFS getstripe -v $dir: "\
5422                       "got $filenum want $((numfiles * numcomp)) lmm_fid"
5423         [[ $($LFS getstripe $dir | grep -c lmm_fid) -eq 0 ]] ||
5424                 error "$LFS getstripe $dir: showed lmm_fid by default"
5425         echo "$LFS getstripe --verbose passed"
5426
5427         #check for FID information
5428         local fid1=$($LFS getstripe --fid $dir/file1)
5429         local fid2=$($LFS getstripe --verbose $dir/file1 |
5430                      awk '/lmm_fid: / { print $2; exit; }')
5431         local fid3=$($LFS path2fid $dir/file1)
5432
5433         [ "$fid1" != "$fid2" ] &&
5434                 error "getstripe --fid '$fid1' != getstripe --verbose '$fid2'"
5435         [ "$fid1" != "$fid3" ] &&
5436                 error "getstripe --fid '$fid1' != lfs path2fid '$fid3'"
5437         echo "$LFS getstripe --fid passed"
5438
5439         #test lfs getstripe with --obd
5440         $LFS getstripe --obd wrong_uuid $dir 2>&1 | grep -q "unknown obduuid" ||
5441                 error "$LFS getstripe --obd wrong_uuid: should return error"
5442
5443         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
5444
5445         local ostidx=1
5446         local obduuid=$(ostuuid_from_index $ostidx)
5447         local found=$($LFS getstripe -r --obd $obduuid $dir |
5448                 grep 'lmm_stripe_offset:' | grep -c " $ostidx\$")
5449
5450         filenum=$($LFS getstripe -ir $dir | grep -c "^$ostidx\$")
5451         [[ $($LFS getstripe -id $dir) -ne $ostidx ]] ||
5452                 ((filenum--))
5453         [[ $($LFS getstripe -id $dir/dir) -ne $ostidx ]] ||
5454                 ((filenum--))
5455
5456         [[ $found -eq $filenum ]] ||
5457                 error "$LFS getstripe --obd: found $found expect $filenum"
5458         [[ $($LFS getstripe -r -v --obd $obduuid $dir |
5459                 sed '/^[         ]*'${ostidx}'[  ]/d' |
5460                 sed -n '/^[      ]*[0-9][0-9]*[  ]/p' | wc -l) -eq 0 ]] ||
5461                 error "$LFS getstripe --obd: should not show file on other obd"
5462         echo "$LFS getstripe --obd passed"
5463 }
5464 run_test 56a "check $LFS getstripe"
5465
5466 test_56b() {
5467         local dir=$DIR/$tdir
5468         local numdirs=3
5469
5470         test_mkdir $dir
5471         for i in $(seq $numdirs); do
5472                 test_mkdir $dir/dir$i
5473         done
5474
5475         # test lfs getdirstripe default mode is non-recursion, which is
5476         # different from lfs getstripe
5477         local dircnt=$($LFS getdirstripe $dir | grep -c lmv_stripe_count)
5478
5479         [[ $dircnt -eq 1 ]] ||
5480                 error "$LFS getdirstripe: found $dircnt, not 1"
5481         dircnt=$($LFS getdirstripe --recursive $dir |
5482                 grep -c lmv_stripe_count)
5483         [[ $dircnt -eq $((numdirs + 1)) ]] ||
5484                 error "$LFS getdirstripe -r: $dircnt, != $((numdirs + 1))"
5485 }
5486 run_test 56b "check $LFS getdirstripe"
5487
5488 test_56c() {
5489         remote_ost_nodsh && skip "remote OST with nodsh"
5490
5491         local ost_idx=0
5492         local ost_name=$(ostname_from_index $ost_idx)
5493         local old_status=$(ost_dev_status $ost_idx)
5494
5495         [[ -z "$old_status" ]] ||
5496                 skip_env "OST $ost_name is in $old_status status"
5497
5498         do_facet ost1 $LCTL set_param -n obdfilter.$ost_name.degraded=1
5499         sleep_maxage
5500
5501         local new_status=$(ost_dev_status $ost_idx)
5502
5503         [[ "$new_status" = "D" ]] ||
5504                 error "OST $ost_name is in status of '$new_status', not 'D'"
5505
5506         do_facet ost1 $LCTL set_param -n obdfilter.$ost_name.degraded=0
5507         sleep_maxage
5508
5509         new_status=$(ost_dev_status $ost_idx)
5510         [[ -z "$new_status" ]] ||
5511                 error "OST $ost_name is in status of '$new_status', not ''"
5512 }
5513 run_test 56c "check 'lfs df' showing device status"
5514
5515 NUMFILES=3
5516 NUMDIRS=3
5517 setup_56() {
5518         local local_tdir="$1"
5519         local local_numfiles="$2"
5520         local local_numdirs="$3"
5521         local dir_params="$4"
5522         local dir_stripe_params="$5"
5523
5524         if [ ! -d "$local_tdir" ] ; then
5525                 test_mkdir -p $dir_stripe_params $local_tdir
5526                 [ "$dir_params" ] && $LFS setstripe $dir_params $local_tdir
5527                 for i in $(seq $local_numfiles) ; do
5528                         touch $local_tdir/file$i
5529                 done
5530                 for i in $(seq $local_numdirs) ; do
5531                         test_mkdir $dir_stripe_params $local_tdir/dir$i
5532                         for j in $(seq $local_numfiles) ; do
5533                                 touch $local_tdir/dir$i/file$j
5534                         done
5535                 done
5536         fi
5537 }
5538
5539 setup_56_special() {
5540         local local_tdir=$1
5541         local local_numfiles=$2
5542         local local_numdirs=$3
5543
5544         setup_56 $local_tdir $local_numfiles $local_numdirs
5545
5546         if [ ! -e "$local_tdir/loop${local_numfiles}b" ] ; then
5547                 for i in $(seq $local_numfiles) ; do
5548                         mknod $local_tdir/loop${i}b b 7 $i
5549                         mknod $local_tdir/null${i}c c 1 3
5550                         ln -s $local_tdir/file1 $local_tdir/link${i}
5551                 done
5552                 for i in $(seq $local_numdirs) ; do
5553                         mknod $local_tdir/dir$i/loop${i}b b 7 $i
5554                         mknod $local_tdir/dir$i/null${i}c c 1 3
5555                         ln -s $local_tdir/dir$i/file1 $local_tdir/dir$i/link${i}
5556                 done
5557         fi
5558 }
5559
5560 test_56g() {
5561         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5562         local expected=$(($NUMDIRS + 2))
5563
5564         setup_56 $dir $NUMFILES $NUMDIRS
5565
5566         # test lfs find with -name
5567         for i in $(seq $NUMFILES) ; do
5568                 local nums=$($LFS find -name "*$i" $dir | wc -l)
5569
5570                 [ $nums -eq $expected ] ||
5571                         error "lfs find -name '*$i' $dir wrong: "\
5572                               "found $nums, expected $expected"
5573         done
5574 }
5575 run_test 56g "check lfs find -name"
5576
5577 test_56h() {
5578         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5579         local expected=$(((NUMDIRS + 1) * (NUMFILES - 1) + NUMFILES))
5580
5581         setup_56 $dir $NUMFILES $NUMDIRS
5582
5583         # test lfs find with ! -name
5584         for i in $(seq $NUMFILES) ; do
5585                 local nums=$($LFS find ! -name "*$i" $dir | wc -l)
5586
5587                 [ $nums -eq $expected ] ||
5588                         error "lfs find ! -name '*$i' $dir wrong: "\
5589                               "found $nums, expected $expected"
5590         done
5591 }
5592 run_test 56h "check lfs find ! -name"
5593
5594 test_56i() {
5595         local dir=$DIR/$tdir
5596
5597         test_mkdir $dir
5598
5599         local cmd="$LFS find -ost $(ostuuid_from_index 0 $dir) $dir"
5600         local out=$($cmd)
5601
5602         [ -z "$out" ] || error "'$cmd' returned directory '$out'"
5603 }
5604 run_test 56i "check 'lfs find -ost UUID' skips directories"
5605
5606 test_56j() {
5607         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5608
5609         setup_56_special $dir $NUMFILES $NUMDIRS
5610
5611         local expected=$((NUMDIRS + 1))
5612         local cmd="$LFS find -type d $dir"
5613         local nums=$($cmd | wc -l)
5614
5615         [ $nums -eq $expected ] ||
5616                 error "'$cmd' wrong: found $nums, expected $expected"
5617 }
5618 run_test 56j "check lfs find -type d"
5619
5620 test_56k() {
5621         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5622
5623         setup_56_special $dir $NUMFILES $NUMDIRS
5624
5625         local expected=$(((NUMDIRS + 1) * NUMFILES))
5626         local cmd="$LFS find -type f $dir"
5627         local nums=$($cmd | wc -l)
5628
5629         [ $nums -eq $expected ] ||
5630                 error "'$cmd' wrong: found $nums, expected $expected"
5631 }
5632 run_test 56k "check lfs find -type f"
5633
5634 test_56l() {
5635         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5636
5637         setup_56_special $dir $NUMFILES $NUMDIRS
5638
5639         local expected=$((NUMDIRS + NUMFILES))
5640         local cmd="$LFS find -type b $dir"
5641         local nums=$($cmd | wc -l)
5642
5643         [ $nums -eq $expected ] ||
5644                 error "'$cmd' wrong: found $nums, expected $expected"
5645 }
5646 run_test 56l "check lfs find -type b"
5647
5648 test_56m() {
5649         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5650
5651         setup_56_special $dir $NUMFILES $NUMDIRS
5652
5653         local expected=$((NUMDIRS + NUMFILES))
5654         local cmd="$LFS find -type c $dir"
5655         local nums=$($cmd | wc -l)
5656         [ $nums -eq $expected ] ||
5657                 error "'$cmd' wrong: found $nums, expected $expected"
5658 }
5659 run_test 56m "check lfs find -type c"
5660
5661 test_56n() {
5662         local dir=$DIR/d$(basetest $testnum)g.$TESTSUITE
5663         setup_56_special $dir $NUMFILES $NUMDIRS
5664
5665         local expected=$((NUMDIRS + NUMFILES))
5666         local cmd="$LFS find -type l $dir"
5667         local nums=$($cmd | wc -l)
5668
5669         [ $nums -eq $expected ] ||
5670                 error "'$cmd' wrong: found $nums, expected $expected"
5671 }
5672 run_test 56n "check lfs find -type l"
5673
5674 test_56o() {
5675         local dir=$DIR/$tdir
5676
5677         setup_56 $dir $NUMFILES $NUMDIRS
5678         utime $dir/file1 > /dev/null || error "utime (1)"
5679         utime $dir/file2 > /dev/null || error "utime (2)"
5680         utime $dir/dir1 > /dev/null || error "utime (3)"
5681         utime $dir/dir2 > /dev/null || error "utime (4)"
5682         utime $dir/dir1/file1 > /dev/null || error "utime (5)"
5683         dd if=/dev/zero count=1 >> $dir/dir1/file1 && sync
5684
5685         local expected=4
5686         local nums=$($LFS find -mtime +0 $dir | wc -l)
5687
5688         [ $nums -eq $expected ] ||
5689                 error "lfs find -mtime +0 $dir: found $nums expect $expected"
5690
5691         expected=12
5692         cmd="$LFS find -mtime 0 $dir"
5693         nums=$($cmd | wc -l)
5694         [ $nums -eq $expected ] ||
5695                 error "'$cmd' wrong: found $nums, expected $expected"
5696 }
5697 run_test 56o "check lfs find -mtime for old files"
5698
5699 test_56ob() {
5700         local dir=$DIR/$tdir
5701         local expected=1
5702         local count=0
5703
5704         # just to make sure there is something that won't be found
5705         test_mkdir $dir
5706         touch $dir/$tfile.now
5707
5708         for age in year week day hour min; do
5709                 count=$((count + 1))
5710
5711                 touch $dir/$tfile-a.$age $dir/$tfile-m.$age
5712                 touch --date="$count $age ago" -a $dir/$tfile-a.$age
5713                 touch --date="$count $age ago" -m $dir/$tfile-m.$age
5714
5715                 local cmd="$LFS find $dir -mtime $count${age:0:1}"
5716                 local nums=$($cmd | wc -l)
5717                 [ $nums -eq $expected ] ||
5718                         error "'$cmd' wrong: found $nums, expected $expected"
5719
5720                 cmd="$LFS find $dir -atime $count${age:0:1}"
5721                 nums=$($cmd | wc -l)
5722                 [ $nums -eq $expected ] ||
5723                         error "'$cmd' wrong: found $nums, expected $expected"
5724         done
5725
5726         sleep 2
5727         cmd="$LFS find $dir -ctime +1s -type f"
5728         nums=$($cmd | wc -l)
5729         (( $nums == $count * 2 + 1)) ||
5730                 error "'$cmd' wrong: found $nums, expected $((expected*2+1))"
5731 }
5732 run_test 56ob "check lfs find -atime -mtime -ctime with units"
5733
5734 test_56p() {
5735         [ $RUNAS_ID -eq $UID ] &&
5736                 skip_env "RUNAS_ID = UID = $UID -- skipping"
5737
5738         local dir=$DIR/$tdir
5739
5740         setup_56 $dir $NUMFILES $NUMDIRS
5741         chown $RUNAS_ID $dir/file* || error "chown $DIR/${tdir}g/file$i failed"
5742
5743         local expected=$NUMFILES
5744         local cmd="$LFS find -uid $RUNAS_ID $dir"
5745         local nums=$($cmd | wc -l)
5746
5747         [ $nums -eq $expected ] ||
5748                 error "'$cmd' wrong: found $nums, expected $expected"
5749
5750         expected=$(((NUMFILES + 1) * NUMDIRS + 1))
5751         cmd="$LFS find ! -uid $RUNAS_ID $dir"
5752         nums=$($cmd | wc -l)
5753         [ $nums -eq $expected ] ||
5754                 error "'$cmd' wrong: found $nums, expected $expected"
5755 }
5756 run_test 56p "check lfs find -uid and ! -uid"
5757
5758 test_56q() {
5759         [ $RUNAS_ID -eq $UID ] &&
5760                 skip_env "RUNAS_ID = UID = $UID -- skipping"
5761
5762         local dir=$DIR/$tdir
5763
5764         setup_56 $dir $NUMFILES $NUMDIRS
5765         chgrp $RUNAS_GID $dir/file* || error "chown $dir/file$i failed"
5766
5767         local expected=$NUMFILES
5768         local cmd="$LFS find -gid $RUNAS_GID $dir"
5769         local nums=$($cmd | wc -l)
5770
5771         [ $nums -eq $expected ] ||
5772                 error "'$cmd' wrong: found $nums, expected $expected"
5773
5774         expected=$(( ($NUMFILES+1) * $NUMDIRS + 1))
5775         cmd="$LFS find ! -gid $RUNAS_GID $dir"
5776         nums=$($cmd | wc -l)
5777         [ $nums -eq $expected ] ||
5778                 error "'$cmd' wrong: found $nums, expected $expected"
5779 }
5780 run_test 56q "check lfs find -gid and ! -gid"
5781
5782 test_56r() {
5783         local dir=$DIR/$tdir
5784
5785         setup_56 $dir $NUMFILES $NUMDIRS
5786
5787         local expected=12
5788         local cmd="$LFS find -size 0 -type f -lazy $dir"
5789         local nums=$($cmd | wc -l)
5790
5791         [ $nums -eq $expected ] ||
5792                 error "'$cmd' wrong: found $nums, expected $expected"
5793         cmd="$LFS find -size 0 -type f $dir"
5794         nums=$($cmd | wc -l)
5795         [ $nums -eq $expected ] ||
5796                 error "'$cmd' wrong: found $nums, expected $expected"
5797
5798         expected=0
5799         cmd="$LFS find ! -size 0 -type f -lazy $dir"
5800         nums=$($cmd | wc -l)
5801         [ $nums -eq $expected ] ||
5802                 error "'$cmd' wrong: found $nums, expected $expected"
5803         cmd="$LFS find ! -size 0 -type f $dir"
5804         nums=$($cmd | wc -l)
5805         [ $nums -eq $expected ] ||
5806                 error "'$cmd' wrong: found $nums, expected $expected"
5807
5808         echo "test" > $dir/$tfile
5809         echo "test2" > $dir/$tfile.2 && sync
5810         expected=1
5811         cmd="$LFS find -size 5 -type f -lazy $dir"
5812         nums=$($cmd | wc -l)
5813         [ $nums -eq $expected ] ||
5814                 error "'$cmd' wrong: found $nums, expected $expected"
5815         cmd="$LFS find -size 5 -type f $dir"
5816         nums=$($cmd | wc -l)
5817         [ $nums -eq $expected ] ||
5818                 error "'$cmd' wrong: found $nums, expected $expected"
5819
5820         expected=1
5821         cmd="$LFS find -size +5 -type f -lazy $dir"
5822         nums=$($cmd | wc -l)
5823         [ $nums -eq $expected ] ||
5824                 error "'$cmd' wrong: found $nums, expected $expected"
5825         cmd="$LFS find -size +5 -type f $dir"
5826         nums=$($cmd | wc -l)
5827         [ $nums -eq $expected ] ||
5828                 error "'$cmd' wrong: found $nums, expected $expected"
5829
5830         expected=2
5831         cmd="$LFS find -size +0 -type f -lazy $dir"
5832         nums=$($cmd | wc -l)
5833         [ $nums -eq $expected ] ||
5834                 error "'$cmd' wrong: found $nums, expected $expected"
5835         cmd="$LFS find -size +0 -type f $dir"
5836         nums=$($cmd | wc -l)
5837         [ $nums -eq $expected ] ||
5838                 error "'$cmd' wrong: found $nums, expected $expected"
5839
5840         expected=2
5841         cmd="$LFS find ! -size -5 -type f -lazy $dir"
5842         nums=$($cmd | wc -l)
5843         [ $nums -eq $expected ] ||
5844                 error "'$cmd' wrong: found $nums, expected $expected"
5845         cmd="$LFS find ! -size -5 -type f $dir"
5846         nums=$($cmd | wc -l)
5847         [ $nums -eq $expected ] ||
5848                 error "'$cmd' wrong: found $nums, expected $expected"
5849
5850         expected=12
5851         cmd="$LFS find -size -5 -type f -lazy $dir"
5852         nums=$($cmd | wc -l)
5853         [ $nums -eq $expected ] ||
5854                 error "'$cmd' wrong: found $nums, expected $expected"
5855         cmd="$LFS find -size -5 -type f $dir"
5856         nums=$($cmd | wc -l)
5857         [ $nums -eq $expected ] ||
5858                 error "'$cmd' wrong: found $nums, expected $expected"
5859 }
5860 run_test 56r "check lfs find -size works"
5861
5862 test_56ra() {
5863         local dir=$DIR/$tdir
5864
5865         [[ $OSC == "mdc" ]] && skip "DoM files" && return
5866
5867         setup_56 $dir $NUMFILES $NUMDIRS "-c 1"
5868
5869         cancel_lru_locks $OSC
5870
5871         local rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5872         local expected=12
5873         local cmd="$LFS find -size 0 -type f -lazy $dir"
5874         local nums=$($cmd | wc -l)
5875
5876         [ $nums -eq $expected ] ||
5877                 error "'$cmd' wrong: found $nums, expected $expected"
5878
5879         local rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5880         [ $rpcs_before -eq $rpcs_after ] ||
5881                 error "'$cmd' should not send glimpse RPCs to OST"
5882         cmd="$LFS find -size 0 -type f $dir"
5883         nums=$($cmd | wc -l)
5884         [ $nums -eq $expected ] ||
5885                 error "'$cmd' wrong: found $nums, expected $expected"
5886         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5887         echo "Before: $rpcs_before After: $rpcs_after $NUMFILES"
5888         $LCTL get_param osc.*.stats
5889         [ $rpcs_after -eq $((rpcs_before + 12)) ] ||
5890                 error "'$cmd' should send 12 glimpse RPCs to OST"
5891
5892         cancel_lru_locks $OSC
5893         rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5894         expected=0
5895         cmd="$LFS find ! -size 0 -type f -lazy $dir"
5896         nums=$($cmd | wc -l)
5897         [ $nums -eq $expected ] ||
5898                 error "'$cmd' wrong: found $nums, expected $expected"
5899         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5900         $LCTL get_param mdc.*.stats
5901         [ $rpcs_before -eq $rpcs_after ] ||
5902                 error "'$cmd' should not send glimpse RPCs to OST"
5903         cmd="$LFS find ! -size 0 -type f $dir"
5904         nums=$($cmd | wc -l)
5905         [ $nums -eq $expected ] ||
5906                 error "'$cmd' wrong: found $nums, expected $expected"
5907         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5908         echo "Before: $rpcs_before After: $rpcs_after $NUMFILES"
5909         [ $rpcs_after -eq $((rpcs_before + 12)) ] ||
5910                 error "'$cmd' should send 12 glimpse RPCs to OST"
5911
5912         echo "test" > $dir/$tfile
5913         echo "test2" > $dir/$tfile.2 && sync
5914         cancel_lru_locks $OSC
5915         rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5916         expected=1
5917         cmd="$LFS find -size 5 -type f -lazy $dir"
5918         nums=$($cmd | wc -l)
5919         [ $nums -eq $expected ] ||
5920                 error "'$cmd' wrong: found $nums, expected $expected"
5921         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5922         [ $rpcs_before -eq $rpcs_after ] ||
5923                 error "'$cmd' should not send glimpse RPCs to OST"
5924         cmd="$LFS find -size 5 -type f $dir"
5925         nums=$($cmd | wc -l)
5926         [ $nums -eq $expected ] ||
5927                 error "'$cmd' wrong: found $nums, expected $expected"
5928         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5929         echo "Before: $rpcs_before After: $rpcs_after $NUMFILES"
5930         [ $rpcs_after -eq $((rpcs_before + 14)) ] ||
5931                 error "'$cmd' should send 14 glimpse RPCs to OST"
5932
5933         cancel_lru_locks $OSC
5934         rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5935         expected=1
5936         cmd="$LFS find -size +5 -type f -lazy $dir"
5937         nums=$($cmd | wc -l)
5938         [ $nums -eq $expected ] ||
5939                 error "'$cmd' wrong: found $nums, expected $expected"
5940         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5941         [ $rpcs_before -eq $rpcs_after ] ||
5942                 error "'$cmd' should not send glimpse RPCs to OST"
5943         cmd="$LFS find -size +5 -type f $dir"
5944         nums=$($cmd | wc -l)
5945         [ $nums -eq $expected ] ||
5946                 error "'$cmd' wrong: found $nums, expected $expected"
5947         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5948         echo "Before: $rpcs_before After: $rpcs_after $NUMFILES"
5949         [ $rpcs_after -eq $((rpcs_before + 14)) ] ||
5950                 error "'$cmd' should send 14 glimpse RPCs to OST"
5951
5952         cancel_lru_locks $OSC
5953         rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5954         expected=2
5955         cmd="$LFS find -size +0 -type f -lazy $dir"
5956         nums=$($cmd | wc -l)
5957         [ $nums -eq $expected ] ||
5958                 error "'$cmd' wrong: found $nums, expected $expected"
5959         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5960         [ $rpcs_before -eq $rpcs_after ] ||
5961                 error "'$cmd' should not send glimpse RPCs to OST"
5962         cmd="$LFS find -size +0 -type f $dir"
5963         nums=$($cmd | wc -l)
5964         [ $nums -eq $expected ] ||
5965                 error "'$cmd' wrong: found $nums, expected $expected"
5966         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5967         echo "Before: $rpcs_before After: $rpcs_after $NUMFILES"
5968         [ $rpcs_after -eq $((rpcs_before + 14)) ] ||
5969                 error "'$cmd' should send 14 glimpse RPCs to OST"
5970
5971         cancel_lru_locks $OSC
5972         rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5973         expected=2
5974         cmd="$LFS find ! -size -5 -type f -lazy $dir"
5975         nums=$($cmd | wc -l)
5976         [ $nums -eq $expected ] ||
5977                 error "'$cmd' wrong: found $nums, expected $expected"
5978         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5979         [ $rpcs_before -eq $rpcs_after ] ||
5980                 error "'$cmd' should not send glimpse RPCs to OST"
5981         cmd="$LFS find ! -size -5 -type f $dir"
5982         nums=$($cmd | wc -l)
5983         [ $nums -eq $expected ] ||
5984                 error "'$cmd' wrong: found $nums, expected $expected"
5985         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5986         echo "Before: $rpcs_before After: $rpcs_after $NUMFILES"
5987         [ $rpcs_after -eq $((rpcs_before + 14)) ] ||
5988                 error "'$cmd' should send 14 glimpse RPCs to OST"
5989
5990         cancel_lru_locks $OSC
5991         rpcs_before=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5992         expected=12
5993         cmd="$LFS find -size -5 -type f -lazy $dir"
5994         nums=$($cmd | wc -l)
5995         [ $nums -eq $expected ] ||
5996                 error "'$cmd' wrong: found $nums, expected $expected"
5997         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
5998         [ $rpcs_before -eq $rpcs_after ] ||
5999                 error "'$cmd' should not send glimpse RPCs to OST"
6000         cmd="$LFS find -size -5 -type f $dir"
6001         nums=$($cmd | wc -l)
6002         [ $nums -eq $expected ] ||
6003                 error "'$cmd' wrong: found $nums, expected $expected"
6004         rpcs_after=$(calc_stats $OSC.*$OSC*.stats ldlm_glimpse_enqueue)
6005         echo "Before: $rpcs_before After: $rpcs_after $NUMFILES"
6006         [ $rpcs_after -eq $((rpcs_before + 14)) ] ||
6007                 error "'$cmd' should send 14 glimpse RPCs to OST"
6008 }
6009 run_test 56ra "check lfs find -size -lazy works for data on OSTs"
6010
6011 test_56s() { # LU-611 #LU-9369
6012         [[ $OSTCOUNT -lt 2 ]] && skip_env "need at least 2 OSTs"
6013
6014         local dir=$DIR/$tdir
6015         local onestripe=$(((NUMDIRS + 1) * NUMFILES))
6016
6017         setup_56 $dir $NUMFILES $NUMDIRS "-c 1"
6018         for i in $(seq $NUMDIRS); do
6019                 $LFS setstripe -c $((OSTCOUNT + 1)) $dir/dir$i/$tfile
6020         done
6021
6022         local expected=$NUMDIRS
6023         local cmd="$LFS find -c $OSTCOUNT $dir"
6024         local nums=$($cmd | wc -l)
6025
6026         [ $nums -eq $expected ] || {
6027                 $LFS getstripe -R $dir
6028                 error "'$cmd' wrong: found $nums, expected $expected"
6029         }
6030
6031         expected=$((NUMDIRS + onestripe))
6032         cmd="$LFS find -stripe-count +0 -type f $dir"
6033         nums=$($cmd | wc -l)
6034         [ $nums -eq $expected ] || {
6035                 $LFS getstripe -R $dir
6036                 error "'$cmd' wrong: found $nums, expected $expected"
6037         }
6038
6039         expected=$onestripe
6040         cmd="$LFS find -stripe-count 1 -type f $dir"
6041         nums=$($cmd | wc -l)
6042         [ $nums -eq $expected ] || {
6043                 $LFS getstripe -R $dir
6044                 error "'$cmd' wrong: found $nums, expected $expected"
6045         }
6046
6047         cmd="$LFS find -stripe-count -2 -type f $dir"
6048         nums=$($cmd | wc -l)
6049         [ $nums -eq $expected ] || {
6050                 $LFS getstripe -R $dir
6051                 error "'$cmd' wrong: found $nums, expected $expected"
6052         }
6053
6054         expected=0
6055         cmd="$LFS find -stripe-count $((OSTCOUNT + 1)) -type f $dir"
6056         nums=$($cmd | wc -l)
6057         [ $nums -eq $expected ] || {
6058                 $LFS getstripe -R $dir
6059                 error "'$cmd' wrong: found $nums, expected $expected"
6060         }
6061 }
6062 run_test 56s "check lfs find -stripe-count works"
6063
6064 test_56t() { # LU-611 #LU-9369
6065         local dir=$DIR/$tdir
6066
6067         setup_56 $dir 0 $NUMDIRS
6068         for i in $(seq $NUMDIRS); do
6069                 $LFS setstripe -S 8M $dir/dir$i/$tfile
6070         done
6071
6072         local expected=$NUMDIRS
6073         local cmd="$LFS find -S 8M $dir"
6074         local nums=$($cmd | wc -l)
6075
6076         [ $nums -eq $expected ] || {
6077                 $LFS getstripe -R $dir
6078                 error "'$cmd' wrong: found $nums, expected $expected"
6079         }
6080         rm -rf $dir
6081
6082         setup_56 $dir $NUMFILES $NUMDIRS "--stripe-size 512k"
6083
6084         $LFS setstripe -S 256k $dir/$tfile.{0,1,2,3}
6085
6086         expected=$(((NUMDIRS + 1) * NUMFILES))
6087         cmd="$LFS find -stripe-size 512k -type f $dir"
6088         nums=$($cmd | wc -l)
6089         [ $nums -eq $expected ] ||
6090                 error "'$cmd' wrong: found $nums, expected $expected"
6091
6092         cmd="$LFS find -stripe-size +320k -type f $dir"
6093         nums=$($cmd | wc -l)
6094         [ $nums -eq $expected ] ||
6095                 error "'$cmd' wrong: found $nums, expected $expected"
6096
6097         expected=$(((NUMDIRS + 1) * NUMFILES + 4))
6098         cmd="$LFS find -stripe-size +200k -type f $dir"
6099         nums=$($cmd | wc -l)
6100         [ $nums -eq $expected ] ||
6101                 error "'$cmd' wrong: found $nums, expected $expected"
6102
6103         cmd="$LFS find -stripe-size -640k -type f $dir"
6104         nums=$($cmd | wc -l)
6105         [ $nums -eq $expected ] ||
6106                 error "'$cmd' wrong: found $nums, expected $expected"
6107
6108         expected=4
6109         cmd="$LFS find -stripe-size 256k -type f $dir"
6110         nums=$($cmd | wc -l)
6111         [ $nums -eq $expected ] ||
6112                 error "'$cmd' wrong: found $nums, expected $expected"
6113
6114         cmd="$LFS find -stripe-size -320k -type f $dir"
6115         nums=$($cmd | wc -l)
6116         [ $nums -eq $expected ] ||
6117                 error "'$cmd' wrong: found $nums, expected $expected"
6118
6119         expected=0
6120         cmd="$LFS find -stripe-size 1024k -type f $dir"
6121         nums=$($cmd | wc -l)
6122         [ $nums -eq $expected ] ||
6123                 error "'$cmd' wrong: found $nums, expected $expected"
6124 }
6125 run_test 56t "check lfs find -stripe-size works"
6126
6127 test_56u() { # LU-611
6128         local dir=$DIR/$tdir
6129
6130         setup_56 $dir $NUMFILES $NUMDIRS "-i 0 -c 1"
6131
6132         if [[ $OSTCOUNT -gt 1 ]]; then
6133                 $LFS setstripe -i 1 -c 1 $dir/$tfile.{0,1,2,3}
6134                 onestripe=4
6135         else
6136                 onestripe=0
6137         fi
6138
6139         local expected=$(((NUMDIRS + 1) * NUMFILES))
6140         local cmd="$LFS find -stripe-index 0 -type f $dir"
6141         local nums=$($cmd | wc -l)
6142
6143         [ $nums -eq $expected ] ||
6144                 error "'$cmd' wrong: found $nums, expected $expected"
6145
6146         expected=$onestripe
6147         cmd="$LFS find -stripe-index 1 -type f $dir"
6148         nums=$($cmd | wc -l)
6149         [ $nums -eq $expected ] ||
6150                 error "'$cmd' wrong: found $nums, expected $expected"
6151
6152         cmd="$LFS find ! -stripe-index 0 -type f $dir"
6153         nums=$($cmd | wc -l)
6154         [ $nums -eq $expected ] ||
6155                 error "'$cmd' wrong: found $nums, expected $expected"
6156
6157         expected=0
6158         # This should produce an error and not return any files
6159         cmd="$LFS find -stripe-index $OSTCOUNT -type f $dir"
6160         nums=$($cmd 2>/dev/null | wc -l)
6161         [ $nums -eq $expected ] ||
6162                 error "'$cmd' wrong: found $nums, expected $expected"
6163
6164         if [[ $OSTCOUNT -gt 1 ]]; then
6165                 expected=$(((NUMDIRS + 1) * NUMFILES + onestripe))
6166                 cmd="$LFS find -stripe-index 0,1 -type f $dir"
6167                 nums=$($cmd | wc -l)
6168                 [ $nums -eq $expected ] ||
6169                         error "'$cmd' wrong: found $nums, expected $expected"
6170         fi
6171 }
6172 run_test 56u "check lfs find -stripe-index works"
6173
6174 test_56v() {
6175         local mdt_idx=0
6176         local dir=$DIR/$tdir
6177
6178         setup_56 $dir $NUMFILES $NUMDIRS
6179
6180         UUID=$(mdtuuid_from_index $mdt_idx $dir)
6181         [ -z "$UUID" ] && error "mdtuuid_from_index cannot find MDT $mdt_idx"
6182
6183         for file in $($LFS find -m $UUID $dir); do
6184                 file_midx=$($LFS getstripe -m $file)
6185                 [ $file_midx -eq $mdt_idx ] ||
6186                         error "lfs find -m $UUID != getstripe -m $file_midx"
6187         done
6188 }
6189 run_test 56v "check 'lfs find -m match with lfs getstripe -m'"
6190
6191 test_56w() {
6192         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
6193         [ $PARALLEL == "yes" ] && skip "skip parallel run"
6194
6195         local dir=$DIR/$tdir
6196
6197         setup_56 $dir $NUMFILES $NUMDIRS "-c $OSTCOUNT" "-c1"
6198
6199         local stripe_size=$($LFS getstripe -S -d $dir) ||
6200                 error "$LFS getstripe -S -d $dir failed"
6201         stripe_size=${stripe_size%% *}
6202
6203         local file_size=$((stripe_size * OSTCOUNT))
6204         local file_num=$((NUMDIRS * NUMFILES + NUMFILES))
6205         local required_space=$((file_num * file_size))
6206         local free_space=$($LCTL get_param -n lov.$FSNAME-clilov-*.kbytesavail |
6207                            head -n1)
6208         [[ $free_space -le $((required_space / 1024)) ]] &&
6209                 skip_env "need $required_space, have $free_space kbytes"
6210
6211         local dd_bs=65536
6212         local dd_count=$((file_size / dd_bs))
6213
6214         # write data into the files
6215         local i
6216         local j
6217         local file
6218
6219         for i in $(seq $NUMFILES); do
6220                 file=$dir/file$i
6221                 yes | dd bs=$dd_bs count=$dd_count of=$file &>/dev/null ||
6222                         error "write data into $file failed"
6223         done
6224         for i in $(seq $NUMDIRS); do
6225                 for j in $(seq $NUMFILES); do
6226                         file=$dir/dir$i/file$j
6227                         yes|dd bs=$dd_bs count=$dd_count of=$file &>/dev/null ||
6228                                 error "write data into $file failed"
6229                 done
6230         done
6231
6232         # $LFS_MIGRATE will fail if hard link migration is unsupported
6233         if [[ $(lustre_version_code mds1) -gt $(version_code 2.5.55) ]]; then
6234                 createmany -l$dir/dir1/file1 $dir/dir1/link 200 ||
6235                         error "creating links to $dir/dir1/file1 failed"
6236         fi
6237
6238         local expected=-1
6239
6240         [[ $OSTCOUNT -gt 1 ]] && expected=$((OSTCOUNT - 1))
6241
6242         # lfs_migrate file
6243         local cmd="$LFS_MIGRATE -y -c $expected $dir/file1"
6244
6245         echo "$cmd"
6246         eval $cmd || error "$cmd failed"
6247
6248         check_stripe_count $dir/file1 $expected
6249
6250         if [ $MDS1_VERSION -ge $(version_code 2.6.90) ];
6251         then
6252                 # lfs_migrate file onto OST 0 if it is on OST 1, or onto
6253                 # OST 1 if it is on OST 0. This file is small enough to
6254                 # be on only one stripe.
6255                 file=$dir/migr_1_ost
6256                 dd bs=$dd_bs count=1 if=/dev/urandom of=$file >/dev/null 2>&1 ||
6257                         error "write data into $file failed"
6258                 local obdidx=$($LFS getstripe -i $file)
6259                 local oldmd5=$(md5sum $file)
6260                 local newobdidx=0
6261
6262                 [[ $obdidx -eq 0 ]] && newobdidx=1
6263                 cmd="$LFS migrate -i $newobdidx $file"
6264                 echo $cmd
6265                 eval $cmd || error "$cmd failed"
6266
6267                 local realobdix=$($LFS getstripe -i $file)
6268                 local newmd5=$(md5sum $file)
6269
6270                 [[ $newobdidx -ne $realobdix ]] &&
6271                         error "new OST is different (was=$obdidx, "\
6272                               "wanted=$newobdidx, got=$realobdix)"
6273                 [[ "$oldmd5" != "$newmd5" ]] &&
6274                         error "md5sum differ: $oldmd5, $newmd5"
6275         fi
6276
6277         # lfs_migrate dir
6278         cmd="$LFS_MIGRATE -y -c $expected $dir/dir1"
6279         echo "$cmd"
6280         eval $cmd || error "$cmd failed"
6281
6282         for j in $(seq $NUMFILES); do
6283                 check_stripe_count $dir/dir1/file$j $expected
6284         done
6285
6286         # lfs_migrate works with lfs find
6287         cmd="$LFS find -stripe_count $OSTCOUNT -type f $dir |
6288              $LFS_MIGRATE -y -c $expected"
6289         echo "$cmd"
6290         eval $cmd || error "$cmd failed"
6291
6292         for i in $(seq 2 $NUMFILES); do
6293                 check_stripe_count $dir/file$i $expected
6294         done
6295         for i in $(seq 2 $NUMDIRS); do
6296                 for j in $(seq $NUMFILES); do
6297                 check_stripe_count $dir/dir$i/file$j $expected
6298                 done
6299         done
6300 }
6301 run_test 56w "check lfs_migrate -c stripe_count works"
6302
6303 test_56wb() {
6304         local file1=$DIR/$tdir/file1
6305         local create_pool=false
6306         local initial_pool=$($LFS getstripe -p $DIR)
6307         local pool_list=()
6308         local pool=""
6309
6310         echo -n "Creating test dir..."
6311         test_mkdir $DIR/$tdir &> /dev/null || error "cannot create dir"
6312         echo "done."
6313
6314         echo -n "Creating test file..."
6315         touch $file1 || error "cannot create file"
6316         echo "done."
6317
6318         echo -n "Detecting existing pools..."
6319         pool_list=($($LFS pool_list $FSNAME | grep "$FSNAME\." | cut -d. -f2))
6320
6321         if [ ${#pool_list[@]} -gt 0 ]; then
6322                 echo "${pool_list[@]}"
6323                 for thispool in "${pool_list[@]}"; do
6324                         if [[ -z "$initial_pool" ||
6325                               "$initial_pool" != "$thispool" ]]; then
6326                                 pool="$thispool"
6327                                 echo "Using existing pool '$pool'"
6328                                 break
6329                         fi
6330                 done
6331         else
6332                 echo "none detected."
6333         fi
6334         if [ -z "$pool" ]; then
6335                 pool=${POOL:-testpool}
6336                 [ "$initial_pool" = "$pool" ] && pool="testpool2"
6337                 echo -n "Creating pool '$pool'..."
6338                 create_pool=true
6339                 pool_add $pool &> /dev/null ||
6340                         error "pool_add failed"
6341                 echo "done."
6342
6343                 echo -n "Adding target to pool..."
6344                 pool_add_targets $pool 0 0 1 &> /dev/null ||
6345                         error "pool_add_targets failed"
6346                 echo "done."
6347         fi
6348
6349         echo -n "Setting pool using -p option..."
6350         $LFS_MIGRATE -y -q --no-rsync -p $pool $file1 &> /dev/null ||
6351                 error "migrate failed rc = $?"
6352         echo "done."
6353
6354         echo -n "Verifying test file is in pool after migrating..."
6355         [ "$($LFS getstripe -p $file1)" = $pool ] ||
6356                 error "file was not migrated to pool $pool"
6357         echo "done."
6358
6359         echo -n "Removing test file from pool '$pool'..."
6360         $LFS migrate $file1 &> /dev/null ||
6361                 error "cannot remove from pool"
6362         [ "$($LFS getstripe -p $file1)" ] &&
6363                 error "pool still set"
6364         echo "done."
6365
6366         echo -n "Setting pool using --pool option..."
6367         $LFS_MIGRATE -y -q --no-rsync --pool $pool $file1 &> /dev/null ||
6368                 error "migrate failed rc = $?"
6369         echo "done."
6370
6371         # Clean up
6372         rm -f $file1
6373         if $create_pool; then
6374                 destroy_test_pools 2> /dev/null ||
6375                         error "destroy test pools failed"
6376         fi
6377 }
6378 run_test 56wb "check lfs_migrate pool support"
6379
6380 test_56wc() {
6381         local file1="$DIR/$tdir/file1"
6382
6383         echo -n "Creating test dir..."
6384         test_mkdir $DIR/$tdir &> /dev/null || error "cannot create dir"
6385         local def_stripe_size=$($LFS getstripe -S $DIR/$tdir 2>/dev/null)
6386         $LFS setstripe -S 1M -c 1 "$DIR/$tdir" &> /dev/null ||
6387                 error "cannot set stripe"
6388         echo "done"
6389
6390         echo -n "Setting initial stripe for test file..."
6391         $LFS setstripe -S 512K -c 1 "$file1" &> /dev/null ||
6392                 error "cannot set stripe"
6393         [ $($LFS getstripe -S "$file1") -eq 524288 ] ||
6394                 error "stripe size not set"
6395         echo "done."
6396
6397         # File currently set to -S 512K -c 1
6398
6399         # Ensure -c and -S options are rejected when -R is set
6400         echo -n "Verifying incompatible options are detected..."
6401         $LFS_MIGRATE -y -R -c 1 "$file1" &> /dev/null &&
6402                 error "incompatible -c and -R options not detected"
6403         $LFS_MIGRATE -y -R -S 1M "$file1" &> /dev/null &&
6404                 error "incompatible -S and -R options not detected"
6405         echo "done."
6406
6407         # Ensure unrecognized options are passed through to 'lfs migrate'
6408         echo -n "Verifying -S option is passed through to lfs migrate..."
6409         $LFS_MIGRATE -y -S 1M "$file1" &> /dev/null ||
6410                 error "migration failed"
6411         [ $($LFS getstripe -S "$file1") -eq 1048576 ] ||
6412                 error "file was not restriped"
6413         echo "done."
6414
6415         # File currently set to -S 1M -c 1
6416
6417         # Ensure long options are supported
6418         echo -n "Verifying long options supported..."
6419         $LFS_MIGRATE -y --non-block "$file1" &> /dev/null ||
6420                 error "long option without argument not supported"
6421         $LFS_MIGRATE -y --stripe-size 512K "$file1" &> /dev/null ||
6422                 error "long option with argument not supported"
6423         [ $($LFS getstripe -S "$file1") -eq 524288 ] ||
6424                 error "file not restriped with --stripe-size option"
6425         echo "done."
6426
6427         # File currently set to -S 512K -c 1
6428
6429         if [ "$OSTCOUNT" -gt 1 ]; then
6430                 echo -n "Verifying explicit stripe count can be set..."
6431                 $LFS_MIGRATE -y -c 2 "$file1" &> /dev/null ||
6432                         error "migrate failed"
6433                 [ $($LFS getstripe -c "$file1") -eq 2 ] ||
6434                         error "file not restriped to explicit count"
6435                 echo "done."
6436         fi
6437
6438         # File currently set to -S 512K -c 1 or -S 512K -c 2
6439
6440         # Ensure parent striping is used if -R is set, and no stripe
6441         # count or size is specified
6442         echo -n "Setting stripe for parent directory..."
6443         $LFS setstripe -S 1M -c 1 "$DIR/$tdir" &> /dev/null ||
6444                 error "cannot set stripe"
6445         echo "done."
6446
6447         echo -n "Verifying restripe option uses parent stripe settings..."
6448         $LFS_MIGRATE -y -R "$file1" &> /dev/null ||
6449                 error "migrate failed"
6450         [ $($LFS getstripe -S "$file1") -eq $def_stripe_size ] ||
6451                 error "file not restriped to parent settings"
6452         [ $($LFS getstripe -c "$file1") -eq 1 ] ||
6453                 error "file not restriped to parent settings"
6454         echo "done."
6455
6456         # File currently set to -S 1M -c 1
6457
6458         # Ensure striping is preserved if -R is not set, and no stripe
6459         # count or size is specified
6460         echo -n "Verifying striping size preserved when not specified..."
6461         local orig_stripe_size=$($LFS getstripe -S "$file1" 2>/dev/null)
6462         $LFS setstripe -S 2M -c 1 "$DIR/$tdir" &> /dev/null ||
6463                 error "cannot set stripe on parent directory"
6464         $LFS_MIGRATE -y "$file1" &> /dev/null ||
6465                 error "migrate failed"
6466         [ $($LFS getstripe -S "$file1") -eq $orig_stripe_size ] ||
6467                 error "file was restriped"
6468         echo "done."
6469
6470         # Ensure file name properly detected when final option has no argument
6471         echo -n "Verifying file name properly detected..."
6472         $LFS_MIGRATE -y "$file1" &> /dev/null ||
6473                 error "file name interpreted as option argument"
6474         echo "done."
6475
6476         # Clean up
6477         rm -f "$file1"
6478 }
6479 run_test 56wc "check unrecognized options for lfs_migrate are passed through"
6480
6481 test_56wd() {
6482         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
6483
6484         local file1=$DIR/$tdir/file1
6485
6486         echo -n "Creating test dir..."
6487         test_mkdir $DIR/$tdir || error "cannot create dir"
6488         echo "done."
6489
6490         echo -n "Creating test file..."
6491         touch $file1
6492         echo "done."
6493
6494         # Ensure 'lfs migrate' will fail by using a non-existent option,
6495         # and make sure rsync is not called to recover
6496         echo -n "Make sure --no-rsync option works..."
6497         $LFS_MIGRATE -y --no-rsync --invalid-opt $file1 2>&1 |
6498                 grep -q 'refusing to fall back to rsync' ||
6499                 error "rsync was called with --no-rsync set"
6500         echo "done."
6501
6502         # Ensure rsync is called without trying 'lfs migrate' first
6503         echo -n "Make sure --rsync option works..."
6504         $LFS_MIGRATE -y --rsync --invalid-opt $file1 2>&1 |
6505                 grep -q 'falling back to rsync' &&
6506                 error "lfs migrate was called with --rsync set"
6507         echo "done."
6508
6509         echo -n "Make sure --rsync and --no-rsync options are exclusive..."
6510         $LFS_MIGRATE -y --rsync --no-rsync $file1 2>&1 |
6511                 grep -q 'at the same time' ||
6512                 error "--rsync and --no-rsync accepted concurrently"
6513         echo "done."
6514
6515         # Clean up
6516         rm -f $file1
6517 }
6518 run_test 56wd "check lfs_migrate --rsync and --no-rsync work"
6519
6520 test_56x() {
6521         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
6522         check_swap_layouts_support
6523
6524         local dir=$DIR/$tdir
6525         local ref1=/etc/passwd
6526         local file1=$dir/file1
6527
6528         test_mkdir $dir || error "creating dir $dir"
6529         $LFS setstripe -c 2 $file1
6530         cp $ref1 $file1
6531         $LFS migrate -c 1 $file1 || error "migrate failed rc = $?"
6532         stripe=$($LFS getstripe -c $file1)
6533         [[ $stripe == 1 ]] || error "stripe of $file1 is $stripe != 1"
6534         cmp $file1 $ref1 || error "content mismatch $file1 differs from $ref1"
6535
6536         # clean up
6537         rm -f $file1
6538 }
6539 run_test 56x "lfs migration support"
6540
6541 test_56xa() {
6542         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
6543         check_swap_layouts_support
6544
6545         local dir=$DIR/$tdir/$testnum
6546
6547         test_mkdir -p $dir
6548
6549         local ref1=/etc/passwd
6550         local file1=$dir/file1
6551
6552         $LFS setstripe -c 2 $file1
6553         cp $ref1 $file1
6554         $LFS migrate --block -c 1 $file1 || error "migrate failed rc = $?"
6555
6556         local stripe=$($LFS getstripe -c $file1)
6557
6558         [[ $stripe == 1 ]] || error "stripe of $file1 is $stripe != 1"
6559         cmp $file1 $ref1 || error "content mismatch $file1 differs from $ref1"
6560
6561         # clean up
6562         rm -f $file1
6563 }
6564 run_test 56xa "lfs migration --block support"
6565
6566 check_migrate_links() {
6567         local dir="$1"
6568         local file1="$dir/file1"
6569         local begin="$2"
6570         local count="$3"
6571         local total_count=$(($begin + $count - 1))
6572         local symlink_count=10
6573         local uniq_count=10
6574
6575         if [ ! -f "$file1" ]; then
6576                 echo -n "creating initial file..."
6577                 $LFS setstripe -c 1 -S "512k" "$file1" ||
6578                         error "cannot setstripe initial file"
6579                 echo "done"
6580
6581                 echo -n "creating symlinks..."
6582                 for s in $(seq 1 $symlink_count); do
6583                         ln -s "$file1" "$dir/slink$s" ||
6584                                 error "cannot create symlinks"
6585                 done
6586                 echo "done"
6587
6588                 echo -n "creating nonlinked files..."
6589                 createmany -o "$dir/uniq" 1 10 &> /dev/null ||
6590                         error "cannot create nonlinked files"
6591                 echo "done"
6592         fi
6593
6594         # create hard links
6595         if [ ! -f "$dir/file$total_count" ]; then
6596                 echo -n "creating hard links $begin:$total_count..."
6597                 createmany -l"$file1" "$dir/file" "$begin" "$count" &>  \
6598                         /dev/null || error "cannot create hard links"
6599                 echo "done"
6600         fi
6601
6602         echo -n "checking number of hard links listed in xattrs..."
6603         local fid=$($LFS getstripe -F "$file1")
6604         local paths=($($LFS fid2path "$MOUNT" "$fid" 2> /dev/null))
6605
6606         echo "${#paths[*]}"
6607         if [ ${#paths[*]} -lt $total_count -a "$begin" -eq 2  ]; then
6608                         skip "hard link list has unexpected size, skipping test"
6609         fi
6610         if [ ${#paths[*]} -ge $total_count -a "$begin" -ne 2  ]; then
6611                         error "link names should exceed xattrs size"
6612         fi
6613
6614         echo -n "migrating files..."
6615         local migrate_out=$($LFS_MIGRATE -y -S '1m' $dir)
6616         local rc=$?
6617         [ $rc -eq 0 ] || error "migrate failed rc = $rc"
6618         echo "done"
6619
6620         # make sure all links have been properly migrated
6621         echo -n "verifying files..."
6622         fid=$($LFS getstripe -F "$file1") ||
6623                 error "cannot get fid for file $file1"
6624         for i in $(seq 2 $total_count); do
6625                 local fid2=$($LFS getstripe -F $dir/file$i)
6626
6627                 [ "$fid2" == "$fid" ] ||
6628                         error "migrated hard link has mismatched FID"
6629         done
6630
6631         # make sure hard links were properly detected, and migration was
6632         # performed only once for the entire link set; nonlinked files should
6633         # also be migrated
6634         local actual=$(grep -c 'done' <<< "$migrate_out")
6635         local expected=$(($uniq_count + 1))
6636
6637         [ "$actual" -eq  "$expected" ] ||
6638                 error "hard links individually migrated ($actual != $expected)"
6639
6640         # make sure the correct number of hard links are present
6641         local hardlinks=$(stat -c '%h' "$file1")
6642
6643         [ $hardlinks -eq $total_count ] ||
6644                 error "num hard links $hardlinks != $total_count"
6645         echo "done"
6646
6647         return 0
6648 }
6649
6650 test_56xb() {
6651         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
6652                 skip "Need MDS version at least 2.10.55"
6653
6654         local dir="$DIR/$tdir"
6655
6656         test_mkdir "$dir" || error "cannot create dir $dir"
6657
6658         echo "testing lfs migrate mode when all links fit within xattrs"
6659         LFS_MIGRATE_RSYNC_MODE=false check_migrate_links "$dir" 2 99
6660
6661         echo "testing rsync mode when all links fit within xattrs"
6662         LFS_MIGRATE_RSYNC_MODE=true check_migrate_links "$dir" 2 99
6663
6664         echo "testing lfs migrate mode when all links do not fit within xattrs"
6665         LFS_MIGRATE_RSYNC_MODE=false check_migrate_links "$dir" 101 100
6666
6667         echo "testing rsync mode when all links do not fit within xattrs"
6668         LFS_MIGRATE_RSYNC_MODE=true check_migrate_links "$dir" 101 100
6669
6670
6671         # clean up
6672         rm -rf $dir
6673 }
6674 run_test 56xb "lfs migration hard link support"
6675
6676 test_56xc() {
6677         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
6678
6679         local dir="$DIR/$tdir"
6680
6681         test_mkdir "$dir" || error "cannot create dir $dir"
6682
6683         # Test 1: ensure file < 1 GB is always migrated with 1 stripe
6684         echo -n "Setting initial stripe for 20MB test file..."
6685         $LFS setstripe -c 2 -i 0 "$dir/20mb" ||
6686                 error "cannot setstripe 20MB file"
6687         echo "done"
6688         echo -n "Sizing 20MB test file..."
6689         truncate "$dir/20mb" 20971520 || error "cannot create 20MB test file"
6690         echo "done"
6691         echo -n "Verifying small file autostripe count is 1..."
6692         $LFS_MIGRATE -y -A -C 1 "$dir/20mb" ||
6693                 error "cannot migrate 20MB file"
6694         local stripe_count=$($LFS getstripe -c "$dir/20mb") ||
6695                 error "cannot get stripe for $dir/20mb"
6696         [ $stripe_count -eq 1 ] ||
6697                 error "unexpected stripe count $stripe_count for 20MB file"
6698         rm -f "$dir/20mb"
6699         echo "done"
6700
6701         # Test 2: File is small enough to fit within the available space on
6702         # sqrt(size_in_gb) + 1 OSTs but is larger than 1GB.  The file must
6703         # have at least an additional 1KB for each desired stripe for test 3
6704         echo -n "Setting stripe for 1GB test file..."
6705         $LFS setstripe -c 1 -i 0 "$dir/1gb" || error "cannot setstripe 1GB file"
6706         echo "done"
6707         echo -n "Sizing 1GB test file..."
6708         # File size is 1GB + 3KB
6709         truncate "$dir/1gb" 1073744896 || error "cannot create 1GB test file"
6710         echo "done"
6711
6712         # need at least 512MB per OST for 1GB file to fit in 2 stripes
6713         local avail=$($LCTL get_param -n llite.$FSNAME*.kbytesavail)
6714         if (( avail > 524288 * OSTCOUNT )); then
6715                 echo -n "Migrating 1GB file..."
6716                 $LFS_MIGRATE -y -A -C 1 "$dir/1gb" ||
6717                         error "cannot migrate 1GB file"
6718                 echo "done"
6719                 echo -n "Verifying autostripe count is sqrt(n) + 1..."
6720                 stripe_count=$($LFS getstripe -c "$dir/1gb") ||
6721                         error "cannot getstripe for 1GB file"
6722                 [ $stripe_count -eq 2 ] ||
6723                         error "unexpected stripe count $stripe_count != 2"
6724                 echo "done"
6725         fi
6726
6727         # Test 3: File is too large to fit within the available space on
6728         # sqrt(n) + 1 OSTs.  Simulate limited available space with -X
6729         if [ $OSTCOUNT -ge 3 ]; then
6730                 # The required available space is calculated as
6731                 # file size (1GB + 3KB) / OST count (3).
6732                 local kb_per_ost=349526
6733
6734                 echo -n "Migrating 1GB file with limit..."
6735                 $LFS_MIGRATE -y -A -C 1 -X $kb_per_ost "$dir/1gb" ||
6736                         error "cannot migrate 1GB file with limit"
6737                 echo "done"
6738
6739                 stripe_count=$($LFS getstripe -c "$dir/1gb")
6740                 echo -n "Verifying 1GB autostripe count with limited space..."
6741                 [ "$stripe_count" -a $stripe_count -ge 3 ] ||
6742                         error "unexpected stripe count $stripe_count (min 3)"
6743                 echo "done"
6744         fi
6745
6746         # clean up
6747         rm -rf $dir
6748 }
6749 run_test 56xc "lfs migration autostripe"
6750
6751 test_56y() {
6752         [ $MDS1_VERSION -lt $(version_code 2.4.53) ] &&
6753                 skip "No HSM $(lustre_build_version $SINGLEMDS) MDS < 2.4.53"
6754
6755         local res=""
6756         local dir=$DIR/$tdir
6757         local f1=$dir/file1
6758         local f2=$dir/file2
6759
6760         test_mkdir -p $dir || error "creating dir $dir"
6761         touch $f1 || error "creating std file $f1"
6762         $MULTIOP $f2 H2c || error "creating released file $f2"
6763
6764         # a directory can be raid0, so ask only for files
6765         res=$($LFS find $dir -L raid0 -type f | wc -l)
6766         [[ $res == 2 ]] || error "search raid0: found $res files != 2"
6767
6768         res=$($LFS find $dir \! -L raid0 -type f | wc -l)
6769         [[ $res == 0 ]] || error "search !raid0: found $res files != 0"
6770
6771         # only files can be released, so no need to force file search
6772         res=$($LFS find $dir -L released)
6773         [[ $res == $f2 ]] || error "search released: found $res != $f2"
6774
6775         res=$($LFS find $dir -type f \! -L released)
6776         [[ $res == $f1 ]] || error "search !released: found $res != $f1"
6777 }
6778 run_test 56y "lfs find -L raid0|released"
6779
6780 test_56z() { # LU-4824
6781         # This checks to make sure 'lfs find' continues after errors
6782         # There are two classes of errors that should be caught:
6783         # - If multiple paths are provided, all should be searched even if one
6784         #   errors out
6785         # - If errors are encountered during the search, it should not terminate
6786         #   early
6787         local dir=$DIR/$tdir
6788         local i
6789
6790         test_mkdir $dir
6791         for i in d{0..9}; do
6792                 test_mkdir $dir/$i
6793                 touch $dir/$i/$tfile
6794         done
6795         $LFS find $DIR/non_existent_dir $dir &&
6796                 error "$LFS find did not return an error"
6797         # Make a directory unsearchable. This should NOT be the last entry in
6798         # directory order.  Arbitrarily pick the 6th entry
6799         chmod 700 $($LFS find $dir -type d | sed '6!d')
6800
6801         $RUNAS $LFS find $DIR/non_existent $dir
6802         local count=$($RUNAS $LFS find $DIR/non_existent $dir | wc -l)
6803
6804         # The user should be able to see 10 directories and 9 files
6805         (( count == 19 )) ||
6806                 error "$LFS find found $count != 19 entries after error"
6807 }
6808 run_test 56z "lfs find should continue after an error"
6809
6810 test_56aa() { # LU-5937
6811         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
6812
6813         local dir=$DIR/$tdir
6814
6815         mkdir $dir
6816         $LFS setdirstripe -c$MDSCOUNT $dir/striped_dir
6817
6818         createmany -o $dir/striped_dir/${tfile}- 1024
6819         local dirs=$($LFS find --size +8k $dir/)
6820
6821         [ -n "$dirs" ] || error "lfs find --size wrong under striped dir"
6822 }
6823 run_test 56aa "lfs find --size under striped dir"
6824
6825 test_56ab() { # LU-10705
6826         test_mkdir $DIR/$tdir
6827         dd if=/dev/zero of=$DIR/$tdir/$tfile.1 bs=8k count=1 seek=2k
6828         dd if=/dev/zero of=$DIR/$tdir/$tfile.2 bs=4k count=1 seek=4k
6829         dd if=/dev/zero of=$DIR/$tdir/$tfile.3 bs=1M count=2 seek=16
6830         # Flush writes to ensure valid blocks.  Need to be more thorough for
6831         # ZFS, since blocks are not allocated/returned to client immediately.
6832         sync_all_data
6833         wait_zfs_commit ost1 2
6834         cancel_lru_locks osc
6835         ls -ls $DIR/$tdir
6836
6837         local files=$($LFS find --size +16M $DIR/$tdir | wc -l)
6838
6839         [[ $files == 3 ]] || error ">16M size files $files isn't 3 as expected"
6840
6841         files=$($LFS find --blocks +1M $DIR/$tdir | wc -l)
6842         [[ $files == 1 ]] || error ">1M blocks files $files isn't 1 as expected"
6843
6844         rm -f $DIR/$tdir/$tfile.[123]
6845 }
6846 run_test 56ab "lfs find --blocks"
6847
6848 test_56ba() {
6849         [ $MDS1_VERSION -lt $(version_code 2.10.50) ] &&
6850                 skip "Need MDS version at least 2.10.50"
6851
6852         # Create composite files with one component
6853         local dir=$DIR/$tdir
6854
6855         setup_56 $dir/1Mfiles 5 1 "-S 1M --component-end 1M"
6856         # Create composite files with three components
6857         setup_56 $dir/2Mfiles 5 2 "-E 2M -S 1M -E 4M -E 6M"
6858         # Create non-composite files
6859         createmany -o $dir/${tfile}- 10
6860
6861         local nfiles=$($LFS find --component-end 1M --type f $dir | wc -l)
6862
6863         [[ $nfiles == 10 ]] ||
6864                 error "lfs find -E 1M found $nfiles != 10 files"
6865
6866         nfiles=$($LFS find ! -E 1M --type f $dir | wc -l)
6867         [[ $nfiles == 25 ]] ||
6868                 error "lfs find ! -E 1M found $nfiles != 25 files"
6869
6870         # All files have a component that starts at 0
6871         nfiles=$($LFS find --component-start 0 --type f $dir | wc -l)
6872         [[ $nfiles == 35 ]] ||
6873                 error "lfs find --component-start 0 - $nfiles != 35 files"
6874
6875         nfiles=$($LFS find --component-start 2M --type f $dir | wc -l)
6876         [[ $nfiles == 15 ]] ||
6877                 error "lfs find --component-start 2M - $nfiles != 15 files"
6878
6879         # All files created here have a componenet that does not starts at 2M
6880         nfiles=$($LFS find ! --component-start 2M --type f $dir | wc -l)
6881         [[ $nfiles == 35 ]] ||
6882                 error "lfs find ! --component-start 2M - $nfiles != 35 files"
6883
6884         # Find files with a specified number of components
6885         local nfiles=$($LFS find --component-count 3 --type f $dir | wc -l)
6886         [[ $nfiles == 15 ]] ||
6887                 error "lfs find --component-count 3 - $nfiles != 15 files"
6888
6889         # Remember non-composite files have a component count of zero
6890         local nfiles=$($LFS find --component-count 0 --type f $dir | wc -l)
6891         [[ $nfiles == 10 ]] ||
6892                 error "lfs find --component-count 0 - $nfiles != 10 files"
6893
6894         nfiles=$($LFS find ! --component-count 3 --type f $dir | wc -l)
6895         [[ $nfiles == 20 ]] ||
6896                 error "lfs find ! --component-count 3 - $nfiles != 20 files"
6897
6898         # All files have a flag called "init"
6899         local nfiles=$($LFS find --component-flags init --type f $dir | wc -l)
6900         [[ $nfiles == 35 ]] ||
6901                 error "lfs find --component-flags init - $nfiles != 35 files"
6902
6903         # Multi-component files will have a component not initialized
6904         local nfiles=$($LFS find ! --component-flags init --type f $dir | wc -l)
6905         [[ $nfiles == 15 ]] ||
6906                 error "lfs find !--component-flags init - $nfiles != 15 files"
6907
6908         rm -rf $dir
6909
6910 }
6911 run_test 56ba "test lfs find --component-end, -start, -count, and -flags"
6912
6913 test_56ca() {
6914         [[ $MDS1_VERSION -ge $(version_code 2.10.57) ]] ||
6915                 skip "Need MDS version at least 2.10.57"
6916
6917         local td=$DIR/$tdir
6918         local tf=$td/$tfile
6919         local dir
6920         local nfiles
6921         local cmd
6922         local i
6923         local j
6924
6925         # create mirrored directories and mirrored files
6926         mkdir $td || error "mkdir $td failed"
6927         $LFS mirror create -N3 $td || error "create mirrored dir $td failed"
6928         createmany -o $tf- 10 || error "create $tf- failed"
6929
6930         for i in $(seq 2); do
6931                 dir=$td/dir$i
6932                 mkdir $dir || error "mkdir $dir failed"
6933                 $LFS mirror create -N$((3 + i)) $dir ||
6934                         error "create mirrored dir $dir failed"
6935                 createmany -o $dir/$tfile- 10 ||
6936                         error "create $dir/$tfile- failed"
6937         done
6938
6939         # change the states of some mirrored files
6940         echo foo > $tf-6
6941         for i in $(seq 2); do
6942                 dir=$td/dir$i
6943                 for j in $(seq 4 9); do
6944                         echo foo > $dir/$tfile-$j
6945                 done
6946         done
6947
6948         # find mirrored files with specific mirror count
6949         cmd="$LFS find --mirror-count 3 --type f $td"
6950         nfiles=$($cmd | wc -l)
6951         [[ $nfiles = 10 ]] || error "$cmd: $nfiles != 10 files"
6952
6953         cmd="$LFS find ! --mirror-count 3 --type f $td"
6954         nfiles=$($cmd | wc -l)
6955         [[ $nfiles = 20 ]] || error "$cmd: $nfiles != 20 files"
6956
6957         cmd="$LFS find --mirror-count +2 --type f $td"
6958         nfiles=$($cmd | wc -l)
6959         [[ $nfiles = 30 ]] || error "$cmd: $nfiles != 30 files"
6960
6961         cmd="$LFS find --mirror-count -6 --type f $td"
6962         nfiles=$($cmd | wc -l)
6963         [[ $nfiles = 30 ]] || error "$cmd: $nfiles != 30 files"
6964
6965         # find mirrored files with specific file state
6966         cmd="$LFS find --maxdepth 1 --mirror-state=^ro --type f $td"
6967         [[ $($cmd) = $tf-6 ]] || error "$cmd: didn't return $tf-6"
6968
6969         cmd="$LFS find --mirror-state=ro --type f $td"
6970         nfiles=$($cmd | wc -l)
6971         [[ $nfiles = 17 ]] || error "$cmd: $nfiles != 17 files"
6972
6973         cmd="$LFS find ! --mirror-state=ro --type f $td"
6974         nfiles=$($cmd | wc -l)
6975         [[ $nfiles = 13 ]] || error "$cmd: $nfiles != 13 files"
6976
6977         cmd="$LFS find --mirror-state=wp --type f $td"
6978         nfiles=$($cmd | wc -l)
6979         [[ $nfiles = 13 ]] || error "$cmd: $nfiles != 13 files"
6980
6981         cmd="$LFS find ! --mirror-state=sp --type f $td"
6982         nfiles=$($cmd | wc -l)
6983         [[ $nfiles = 30 ]] || error "$cmd: $nfiles != 30 files"
6984 }
6985 run_test 56ca "check lfs find --mirror-count|-N and --mirror-state"
6986
6987 test_57a() {
6988         [ $PARALLEL == "yes" ] && skip "skip parallel run"
6989         # note test will not do anything if MDS is not local
6990         if [ "$mds1_FSTYPE" != ldiskfs ]; then
6991                 skip_env "ldiskfs only test"
6992         fi
6993         remote_mds_nodsh && skip "remote MDS with nodsh"
6994
6995         local MNTDEV="osd*.*MDT*.mntdev"
6996         DEV=$(do_facet $SINGLEMDS lctl get_param -n $MNTDEV)
6997         [ -z "$DEV" ] && error "can't access $MNTDEV"
6998         for DEV in $(do_facet $SINGLEMDS lctl get_param -n $MNTDEV); do
6999                 do_facet $SINGLEMDS $DUMPE2FS -h $DEV > $TMP/t57a.dump ||
7000                         error "can't access $DEV"
7001                 DEVISIZE=$(awk '/Inode size:/ { print $3 }' $TMP/t57a.dump)
7002                 [[ $DEVISIZE -gt 128 ]] || error "inode size $DEVISIZE"
7003                 rm $TMP/t57a.dump
7004         done
7005 }
7006 run_test 57a "verify MDS filesystem created with large inodes =="
7007
7008 test_57b() {
7009         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7010         if [ "$mds1_FSTYPE" != ldiskfs ]; then
7011                 skip_env "ldiskfs only test"
7012         fi
7013         remote_mds_nodsh && skip "remote MDS with nodsh"
7014
7015         local dir=$DIR/$tdir
7016         local filecount=100
7017         local file1=$dir/f1
7018         local fileN=$dir/f$filecount
7019
7020         rm -rf $dir || error "removing $dir"
7021         test_mkdir -c1 $dir
7022         local mdtidx=$($LFS getstripe -m $dir)
7023         local mdtname=MDT$(printf %04x $mdtidx)
7024         local facet=mds$((mdtidx + 1))
7025
7026         echo "mcreating $filecount files"
7027         createmany -m $dir/f 1 $filecount || error "creating files in $dir"
7028
7029         # verify that files do not have EAs yet
7030         $LFS getstripe $file1 2>&1 | grep -q "no stripe" ||
7031                 error "$file1 has an EA"
7032         $LFS getstripe $fileN 2>&1 | grep -q "no stripe" ||
7033                 error "$fileN has an EA"
7034
7035         sync
7036         sleep 1
7037         df $dir  #make sure we get new statfs data
7038         local mdsfree=$(do_facet $facet \
7039                         lctl get_param -n osd*.*$mdtname.kbytesfree)
7040         local mdcfree=$(lctl get_param -n mdc.*$mdtname-mdc-*.kbytesfree)
7041         local file
7042
7043         echo "opening files to create objects/EAs"
7044         for file in $(seq -f $dir/f%g 1 $filecount); do
7045                 $OPENFILE -f O_RDWR $file > /dev/null 2>&1 ||
7046                         error "opening $file"
7047         done
7048
7049         # verify that files have EAs now
7050         $LFS getstripe $file1 | grep -q "obdidx" || error "$file1 missing EA"
7051         $LFS getstripe $fileN | grep -q "obdidx" || error "$fileN missing EA"
7052
7053         sleep 1  #make sure we get new statfs data
7054         df $dir
7055         local mdsfree2=$(do_facet $facet \
7056                          lctl get_param -n osd*.*$mdtname.kbytesfree)
7057         local mdcfree2=$(lctl get_param -n mdc.*$mdtname-mdc-*.kbytesfree)
7058
7059         if [[ $mdcfree2 -lt $((mdcfree - 16)) ]]; then
7060                 if [ "$mdsfree" != "$mdsfree2" ]; then
7061                         error "MDC before $mdcfree != after $mdcfree2"
7062                 else
7063                         echo "MDC before $mdcfree != after $mdcfree2"
7064                         echo "unable to confirm if MDS has large inodes"
7065                 fi
7066         fi
7067         rm -rf $dir
7068 }
7069 run_test 57b "default LOV EAs are stored inside large inodes ==="
7070
7071 test_58() {
7072         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7073         [ -z "$(which wiretest 2>/dev/null)" ] &&
7074                         skip_env "could not find wiretest"
7075
7076         wiretest
7077 }
7078 run_test 58 "verify cross-platform wire constants =============="
7079
7080 test_59() {
7081         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7082
7083         echo "touch 130 files"
7084         createmany -o $DIR/f59- 130
7085         echo "rm 130 files"
7086         unlinkmany $DIR/f59- 130
7087         sync
7088         # wait for commitment of removal
7089         wait_delete_completed
7090 }
7091 run_test 59 "verify cancellation of llog records async ========="
7092
7093 TEST60_HEAD="test_60 run $RANDOM"
7094 test_60a() {
7095         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7096         remote_mgs_nodsh && skip "remote MGS with nodsh"
7097         do_facet mgs "! which run-llog.sh &> /dev/null" &&
7098                 do_facet mgs "! ls run-llog.sh &> /dev/null" &&
7099                         skip_env "missing subtest run-llog.sh"
7100
7101         log "$TEST60_HEAD - from kernel mode"
7102         do_facet mgs "$LCTL dk > /dev/null"
7103         do_facet mgs "bash run-llog.sh" || error "run-llog.sh failed"
7104         do_facet mgs $LCTL dk > $TMP/$tfile
7105
7106         # LU-6388: test llog_reader
7107         local llog_reader=$(do_facet mgs "which llog_reader 2> /dev/null")
7108         llog_reader=${llog_reader:-$LUSTRE/utils/llog_reader}
7109         [ -z $(do_facet mgs ls -d $llog_reader 2> /dev/null) ] &&
7110                         skip_env "missing llog_reader"
7111         local fstype=$(facet_fstype mgs)
7112         [ $fstype != ldiskfs -a $fstype != zfs ] &&
7113                 skip_env "Only for ldiskfs or zfs type mgs"
7114
7115         local mntpt=$(facet_mntpt mgs)
7116         local mgsdev=$(mgsdevname 1)
7117         local fid_list
7118         local fid
7119         local rec_list
7120         local rec
7121         local rec_type
7122         local obj_file
7123         local path
7124         local seq
7125         local oid
7126         local pass=true
7127
7128         #get fid and record list
7129         fid_list=($(awk '/9_sub.*record/ { print $NF }' $TMP/$tfile |
7130                 tail -n 4))
7131         rec_list=($(awk '/9_sub.*record/ { print $((NF-3)) }' $TMP/$tfile |
7132                 tail -n 4))
7133         #remount mgs as ldiskfs or zfs type
7134         stop mgs || error "stop mgs failed"
7135         mount_fstype mgs || error "remount mgs failed"
7136         for ((i = 0; i < ${#fid_list[@]}; i++)); do
7137                 fid=${fid_list[i]}
7138                 rec=${rec_list[i]}
7139                 seq=$(echo $fid | awk -F ':' '{ print $1 }' | sed -e "s/^0x//g")
7140                 oid=$(echo $fid | awk -F ':' '{ print $2 }' | sed -e "s/^0x//g")
7141                 oid=$((16#$oid))
7142
7143                 case $fstype in
7144                         ldiskfs )
7145                                 obj_file=$mntpt/O/$seq/d$((oid%32))/$oid ;;
7146                         zfs )
7147                                 obj_file=$mntpt/oi.$(($((16#$seq))&127))/$fid ;;
7148                 esac
7149                 echo "obj_file is $obj_file"
7150                 do_facet mgs $llog_reader $obj_file
7151
7152                 rec_type=$(do_facet mgs $llog_reader $obj_file | grep "type=" |
7153                         awk '{ print $3 }' | sed -e "s/^type=//g")
7154                 if [ $rec_type != $rec ]; then
7155                         echo "FAILED test_60a wrong record type $rec_type," \
7156                               "should be $rec"
7157                         pass=false
7158                         break
7159                 fi
7160
7161                 #check obj path if record type is LLOG_LOGID_MAGIC
7162                 if [ "$rec" == "1064553b" ]; then
7163                         path=$(do_facet mgs $llog_reader $obj_file |
7164                                 grep "path=" | awk '{ print $NF }' |
7165                                 sed -e "s/^path=//g")
7166                         if [ $obj_file != $mntpt/$path ]; then
7167                                 echo "FAILED test_60a wrong obj path" \
7168                                       "$montpt/$path, should be $obj_file"
7169                                 pass=false
7170                                 break
7171                         fi
7172                 fi
7173         done
7174         rm -f $TMP/$tfile
7175         #restart mgs before "error", otherwise it will block the next test
7176         stop mgs || error "stop mgs failed"
7177         start mgs $(mgsdevname) $MGS_MOUNT_OPTS || error "start mgs failed"
7178         $pass || error "test failed, see FAILED test_60a messages for specifics"
7179 }
7180 run_test 60a "llog_test run from kernel module and test llog_reader"
7181
7182 test_60b() { # bug 6411
7183         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7184
7185         dmesg > $DIR/$tfile
7186         LLOG_COUNT=$(do_facet mgs dmesg |
7187                      awk "/$TEST60_HEAD/ { marker = 1; from_marker = 0; }
7188                           /llog_[a-z]*.c:[0-9]/ {
7189                                 if (marker)
7190                                         from_marker++
7191                                 from_begin++
7192                           }
7193                           END {
7194                                 if (marker)
7195                                         print from_marker
7196                                 else
7197                                         print from_begin
7198                           }")
7199
7200         [[ $LLOG_COUNT -gt 120 ]] &&
7201                 error "CDEBUG_LIMIT not limiting messages ($LLOG_COUNT)" || true
7202 }
7203 run_test 60b "limit repeated messages from CERROR/CWARN"
7204
7205 test_60c() {
7206         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7207
7208         echo "create 5000 files"
7209         createmany -o $DIR/f60c- 5000
7210 #define OBD_FAIL_MDS_LLOG_CREATE_FAILED  0x137
7211         lctl set_param fail_loc=0x80000137
7212         unlinkmany $DIR/f60c- 5000
7213         lctl set_param fail_loc=0
7214 }
7215 run_test 60c "unlink file when mds full"
7216
7217 test_60d() {
7218         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7219
7220         SAVEPRINTK=$(lctl get_param -n printk)
7221         # verify "lctl mark" is even working"
7222         MESSAGE="test message ID $RANDOM $$"
7223         $LCTL mark "$MESSAGE" || error "$LCTL mark failed"
7224         dmesg | grep -q "$MESSAGE" || error "didn't find debug marker in log"
7225
7226         lctl set_param printk=0 || error "set lnet.printk failed"
7227         lctl get_param -n printk | grep emerg || error "lnet.printk dropped emerg"
7228         MESSAGE="new test message ID $RANDOM $$"
7229         # Assume here that libcfs_debug_mark_buffer() uses D_WARNING
7230         $LCTL mark "$MESSAGE" || error "$LCTL mark failed"
7231         dmesg | grep -q "$MESSAGE" && error "D_WARNING wasn't masked" || true
7232
7233         lctl set_param -n printk="$SAVEPRINTK"
7234 }
7235 run_test 60d "test printk console message masking"
7236
7237 test_60e() {
7238         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7239         remote_mds_nodsh && skip "remote MDS with nodsh"
7240
7241         touch $DIR/$tfile
7242 #define OBD_FAIL_MDS_LLOG_CREATE_FAILED2  0x15b
7243         do_facet mds1 lctl set_param fail_loc=0x15b
7244         rm $DIR/$tfile
7245 }
7246 run_test 60e "no space while new llog is being created"
7247
7248 test_60g() {
7249         local pid
7250         local i
7251
7252         test_mkdir -c $MDSCOUNT $DIR/$tdir
7253
7254         (
7255                 local index=0
7256                 while true; do
7257                         $LFS setdirstripe -i $(($index % $MDSCOUNT)) \
7258                                 -c $MDSCOUNT $DIR/$tdir/subdir$index \
7259                                 2>/dev/null
7260                         mkdir $DIR/$tdir/subdir$index 2>/dev/null
7261                         rmdir $DIR/$tdir/subdir$index 2>/dev/null
7262                         index=$((index + 1))
7263                 done
7264         ) &
7265
7266         pid=$!
7267
7268         for i in {0..100}; do
7269                 # define OBD_FAIL_OSD_TXN_START    0x19a
7270                 local index=$((i % MDSCOUNT + 1))
7271
7272                 do_facet mds$index $LCTL set_param fail_loc=0x8000019a \
7273                         > /dev/null
7274                 usleep 100
7275         done
7276
7277         kill -9 $pid
7278
7279         for i in $(seq $MDSCOUNT); do
7280                 do_facet mds$i $LCTL set_param fail_loc=0 > /dev/null
7281         done
7282
7283         mkdir $DIR/$tdir/new || error "mkdir failed"
7284         rmdir $DIR/$tdir/new || error "rmdir failed"
7285
7286         do_facet mds1 $LCTL lfsck_start -M $(facet_svc mds1) -A -C \
7287                 -t namespace
7288         for i in $(seq $MDSCOUNT); do
7289                 wait_update_facet mds$i "$LCTL get_param -n \
7290                         mdd.$(facet_svc mds$i).lfsck_namespace |
7291                         awk '/^status/ { print \\\$2 }'" "completed"
7292         done
7293
7294         ls -R $DIR/$tdir || error "ls failed"
7295         rm -rf $DIR/$tdir || error "rmdir failed"
7296 }
7297 run_test 60g "transaction abort won't cause MDT hung"
7298
7299 test_60h() {
7300         [ $MDS1_VERSION -le $(version_code 2.12.52) ] &&
7301                 skip "Need MDS version at least 2.12.52"
7302         [ $MDSCOUNT -lt 2 ] && skip "Need at least 2 MDTs"
7303
7304         local f
7305
7306         #define OBD_FAIL_MDS_STRIPE_CREATE       0x188
7307         #define OBD_FAIL_MDS_STRIPE_FID          0x189
7308         for fail_loc in 0x80000188 0x80000189; do
7309                 do_facet mds1 "$LCTL set_param fail_loc=$fail_loc"
7310                 $LFS mkdir -c $MDSCOUNT -i 0 $DIR/$tdir-$fail_loc ||
7311                         error "mkdir $dir-$fail_loc failed"
7312                 for i in {0..10}; do
7313                         # create may fail on missing stripe
7314                         echo $i > $DIR/$tdir-$fail_loc/$i
7315                 done
7316                 $LFS getdirstripe $DIR/$tdir-$fail_loc ||
7317                         error "getdirstripe $tdir-$fail_loc failed"
7318                 $LFS migrate -m 1 $DIR/$tdir-$fail_loc ||
7319                         error "migrate $tdir-$fail_loc failed"
7320                 $LFS getdirstripe $DIR/$tdir-$fail_loc ||
7321                         error "getdirstripe $tdir-$fail_loc failed"
7322                 pushd $DIR/$tdir-$fail_loc
7323                 for f in *; do
7324                         echo $f | cmp $f - || error "$f data mismatch"
7325                 done
7326                 popd
7327                 rm -rf $DIR/$tdir-$fail_loc
7328         done
7329 }
7330 run_test 60h "striped directory with missing stripes can be accessed"
7331
7332 test_61a() {
7333         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7334
7335         f="$DIR/f61"
7336         dd if=/dev/zero of=$f bs=$PAGE_SIZE count=1 || error "dd $f failed"
7337         cancel_lru_locks osc
7338         $MULTIOP $f OSMWUc || error "$MULTIOP $f failed"
7339         sync
7340 }
7341 run_test 61a "mmap() writes don't make sync hang ================"
7342
7343 test_61b() {
7344         mmap_mknod_test $DIR/$tfile || error "mmap_mknod_test failed"
7345 }
7346 run_test 61b "mmap() of unstriped file is successful"
7347
7348 # bug 2330 - insufficient obd_match error checking causes LBUG
7349 test_62() {
7350         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7351
7352         f="$DIR/f62"
7353         echo foo > $f
7354         cancel_lru_locks osc
7355         lctl set_param fail_loc=0x405
7356         cat $f && error "cat succeeded, expect -EIO"
7357         lctl set_param fail_loc=0
7358 }
7359 # This test is now irrelevant (as of bug 10718 inclusion), we no longer
7360 # match every page all of the time.
7361 #run_test 62 "verify obd_match failure doesn't LBUG (should -EIO)"
7362
7363 # bug 2319 - oig_wait() interrupted causes crash because of invalid waitq.
7364 # Though this test is irrelevant anymore, it helped to reveal some
7365 # other grant bugs (LU-4482), let's keep it.
7366 test_63a() {   # was test_63
7367         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7368
7369         MAX_DIRTY_MB=$(lctl get_param -n osc.*.max_dirty_mb | head -n 1)
7370
7371         for i in `seq 10` ; do
7372                 dd if=/dev/zero of=$DIR/f63 bs=8k &
7373                 sleep 5
7374                 kill $!
7375                 sleep 1
7376         done
7377
7378         rm -f $DIR/f63 || true
7379 }
7380 run_test 63a "Verify oig_wait interruption does not crash ======="
7381
7382 # bug 2248 - async write errors didn't return to application on sync
7383 # bug 3677 - async write errors left page locked
7384 test_63b() {
7385         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7386
7387         debugsave
7388         lctl set_param debug=-1
7389
7390         # ensure we have a grant to do async writes
7391         dd if=/dev/zero of=$DIR/$tfile bs=4k count=1
7392         rm $DIR/$tfile
7393
7394         sync    # sync lest earlier test intercept the fail_loc
7395
7396         #define OBD_FAIL_OSC_BRW_PREP_REQ        0x406
7397         lctl set_param fail_loc=0x80000406
7398         $MULTIOP $DIR/$tfile Owy && \
7399                 error "sync didn't return ENOMEM"
7400         sync; sleep 2; sync     # do a real sync this time to flush page
7401         lctl get_param -n llite.*.dump_page_cache | grep locked && \
7402                 error "locked page left in cache after async error" || true
7403         debugrestore
7404 }
7405 run_test 63b "async write errors should be returned to fsync ==="
7406
7407 test_64a () {
7408         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7409
7410         df $DIR
7411         lctl get_param -n osc.*[oO][sS][cC][_-]*.cur* | grep "[0-9]"
7412 }
7413 run_test 64a "verify filter grant calculations (in kernel) ====="
7414
7415 test_64b () {
7416         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7417
7418         sh oos.sh $MOUNT || error "oos.sh failed: $?"
7419 }
7420 run_test 64b "check out-of-space detection on client"
7421
7422 test_64c() {
7423         $LCTL set_param osc.*OST0000-osc-[^mM]*.cur_grant_bytes=0
7424 }
7425 run_test 64c "verify grant shrink"
7426
7427 # this does exactly what osc_request.c:osc_announce_cached() does in
7428 # order to calculate max amount of grants to ask from server
7429 want_grant() {
7430         local tgt=$1
7431
7432         local nrpages=$($LCTL get_param -n osc.${tgt}.max_pages_per_rpc)
7433         local rpc_in_flight=$($LCTL get_param -n osc.${tgt}.max_rpcs_in_flight)
7434
7435         ((rpc_in_flight ++));
7436         nrpages=$((nrpages * rpc_in_flight))
7437
7438         local dirty_max_pages=$($LCTL get_param -n osc.${tgt}.max_dirty_mb)
7439
7440         dirty_max_pages=$((dirty_max_pages * 1024 * 1024 / PAGE_SIZE))
7441
7442         [[ $dirty_max_pages -gt $nrpages ]] && nrpages=$dirty_max_pages
7443         local undirty=$((nrpages * PAGE_SIZE))
7444
7445         local max_extent_pages
7446         max_extent_pages=$($LCTL get_param osc.${tgt}.import |
7447             grep grant_max_extent_size | awk '{print $2}')
7448         max_extent_pages=$((max_extent_pages / PAGE_SIZE))
7449         local nrextents=$(((nrpages + max_extent_pages - 1) / max_extent_pages))
7450         local grant_extent_tax
7451         grant_extent_tax=$($LCTL get_param osc.${tgt}.import |
7452             grep grant_extent_tax | awk '{print $2}')
7453
7454         undirty=$((undirty + nrextents * grant_extent_tax))
7455
7456         echo $undirty
7457 }
7458
7459 # this is size of unit for grant allocation. It should be equal to
7460 # what tgt_grant.c:tgt_grant_chunk() calculates
7461 grant_chunk() {
7462         local tgt=$1
7463         local max_brw_size
7464         local grant_extent_tax
7465
7466         max_brw_size=$($LCTL get_param osc.${tgt}.import |
7467             grep max_brw_size | awk '{print $2}')
7468
7469         grant_extent_tax=$($LCTL get_param osc.${tgt}.import |
7470             grep grant_extent_tax | awk '{print $2}')
7471
7472         echo $(((max_brw_size + grant_extent_tax) * 2))
7473 }
7474
7475 test_64d() {
7476         [ $OST1_VERSION -lt $(version_code 2.10.56) ] &&
7477                 skip "OST < 2.10.55 doesn't limit grants enough"
7478
7479         local tgt=$($LCTL dl | grep "0000-osc-[^mM]" | awk '{print $4}')
7480         local file=$DIR/$tfile
7481
7482         [[ $($LCTL get_param osc.${tgt}.import |
7483              grep "connect_flags:.*grant_param") ]] ||
7484                 skip "no grant_param connect flag"
7485
7486         local olddebug=$($LCTL get_param -n debug 2> /dev/null)
7487
7488         $LCTL set_param debug="$OLDDEBUG" 2> /dev/null || true
7489
7490         local max_cur_granted=$(($(want_grant $tgt) + $(grant_chunk $tgt)))
7491         stack_trap "rm -f $file" EXIT
7492
7493         $LFS setstripe $file -i 0 -c 1
7494         dd if=/dev/zero of=$file bs=1M count=1000 &
7495         ddpid=$!
7496
7497         while true
7498         do
7499                 local cur_grant=$($LCTL get_param -n osc.${tgt}.cur_grant_bytes)
7500                 if [[ $cur_grant -gt $max_cur_granted ]]
7501                 then
7502                         kill $ddpid
7503                         error "cur_grant $cur_grant > $max_cur_granted"
7504                 fi
7505                 kill -0 $ddpid
7506                 [[ $? -ne 0 ]] && break;
7507                 sleep 2
7508         done
7509
7510         rm -f $DIR/$tfile
7511         wait_delete_completed
7512         $LCTL set_param debug="$olddebug" 2> /dev/null || true
7513 }
7514 run_test 64d "check grant limit exceed"
7515
7516 # bug 1414 - set/get directories' stripe info
7517 test_65a() {
7518         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7519
7520         test_mkdir $DIR/$tdir
7521         touch $DIR/$tdir/f1
7522         $LVERIFY $DIR/$tdir $DIR/$tdir/f1 || error "lverify failed"
7523 }
7524 run_test 65a "directory with no stripe info"
7525
7526 test_65b() {
7527         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7528
7529         test_mkdir $DIR/$tdir
7530         local STRIPESIZE=$($LFS getstripe -S $DIR/$tdir)
7531
7532         $LFS setstripe -S $((STRIPESIZE * 2)) -i 0 -c 1 $DIR/$tdir ||
7533                                                 error "setstripe"
7534         touch $DIR/$tdir/f2
7535         $LVERIFY $DIR/$tdir $DIR/$tdir/f2 || error "lverify failed"
7536 }
7537 run_test 65b "directory setstripe -S stripe_size*2 -i 0 -c 1"
7538
7539 test_65c() {
7540         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7541         [ $OSTCOUNT -lt 2 ] && skip_env "need at least 2 OSTs"
7542
7543         test_mkdir $DIR/$tdir
7544         local stripesize=$($LFS getstripe -S $DIR/$tdir)
7545
7546         $LFS setstripe -S $((stripesize * 4)) -i 1 \
7547                 -c $((OSTCOUNT - 1)) $DIR/$tdir || error "setstripe"
7548         touch $DIR/$tdir/f3
7549         $LVERIFY $DIR/$tdir $DIR/$tdir/f3 || error "lverify failed"
7550 }
7551 run_test 65c "directory setstripe -S stripe_size*4 -i 1 -c $((OSTCOUNT-1))"
7552
7553 test_65d() {
7554         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7555
7556         test_mkdir $DIR/$tdir
7557         local STRIPECOUNT=$($LFS getstripe -c $DIR/$tdir)
7558         local STRIPESIZE=$($LFS getstripe -S $DIR/$tdir)
7559
7560         if [[ $STRIPECOUNT -le 0 ]]; then
7561                 sc=1
7562         elif [[ $STRIPECOUNT -gt $LOV_MAX_STRIPE_COUNT ]]; then
7563                 [[ $OSTCOUNT -gt $LOV_MAX_STRIPE_COUNT ]] &&
7564                         sc=$LOV_MAX_STRIPE_COUNT || sc=$(($OSTCOUNT - 1))
7565         else
7566                 sc=$(($STRIPECOUNT - 1))
7567         fi
7568         $LFS setstripe -S $STRIPESIZE -c $sc $DIR/$tdir || error "setstripe"
7569         touch $DIR/$tdir/f4 $DIR/$tdir/f5
7570         $LVERIFY $DIR/$tdir $DIR/$tdir/f4 $DIR/$tdir/f5 ||
7571                 error "lverify failed"
7572 }
7573 run_test 65d "directory setstripe -S stripe_size -c stripe_count"
7574
7575 test_65e() {
7576         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7577
7578         test_mkdir $DIR/$tdir
7579
7580         $LFS setstripe $DIR/$tdir || error "setstripe"
7581         $LFS getstripe -v $DIR/$tdir | grep "Default" ||
7582                                         error "no stripe info failed"
7583         touch $DIR/$tdir/f6
7584         $LVERIFY $DIR/$tdir $DIR/$tdir/f6 || error "lverify failed"
7585 }
7586 run_test 65e "directory setstripe defaults"
7587
7588 test_65f() {
7589         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7590
7591         test_mkdir $DIR/${tdir}f
7592         $RUNAS $LFS setstripe $DIR/${tdir}f &&
7593                 error "setstripe succeeded" || true
7594 }
7595 run_test 65f "dir setstripe permission (should return error) ==="
7596
7597 test_65g() {
7598         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7599
7600         test_mkdir $DIR/$tdir
7601         local STRIPESIZE=$($LFS getstripe -S $DIR/$tdir)
7602
7603         $LFS setstripe -S $((STRIPESIZE * 2)) -i 0 -c 1 $DIR/$tdir ||
7604                 error "setstripe -S failed"
7605         $LFS setstripe -d $DIR/$tdir || error "setstripe -d failed"
7606         $LFS getstripe -v $DIR/$tdir | grep "Default" ||
7607                 error "delete default stripe failed"
7608 }
7609 run_test 65g "directory setstripe -d"
7610
7611 test_65h() {
7612         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7613
7614         test_mkdir $DIR/$tdir
7615         local STRIPESIZE=$($LFS getstripe -S $DIR/$tdir)
7616
7617         $LFS setstripe -S $((STRIPESIZE * 2)) -i 0 -c 1 $DIR/$tdir ||
7618                 error "setstripe -S failed"
7619         test_mkdir $DIR/$tdir/dd1
7620         [ $($LFS getstripe -c $DIR/$tdir) = $($LFS getstripe -c $DIR/$tdir/dd1) ] ||
7621                 error "stripe info inherit failed"
7622 }
7623 run_test 65h "directory stripe info inherit ===================="
7624
7625 test_65i() {
7626         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7627
7628         save_layout_restore_at_exit $MOUNT
7629
7630         # bug6367: set non-default striping on root directory
7631         $LFS setstripe -S 65536 -c -1 $MOUNT || error "error setting stripe"
7632
7633         # bug12836: getstripe on -1 default directory striping
7634         $LFS getstripe $MOUNT || error "getstripe $MOUNT failed"
7635
7636         # bug12836: getstripe -v on -1 default directory striping
7637         $LFS getstripe -v $MOUNT || error "getstripe -v $MOUNT failed"
7638
7639         # bug12836: new find on -1 default directory striping
7640         $LFS find -mtime -1 $MOUNT > /dev/null || error "find $MOUNT failed"
7641 }
7642 run_test 65i "various tests to set root directory striping"
7643
7644 test_65j() { # bug6367
7645         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7646
7647         sync; sleep 1
7648
7649         # if we aren't already remounting for each test, do so for this test
7650         if [ "$I_MOUNTED" = "yes" ]; then
7651                 cleanup || error "failed to unmount"
7652                 setup
7653         fi
7654
7655         save_layout_restore_at_exit $MOUNT
7656
7657         $LFS setstripe -d $MOUNT || error "setstripe failed"
7658 }
7659 run_test 65j "set default striping on root directory (bug 6367)="
7660
7661 cleanup_65k() {
7662         rm -rf $DIR/$tdir
7663         wait_delete_completed
7664         do_facet $SINGLEMDS "lctl set_param -n \
7665                 osp.$ost*MDT0000.max_create_count=$max_count"
7666         do_facet $SINGLEMDS "lctl set_param -n \
7667                 osp.$ost*MDT0000.create_count=$count"
7668         do_facet $SINGLEMDS lctl --device  %$INACTIVE_OSC activate
7669         echo $INACTIVE_OSC "is Activate"
7670
7671         wait_osc_import_state mds ost$(( ostnum + 1 )) FULL
7672 }
7673
7674 test_65k() { # bug11679
7675         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7676         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
7677         remote_mds_nodsh && skip "remote MDS with nodsh"
7678
7679         local disable_precreate=true
7680         [ $MDS1_VERSION -le $(version_code 2.8.54) ] &&
7681                 disable_precreate=false
7682
7683         echo "Check OST status: "
7684         local MDS_OSCS=$(do_facet $SINGLEMDS lctl dl |
7685                 awk '/[oO][sS][cC].*md[ts]/ { print $4 }')
7686
7687         for OSC in $MDS_OSCS; do
7688                 echo $OSC "is active"
7689                 do_facet $SINGLEMDS lctl --device %$OSC activate
7690         done
7691
7692         for INACTIVE_OSC in $MDS_OSCS; do
7693                 local ost=$(osc_to_ost $INACTIVE_OSC)
7694                 local ostnum=$(do_facet $SINGLEMDS lctl get_param -n \
7695                                lov.*md*.target_obd |
7696                                awk -F: /$ost/'{ print $1 }' | head -n 1)
7697
7698                 mkdir -p $DIR/$tdir
7699                 $LFS setstripe -i $ostnum -c 1 $DIR/$tdir
7700                 createmany -o $DIR/$tdir/$tfile.$ostnum. 1000
7701
7702                 echo "Deactivate: " $INACTIVE_OSC
7703                 do_facet $SINGLEMDS lctl --device %$INACTIVE_OSC deactivate
7704
7705                 local count=$(do_facet $SINGLEMDS "lctl get_param -n \
7706                               osp.$ost*MDT0000.create_count")
7707                 local max_count=$(do_facet $SINGLEMDS "lctl get_param -n \
7708                                   osp.$ost*MDT0000.max_create_count")
7709                 $disable_precreate &&
7710                         do_facet $SINGLEMDS "lctl set_param -n \
7711                                 osp.$ost*MDT0000.max_create_count=0"
7712
7713                 for idx in $(seq 0 $((OSTCOUNT - 1))); do
7714                         [ -f $DIR/$tdir/$idx ] && continue
7715                         echo "$LFS setstripe -i $idx -c 1 $DIR/$tdir/$idx"
7716                         $LFS setstripe -i $idx -c 1 $DIR/$tdir/$idx ||
7717                                 { cleanup_65k;
7718                                   error "setstripe $idx should succeed"; }
7719                         rm -f $DIR/$tdir/$idx || error "rm $idx failed"
7720                 done
7721                 unlinkmany $DIR/$tdir/$tfile.$ostnum. 1000
7722                 rmdir $DIR/$tdir
7723
7724                 do_facet $SINGLEMDS "lctl set_param -n \
7725                         osp.$ost*MDT0000.max_create_count=$max_count"
7726                 do_facet $SINGLEMDS "lctl set_param -n \
7727                         osp.$ost*MDT0000.create_count=$count"
7728                 do_facet $SINGLEMDS lctl --device  %$INACTIVE_OSC activate
7729                 echo $INACTIVE_OSC "is Activate"
7730
7731                 wait_osc_import_state mds ost$(( ostnum + 1 )) FULL
7732         done
7733 }
7734 run_test 65k "validate manual striping works properly with deactivated OSCs"
7735
7736 test_65l() { # bug 12836
7737         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7738
7739         test_mkdir -p $DIR/$tdir/test_dir
7740         $LFS setstripe -c -1 $DIR/$tdir/test_dir
7741         $LFS find -mtime -1 $DIR/$tdir >/dev/null
7742 }
7743 run_test 65l "lfs find on -1 stripe dir ========================"
7744
7745 test_65m() {
7746         local layout=$(save_layout $MOUNT)
7747         $RUNAS $LFS setstripe -c 2 $MOUNT && {
7748                 restore_layout $MOUNT $layout
7749                 error "setstripe should fail by non-root users"
7750         }
7751         true
7752 }
7753 run_test 65m "normal user can't set filesystem default stripe"
7754
7755 test_65n() {
7756         [ -n "$FILESET" ] && skip "Not functional for FILESET set"
7757         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.12.50) ]] ||
7758                 skip "Need MDS version at least 2.12.50"
7759         [[ $PARALLEL != "yes" ]] || skip "skip parallel run"
7760
7761         [[ $OSTCOUNT -ge 2 ]] || skip_env "needs >= 2 OSTs"
7762         which getfattr > /dev/null 2>&1 || skip_env "no getfattr command"
7763         which setfattr > /dev/null 2>&1 || skip_env "no setfattr command"
7764
7765         local root_layout=$(save_layout $MOUNT)
7766         stack_trap "restore_layout $MOUNT $root_layout" EXIT
7767
7768         # new subdirectory under root directory should not inherit
7769         # the default layout from root
7770         local dir1=$MOUNT/$tdir-1
7771         mkdir $dir1 || error "mkdir $dir1 failed"
7772         ! getfattr -n trusted.lov $dir1 &> /dev/null ||
7773                 error "$dir1 shouldn't have LOV EA"
7774
7775         # delete the default layout on root directory
7776         $LFS setstripe -d $MOUNT || error "delete root default layout failed"
7777
7778         local dir2=$MOUNT/$tdir-2
7779         mkdir $dir2 || error "mkdir $dir2 failed"
7780         ! getfattr -n trusted.lov $dir2 &> /dev/null ||
7781                 error "$dir2 shouldn't have LOV EA"
7782
7783         # set a new striping pattern on root directory
7784         local def_stripe_size=$($LFS getstripe -S $MOUNT)
7785         local new_def_stripe_size=$((def_stripe_size * 2))
7786         $LFS setstripe -S $new_def_stripe_size $MOUNT ||
7787                 error "set stripe size on $MOUNT failed"
7788
7789         # new file created in $dir2 should inherit the new stripe size from
7790         # the filesystem default
7791         local file2=$dir2/$tfile-2
7792         touch $file2 || error "touch $file2 failed"
7793
7794         local file2_stripe_size=$($LFS getstripe -S $file2)
7795         [[ $file2_stripe_size -eq $new_def_stripe_size ]] ||
7796                 error "$file2 didn't inherit stripe size $new_def_stripe_size"
7797
7798         local dir3=$MOUNT/$tdir-3
7799         mkdir $dir3 || error "mkdir $dir3 failed"
7800         ! getfattr -n trusted.lov $dir3 &> /dev/null ||
7801                 error "$dir3 shouldn't have LOV EA"
7802
7803         # set OST pool on root directory
7804         local pool=$TESTNAME
7805         pool_add $pool || error "add $pool failed"
7806         pool_add_targets $pool 0 $((OSTCOUNT - 1)) 1 ||
7807                 error "add targets to $pool failed"
7808
7809         $LFS setstripe -p $pool $MOUNT ||
7810                 error "set OST pool on $MOUNT failed"
7811
7812         # new file created in $dir3 should inherit the pool from
7813         # the filesystem default
7814         local file3=$dir3/$tfile-3
7815         touch $file3 || error "touch $file3 failed"
7816
7817         local file3_pool=$($LFS getstripe -p $file3)
7818         [[ "$file3_pool" = "$pool" ]] ||
7819                 error "$file3 didn't inherit OST pool $pool"
7820
7821         local dir4=$MOUNT/$tdir-4
7822         mkdir $dir4 || error "mkdir $dir4 failed"
7823         ! getfattr -n trusted.lov $dir4 &> /dev/null ||
7824                 error "$dir4 shouldn't have LOV EA"
7825
7826         # new file created in $dir4 should inherit the pool from
7827         # the filesystem default
7828         local file4=$dir4/$tfile-4
7829         touch $file4 || error "touch $file4 failed"
7830
7831         local file4_pool=$($LFS getstripe -p $file4)
7832         [[ "$file4_pool" = "$pool" ]] ||
7833                 error "$file4 didn't inherit OST pool $pool"
7834
7835         # new subdirectory under non-root directory should inherit
7836         # the default layout from its parent directory
7837         $LFS setstripe -S $new_def_stripe_size -p $pool $dir4 ||
7838                 error "set directory layout on $dir4 failed"
7839
7840         local dir5=$dir4/$tdir-5
7841         mkdir $dir5 || error "mkdir $dir5 failed"
7842
7843         local dir4_layout=$(get_layout_param $dir4)
7844         local dir5_layout=$(get_layout_param $dir5)
7845         [[ "$dir4_layout" = "$dir5_layout" ]] ||
7846                 error "$dir5 should inherit the default layout from $dir4"
7847 }
7848 run_test 65n "don't inherit default layout from root for new subdirectories"
7849
7850 # bug 2543 - update blocks count on client
7851 test_66() {
7852         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7853
7854         COUNT=${COUNT:-8}
7855         dd if=/dev/zero of=$DIR/f66 bs=1k count=$COUNT
7856         sync; sync_all_data; sync; sync_all_data
7857         cancel_lru_locks osc
7858         BLOCKS=`ls -s $DIR/f66 | awk '{ print $1 }'`
7859         [ $BLOCKS -ge $COUNT ] || error "$DIR/f66 blocks $BLOCKS < $COUNT"
7860 }
7861 run_test 66 "update inode blocks count on client ==============="
7862
7863 meminfo() {
7864         awk '($1 == "'$1':") { print $2 }' /proc/meminfo
7865 }
7866
7867 swap_used() {
7868         swapon -s | awk '($1 == "'$1'") { print $4 }'
7869 }
7870
7871 # bug5265, obdfilter oa2dentry return -ENOENT
7872 # #define OBD_FAIL_SRV_ENOENT 0x217
7873 test_69() {
7874         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7875         remote_ost_nodsh && skip "remote OST with nodsh"
7876
7877         f="$DIR/$tfile"
7878         $LFS setstripe -c 1 -i 0 $f
7879
7880         $DIRECTIO write ${f}.2 0 1 || error "directio write error"
7881
7882         do_facet ost1 lctl set_param fail_loc=0x217
7883         $TRUNCATE $f 1 # vmtruncate() will ignore truncate() error.
7884         $DIRECTIO write $f 0 2 && error "write succeeded, expect -ENOENT"
7885
7886         do_facet ost1 lctl set_param fail_loc=0
7887         $DIRECTIO write $f 0 2 || error "write error"
7888
7889         cancel_lru_locks osc
7890         $DIRECTIO read $f 0 1 || error "read error"
7891
7892         do_facet ost1 lctl set_param fail_loc=0x217
7893         $DIRECTIO read $f 1 1 && error "read succeeded, expect -ENOENT"
7894
7895         do_facet ost1 lctl set_param fail_loc=0
7896         rm -f $f
7897 }
7898 run_test 69 "verify oa2dentry return -ENOENT doesn't LBUG ======"
7899
7900 test_71() {
7901         test_mkdir $DIR/$tdir
7902         $LFS setdirstripe -D -c$MDSCOUNT $DIR/$tdir
7903         sh rundbench -C -D $DIR/$tdir 2 || error "dbench failed!"
7904 }
7905 run_test 71 "Running dbench on lustre (don't segment fault) ===="
7906
7907 test_72a() { # bug 5695 - Test that on 2.6 remove_suid works properly
7908         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7909         [ "$RUNAS_ID" = "$UID" ] &&
7910                 skip_env "RUNAS_ID = UID = $UID -- skipping"
7911         # Check that testing environment is properly set up. Skip if not
7912         FAIL_ON_ERROR=false check_runas_id_ret $RUNAS_ID $RUNAS_GID $RUNAS ||
7913                 skip_env "User $RUNAS_ID does not exist - skipping"
7914
7915         touch $DIR/$tfile
7916         chmod 777 $DIR/$tfile
7917         chmod ug+s $DIR/$tfile
7918         $RUNAS dd if=/dev/zero of=$DIR/$tfile bs=512 count=1 ||
7919                 error "$RUNAS dd $DIR/$tfile failed"
7920         # See if we are still setuid/sgid
7921         [ -u $DIR/$tfile ] || [ -g $DIR/$tfile ] &&
7922                 error "S/gid is not dropped on write"
7923         # Now test that MDS is updated too
7924         cancel_lru_locks mdc
7925         [ -u $DIR/$tfile ] || [ -g $DIR/$tfile ] &&
7926                 error "S/gid is not dropped on MDS"
7927         rm -f $DIR/$tfile
7928 }
7929 run_test 72a "Test that remove suid works properly (bug5695) ===="
7930
7931 test_72b() { # bug 24226 -- keep mode setting when size is not changing
7932         local perm
7933
7934         [ "$RUNAS_ID" = "$UID" ] &&
7935                 skip_env "RUNAS_ID = UID = $UID -- skipping"
7936         [ "$RUNAS_ID" -eq 0 ] &&
7937                 skip_env "RUNAS_ID = 0 -- skipping"
7938         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7939         # Check that testing environment is properly set up. Skip if not
7940         FAIL_ON_ERROR=false check_runas_id_ret $RUNAS_ID $RUNAS_ID $RUNAS ||
7941                 skip_env "User $RUNAS_ID does not exist - skipping"
7942
7943         touch $DIR/${tfile}-f{g,u}
7944         test_mkdir $DIR/${tfile}-dg
7945         test_mkdir $DIR/${tfile}-du
7946         chmod 770 $DIR/${tfile}-{f,d}{g,u}
7947         chmod g+s $DIR/${tfile}-{f,d}g
7948         chmod u+s $DIR/${tfile}-{f,d}u
7949         for perm in 777 2777 4777; do
7950                 $RUNAS chmod $perm $DIR/${tfile}-fg && error "S/gid file allowed improper chmod to $perm"
7951                 $RUNAS chmod $perm $DIR/${tfile}-fu && error "S/uid file allowed improper chmod to $perm"
7952                 $RUNAS chmod $perm $DIR/${tfile}-dg && error "S/gid dir allowed improper chmod to $perm"
7953                 $RUNAS chmod $perm $DIR/${tfile}-du && error "S/uid dir allowed improper chmod to $perm"
7954         done
7955         true
7956 }
7957 run_test 72b "Test that we keep mode setting if without file data changed (bug 24226)"
7958
7959 # bug 3462 - multiple simultaneous MDC requests
7960 test_73() {
7961         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7962
7963         test_mkdir $DIR/d73-1
7964         test_mkdir $DIR/d73-2
7965         multiop_bg_pause $DIR/d73-1/f73-1 O_c || return 1
7966         pid1=$!
7967
7968         lctl set_param fail_loc=0x80000129
7969         $MULTIOP $DIR/d73-1/f73-2 Oc &
7970         sleep 1
7971         lctl set_param fail_loc=0
7972
7973         $MULTIOP $DIR/d73-2/f73-3 Oc &
7974         pid3=$!
7975
7976         kill -USR1 $pid1
7977         wait $pid1 || return 1
7978
7979         sleep 25
7980
7981         $CHECKSTAT -t file $DIR/d73-1/f73-1 || return 4
7982         $CHECKSTAT -t file $DIR/d73-1/f73-2 || return 5
7983         $CHECKSTAT -t file $DIR/d73-2/f73-3 || return 6
7984
7985         rm -rf $DIR/d73-*
7986 }
7987 run_test 73 "multiple MDC requests (should not deadlock)"
7988
7989 test_74a() { # bug 6149, 6184
7990         [ $PARALLEL == "yes" ] && skip "skip parallel run"
7991
7992         touch $DIR/f74a
7993         #define OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT 0x30e
7994         #
7995         # very important to OR with OBD_FAIL_ONCE (0x80000000) -- otherwise it
7996         # will spin in a tight reconnection loop
7997         $LCTL set_param fail_loc=0x8000030e
7998         # get any lock that won't be difficult - lookup works.
7999         ls $DIR/f74a
8000         $LCTL set_param fail_loc=0
8001         rm -f $DIR/f74a
8002         true
8003 }
8004 run_test 74a "ldlm_enqueue freed-export error path, ls (shouldn't LBUG)"
8005
8006 test_74b() { # bug 13310
8007         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8008
8009         #define OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT 0x30e
8010         #
8011         # very important to OR with OBD_FAIL_ONCE (0x80000000) -- otherwise it
8012         # will spin in a tight reconnection loop
8013         $LCTL set_param fail_loc=0x8000030e
8014         # get a "difficult" lock
8015         touch $DIR/f74b
8016         $LCTL set_param fail_loc=0
8017         rm -f $DIR/f74b
8018         true
8019 }
8020 run_test 74b "ldlm_enqueue freed-export error path, touch (shouldn't LBUG)"
8021
8022 test_74c() {
8023         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8024
8025         #define OBD_FAIL_LDLM_NEW_LOCK
8026         $LCTL set_param fail_loc=0x319
8027         touch $DIR/$tfile && error "touch successful"
8028         $LCTL set_param fail_loc=0
8029         true
8030 }
8031 run_test 74c "ldlm_lock_create error path, (shouldn't LBUG)"
8032
8033 num_inodes() {
8034         awk '/lustre_inode_cache/ {print $2; exit}' /proc/slabinfo
8035 }
8036
8037 test_76() { # Now for bug 20433, added originally in bug 1443
8038         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8039
8040         local CPUS=$(getconf _NPROCESSORS_ONLN 2>/dev/null)
8041
8042         cancel_lru_locks osc
8043         BEFORE_INODES=$(num_inodes)
8044         echo "before inodes: $BEFORE_INODES"
8045         local COUNT=1000
8046         [ "$SLOW" = "no" ] && COUNT=100
8047         for i in $(seq $COUNT); do
8048                 touch $DIR/$tfile
8049                 rm -f $DIR/$tfile
8050         done
8051         cancel_lru_locks osc
8052         AFTER_INODES=$(num_inodes)
8053         echo "after inodes: $AFTER_INODES"
8054         local wait=0
8055         while [[ $((AFTER_INODES-1*${CPUS:-1})) -gt $BEFORE_INODES ]]; do
8056                 sleep 2
8057                 AFTER_INODES=$(num_inodes)
8058                 wait=$((wait+2))
8059                 echo "wait $wait seconds inodes: $AFTER_INODES"
8060                 if [ $wait -gt 30 ]; then
8061                         error "inode slab grew from $BEFORE_INODES to $AFTER_INODES"
8062                 fi
8063         done
8064 }
8065 run_test 76 "confirm clients recycle inodes properly ===="
8066
8067
8068 export ORIG_CSUM=""
8069 set_checksums()
8070 {
8071         # Note: in sptlrpc modes which enable its own bulk checksum, the
8072         # original crc32_le bulk checksum will be automatically disabled,
8073         # and the OBD_FAIL_OSC_CHECKSUM_SEND/OBD_FAIL_OSC_CHECKSUM_RECEIVE
8074         # will be checked by sptlrpc code against sptlrpc bulk checksum.
8075         # In this case set_checksums() will not be no-op, because sptlrpc
8076         # bulk checksum will be enabled all through the test.
8077
8078         [ "$ORIG_CSUM" ] || ORIG_CSUM=`lctl get_param -n osc.*.checksums | head -n1`
8079         lctl set_param -n osc.*.checksums $1
8080         return 0
8081 }
8082
8083 export ORIG_CSUM_TYPE="`lctl get_param -n osc.*osc-[^mM]*.checksum_type |
8084                         sed 's/.*\[\(.*\)\].*/\1/g' | head -n1`"
8085 CKSUM_TYPES=${CKSUM_TYPES:-$(lctl get_param -n osc.*osc-[^mM]*.checksum_type |
8086                              tr -d [] | head -n1)}
8087 set_checksum_type()
8088 {
8089         lctl set_param -n osc.*osc-[^mM]*.checksum_type $1
8090         rc=$?
8091         log "set checksum type to $1, rc = $rc"
8092         return $rc
8093 }
8094
8095 get_osc_checksum_type()
8096 {
8097         # arugment 1: OST name, like OST0000
8098         ost=$1
8099         checksum_type=$(lctl get_param -n osc.*${ost}-osc-[^mM]*.checksum_type |
8100                         sed 's/.*\[\(.*\)\].*/\1/g')
8101         rc=$?
8102         [ $rc -ne 0 ] && error "failed to get checksum type of $ost, rc = $rc, output = $checksum_type"
8103         echo $checksum_type
8104 }
8105
8106 F77_TMP=$TMP/f77-temp
8107 F77SZ=8
8108 setup_f77() {
8109         dd if=/dev/urandom of=$F77_TMP bs=1M count=$F77SZ || \
8110                 error "error writing to $F77_TMP"
8111 }
8112
8113 test_77a() { # bug 10889
8114         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8115         $GSS && skip_env "could not run with gss"
8116
8117         [ ! -f $F77_TMP ] && setup_f77
8118         set_checksums 1
8119         dd if=$F77_TMP of=$DIR/$tfile bs=1M count=$F77SZ || error "dd error"
8120         set_checksums 0
8121         rm -f $DIR/$tfile
8122 }
8123 run_test 77a "normal checksum read/write operation"
8124
8125 test_77b() { # bug 10889
8126         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8127         $GSS && skip_env "could not run with gss"
8128
8129         [ ! -f $F77_TMP ] && setup_f77
8130         #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
8131         $LCTL set_param fail_loc=0x80000409
8132         set_checksums 1
8133
8134         dd if=$F77_TMP of=$DIR/$tfile bs=1M count=$F77SZ conv=sync ||
8135                 error "dd error: $?"
8136         $LCTL set_param fail_loc=0
8137
8138         for algo in $CKSUM_TYPES; do
8139                 cancel_lru_locks osc
8140                 set_checksum_type $algo
8141                 #define OBD_FAIL_OSC_CHECKSUM_RECEIVE    0x408
8142                 $LCTL set_param fail_loc=0x80000408
8143                 cmp $F77_TMP $DIR/$tfile || error "file compare failed"
8144                 $LCTL set_param fail_loc=0
8145         done
8146         set_checksums 0
8147         set_checksum_type $ORIG_CSUM_TYPE
8148         rm -f $DIR/$tfile
8149 }
8150 run_test 77b "checksum error on client write, read"
8151
8152 cleanup_77c() {
8153         trap 0
8154         set_checksums 0
8155         $LCTL set_param osc.*osc-[^mM]*.checksum_dump=0
8156         $check_ost &&
8157                 do_facet ost1 $LCTL set_param obdfilter.*-OST*.checksum_dump=0
8158         [ -n "$osc_file_prefix" ] && rm -f ${osc_file_prefix}*
8159         $check_ost && [ -n "$ost_file_prefix" ] &&
8160                 do_facet ost1 rm -f ${ost_file_prefix}\*
8161 }
8162
8163 test_77c() {
8164         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8165         $GSS && skip_env "could not run with gss"
8166         remote_ost_nodsh && skip "remote OST with nodsh"
8167
8168         local bad1
8169         local osc_file_prefix
8170         local osc_file
8171         local check_ost=false
8172         local ost_file_prefix
8173         local ost_file
8174         local orig_cksum
8175         local dump_cksum
8176         local fid
8177
8178         # ensure corruption will occur on first OSS/OST
8179         $LFS setstripe -i 0 $DIR/$tfile
8180
8181         [ ! -f $F77_TMP ] && setup_f77
8182         dd if=$F77_TMP of=$DIR/$tfile bs=1M count=$F77SZ conv=sync ||
8183                 error "dd write error: $?"
8184         fid=$($LFS path2fid $DIR/$tfile)
8185
8186         if [ $OST1_VERSION -ge $(version_code 2.9.57) ]
8187         then
8188                 check_ost=true
8189                 ost_file_prefix=$(do_facet ost1 $LCTL get_param -n debug_path)
8190                 ost_file_prefix=${ost_file_prefix}-checksum_dump-ost-\\${fid}
8191         else
8192                 echo "OSS do not support bulk pages dump upon error"
8193         fi
8194
8195         osc_file_prefix=$($LCTL get_param -n debug_path)
8196         osc_file_prefix=${osc_file_prefix}-checksum_dump-osc-\\${fid}
8197
8198         trap cleanup_77c EXIT
8199
8200         set_checksums 1
8201         # enable bulk pages dump upon error on Client
8202         $LCTL set_param osc.*osc-[^mM]*.checksum_dump=1
8203         # enable bulk pages dump upon error on OSS
8204         $check_ost &&
8205                 do_facet ost1 $LCTL set_param obdfilter.*-OST*.checksum_dump=1
8206
8207         # flush Client cache to allow next read to reach OSS
8208         cancel_lru_locks osc
8209
8210         #define OBD_FAIL_OSC_CHECKSUM_RECEIVE       0x408
8211         $LCTL set_param fail_loc=0x80000408
8212         dd if=$DIR/$tfile of=/dev/null bs=1M || error "dd read error: $?"
8213         $LCTL set_param fail_loc=0
8214
8215         rm -f $DIR/$tfile
8216
8217         # check cksum dump on Client
8218         osc_file=$(ls ${osc_file_prefix}*)
8219         [ -n "$osc_file" ] || error "no checksum dump file on Client"
8220         # OBD_FAIL_OSC_CHECKSUM_RECEIVE corrupts with "bad1" at start of file
8221         bad1=$(dd if=$osc_file bs=1 count=4 2>/dev/null) || error "dd error: $?"
8222         [ $bad1 == "bad1" ] || error "unexpected corrupt pattern"
8223         orig_cksum=$(dd if=$F77_TMP bs=1 skip=4 count=1048572 2>/dev/null |
8224                      cksum)
8225         dump_cksum=$(dd if=$osc_file bs=1 skip=4 2>/dev/null | cksum)
8226         [[ "$orig_cksum" == "$dump_cksum" ]] ||
8227                 error "dump content does not match on Client"
8228
8229         $check_ost || skip "No need to check cksum dump on OSS"
8230
8231         # check cksum dump on OSS
8232         ost_file=$(do_facet ost1 ls ${ost_file_prefix}\*)
8233         [ -n "$ost_file" ] || error "no checksum dump file on OSS"
8234         orig_cksum=$(dd if=$F77_TMP bs=1048576 count=1 2>/dev/null | cksum)
8235         dump_cksum=$(do_facet ost1 dd if=$ost_file 2>/dev/null \| cksum)
8236         [[ "$orig_cksum" == "$dump_cksum" ]] ||
8237                 error "dump content does not match on OSS"
8238
8239         cleanup_77c
8240 }
8241 run_test 77c "checksum error on client read with debug"
8242
8243 test_77d() { # bug 10889
8244         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8245         $GSS && skip_env "could not run with gss"
8246
8247         #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
8248         $LCTL set_param fail_loc=0x80000409
8249         set_checksums 1
8250         $DIRECTIO write $DIR/$tfile 0 $F77SZ $((1024 * 1024)) ||
8251                 error "direct write: rc=$?"
8252         $LCTL set_param fail_loc=0
8253         set_checksums 0
8254
8255         #define OBD_FAIL_OSC_CHECKSUM_RECEIVE    0x408
8256         $LCTL set_param fail_loc=0x80000408
8257         set_checksums 1
8258         cancel_lru_locks osc
8259         $DIRECTIO read $DIR/$tfile 0 $F77SZ $((1024 * 1024)) ||
8260                 error "direct read: rc=$?"
8261         $LCTL set_param fail_loc=0
8262         set_checksums 0
8263 }
8264 run_test 77d "checksum error on OST direct write, read"
8265
8266 test_77f() { # bug 10889
8267         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8268         $GSS && skip_env "could not run with gss"
8269
8270         set_checksums 1
8271         for algo in $CKSUM_TYPES; do
8272                 cancel_lru_locks osc
8273                 set_checksum_type $algo
8274                 #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
8275                 $LCTL set_param fail_loc=0x409
8276                 $DIRECTIO write $DIR/$tfile 0 $F77SZ $((1024 * 1024)) &&
8277                         error "direct write succeeded"
8278                 $LCTL set_param fail_loc=0
8279         done
8280         set_checksum_type $ORIG_CSUM_TYPE
8281         set_checksums 0
8282 }
8283 run_test 77f "repeat checksum error on write (expect error)"
8284
8285 test_77g() { # bug 10889
8286         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8287         $GSS && skip_env "could not run with gss"
8288         remote_ost_nodsh && skip "remote OST with nodsh"
8289
8290         [ ! -f $F77_TMP ] && setup_f77
8291
8292         local file=$DIR/$tfile
8293         stack_trap "rm -f $file" EXIT
8294
8295         $LFS setstripe -c 1 -i 0 $file
8296         #define OBD_FAIL_OST_CHECKSUM_RECEIVE       0x21a
8297         do_facet ost1 lctl set_param fail_loc=0x8000021a
8298         set_checksums 1
8299         dd if=$F77_TMP of=$file bs=1M count=$F77SZ ||
8300                 error "write error: rc=$?"
8301         do_facet ost1 lctl set_param fail_loc=0
8302         set_checksums 0
8303
8304         cancel_lru_locks osc
8305         #define OBD_FAIL_OST_CHECKSUM_SEND          0x21b
8306         do_facet ost1 lctl set_param fail_loc=0x8000021b
8307         set_checksums 1
8308         cmp $F77_TMP $file || error "file compare failed"
8309         do_facet ost1 lctl set_param fail_loc=0
8310         set_checksums 0
8311 }
8312 run_test 77g "checksum error on OST write, read"
8313
8314 test_77k() { # LU-10906
8315         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8316         $GSS && skip_env "could not run with gss"
8317
8318         local cksum_param="osc.$FSNAME*.checksums"
8319         local get_checksum="$LCTL get_param -n $cksum_param | head -n1"
8320         local checksum
8321         local i
8322
8323         [ "$ORIG_CSUM" ] || ORIG_CSUM=$(eval $get_checksum)
8324         stack_trap "wait_update $HOSTNAME '$get_checksum' $ORIG_CSUM" EXIT
8325         stack_trap "do_facet mgs $LCTL set_param -P $cksum_param=$ORIG_CSUM" \
8326                 EXIT
8327
8328         for i in 0 1; do
8329                 do_facet mgs $LCTL set_param -P $cksum_param=$i ||
8330                         error "failed to set checksum=$i on MGS"
8331                 wait_update $HOSTNAME "$get_checksum" $i
8332                 #remount
8333                 echo "remount client, checksum should be $i"
8334                 remount_client $MOUNT || error "failed to remount client"
8335                 checksum=$(eval $get_checksum)
8336                 [ $checksum -eq $i ] || error "checksum($checksum) != $i"
8337         done
8338         # remove persistent param to avoid races with checksum mountopt below
8339         do_facet mgs $LCTL set_param -P -d $cksum_param ||
8340                 error "failed to delete checksum on MGS"
8341
8342         for opt in "checksum" "nochecksum"; do
8343                 #remount with mount option
8344                 echo "remount client with option $opt, checksum should be $i"
8345                 umount_client $MOUNT || error "failed to umount client"
8346                 mount_client $MOUNT "$MOUNT_OPTS,$opt" ||
8347                         error "failed to mount client with option '$opt'"
8348                 checksum=$(eval $get_checksum)
8349                 [ $checksum -eq $i ] || error "checksum($checksum) != $i"
8350                 i=$((i - 1))
8351         done
8352
8353         remount_client $MOUNT || error "failed to remount client"
8354 }
8355 run_test 77k "enable/disable checksum correctly"
8356
8357 test_77l() {
8358         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8359         $GSS && skip_env "could not run with gss"
8360
8361         set_checksums 1
8362         stack_trap "set_checksums $ORIG_CSUM" EXIT
8363         stack_trap "set_checksum_type $ORIG_CSUM_TYPE" EXIT
8364
8365         set_checksum_type invalid && error "unexpected success of invalid checksum type"
8366
8367         $LFS setstripe -c 1 -i 0 $DIR/$tfile
8368         for algo in $CKSUM_TYPES; do
8369                 set_checksum_type $algo || error "fail to set checksum type $algo"
8370                 osc_algo=$(get_osc_checksum_type OST0000)
8371                 [ "$osc_algo" != "$algo" ] && error "checksum type is $osc_algo after setting it to $algo"
8372
8373                 # no locks, no reqs to let the connection idle
8374                 cancel_lru_locks osc
8375                 lru_resize_disable osc
8376                 wait_osc_import_state client ost1 IDLE
8377
8378                 # ensure ost1 is connected
8379                 stat $DIR/$tfile >/dev/null || error "can't stat"
8380                 wait_osc_import_state client ost1 FULL
8381
8382                 osc_algo=$(get_osc_checksum_type OST0000)
8383                 [ "$osc_algo" != "$algo" ] && error "checksum type changed from $algo to $osc_algo after reconnection"
8384         done
8385         return 0
8386 }
8387 run_test 77l "preferred checksum type is remembered after reconnected"
8388
8389 [ "$ORIG_CSUM" ] && set_checksums $ORIG_CSUM || true
8390 rm -f $F77_TMP
8391 unset F77_TMP
8392
8393 cleanup_test_78() {
8394         trap 0
8395         rm -f $DIR/$tfile
8396 }
8397
8398 test_78() { # bug 10901
8399         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8400         remote_ost || skip_env "local OST"
8401
8402         NSEQ=5
8403         F78SIZE=$(($(awk '/MemFree:/ { print $2 }' /proc/meminfo) / 1024))
8404         echo "MemFree: $F78SIZE, Max file size: $MAXFREE"
8405         MEMTOTAL=$(($(awk '/MemTotal:/ { print $2 }' /proc/meminfo) / 1024))
8406         echo "MemTotal: $MEMTOTAL"
8407
8408         # reserve 256MB of memory for the kernel and other running processes,
8409         # and then take 1/2 of the remaining memory for the read/write buffers.
8410         if [ $MEMTOTAL -gt 512 ] ;then
8411                 MEMTOTAL=$(((MEMTOTAL - 256 ) / 2))
8412         else
8413                 # for those poor memory-starved high-end clusters...
8414                 MEMTOTAL=$((MEMTOTAL / 2))
8415         fi
8416         echo "Mem to use for directio: $MEMTOTAL"
8417
8418         [[ $F78SIZE -gt $MEMTOTAL ]] && F78SIZE=$MEMTOTAL
8419         [[ $F78SIZE -gt 512 ]] && F78SIZE=512
8420         [[ $F78SIZE -gt $((MAXFREE / 1024)) ]] && F78SIZE=$((MAXFREE / 1024))
8421         SMALLESTOST=$($LFS df $DIR | grep OST | awk '{ print $4 }' | sort -n |
8422                 head -n1)
8423         echo "Smallest OST: $SMALLESTOST"
8424         [[ $SMALLESTOST -lt 10240 ]] &&
8425                 skip "too small OSTSIZE, useless to run large O_DIRECT test"
8426
8427         trap cleanup_test_78 EXIT
8428
8429         [[ $F78SIZE -gt $((SMALLESTOST * $OSTCOUNT / 1024 - 80)) ]] &&
8430                 F78SIZE=$((SMALLESTOST * $OSTCOUNT / 1024 - 80))
8431
8432         [ "$SLOW" = "no" ] && NSEQ=1 && [ $F78SIZE -gt 32 ] && F78SIZE=32
8433         echo "File size: $F78SIZE"
8434         $LFS setstripe -c $OSTCOUNT $DIR/$tfile || error "setstripe failed"
8435         for i in $(seq 1 $NSEQ); do
8436                 FSIZE=$(($F78SIZE / ($NSEQ - $i + 1)))
8437                 echo directIO rdwr round $i of $NSEQ
8438                 $DIRECTIO rdwr $DIR/$tfile 0 $FSIZE 1048576||error "rdwr failed"
8439         done
8440
8441         cleanup_test_78
8442 }
8443 run_test 78 "handle large O_DIRECT writes correctly ============"
8444
8445 test_79() { # bug 12743
8446         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8447
8448         wait_delete_completed
8449
8450         BKTOTAL=$(calc_osc_kbytes kbytestotal)
8451         BKFREE=$(calc_osc_kbytes kbytesfree)
8452         BKAVAIL=$(calc_osc_kbytes kbytesavail)
8453
8454         STRING=`df -P $MOUNT | tail -n 1 | awk '{print $2","$3","$4}'`
8455         DFTOTAL=`echo $STRING | cut -d, -f1`
8456         DFUSED=`echo $STRING  | cut -d, -f2`
8457         DFAVAIL=`echo $STRING | cut -d, -f3`
8458         DFFREE=$(($DFTOTAL - $DFUSED))
8459
8460         ALLOWANCE=$((64 * $OSTCOUNT))
8461
8462         if [ $DFTOTAL -lt $(($BKTOTAL - $ALLOWANCE)) ] ||
8463            [ $DFTOTAL -gt $(($BKTOTAL + $ALLOWANCE)) ] ; then
8464                 error "df total($DFTOTAL) mismatch OST total($BKTOTAL)"
8465         fi
8466         if [ $DFFREE -lt $(($BKFREE - $ALLOWANCE)) ] ||
8467            [ $DFFREE -gt $(($BKFREE + $ALLOWANCE)) ] ; then
8468                 error "df free($DFFREE) mismatch OST free($BKFREE)"
8469         fi
8470         if [ $DFAVAIL -lt $(($BKAVAIL - $ALLOWANCE)) ] ||
8471            [ $DFAVAIL -gt $(($BKAVAIL + $ALLOWANCE)) ] ; then
8472                 error "df avail($DFAVAIL) mismatch OST avail($BKAVAIL)"
8473         fi
8474 }
8475 run_test 79 "df report consistency check ======================="
8476
8477 test_80() { # bug 10718
8478         remote_ost_nodsh && skip "remote OST with nodsh"
8479         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8480
8481         # relax strong synchronous semantics for slow backends like ZFS
8482         local soc="obdfilter.*.sync_on_lock_cancel"
8483         local soc_old=$(do_facet ost1 lctl get_param -n $soc | head -n1)
8484         local hosts=
8485         if [ "$soc_old" != "never" ] &&
8486                 [ "$ost1_FSTYPE" != "ldiskfs" ]; then
8487                         hosts=$(for host in $(seq -f "ost%g" 1 $OSTCOUNT); do
8488                                 facet_active_host $host; done | sort -u)
8489                         do_nodes $hosts lctl set_param $soc=never
8490         fi
8491
8492         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1M
8493         sync; sleep 1; sync
8494         local BEFORE=`date +%s`
8495         cancel_lru_locks osc
8496         local AFTER=`date +%s`
8497         local DIFF=$((AFTER-BEFORE))
8498         if [ $DIFF -gt 1 ] ; then
8499                 error "elapsed for 1M@1T = $DIFF"
8500         fi
8501
8502         [ -n "$hosts" ] && do_nodes $hosts lctl set_param $soc=$soc_old
8503
8504         rm -f $DIR/$tfile
8505 }
8506 run_test 80 "Page eviction is equally fast at high offsets too  ===="
8507
8508 test_81a() { # LU-456
8509         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8510         remote_ost_nodsh && skip "remote OST with nodsh"
8511
8512         # define OBD_FAIL_OST_MAPBLK_ENOSPC    0x228
8513         # MUST OR with the OBD_FAIL_ONCE (0x80000000)
8514         do_facet ost1 lctl set_param fail_loc=0x80000228
8515
8516         # write should trigger a retry and success
8517         $LFS setstripe -i 0 -c 1 $DIR/$tfile
8518         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
8519         RC=$?
8520         if [ $RC -ne 0 ] ; then
8521                 error "write should success, but failed for $RC"
8522         fi
8523 }
8524 run_test 81a "OST should retry write when get -ENOSPC ==============="
8525
8526 test_81b() { # LU-456
8527         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8528         remote_ost_nodsh && skip "remote OST with nodsh"
8529
8530         # define OBD_FAIL_OST_MAPBLK_ENOSPC    0x228
8531         # Don't OR with the OBD_FAIL_ONCE (0x80000000)
8532         do_facet ost1 lctl set_param fail_loc=0x228
8533
8534         # write should retry several times and return -ENOSPC finally
8535         $LFS setstripe -i 0 -c 1 $DIR/$tfile
8536         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
8537         RC=$?
8538         ENOSPC=28
8539         if [ $RC -ne $ENOSPC ] ; then
8540                 error "dd should fail for -ENOSPC, but succeed."
8541         fi
8542 }
8543 run_test 81b "OST should return -ENOSPC when retry still fails ======="
8544
8545 test_82() { # LU-1031
8546         dd if=/dev/zero of=$DIR/$tfile bs=1M count=10
8547         local gid1=14091995
8548         local gid2=16022000
8549
8550         multiop_bg_pause $DIR/$tfile OG${gid1}_g${gid1}c || return 1
8551         local MULTIPID1=$!
8552         multiop_bg_pause $DIR/$tfile O_G${gid2}r10g${gid2}c || return 2
8553         local MULTIPID2=$!
8554         kill -USR1 $MULTIPID2
8555         sleep 2
8556         if [[ `ps h -o comm -p $MULTIPID2` == "" ]]; then
8557                 error "First grouplock does not block second one"
8558         else
8559                 echo "Second grouplock blocks first one"
8560         fi
8561         kill -USR1 $MULTIPID1
8562         wait $MULTIPID1
8563         wait $MULTIPID2
8564 }
8565 run_test 82 "Basic grouplock test"
8566
8567 test_99() {
8568         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs"
8569
8570         test_mkdir $DIR/$tdir.cvsroot
8571         chown $RUNAS_ID $DIR/$tdir.cvsroot
8572
8573         cd $TMP
8574         $RUNAS cvs -d $DIR/$tdir.cvsroot init || error "cvs init failed"
8575
8576         cd /etc/init.d
8577         # some versions of cvs import exit(1) when asked to import links or
8578         # files they can't read.  ignore those files.
8579         local toignore=$(find . -type l -printf '-I %f\n' -o \
8580                          ! -perm /4 -printf '-I %f\n')
8581         $RUNAS cvs -d $DIR/$tdir.cvsroot import -m "nomesg" $toignore \
8582                 $tdir.reposname vtag rtag
8583
8584         cd $DIR
8585         test_mkdir $DIR/$tdir.reposname
8586         chown $RUNAS_ID $DIR/$tdir.reposname
8587         $RUNAS cvs -d $DIR/$tdir.cvsroot co $tdir.reposname
8588
8589         cd $DIR/$tdir.reposname
8590         $RUNAS touch foo99
8591         $RUNAS cvs add -m 'addmsg' foo99
8592         $RUNAS cvs update
8593         $RUNAS cvs commit -m 'nomsg' foo99
8594         rm -fr $DIR/$tdir.cvsroot
8595 }
8596 run_test 99 "cvs strange file/directory operations"
8597
8598 test_100() {
8599         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8600         [[ "$NETTYPE" =~ tcp ]] ||
8601                 skip_env "TCP secure port test, not useful for NETTYPE=$NETTYPE"
8602         remote_ost_nodsh && skip "remote OST with nodsh"
8603         remote_mds_nodsh && skip "remote MDS with nodsh"
8604         remote_servers ||
8605                 skip "useless for local single node setup"
8606
8607         netstat -tna | ( rc=1; while read PROT SND RCV LOCAL REMOTE STAT; do
8608                 [ "$PROT" != "tcp" ] && continue
8609                 RPORT=$(echo $REMOTE | cut -d: -f2)
8610                 [ "$RPORT" != "$ACCEPTOR_PORT" ] && continue
8611
8612                 rc=0
8613                 LPORT=`echo $LOCAL | cut -d: -f2`
8614                 if [ $LPORT -ge 1024 ]; then
8615                         echo "bad: $PROT $SND $RCV $LOCAL $REMOTE $STAT"
8616                         netstat -tna
8617                         error_exit "local: $LPORT > 1024, remote: $RPORT"
8618                 fi
8619         done
8620         [ "$rc" = 0 ] || error_exit "privileged port not found" )
8621 }
8622 run_test 100 "check local port using privileged port ==========="
8623
8624 function get_named_value()
8625 {
8626     local tag
8627
8628     tag=$1
8629     while read ;do
8630         line=$REPLY
8631         case $line in
8632         $tag*)
8633             echo $line | sed "s/^$tag[ ]*//"
8634             break
8635             ;;
8636         esac
8637     done
8638 }
8639
8640 export CACHE_MAX=$($LCTL get_param -n llite.*.max_cached_mb |
8641                    awk '/^max_cached_mb/ { print $2 }')
8642
8643 cleanup_101a() {
8644         $LCTL set_param -n llite.*.max_cached_mb $CACHE_MAX
8645         trap 0
8646 }
8647
8648 test_101a() {
8649         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8650         [ $MDSCOUNT -ge 2 ] && skip_env "needs < 2 MDTs" #LU-4322
8651
8652         local s
8653         local discard
8654         local nreads=10000
8655         local cache_limit=32
8656
8657         $LCTL set_param -n osc.*-osc*.rpc_stats 0
8658         trap cleanup_101a EXIT
8659         $LCTL set_param -n llite.*.read_ahead_stats 0
8660         $LCTL set_param -n llite.*.max_cached_mb $cache_limit
8661
8662         #
8663         # randomly read 10000 of 64K chunks from file 3x 32MB in size
8664         #
8665         echo "nreads: $nreads file size: $((cache_limit * 3))MB"
8666         $READS -f $DIR/$tfile -s$((cache_limit * 3192 * 1024)) -b65536 -C -n$nreads -t 180
8667
8668         discard=0
8669         for s in $($LCTL get_param -n llite.*.read_ahead_stats |
8670                 get_named_value 'read but discarded' | cut -d" " -f1); do
8671                         discard=$(($discard + $s))
8672         done
8673         cleanup_101a
8674
8675         if [[ $(($discard * 10)) -gt $nreads ]]; then
8676                 $LCTL get_param osc.*-osc*.rpc_stats
8677                 $LCTL get_param llite.*.read_ahead_stats
8678                 error "too many ($discard) discarded pages"
8679         fi
8680         rm -f $DIR/$tfile || true
8681 }
8682 run_test 101a "check read-ahead for random reads"
8683
8684 setup_test101bc() {
8685         test_mkdir $DIR/$tdir
8686         local ssize=$1
8687         local FILE_LENGTH=$2
8688         STRIPE_OFFSET=0
8689
8690         local FILE_SIZE_MB=$((FILE_LENGTH / ssize))
8691
8692         local list=$(comma_list $(osts_nodes))
8693         set_osd_param $list '' read_cache_enable 0
8694         set_osd_param $list '' writethrough_cache_enable 0
8695
8696         trap cleanup_test101bc EXIT
8697         # prepare the read-ahead file
8698         $LFS setstripe -S $ssize -i $STRIPE_OFFSET -c $OSTCOUNT $DIR/$tfile
8699
8700         dd if=/dev/zero of=$DIR/$tfile bs=$ssize \
8701                                 count=$FILE_SIZE_MB 2> /dev/null
8702
8703 }
8704
8705 cleanup_test101bc() {
8706         trap 0
8707         rm -rf $DIR/$tdir
8708         rm -f $DIR/$tfile
8709
8710         local list=$(comma_list $(osts_nodes))
8711         set_osd_param $list '' read_cache_enable 1
8712         set_osd_param $list '' writethrough_cache_enable 1
8713 }
8714
8715 calc_total() {
8716         awk 'BEGIN{total=0}; {total+=$1}; END{print total}'
8717 }
8718
8719 ra_check_101() {
8720         local READ_SIZE=$1
8721         local STRIPE_SIZE=$2
8722         local FILE_LENGTH=$3
8723         local RA_INC=1048576
8724         local STRIDE_LENGTH=$((STRIPE_SIZE/READ_SIZE))
8725         local discard_limit=$((((STRIDE_LENGTH - 1)*3/(STRIDE_LENGTH*OSTCOUNT))* \
8726                              (STRIDE_LENGTH*OSTCOUNT - STRIDE_LENGTH)))
8727         DISCARD=$($LCTL get_param -n llite.*.read_ahead_stats |
8728                         get_named_value 'read but discarded' |
8729                         cut -d" " -f1 | calc_total)
8730         if [[ $DISCARD -gt $discard_limit ]]; then
8731                 $LCTL get_param llite.*.read_ahead_stats
8732                 error "Too many ($DISCARD) discarded pages with size (${READ_SIZE})"
8733         else
8734                 echo "Read-ahead success for size ${READ_SIZE}"
8735         fi
8736 }
8737
8738 test_101b() {
8739         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8740         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
8741
8742         local STRIPE_SIZE=1048576
8743         local STRIDE_SIZE=$((STRIPE_SIZE*OSTCOUNT))
8744
8745         if [ $SLOW == "yes" ]; then
8746                 local FILE_LENGTH=$((STRIDE_SIZE * 64))
8747         else
8748                 local FILE_LENGTH=$((STRIDE_SIZE * 8))
8749         fi
8750
8751         local ITERATION=$((FILE_LENGTH / STRIDE_SIZE))
8752
8753         # prepare the read-ahead file
8754         setup_test101bc $STRIPE_SIZE $FILE_LENGTH
8755         cancel_lru_locks osc
8756         for BIDX in 2 4 8 16 32 64 128 256
8757         do
8758                 local BSIZE=$((BIDX*4096))
8759                 local READ_COUNT=$((STRIPE_SIZE/BSIZE))
8760                 local STRIDE_LENGTH=$((STRIDE_SIZE/BSIZE))
8761                 local OFFSET=$((STRIPE_SIZE/BSIZE*(OSTCOUNT - 1)))
8762                 $LCTL set_param -n llite.*.read_ahead_stats 0
8763                 $READS -f $DIR/$tfile  -l $STRIDE_LENGTH -o $OFFSET \
8764                               -s $FILE_LENGTH -b $STRIPE_SIZE -a $READ_COUNT -n $ITERATION
8765                 cancel_lru_locks osc
8766                 ra_check_101 $BSIZE $STRIPE_SIZE $FILE_LENGTH
8767         done
8768         cleanup_test101bc
8769         true
8770 }
8771 run_test 101b "check stride-io mode read-ahead ================="
8772
8773 test_101c() {
8774         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8775
8776         local STRIPE_SIZE=1048576
8777         local FILE_LENGTH=$((STRIPE_SIZE*100))
8778         local nreads=10000
8779         local rsize=65536
8780         local osc_rpc_stats
8781
8782         setup_test101bc $STRIPE_SIZE $FILE_LENGTH
8783
8784         cancel_lru_locks osc
8785         $LCTL set_param osc.*.rpc_stats 0
8786         $READS -f $DIR/$tfile -s$FILE_LENGTH -b$rsize -n$nreads -t 180
8787         $LCTL get_param osc.*.rpc_stats
8788         for osc_rpc_stats in $($LCTL get_param -N osc.*.rpc_stats); do
8789                 local stats=$($LCTL get_param -n $osc_rpc_stats)
8790                 local lines=$(echo "$stats" | awk 'END {print NR;}')
8791                 local size
8792
8793                 if [ $lines -le 20 ]; then
8794                         echo "continue debug"
8795                         continue
8796                 fi
8797                 for size in 1 2 4 8; do
8798                         local rpc=$(echo "$stats" |
8799                                     awk '($1 == "'$size':") {print $2; exit; }')
8800                         [ $rpc != 0 ] && ((size * PAGE_SIZE < rsize)) &&
8801                                 error "Small $((size*PAGE_SIZE)) read IO $rpc!"
8802                 done
8803                 echo "$osc_rpc_stats check passed!"
8804         done
8805         cleanup_test101bc
8806         true
8807 }
8808 run_test 101c "check stripe_size aligned read-ahead ================="
8809
8810 set_read_ahead() {
8811         $LCTL get_param -n llite.*.max_read_ahead_mb | head -n 1
8812         $LCTL set_param -n llite.*.max_read_ahead_mb $1 > /dev/null 2>&1
8813 }
8814
8815 test_101d() {
8816         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8817
8818         local file=$DIR/$tfile
8819         local sz_MB=${FILESIZE_101d:-500}
8820         local ra_MB=${READAHEAD_MB:-40}
8821
8822         local free_MB=$(($(df -P $DIR | tail -n 1 | awk '{ print $4 }') / 1024))
8823         [ $free_MB -lt $sz_MB ] &&
8824                 skip "Need free space ${sz_MB}M, have ${free_MB}M"
8825
8826         echo "Create test file $file size ${sz_MB}M, ${free_MB}M free"
8827         $LFS setstripe -c -1 $file || error "setstripe failed"
8828
8829         dd if=/dev/zero of=$file bs=1M count=$sz_MB || error "dd failed"
8830         echo Cancel LRU locks on lustre client to flush the client cache
8831         cancel_lru_locks osc
8832
8833         echo Disable read-ahead
8834         local old_READAHEAD=$(set_read_ahead 0)
8835
8836         echo Reading the test file $file with read-ahead disabled
8837         local raOFF=$(do_and_time "dd if=$file of=/dev/null bs=1M count=$sz_MB")
8838
8839         echo Cancel LRU locks on lustre client to flush the client cache
8840         cancel_lru_locks osc
8841         echo Enable read-ahead with ${ra_MB}MB
8842         set_read_ahead $ra_MB
8843
8844         echo Reading the test file $file with read-ahead enabled
8845         local raON=$(do_and_time "dd if=$file of=/dev/null bs=1M count=$sz_MB")
8846
8847         echo "read-ahead disabled time read $raOFF"
8848         echo "read-ahead enabled  time read $raON"
8849
8850         set_read_ahead $old_READAHEAD
8851         rm -f $file
8852         wait_delete_completed
8853
8854         [ $raOFF -le 1 ] || [ $raON -lt $raOFF ] ||
8855                 error "readahead ${raON}s > no-readahead ${raOFF}s ${sz_MB}M"
8856 }
8857 run_test 101d "file read with and without read-ahead enabled"
8858
8859 test_101e() {
8860         [ $PARALLEL == "yes" ] && skip "skip parallel run"
8861
8862         local file=$DIR/$tfile
8863         local size_KB=500  #KB
8864         local count=100
8865         local bsize=1024
8866
8867         local free_KB=$(df -P $DIR | tail -n 1 | awk '{ print $4 }')
8868         local need_KB=$((count * size_KB))
8869         [[ $free_KB -le $need_KB ]] &&
8870                 skip_env "Need free space $need_KB, have $free_KB"
8871
8872         echo "Creating $count ${size_KB}K test files"
8873         for ((i = 0; i < $count; i++)); do
8874                 dd if=/dev/zero of=$file.$i bs=$bsize count=$size_KB 2>/dev/null
8875         done
8876
8877         echo "Cancel LRU locks on lustre client to flush the client cache"
8878         cancel_lru_locks $OSC
8879
8880         echo "Reset readahead stats"
8881         $LCTL set_param -n llite.*.read_ahead_stats 0
8882
8883         for ((i = 0; i < $count; i++)); do
8884                 dd if=$file.$i of=/dev/null bs=$bsize count=$size_KB 2>/dev/null
8885         done
8886
8887         local miss=$($LCTL get_param -n llite.*.read_ahead_stats |
8888                      get_named_value 'misses' | cut -d" " -f1 | calc_total)
8889
8890         for ((i = 0; i < $count; i++)); do
8891                 rm -rf $file.$i 2>/dev/null
8892         done
8893
8894         #10000 means 20% reads are missing in readahead
8895         [[ $miss -lt 10000 ]] ||  error "misses too much for small reads"
8896 }
8897 run_test 101e "check read-ahead for small read(1k) for small files(500k)"
8898
8899 test_101f() {
8900         which iozone || skip_env "no iozone installed"
8901
8902         local old_debug=$($LCTL get_param debug)
8903         old_debug=${old_debug#*=}
8904         $LCTL set_param debug="reada mmap"
8905
8906         # create a test file
8907         iozone -i 0 -+n -r 1m -s 128m -w -f $DIR/$tfile > /dev/null 2>&1
8908
8909         echo Cancel LRU locks on lustre client to flush the client cache
8910         cancel_lru_locks osc
8911
8912         echo Reset readahead stats
8913         $LCTL set_param -n llite.*.read_ahead_stats 0
8914
8915         echo mmap read the file with small block size
8916         iozone -i 1 -u 1 -l 1 -+n -r 32k -s 128m -B -f $DIR/$tfile \
8917                 > /dev/null 2>&1
8918
8919         echo checking missing pages
8920         $LCTL get_param llite.*.read_ahead_stats
8921         local miss=$($LCTL get_param -n llite.*.read_ahead_stats |
8922                         get_named_value 'misses' | cut -d" " -f1 | calc_total)
8923
8924         $LCTL set_param debug="$old_debug"
8925         [ $miss -lt 3 ] || error "misses too much pages ('$miss')!"
8926         rm -f $DIR/$tfile
8927 }
8928 run_test 101f "check mmap read performance"
8929
8930 test_101g_brw_size_test() {
8931         local mb=$1
8932         local pages=$((mb * 1048576 / PAGE_SIZE))
8933         local file=$DIR/$tfile
8934
8935         $LCTL set_param osc.*.max_pages_per_rpc=${mb}M ||
8936                 { error "unable to set max_pages_per_rpc=${mb}M"; return 1; }
8937         for mp in $($LCTL get_param -n osc.*.max_pages_per_rpc); do
8938                 [ $mp -ne $pages ] && error "max_pages_per_rpc $mp != $pages" &&
8939                         return 2
8940         done
8941
8942         stack_trap "rm -f $file" EXIT
8943         $LCTL set_param -n osc.*.rpc_stats=0
8944
8945         # 10 RPCs should be enough for the test
8946         local count=10
8947         dd if=/dev/zero of=$file bs=${mb}M count=$count ||
8948                 { error "dd write ${mb} MB blocks failed"; return 3; }
8949         cancel_lru_locks osc
8950         dd of=/dev/null if=$file bs=${mb}M count=$count ||
8951                 { error "dd write ${mb} MB blocks failed"; return 4; }
8952
8953         # calculate number of full-sized read and write RPCs
8954         rpcs=($($LCTL get_param -n 'osc.*.rpc_stats' |
8955                 sed -n '/pages per rpc/,/^$/p' |
8956                 awk '/'$pages':/ { reads += $2; writes += $6 }; \
8957                 END { print reads,writes }'))
8958         [ ${rpcs[0]} -ne $count ] && error "${rpcs[0]} != $count read RPCs" &&
8959                 return 5
8960         [ ${rpcs[1]} -ne $count ] && error "${rpcs[1]} != $count write RPCs" &&
8961                 return 6
8962
8963         return 0
8964 }
8965
8966 test_101g() {
8967         remote_ost_nodsh && skip "remote OST with nodsh"
8968
8969         local rpcs
8970         local osts=$(get_facets OST)
8971         local list=$(comma_list $(osts_nodes))
8972         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
8973         local brw_size="obdfilter.*.brw_size"
8974
8975         $LFS setstripe -i 0 -c 1 $DIR/$tfile
8976
8977         local orig_mb=$(do_facet ost1 $LCTL get_param -n $brw_size | head -n 1)
8978
8979         if { [ $OST1_VERSION -ge $(version_code 2.8.52) ] ||
8980                 { [ $OST1_VERSION -ge $(version_code 2.7.17) ] &&
8981                   [ $OST1_VERSION -lt $(version_code 2.7.50) ]; }; } &&
8982            { [ $CLIENT_VERSION -ge $(version_code 2.8.52) ] ||
8983                 { [ $CLIENT_VERSION -ge $(version_code 2.7.17) ] &&
8984                   [ $CLIENT_VERSION -lt $(version_code 2.7.50) ]; }; }; then
8985
8986                 [ $OST1_VERSION -ge $(version_code 2.9.52) ] &&
8987                         suffix="M"
8988
8989                 if [[ $orig_mb -lt 16 ]]; then
8990                         save_lustre_params $osts "$brw_size" > $p
8991                         do_nodes $list $LCTL set_param -n $brw_size=16$suffix ||
8992                                 error "set 16MB RPC size failed"
8993
8994                         echo "remount client to enable new RPC size"
8995                         remount_client $MOUNT || error "remount_client failed"
8996                 fi
8997
8998                 test_101g_brw_size_test 16 || error "16MB RPC test failed"
8999                 # should be able to set brw_size=12, but no rpc_stats for that
9000                 test_101g_brw_size_test 8 || error "8MB RPC test failed"
9001         fi
9002
9003         test_101g_brw_size_test 4 || error "4MB RPC test failed"
9004
9005         if [[ $orig_mb -lt 16 ]]; then
9006                 restore_lustre_params < $p
9007                 remount_client $MOUNT || error "remount_client restore failed"
9008         fi
9009
9010         rm -f $p $DIR/$tfile
9011 }
9012 run_test 101g "Big bulk(4/16 MiB) readahead"
9013
9014 test_101h() {
9015         $LFS setstripe -i 0 -c 1 $DIR/$tfile
9016
9017         dd if=/dev/zero of=$DIR/$tfile bs=1M count=70 ||
9018                 error "dd 70M file failed"
9019         echo Cancel LRU locks on lustre client to flush the client cache
9020         cancel_lru_locks osc
9021
9022         echo "Reset readahead stats"
9023         $LCTL set_param -n llite.*.read_ahead_stats 0
9024
9025         echo "Read 10M of data but cross 64M bundary"
9026         dd if=$DIR/$tfile of=/dev/null bs=10M skip=6 count=1
9027         local miss=$($LCTL get_param -n llite.*.read_ahead_stats |
9028                         get_named_value 'misses' | cut -d" " -f1 | calc_total)
9029         [ $miss -eq 1 ] || error "expected miss 1 but got $miss"
9030         rm -f $p $DIR/$tfile
9031 }
9032 run_test 101h "Readahead should cover current read window"
9033
9034 setup_test102() {
9035         test_mkdir $DIR/$tdir
9036         chown $RUNAS_ID $DIR/$tdir
9037         STRIPE_SIZE=65536
9038         STRIPE_OFFSET=1
9039         STRIPE_COUNT=$OSTCOUNT
9040         [[ $OSTCOUNT -gt 4 ]] && STRIPE_COUNT=4
9041
9042         trap cleanup_test102 EXIT
9043         cd $DIR
9044         $1 $LFS setstripe -S $STRIPE_SIZE -i $STRIPE_OFFSET -c $STRIPE_COUNT $tdir
9045         cd $DIR/$tdir
9046         for num in 1 2 3 4; do
9047                 for count in $(seq 1 $STRIPE_COUNT); do
9048                         for idx in $(seq 0 $[$STRIPE_COUNT - 1]); do
9049                                 local size=`expr $STRIPE_SIZE \* $num`
9050                                 local file=file"$num-$idx-$count"
9051                                 $1 $LFS setstripe -S $size -i $idx -c $count $file
9052                         done
9053                 done
9054         done
9055
9056         cd $DIR
9057         $1 tar cf $TMP/f102.tar $tdir --xattrs
9058 }
9059
9060 cleanup_test102() {
9061         trap 0
9062         rm -f $TMP/f102.tar
9063         rm -rf $DIR/d0.sanity/d102
9064 }
9065
9066 test_102a() {
9067         [ "$UID" != 0 ] && skip "must run as root"
9068         [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep xattr)" ] &&
9069                 skip_env "must have user_xattr"
9070
9071         [ -z "$(which setfattr 2>/dev/null)" ] &&
9072                 skip_env "could not find setfattr"
9073
9074         local testfile=$DIR/$tfile
9075
9076         touch $testfile
9077         echo "set/get xattr..."
9078         setfattr -n trusted.name1 -v value1 $testfile ||
9079                 error "setfattr -n trusted.name1=value1 $testfile failed"
9080         getfattr -n trusted.name1 $testfile 2> /dev/null |
9081           grep "trusted.name1=.value1" ||
9082                 error "$testfile missing trusted.name1=value1"
9083
9084         setfattr -n user.author1 -v author1 $testfile ||
9085                 error "setfattr -n user.author1=author1 $testfile failed"
9086         getfattr -n user.author1 $testfile 2> /dev/null |
9087           grep "user.author1=.author1" ||
9088                 error "$testfile missing trusted.author1=author1"
9089
9090         echo "listxattr..."
9091         setfattr -n trusted.name2 -v value2 $testfile ||
9092                 error "$testfile unable to set trusted.name2"
9093         setfattr -n trusted.name3 -v value3 $testfile ||
9094                 error "$testfile unable to set trusted.name3"
9095         [ $(getfattr -d -m "^trusted" $testfile 2> /dev/null |
9096             grep "trusted.name" | wc -l) -eq 3 ] ||
9097                 error "$testfile missing 3 trusted.name xattrs"
9098
9099         setfattr -n user.author2 -v author2 $testfile ||
9100                 error "$testfile unable to set user.author2"
9101         setfattr -n user.author3 -v author3 $testfile ||
9102                 error "$testfile unable to set user.author3"
9103         [ $(getfattr -d -m "^user" $testfile 2> /dev/null |
9104             grep "user.author" | wc -l) -eq 3 ] ||
9105                 error "$testfile missing 3 user.author xattrs"
9106
9107         echo "remove xattr..."
9108         setfattr -x trusted.name1 $testfile ||
9109                 error "$testfile error deleting trusted.name1"
9110         getfattr -d -m trusted $testfile 2> /dev/null | grep "trusted.name1" &&
9111                 error "$testfile did not delete trusted.name1 xattr"
9112
9113         setfattr -x user.author1 $testfile ||
9114                 error "$testfile error deleting user.author1"
9115         echo "set lustre special xattr ..."
9116         $LFS setstripe -c1 $testfile
9117         local lovea=$(getfattr -n "trusted.lov" -e hex $testfile |
9118                 awk -F "=" '/trusted.lov/ { print $2 }' )
9119         setfattr -n "trusted.lov" -v $lovea $testfile ||
9120                 error "$testfile doesn't ignore setting trusted.lov again"
9121         setfattr -n "trusted.lov" -v "invalid_value" $testfile &&
9122                 error "$testfile allow setting invalid trusted.lov"
9123         rm -f $testfile
9124 }
9125 run_test 102a "user xattr test =================================="
9126
9127 test_102b() {
9128         [ -z "$(which setfattr 2>/dev/null)" ] &&
9129                 skip_env "could not find setfattr"
9130         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
9131
9132         # b10930: get/set/list trusted.lov xattr
9133         echo "get/set/list trusted.lov xattr ..."
9134         local testfile=$DIR/$tfile
9135         $LFS setstripe -S 65536 -i 1 -c $OSTCOUNT $testfile ||
9136                 error "setstripe failed"
9137         local STRIPECOUNT=$($LFS getstripe -c $testfile) ||
9138                 error "getstripe failed"
9139         getfattr -d -m "^trusted" $testfile 2>/dev/null | grep "trusted.lov" ||
9140                 error "can't get trusted.lov from $testfile"
9141
9142         local testfile2=${testfile}2
9143         local value=$(getfattr -n trusted.lov $testfile 2>/dev/null |
9144                         grep "trusted.lov" | sed -e 's/[^=]\+=//')
9145
9146         $MCREATE $testfile2
9147         setfattr -n trusted.lov -v $value $testfile2
9148         local stripe_size=$($LFS getstripe -S $testfile2)
9149         local stripe_count=$($LFS getstripe -c $testfile2)
9150         [[ $stripe_size -eq 65536 ]] ||
9151                 error "stripe size $stripe_size != 65536"
9152         [[ $stripe_count -eq $STRIPECOUNT ]] ||
9153                 error "stripe count $stripe_count != $STRIPECOUNT"
9154         rm -f $DIR/$tfile
9155 }
9156 run_test 102b "getfattr/setfattr for trusted.lov EAs ============"
9157
9158 test_102c() {
9159         [ -z "$(which setfattr 2>/dev/null)" ] &&
9160                 skip_env "could not find setfattr"
9161         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
9162
9163         # b10930: get/set/list lustre.lov xattr
9164         echo "get/set/list lustre.lov xattr ..."
9165         test_mkdir $DIR/$tdir
9166         chown $RUNAS_ID $DIR/$tdir
9167         local testfile=$DIR/$tdir/$tfile
9168         $RUNAS $LFS setstripe -S 65536 -i 1 -c $OSTCOUNT $testfile ||
9169                 error "setstripe failed"
9170         local STRIPECOUNT=$($RUNAS $LFS getstripe -c $testfile) ||
9171                 error "getstripe failed"
9172         $RUNAS getfattr -d -m "^lustre" $testfile 2> /dev/null | \
9173         grep "lustre.lov" || error "can't get lustre.lov from $testfile"
9174
9175         local testfile2=${testfile}2
9176         local value=`getfattr -n lustre.lov $testfile 2> /dev/null | \
9177                      grep "lustre.lov" |sed -e 's/[^=]\+=//'  `
9178
9179         $RUNAS $MCREATE $testfile2
9180         $RUNAS setfattr -n lustre.lov -v $value $testfile2
9181         local stripe_size=$($RUNAS $LFS getstripe -S $testfile2)
9182         local stripe_count=$($RUNAS $LFS getstripe -c $testfile2)
9183         [ $stripe_size -eq 65536 ] || error "stripe size $stripe_size != 65536"
9184         [ $stripe_count -eq $STRIPECOUNT ] ||
9185                 error "stripe count $stripe_count != $STRIPECOUNT"
9186 }
9187 run_test 102c "non-root getfattr/setfattr for lustre.lov EAs ==========="
9188
9189 compare_stripe_info1() {
9190         local stripe_index_all_zero=true
9191
9192         for num in 1 2 3 4; do
9193                 for count in $(seq 1 $STRIPE_COUNT); do
9194                         for offset in $(seq 0 $[$STRIPE_COUNT - 1]); do
9195                                 local size=$((STRIPE_SIZE * num))
9196                                 local file=file"$num-$offset-$count"
9197                                 stripe_size=$($LFS getstripe -S $PWD/$file)
9198                                 [[ $stripe_size -ne $size ]] &&
9199                                     error "$file: size $stripe_size != $size"
9200                                 stripe_count=$($LFS getstripe -c $PWD/$file)
9201                                 # allow fewer stripes to be created, ORI-601
9202                                 [[ $stripe_count -lt $(((3 * count + 3) / 4)) ]] &&
9203                                     error "$file: count $stripe_count != $count"
9204                                 stripe_index=$($LFS getstripe -i $PWD/$file)
9205                                 [[ $stripe_index -ne 0 ]] &&
9206                                         stripe_index_all_zero=false
9207                         done
9208                 done
9209         done
9210         $stripe_index_all_zero &&
9211                 error "all files are being extracted starting from OST index 0"
9212         return 0
9213 }
9214
9215 have_xattrs_include() {
9216         tar --help | grep -q xattrs-include &&
9217                 echo --xattrs-include="lustre.*"
9218 }
9219
9220 test_102d() {
9221         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9222         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
9223
9224         XINC=$(have_xattrs_include)
9225         setup_test102
9226         tar xf $TMP/f102.tar -C $DIR/$tdir --xattrs $XINC
9227         cd $DIR/$tdir/$tdir
9228         compare_stripe_info1
9229 }
9230 run_test 102d "tar restore stripe info from tarfile,not keep osts"
9231
9232 test_102f() {
9233         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9234         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
9235
9236         XINC=$(have_xattrs_include)
9237         setup_test102
9238         test_mkdir $DIR/$tdir.restore
9239         cd $DIR
9240         tar cf - --xattrs $tdir | tar xf - \
9241                 -C $DIR/$tdir.restore --xattrs $XINC
9242         cd $DIR/$tdir.restore/$tdir
9243         compare_stripe_info1
9244 }
9245 run_test 102f "tar copy files, not keep osts"
9246
9247 grow_xattr() {
9248         [ -z "$(lctl get_param -n mdc.*.connect_flags | grep xattr)" ] &&
9249                 skip "must have user_xattr"
9250         [ -z "$(which setfattr 2>/dev/null)" ] &&
9251                 skip_env "could not find setfattr"
9252         [ -z "$(which getfattr 2>/dev/null)" ] &&
9253                 skip_env "could not find getfattr"
9254
9255         local xsize=${1:-1024}  # in bytes
9256         local file=$DIR/$tfile
9257         local value="$(generate_string $xsize)"
9258         local xbig=trusted.big
9259         local toobig=$2
9260
9261         touch $file
9262         log "save $xbig on $file"
9263         if [ -z "$toobig" ]
9264         then
9265                 setfattr -n $xbig -v $value $file ||
9266                         error "saving $xbig on $file failed"
9267         else
9268                 setfattr -n $xbig -v $value $file &&
9269                         error "saving $xbig on $file succeeded"
9270                 return 0
9271         fi
9272
9273         local orig=$(get_xattr_value $xbig $file)
9274         [[ "$orig" != "$value" ]] && error "$xbig different after saving $xbig"
9275
9276         local xsml=trusted.sml
9277         log "save $xsml on $file"
9278         setfattr -n $xsml -v val $file || error "saving $xsml on $file failed"
9279
9280         local new=$(get_xattr_value $xbig $file)
9281         [[ "$new" != "$orig" ]] && error "$xbig different after saving $xsml"
9282
9283         log "grow $xsml on $file"
9284         setfattr -n $xsml -v "$value" $file ||
9285                 error "growing $xsml on $file failed"
9286
9287         new=$(get_xattr_value $xbig $file)
9288         [[ "$new" != "$orig" ]] && error "$xbig different after growing $xsml"
9289         log "$xbig still valid after growing $xsml"
9290
9291         rm -f $file
9292 }
9293
9294 test_102h() { # bug 15777
9295         grow_xattr 1024
9296 }
9297 run_test 102h "grow xattr from inside inode to external block"
9298
9299 test_102ha() {
9300         large_xattr_enabled || skip_env "ea_inode feature disabled"
9301
9302         echo "setting xattr of max xattr size: $(max_xattr_size)"
9303         grow_xattr $(max_xattr_size)
9304
9305         echo "setting xattr of > max xattr size: $(max_xattr_size) + 10"
9306         echo "This should fail:"
9307         grow_xattr $(($(max_xattr_size) + 10)) 1
9308 }
9309 run_test 102ha "grow xattr from inside inode to external inode"
9310
9311 test_102i() { # bug 17038
9312         [ -z "$(which getfattr 2>/dev/null)" ] &&
9313                 skip "could not find getfattr"
9314
9315         touch $DIR/$tfile
9316         ln -s $DIR/$tfile $DIR/${tfile}link
9317         getfattr -n trusted.lov $DIR/$tfile ||
9318                 error "lgetxattr on $DIR/$tfile failed"
9319         getfattr -h -n trusted.lov $DIR/${tfile}link 2>&1 |
9320                 grep -i "no such attr" ||
9321                 error "error for lgetxattr on $DIR/${tfile}link is not ENODATA"
9322         rm -f $DIR/$tfile $DIR/${tfile}link
9323 }
9324 run_test 102i "lgetxattr test on symbolic link ============"
9325
9326 test_102j() {
9327         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9328         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
9329
9330         XINC=$(have_xattrs_include)
9331         setup_test102 "$RUNAS"
9332         chown $RUNAS_ID $DIR/$tdir
9333         $RUNAS tar xf $TMP/f102.tar -C $DIR/$tdir --xattrs $XINC
9334         cd $DIR/$tdir/$tdir
9335         compare_stripe_info1 "$RUNAS"
9336 }
9337 run_test 102j "non-root tar restore stripe info from tarfile, not keep osts ==="
9338
9339 test_102k() {
9340         [ -z "$(which setfattr 2>/dev/null)" ] &&
9341                 skip "could not find setfattr"
9342
9343         touch $DIR/$tfile
9344         # b22187 just check that does not crash for regular file.
9345         setfattr -n trusted.lov $DIR/$tfile
9346         # b22187 'setfattr -n trusted.lov' should remove LOV EA for directories
9347         local test_kdir=$DIR/$tdir
9348         test_mkdir $test_kdir
9349         local default_size=$($LFS getstripe -S $test_kdir)
9350         local default_count=$($LFS getstripe -c $test_kdir)
9351         local default_offset=$($LFS getstripe -i $test_kdir)
9352         $LFS setstripe -S 65536 -i 0 -c $OSTCOUNT $test_kdir ||
9353                 error 'dir setstripe failed'
9354         setfattr -n trusted.lov $test_kdir
9355         local stripe_size=$($LFS getstripe -S $test_kdir)
9356         local stripe_count=$($LFS getstripe -c $test_kdir)
9357         local stripe_offset=$($LFS getstripe -i $test_kdir)
9358         [ $stripe_size -eq $default_size ] ||
9359                 error "stripe size $stripe_size != $default_size"
9360         [ $stripe_count -eq $default_count ] ||
9361                 error "stripe count $stripe_count != $default_count"
9362         [ $stripe_offset -eq $default_offset ] ||
9363                 error "stripe offset $stripe_offset != $default_offset"
9364         rm -rf $DIR/$tfile $test_kdir
9365 }
9366 run_test 102k "setfattr without parameter of value shouldn't cause a crash"
9367
9368 test_102l() {
9369         [ -z "$(which getfattr 2>/dev/null)" ] &&
9370                 skip "could not find getfattr"
9371
9372         # LU-532 trusted. xattr is invisible to non-root
9373         local testfile=$DIR/$tfile
9374
9375         touch $testfile
9376
9377         echo "listxattr as user..."
9378         chown $RUNAS_ID $testfile
9379         $RUNAS getfattr -d -m '.*' $testfile 2>&1 |
9380             grep -q "trusted" &&
9381                 error "$testfile trusted xattrs are user visible"
9382
9383         return 0;
9384 }
9385 run_test 102l "listxattr size test =================================="
9386
9387 test_102m() { # LU-3403 llite: error of listxattr when buffer is small
9388         local path=$DIR/$tfile
9389         touch $path
9390
9391         listxattr_size_check $path || error "listattr_size_check $path failed"
9392 }
9393 run_test 102m "Ensure listxattr fails on small bufffer ========"
9394
9395 cleanup_test102
9396
9397 getxattr() { # getxattr path name
9398         # Return the base64 encoding of the value of xattr name on path.
9399         local path=$1
9400         local name=$2
9401
9402         # # getfattr --absolute-names --encoding=base64 --name=trusted.lov $path
9403         # file: $path
9404         # trusted.lov=0s0AvRCwEAAAAGAAAAAAAAAAAEAAACAAAAAAAQAAEAA...AAAAAAAAA=
9405         #
9406         # We print just 0s0AvRCwEAAAAGAAAAAAAAAAAEAAACAAAAAAAQAAEAA...AAAAAAAAA=
9407
9408         getfattr --absolute-names --encoding=base64 --name=$name $path |
9409                 awk -F= -v name=$name '$1 == name {
9410                         print substr($0, index($0, "=") + 1);
9411         }'
9412 }
9413
9414 test_102n() { # LU-4101 mdt: protect internal xattrs
9415         [ -z "$(which setfattr 2>/dev/null)" ] &&
9416                 skip "could not find setfattr"
9417         if [ $MDS1_VERSION -lt $(version_code 2.5.50) ]
9418         then
9419                 skip "MDT < 2.5.50 allows setxattr on internal trusted xattrs"
9420         fi
9421
9422         local file0=$DIR/$tfile.0
9423         local file1=$DIR/$tfile.1
9424         local xattr0=$TMP/$tfile.0
9425         local xattr1=$TMP/$tfile.1
9426         local namelist="lov lma lmv link fid version som hsm"
9427         local name
9428         local value
9429
9430         rm -rf $file0 $file1 $xattr0 $xattr1
9431         touch $file0 $file1
9432
9433         # Get 'before' xattrs of $file1.
9434         getfattr --absolute-names --dump --match=- $file1 > $xattr0
9435
9436         [ $MDS1_VERSION -lt $(version_code 2.8.53) ] &&
9437                 namelist+=" lfsck_namespace"
9438         for name in $namelist; do
9439                 # Try to copy xattr from $file0 to $file1.
9440                 value=$(getxattr $file0 trusted.$name 2> /dev/null)
9441
9442                 setfattr --name=trusted.$name --value="$value" $file1 ||
9443                         error "setxattr 'trusted.$name' failed"
9444
9445                 # Try to set a garbage xattr.
9446                 value=0sVGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIGl0c2VsZi4=
9447
9448                 if [[ x$name == "xlov" ]]; then
9449                         setfattr --name=trusted.lov --value="$value" $file1 &&
9450                         error "setxattr invalid 'trusted.lov' success"
9451                 else
9452                         setfattr --name=trusted.$name --value="$value" $file1 ||
9453                                 error "setxattr invalid 'trusted.$name' failed"
9454                 fi
9455
9456                 # Try to remove the xattr from $file1. We don't care if this
9457                 # appears to succeed or fail, we just don't want there to be
9458                 # any changes or crashes.
9459                 setfattr --remove=$trusted.$name $file1 2> /dev/null
9460         done
9461
9462         if [ $MDS1_VERSION -gt $(version_code 2.6.50) ]
9463         then
9464                 name="lfsck_ns"
9465                 # Try to copy xattr from $file0 to $file1.
9466                 value=$(getxattr $file0 trusted.$name 2> /dev/null)
9467
9468                 setfattr --name=trusted.$name --value="$value" $file1 ||
9469                         error "setxattr 'trusted.$name' failed"
9470
9471                 # Try to set a garbage xattr.
9472                 value=0sVGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIGl0c2VsZi4=
9473
9474                 setfattr --name=trusted.$name --value="$value" $file1 ||
9475                         error "setxattr 'trusted.$name' failed"
9476
9477                 # Try to remove the xattr from $file1. We don't care if this
9478                 # appears to succeed or fail, we just don't want there to be
9479                 # any changes or crashes.
9480                 setfattr --remove=$trusted.$name $file1 2> /dev/null
9481         fi
9482
9483         # Get 'after' xattrs of file1.
9484         getfattr --absolute-names --dump --match=- $file1 > $xattr1
9485
9486         if ! diff $xattr0 $xattr1; then
9487                 error "before and after xattrs of '$file1' differ"
9488         fi
9489
9490         rm -rf $file0 $file1 $xattr0 $xattr1
9491
9492         return 0
9493 }
9494 run_test 102n "silently ignore setxattr on internal trusted xattrs"
9495
9496 test_102p() { # LU-4703 setxattr did not check ownership
9497         [ $MDS1_VERSION -lt $(version_code 2.5.56) ] &&
9498                 skip "MDS needs to be at least 2.5.56"
9499
9500         local testfile=$DIR/$tfile
9501
9502         touch $testfile
9503
9504         echo "setfacl as user..."
9505         $RUNAS setfacl -m "u:$RUNAS_ID:rwx" $testfile
9506         [ $? -ne 0 ] || error "setfacl by $RUNAS_ID was allowed on $testfile"
9507
9508         echo "setfattr as user..."
9509         setfacl -m "u:$RUNAS_ID:---" $testfile
9510         $RUNAS setfattr -x system.posix_acl_access $testfile
9511         [ $? -ne 0 ] || error "setfattr by $RUNAS_ID was allowed on $testfile"
9512 }
9513 run_test 102p "check setxattr(2) correctly fails without permission"
9514
9515 test_102q() {
9516         [ $MDS1_VERSION -lt $(version_code 2.6.92) ] &&
9517                 skip "MDS needs to be at least 2.6.92"
9518
9519         orphan_linkea_check $DIR/$tfile || error "orphan_linkea_check"
9520 }
9521 run_test 102q "flistxattr should not return trusted.link EAs for orphans"
9522
9523 test_102r() {
9524         [ $MDS1_VERSION -lt $(version_code 2.6.93) ] &&
9525                 skip "MDS needs to be at least 2.6.93"
9526
9527         touch $DIR/$tfile || error "touch"
9528         setfattr -n user.$(basename $tfile) $DIR/$tfile || error "setfattr"
9529         getfattr -n user.$(basename $tfile) $DIR/$tfile || error "getfattr"
9530         rm $DIR/$tfile || error "rm"
9531
9532         #normal directory
9533         mkdir -p $DIR/$tdir || error "mkdir"
9534         setfattr -n user.$(basename $tdir) $DIR/$tdir || error "setfattr dir"
9535         getfattr -n user.$(basename $tdir) $DIR/$tdir || error "getfattr dir"
9536         setfattr -x user.$(basename $tdir) $DIR/$tdir ||
9537                 error "$testfile error deleting user.author1"
9538         getfattr -d -m user.$(basename $tdir) 2> /dev/null |
9539                 grep "user.$(basename $tdir)" &&
9540                 error "$tdir did not delete user.$(basename $tdir)"
9541         rmdir $DIR/$tdir || error "rmdir"
9542
9543         #striped directory
9544         test_mkdir $DIR/$tdir
9545         setfattr -n user.$(basename $tdir) $DIR/$tdir || error "setfattr dir"
9546         getfattr -n user.$(basename $tdir) $DIR/$tdir || error "getfattr dir"
9547         setfattr -x user.$(basename $tdir) $DIR/$tdir ||
9548                 error "$testfile error deleting user.author1"
9549         getfattr -d -m user.$(basename $tdir) 2> /dev/null |
9550                 grep "user.$(basename $tdir)" &&
9551                 error "$tdir did not delete user.$(basename $tdir)"
9552         rmdir $DIR/$tdir || error "rm striped dir"
9553 }
9554 run_test 102r "set EAs with empty values"
9555
9556 test_102s() {
9557         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
9558                 skip "MDS needs to be at least 2.11.52"
9559
9560         local save="$TMP/$TESTSUITE-$TESTNAME.parameters"
9561
9562         save_lustre_params client "llite.*.xattr_cache" > $save
9563
9564         for cache in 0 1; do
9565                 lctl set_param llite.*.xattr_cache=$cache
9566
9567                 rm -f $DIR/$tfile
9568                 touch $DIR/$tfile || error "touch"
9569                 for prefix in lustre security system trusted user; do
9570                         # Note getxattr() may fail with 'Operation not
9571                         # supported' or 'No such attribute' depending
9572                         # on prefix and cache.
9573                         getfattr -n $prefix.n102s $DIR/$tfile &&
9574                                 error "getxattr '$prefix.n102s' should fail (cache = $cache)"
9575                 done
9576         done
9577
9578         restore_lustre_params < $save
9579 }
9580 run_test 102s "getting nonexistent xattrs should fail"
9581
9582 test_102t() {
9583         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
9584                 skip "MDS needs to be at least 2.11.52"
9585
9586         local save="$TMP/$TESTSUITE-$TESTNAME.parameters"
9587
9588         save_lustre_params client "llite.*.xattr_cache" > $save
9589
9590         for cache in 0 1; do
9591                 lctl set_param llite.*.xattr_cache=$cache
9592
9593                 for buf_size in 0 256; do
9594                         rm -f $DIR/$tfile
9595                         touch $DIR/$tfile || error "touch"
9596                         setfattr -n user.multiop $DIR/$tfile
9597                         $MULTIOP $DIR/$tfile oa$buf_size ||
9598                                 error "cannot get zero length xattr value (buf_size = $buf_size)"
9599                 done
9600         done
9601
9602         restore_lustre_params < $save
9603 }
9604 run_test 102t "zero length xattr values handled correctly"
9605
9606 run_acl_subtest()
9607 {
9608     $LUSTRE/tests/acl/run $LUSTRE/tests/acl/$1.test
9609     return $?
9610 }
9611
9612 test_103a() {
9613         [ "$UID" != 0 ] && skip "must run as root"
9614         $GSS && skip_env "could not run under gss"
9615         [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep acl)" ] &&
9616                 skip_env "must have acl enabled"
9617         [ -z "$(which setfacl 2>/dev/null)" ] &&
9618                 skip_env "could not find setfacl"
9619         remote_mds_nodsh && skip "remote MDS with nodsh"
9620
9621         gpasswd -a daemon bin                           # LU-5641
9622         do_facet $SINGLEMDS gpasswd -a daemon bin       # LU-5641
9623
9624         declare -a identity_old
9625
9626         for num in $(seq $MDSCOUNT); do
9627                 switch_identity $num true || identity_old[$num]=$?
9628         done
9629
9630         SAVE_UMASK=$(umask)
9631         umask 0022
9632         mkdir -p $DIR/$tdir
9633         cd $DIR/$tdir
9634
9635         echo "performing cp ..."
9636         run_acl_subtest cp || error "run_acl_subtest cp failed"
9637         echo "performing getfacl-noacl..."
9638         run_acl_subtest getfacl-noacl || error "getfacl-noacl test failed"
9639         echo "performing misc..."
9640         run_acl_subtest misc || error  "misc test failed"
9641         echo "performing permissions..."
9642         run_acl_subtest permissions || error "permissions failed"
9643         # LU-1482 mdd: Setting xattr are properly checked with and without ACLs
9644         if [ $MDS1_VERSION -gt $(version_code 2.8.55) ] ||
9645                 { [ $MDS1_VERSION -lt $(version_code 2.6) ] &&
9646                         [ $MDS1_VERSION -ge $(version_code 2.5.29) ]; }
9647         then
9648                 echo "performing permissions xattr..."
9649                 run_acl_subtest permissions_xattr ||
9650                         error "permissions_xattr failed"
9651         fi
9652         echo "performing setfacl..."
9653         run_acl_subtest setfacl || error  "setfacl test failed"
9654
9655         # inheritance test got from HP
9656         echo "performing inheritance..."
9657         cp $LUSTRE/tests/acl/make-tree . || error "cannot copy make-tree"
9658         chmod +x make-tree || error "chmod +x failed"
9659         run_acl_subtest inheritance || error "inheritance test failed"
9660         rm -f make-tree
9661
9662         echo "LU-974 ignore umask when acl is enabled..."
9663         run_acl_subtest 974 || error "LU-974 umask test failed"
9664         if [ $MDSCOUNT -ge 2 ]; then
9665                 run_acl_subtest 974_remote ||
9666                         error "LU-974 umask test failed under remote dir"
9667         fi
9668
9669         echo "LU-2561 newly created file is same size as directory..."
9670         if [ "$mds1_FSTYPE" != "zfs" ]; then
9671                 run_acl_subtest 2561 || error "LU-2561 test failed"
9672         else
9673                 run_acl_subtest 2561_zfs || error "LU-2561 zfs test failed"
9674         fi
9675
9676         run_acl_subtest 4924 || error "LU-4924 test failed"
9677
9678         cd $SAVE_PWD
9679         umask $SAVE_UMASK
9680
9681         for num in $(seq $MDSCOUNT); do
9682                 if [ "${identity_old[$num]}" = 1 ]; then
9683                         switch_identity $num false || identity_old[$num]=$?
9684                 fi
9685         done
9686 }
9687 run_test 103a "acl test"
9688
9689 test_103b() {
9690         declare -a pids
9691         local U
9692
9693         for U in {0..511}; do
9694                 {
9695                 local O=$(printf "%04o" $U)
9696
9697                 umask $(printf "%04o" $((511 ^ $O)))
9698                 $LFS setstripe -c 1 $DIR/$tfile.s$O
9699                 local S=$(printf "%04o" 0$(stat -c%a $DIR/$tfile.s$O))
9700
9701                 (( $S == ($O & 0666) )) ||
9702                         error "lfs setstripe $DIR/$tfile.s$O '$S' != '$O'"
9703
9704                 $LFS setstripe -E16M -c 1 -E1G -S4M $DIR/$tfile.p$O
9705                 S=$(printf "%04o" 0$(stat -c%a $DIR/$tfile.p$O))
9706                 (( $S == ($O & 0666) )) ||
9707                         error "lfs setstripe -E $DIR/$tfile.p$O '$S' != '$O'"
9708
9709                 $LFS setstripe -N2 -c 1 $DIR/$tfile.m$O
9710                 S=$(printf "%04o" 0$(stat -c%a $DIR/$tfile.m$O))
9711                 (( $S == ($O & 0666) )) ||
9712                         error "lfs setstripe -N2 $DIR/$tfile.m$O '$S' != '$O'"
9713                 rm -f $DIR/$tfile.[smp]$0
9714                 } &
9715                 local pid=$!
9716
9717                 # limit the concurrently running threads to 64. LU-11878
9718                 local idx=$((U % 64))
9719                 [ -z "${pids[idx]}" ] || wait ${pids[idx]}
9720                 pids[idx]=$pid
9721         done
9722         wait
9723 }
9724 run_test 103b "umask lfs setstripe"
9725
9726 test_103c() {
9727         mkdir -p $DIR/$tdir
9728         cp -rp $DIR/$tdir $DIR/$tdir.bak
9729
9730         [ -n "$(getfattr -d -m. $DIR/$tdir | grep posix_acl_default)" ] &&
9731                 error "$DIR/$tdir shouldn't contain default ACL"
9732         [ -n "$(getfattr -d -m. $DIR/$tdir.bak | grep posix_acl_default)" ] &&
9733                 error "$DIR/$tdir.bak shouldn't contain default ACL"
9734         true
9735 }
9736 run_test 103c "'cp -rp' won't set empty acl"
9737
9738 test_104a() {
9739         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9740
9741         touch $DIR/$tfile
9742         lfs df || error "lfs df failed"
9743         lfs df -ih || error "lfs df -ih failed"
9744         lfs df -h $DIR || error "lfs df -h $DIR failed"
9745         lfs df -i $DIR || error "lfs df -i $DIR failed"
9746         lfs df $DIR/$tfile || error "lfs df $DIR/$tfile failed"
9747         lfs df -ih $DIR/$tfile || error "lfs df -ih $DIR/$tfile failed"
9748
9749         local OSC=$(lctl dl | grep OST0000-osc-[^M] | awk '{ print $4 }')
9750         lctl --device %$OSC deactivate
9751         lfs df || error "lfs df with deactivated OSC failed"
9752         lctl --device %$OSC activate
9753         # wait the osc back to normal
9754         wait_osc_import_ready client ost
9755
9756         lfs df || error "lfs df with reactivated OSC failed"
9757         rm -f $DIR/$tfile
9758 }
9759 run_test 104a "lfs df [-ih] [path] test ========================="
9760
9761 test_104b() {
9762         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9763         [ $RUNAS_ID -eq $UID ] &&
9764                 skip_env "RUNAS_ID = UID = $UID -- skipping"
9765
9766         denied_cnt=$(($($RUNAS $LFS check servers 2>&1 |
9767                         grep "Permission denied" | wc -l)))
9768         if [ $denied_cnt -ne 0 ]; then
9769                 error "lfs check servers test failed"
9770         fi
9771 }
9772 run_test 104b "$RUNAS lfs check servers test ===================="
9773
9774 test_105a() {
9775         # doesn't work on 2.4 kernels
9776         touch $DIR/$tfile
9777         if $(flock_is_enabled); then
9778                 flocks_test 1 on -f $DIR/$tfile || error "fail flock on"
9779         else
9780                 flocks_test 1 off -f $DIR/$tfile || error "fail flock off"
9781         fi
9782         rm -f $DIR/$tfile
9783 }
9784 run_test 105a "flock when mounted without -o flock test ========"
9785
9786 test_105b() {
9787         touch $DIR/$tfile
9788         if $(flock_is_enabled); then
9789                 flocks_test 1 on -c $DIR/$tfile || error "fail flock on"
9790         else
9791                 flocks_test 1 off -c $DIR/$tfile || error "fail flock off"
9792         fi
9793         rm -f $DIR/$tfile
9794 }
9795 run_test 105b "fcntl when mounted without -o flock test ========"
9796
9797 test_105c() {
9798         touch $DIR/$tfile
9799         if $(flock_is_enabled); then
9800                 flocks_test 1 on -l $DIR/$tfile || error "fail flock on"
9801         else
9802                 flocks_test 1 off -l $DIR/$tfile || error "fail flock off"
9803         fi
9804         rm -f $DIR/$tfile
9805 }
9806 run_test 105c "lockf when mounted without -o flock test"
9807
9808 test_105d() { # bug 15924
9809         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9810
9811         test_mkdir $DIR/$tdir
9812         flock_is_enabled || skip_env "mount w/o flock enabled"
9813         #define OBD_FAIL_LDLM_CP_CB_WAIT  0x315
9814         $LCTL set_param fail_loc=0x80000315
9815         flocks_test 2 $DIR/$tdir
9816 }
9817 run_test 105d "flock race (should not freeze) ========"
9818
9819 test_105e() { # bug 22660 && 22040
9820         flock_is_enabled || skip_env "mount w/o flock enabled"
9821
9822         touch $DIR/$tfile
9823         flocks_test 3 $DIR/$tfile
9824 }
9825 run_test 105e "Two conflicting flocks from same process"
9826
9827 test_106() { #bug 10921
9828         test_mkdir $DIR/$tdir
9829         $DIR/$tdir && error "exec $DIR/$tdir succeeded"
9830         chmod 777 $DIR/$tdir || error "chmod $DIR/$tdir failed"
9831 }
9832 run_test 106 "attempt exec of dir followed by chown of that dir"
9833
9834 test_107() {
9835         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9836
9837         CDIR=`pwd`
9838         local file=core
9839
9840         cd $DIR
9841         rm -f $file
9842
9843         local save_pattern=$(sysctl -n kernel.core_pattern)
9844         local save_uses_pid=$(sysctl -n kernel.core_uses_pid)
9845         sysctl -w kernel.core_pattern=$file
9846         sysctl -w kernel.core_uses_pid=0
9847
9848         ulimit -c unlimited
9849         sleep 60 &
9850         SLEEPPID=$!
9851
9852         sleep 1
9853
9854         kill -s 11 $SLEEPPID
9855         wait $SLEEPPID
9856         if [ -e $file ]; then
9857                 size=`stat -c%s $file`
9858                 [ $size -eq 0 ] && error "Fail to create core file $file"
9859         else
9860                 error "Fail to create core file $file"
9861         fi
9862         rm -f $file
9863         sysctl -w kernel.core_pattern=$save_pattern
9864         sysctl -w kernel.core_uses_pid=$save_uses_pid
9865         cd $CDIR
9866 }
9867 run_test 107 "Coredump on SIG"
9868
9869 test_110() {
9870         test_mkdir $DIR/$tdir
9871         test_mkdir $DIR/$tdir/$(str_repeat 'a' 255)
9872         $LFS mkdir -c $MDSCOUNT $DIR/$tdir/$(str_repeat 'b' 256) &&
9873                 error "mkdir with 256 char should fail, but did not"
9874         touch $DIR/$tdir/$(str_repeat 'x' 255) ||
9875                 error "create with 255 char failed"
9876         touch $DIR/$tdir/$(str_repeat 'y' 256) &&
9877                 error "create with 256 char should fail, but did not"
9878
9879         ls -l $DIR/$tdir
9880         rm -rf $DIR/$tdir
9881 }
9882 run_test 110 "filename length checking"
9883
9884 #
9885 # Purpose: To verify dynamic thread (OSS) creation.
9886 #
9887 test_115() {
9888         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9889         remote_ost_nodsh && skip "remote OST with nodsh"
9890
9891         # Lustre does not stop service threads once they are started.
9892         # Reset number of running threads to default.
9893         stopall
9894         setupall
9895
9896         local OSTIO_pre
9897         local save_params="$TMP/sanity-$TESTNAME.parameters"
9898
9899         # Get ll_ost_io count before I/O
9900         OSTIO_pre=$(do_facet ost1 \
9901                 "$LCTL get_param ost.OSS.ost_io.threads_started | cut -d= -f2")
9902         # Exit if lustre is not running (ll_ost_io not running).
9903         [ -z "$OSTIO_pre" ] && error "no OSS threads"
9904
9905         echo "Starting with $OSTIO_pre threads"
9906         local thread_max=$((OSTIO_pre * 2))
9907         local rpc_in_flight=$((thread_max * 2))
9908         # Number of I/O Process proposed to be started.
9909         local nfiles
9910         local facets=$(get_facets OST)
9911
9912         save_lustre_params client "osc.*OST*.max_rpcs_in_flight" > $save_params
9913         save_lustre_params $facets "ost.OSS.ost_io.threads_max" >> $save_params
9914
9915         # Set in_flight to $rpc_in_flight
9916         $LCTL set_param osc.*OST*.max_rpcs_in_flight=$rpc_in_flight ||
9917                 error "Failed to set max_rpcs_in_flight to $rpc_in_flight"
9918         nfiles=${rpc_in_flight}
9919         # Set ost thread_max to $thread_max
9920         do_facet ost1 "$LCTL set_param ost.OSS.ost_io.threads_max=$thread_max"
9921
9922         # 5 Minutes should be sufficient for max number of OSS
9923         # threads(thread_max) to be created.
9924         local timeout=300
9925
9926         # Start I/O.
9927         local WTL=${WTL:-"$LUSTRE/tests/write_time_limit"}
9928         test_mkdir $DIR/$tdir
9929         for i in $(seq $nfiles); do
9930                 local file=$DIR/$tdir/${tfile}-$i
9931                 $LFS setstripe -c -1 -i 0 $file
9932                 ($WTL $file $timeout)&
9933         done
9934
9935         # I/O Started - Wait for thread_started to reach thread_max or report
9936         # error if thread_started is more than thread_max.
9937         echo "Waiting for thread_started to reach thread_max"
9938         local thread_started=0
9939         local end_time=$((SECONDS + timeout))
9940
9941         while [ $SECONDS -le $end_time ] ; do
9942                 echo -n "."
9943                 # Get ost i/o thread_started count.
9944                 thread_started=$(do_facet ost1 \
9945                         "$LCTL get_param \
9946                         ost.OSS.ost_io.threads_started | cut -d= -f2")
9947                 # Break out if thread_started is equal/greater than thread_max
9948                 if [[ $thread_started -ge $thread_max ]]; then
9949                         echo ll_ost_io thread_started $thread_started, \
9950                                 equal/greater than thread_max $thread_max
9951                         break
9952                 fi
9953                 sleep 1
9954         done
9955
9956         # Cleanup - We have the numbers, Kill i/o jobs if running.
9957         jobcount=($(jobs -p))
9958         for i in $(seq 0 $((${#jobcount[@]}-1)))
9959         do
9960                 kill -9 ${jobcount[$i]}
9961                 if [ $? -ne 0 ] ; then
9962                         echo Warning: \
9963                         Failed to Kill \'WTL\(I/O\)\' with pid ${jobcount[$i]}
9964                 fi
9965         done
9966
9967         # Cleanup files left by WTL binary.
9968         for i in $(seq $nfiles); do
9969                 local file=$DIR/$tdir/${tfile}-$i
9970                 rm -rf $file
9971                 if [ $? -ne 0 ] ; then
9972                         echo "Warning: Failed to delete file $file"
9973                 fi
9974         done
9975
9976         restore_lustre_params <$save_params
9977         rm -f $save_params || echo "Warning: delete file '$save_params' failed"
9978
9979         # Error out if no new thread has started or Thread started is greater
9980         # than thread max.
9981         if [[ $thread_started -le $OSTIO_pre ||
9982                         $thread_started -gt $thread_max ]]; then
9983                 error "ll_ost_io: thread_started $thread_started" \
9984                       "OSTIO_pre $OSTIO_pre, thread_max $thread_max." \
9985                       "No new thread started or thread started greater " \
9986                       "than thread_max."
9987         fi
9988 }
9989 run_test 115 "verify dynamic thread creation===================="
9990
9991 free_min_max () {
9992         wait_delete_completed
9993         AVAIL=($(lctl get_param -n osc.*[oO][sS][cC]-[^M]*.kbytesavail))
9994         echo "OST kbytes available: ${AVAIL[@]}"
9995         MAXV=${AVAIL[0]}
9996         MAXI=0
9997         MINV=${AVAIL[0]}
9998         MINI=0
9999         for ((i = 0; i < ${#AVAIL[@]}; i++)); do
10000                 #echo OST $i: ${AVAIL[i]}kb
10001                 if [[ ${AVAIL[i]} -gt $MAXV ]]; then
10002                         MAXV=${AVAIL[i]}
10003                         MAXI=$i
10004                 fi
10005                 if [[ ${AVAIL[i]} -lt $MINV ]]; then
10006                         MINV=${AVAIL[i]}
10007                         MINI=$i
10008                 fi
10009         done
10010         echo "Min free space: OST $MINI: $MINV"
10011         echo "Max free space: OST $MAXI: $MAXV"
10012 }
10013
10014 test_116a() { # was previously test_116()
10015         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10016         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
10017         remote_mds_nodsh && skip "remote MDS with nodsh"
10018
10019         echo -n "Free space priority "
10020         do_facet $SINGLEMDS lctl get_param -n lo[vd].*-mdtlov.qos_prio_free |
10021                 head -n1
10022         declare -a AVAIL
10023         free_min_max
10024
10025         [ $MINV -eq 0 ] && skip "no free space in OST$MINI, skip"
10026         [ $MINV -gt 10000000 ] && skip "too much free space in OST$MINI, skip"
10027         trap simple_cleanup_common EXIT
10028
10029         # Check if we need to generate uneven OSTs
10030         test_mkdir -p $DIR/$tdir/OST${MINI}
10031         local FILL=$((MINV / 4))
10032         local DIFF=$((MAXV - MINV))
10033         local DIFF2=$((DIFF * 100 / MINV))
10034
10035         local threshold=$(do_facet $SINGLEMDS \
10036                 lctl get_param -n *.*MDT0000-mdtlov.qos_threshold_rr | head -n1)
10037         threshold=${threshold%%%}
10038         echo -n "Check for uneven OSTs: "
10039         echo -n "diff=${DIFF}KB (${DIFF2}%) must be > ${threshold}% ..."
10040
10041         if [[ $DIFF2 -gt $threshold ]]; then
10042                 echo "ok"
10043                 echo "Don't need to fill OST$MINI"
10044         else
10045                 # generate uneven OSTs. Write 2% over the QOS threshold value
10046                 echo "no"
10047                 DIFF=$((threshold - DIFF2 + 2))
10048                 DIFF2=$((MINV * DIFF / 100))
10049                 echo "Fill $DIFF% remaining space in OST$MINI with ${DIFF2}KB"
10050                 $LFS setstripe -i $MINI -c 1 $DIR/$tdir/OST${MINI} ||
10051                         error "setstripe failed"
10052                 DIFF=$((DIFF2 / 2048))
10053                 i=0
10054                 while [ $i -lt $DIFF ]; do
10055                         i=$((i + 1))
10056                         dd if=/dev/zero of=$DIR/$tdir/OST${MINI}/$tfile-$i \
10057                                 bs=2M count=1 2>/dev/null
10058                         echo -n .
10059                 done
10060                 echo .
10061                 sync
10062                 sleep_maxage
10063                 free_min_max
10064         fi
10065
10066         DIFF=$((MAXV - MINV))
10067         DIFF2=$((DIFF * 100 / MINV))
10068         echo -n "diff=$DIFF=$DIFF2% must be > $threshold% for QOS mode..."
10069         if [ $DIFF2 -gt $threshold ]; then
10070                 echo "ok"
10071         else
10072                 echo "failed - QOS mode won't be used"
10073                 simple_cleanup_common
10074                 skip "QOS imbalance criteria not met"
10075         fi
10076
10077         MINI1=$MINI
10078         MINV1=$MINV
10079         MAXI1=$MAXI
10080         MAXV1=$MAXV
10081
10082         # now fill using QOS
10083         $LFS setstripe -c 1 $DIR/$tdir
10084         FILL=$((FILL / 200))
10085         if [ $FILL -gt 600 ]; then
10086                 FILL=600
10087         fi
10088         echo "writing $FILL files to QOS-assigned OSTs"
10089         i=0
10090         while [ $i -lt $FILL ]; do
10091                 i=$((i + 1))
10092                 dd if=/dev/zero of=$DIR/$tdir/$tfile-$i bs=200k \
10093                         count=1 2>/dev/null
10094                 echo -n .
10095         done
10096         echo "wrote $i 200k files"
10097         sync
10098         sleep_maxage
10099
10100         echo "Note: free space may not be updated, so measurements might be off"
10101         free_min_max
10102         DIFF2=$((MAXV - MINV))
10103         echo "free space delta: orig $DIFF final $DIFF2"
10104         [ $DIFF2 -gt $DIFF ] && echo "delta got worse!"
10105         DIFF=$((MINV1 - ${AVAIL[$MINI1]}))
10106         echo "Wrote ${DIFF}KB to smaller OST $MINI1"
10107         DIFF2=$((MAXV1 - ${AVAIL[$MAXI1]}))
10108         echo "Wrote ${DIFF2}KB to larger OST $MAXI1"
10109         if [[ $DIFF -gt 0 ]]; then
10110                 FILL=$((DIFF2 * 100 / DIFF - 100))
10111                 echo "Wrote ${FILL}% more data to larger OST $MAXI1"
10112         fi
10113
10114         # Figure out which files were written where
10115         UUID=$(lctl get_param -n lov.${FSNAME}-clilov-*.target_obd |
10116                awk '/'$MINI1': / {print $2; exit}')
10117         echo $UUID
10118         MINC=$($LFS getstripe --ost $UUID $DIR/$tdir | grep $DIR | wc -l)
10119         echo "$MINC files created on smaller OST $MINI1"
10120         UUID=$(lctl get_param -n lov.${FSNAME}-clilov-*.target_obd |
10121                awk '/'$MAXI1': / {print $2; exit}')
10122         echo $UUID
10123         MAXC=$($LFS getstripe --ost $UUID $DIR/$tdir | grep $DIR | wc -l)
10124         echo "$MAXC files created on larger OST $MAXI1"
10125         if [[ $MINC -gt 0 ]]; then
10126                 FILL=$((MAXC * 100 / MINC - 100))
10127                 echo "Wrote ${FILL}% more files to larger OST $MAXI1"
10128         fi
10129         [[ $MAXC -gt $MINC ]] ||
10130                 error_ignore LU-9 "stripe QOS didn't balance free space"
10131         simple_cleanup_common
10132 }
10133 run_test 116a "stripe QOS: free space balance ==================="
10134
10135 test_116b() { # LU-2093
10136         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10137         remote_mds_nodsh && skip "remote MDS with nodsh"
10138
10139 #define OBD_FAIL_MDS_OSC_CREATE_FAIL     0x147
10140         local old_rr=$(do_facet $SINGLEMDS lctl get_param -n \
10141                        lo[vd].$FSNAME-MDT0000-mdtlov.qos_threshold_rr | head -1)
10142         [ -z "$old_rr" ] && skip "no QOS"
10143         do_facet $SINGLEMDS lctl set_param \
10144                 lo[vd].$FSNAME-MDT0000-mdtlov.qos_threshold_rr=0
10145         mkdir -p $DIR/$tdir
10146         do_facet $SINGLEMDS lctl set_param fail_loc=0x147
10147         createmany -o $DIR/$tdir/f- 20 || error "can't create"
10148         do_facet $SINGLEMDS lctl set_param fail_loc=0
10149         rm -rf $DIR/$tdir
10150         do_facet $SINGLEMDS lctl set_param \
10151                 lo[vd].$FSNAME-MDT0000-mdtlov.qos_threshold_rr=$old_rr
10152 }
10153 run_test 116b "QoS shouldn't LBUG if not enough OSTs found on the 2nd pass"
10154
10155 test_117() # bug 10891
10156 {
10157         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10158
10159         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1
10160         #define OBD_FAIL_OST_SETATTR_CREDITS 0x21e
10161         lctl set_param fail_loc=0x21e
10162         > $DIR/$tfile || error "truncate failed"
10163         lctl set_param fail_loc=0
10164         echo "Truncate succeeded."
10165         rm -f $DIR/$tfile
10166 }
10167 run_test 117 "verify osd extend =========="
10168
10169 NO_SLOW_RESENDCOUNT=4
10170 export OLD_RESENDCOUNT=""
10171 set_resend_count () {
10172         local PROC_RESENDCOUNT="osc.${FSNAME}-OST*-osc-*.resend_count"
10173         OLD_RESENDCOUNT=$(lctl get_param -n $PROC_RESENDCOUNT | head -n1)
10174         lctl set_param -n $PROC_RESENDCOUNT $1
10175         echo resend_count is set to $(lctl get_param -n $PROC_RESENDCOUNT)
10176 }
10177
10178 # for reduce test_118* time (b=14842)
10179 [ "$SLOW" = "no" ] && set_resend_count $NO_SLOW_RESENDCOUNT
10180
10181 # Reset async IO behavior after error case
10182 reset_async() {
10183         FILE=$DIR/reset_async
10184
10185         # Ensure all OSCs are cleared
10186         $LFS setstripe -c -1 $FILE
10187         dd if=/dev/zero of=$FILE bs=64k count=$OSTCOUNT
10188         sync
10189         rm $FILE
10190 }
10191
10192 test_118a() #bug 11710
10193 {
10194         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10195
10196         reset_async
10197
10198         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
10199         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10200         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
10201
10202         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10203                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10204                 return 1;
10205         fi
10206         rm -f $DIR/$tfile
10207 }
10208 run_test 118a "verify O_SYNC works =========="
10209
10210 test_118b()
10211 {
10212         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10213         remote_ost_nodsh && skip "remote OST with nodsh"
10214
10215         reset_async
10216
10217         #define OBD_FAIL_SRV_ENOENT 0x217
10218         set_nodes_failloc "$(osts_nodes)" 0x217
10219         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
10220         RC=$?
10221         set_nodes_failloc "$(osts_nodes)" 0
10222         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10223         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
10224                     grep -c writeback)
10225
10226         if [[ $RC -eq 0 ]]; then
10227                 error "Must return error due to dropped pages, rc=$RC"
10228                 return 1;
10229         fi
10230
10231         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10232                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10233                 return 1;
10234         fi
10235
10236         echo "Dirty pages not leaked on ENOENT"
10237
10238         # Due to the above error the OSC will issue all RPCs syncronously
10239         # until a subsequent RPC completes successfully without error.
10240         $MULTIOP $DIR/$tfile Ow4096yc
10241         rm -f $DIR/$tfile
10242
10243         return 0
10244 }
10245 run_test 118b "Reclaim dirty pages on fatal error =========="
10246
10247 test_118c()
10248 {
10249         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10250
10251         # for 118c, restore the original resend count, LU-1940
10252         [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] &&
10253                                 set_resend_count $OLD_RESENDCOUNT
10254         remote_ost_nodsh && skip "remote OST with nodsh"
10255
10256         reset_async
10257
10258         #define OBD_FAIL_OST_EROFS               0x216
10259         set_nodes_failloc "$(osts_nodes)" 0x216
10260
10261         # multiop should block due to fsync until pages are written
10262         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
10263         MULTIPID=$!
10264         sleep 1
10265
10266         if [[ `ps h -o comm -p $MULTIPID` != "multiop" ]]; then
10267                 error "Multiop failed to block on fsync, pid=$MULTIPID"
10268         fi
10269
10270         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
10271                     grep -c writeback)
10272         if [[ $WRITEBACK -eq 0 ]]; then
10273                 error "No page in writeback, writeback=$WRITEBACK"
10274         fi
10275
10276         set_nodes_failloc "$(osts_nodes)" 0
10277         wait $MULTIPID
10278         RC=$?
10279         if [[ $RC -ne 0 ]]; then
10280                 error "Multiop fsync failed, rc=$RC"
10281         fi
10282
10283         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10284         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
10285                     grep -c writeback)
10286         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10287                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10288         fi
10289
10290         rm -f $DIR/$tfile
10291         echo "Dirty pages flushed via fsync on EROFS"
10292         return 0
10293 }
10294 run_test 118c "Fsync blocks on EROFS until dirty pages are flushed =========="
10295
10296 # continue to use small resend count to reduce test_118* time (b=14842)
10297 [ "$SLOW" = "no" ] && set_resend_count $NO_SLOW_RESENDCOUNT
10298
10299 test_118d()
10300 {
10301         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10302         remote_ost_nodsh && skip "remote OST with nodsh"
10303
10304         reset_async
10305
10306         #define OBD_FAIL_OST_BRW_PAUSE_BULK
10307         set_nodes_failloc "$(osts_nodes)" 0x214
10308         # multiop should block due to fsync until pages are written
10309         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
10310         MULTIPID=$!
10311         sleep 1
10312
10313         if [[ `ps h -o comm -p $MULTIPID` != "multiop" ]]; then
10314                 error "Multiop failed to block on fsync, pid=$MULTIPID"
10315         fi
10316
10317         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
10318                     grep -c writeback)
10319         if [[ $WRITEBACK -eq 0 ]]; then
10320                 error "No page in writeback, writeback=$WRITEBACK"
10321         fi
10322
10323         wait $MULTIPID || error "Multiop fsync failed, rc=$?"
10324         set_nodes_failloc "$(osts_nodes)" 0
10325
10326         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10327         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
10328                     grep -c writeback)
10329         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10330                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10331         fi
10332
10333         rm -f $DIR/$tfile
10334         echo "Dirty pages gaurenteed flushed via fsync"
10335         return 0
10336 }
10337 run_test 118d "Fsync validation inject a delay of the bulk =========="
10338
10339 test_118f() {
10340         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10341
10342         reset_async
10343
10344         #define OBD_FAIL_OSC_BRW_PREP_REQ2        0x40a
10345         lctl set_param fail_loc=0x8000040a
10346
10347         # Should simulate EINVAL error which is fatal
10348         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
10349         RC=$?
10350         if [[ $RC -eq 0 ]]; then
10351                 error "Must return error due to dropped pages, rc=$RC"
10352         fi
10353
10354         lctl set_param fail_loc=0x0
10355
10356         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
10357         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10358         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
10359                     grep -c writeback)
10360         if [[ $LOCKED -ne 0 ]]; then
10361                 error "Locked pages remain in cache, locked=$LOCKED"
10362         fi
10363
10364         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10365                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10366         fi
10367
10368         rm -f $DIR/$tfile
10369         echo "No pages locked after fsync"
10370
10371         reset_async
10372         return 0
10373 }
10374 run_test 118f "Simulate unrecoverable OSC side error =========="
10375
10376 test_118g() {
10377         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10378
10379         reset_async
10380
10381         #define OBD_FAIL_OSC_BRW_PREP_REQ        0x406
10382         lctl set_param fail_loc=0x406
10383
10384         # simulate local -ENOMEM
10385         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
10386         RC=$?
10387
10388         lctl set_param fail_loc=0
10389         if [[ $RC -eq 0 ]]; then
10390                 error "Must return error due to dropped pages, rc=$RC"
10391         fi
10392
10393         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
10394         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10395         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
10396                         grep -c writeback)
10397         if [[ $LOCKED -ne 0 ]]; then
10398                 error "Locked pages remain in cache, locked=$LOCKED"
10399         fi
10400
10401         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10402                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10403         fi
10404
10405         rm -f $DIR/$tfile
10406         echo "No pages locked after fsync"
10407
10408         reset_async
10409         return 0
10410 }
10411 run_test 118g "Don't stay in wait if we got local -ENOMEM  =========="
10412
10413 test_118h() {
10414         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10415         remote_ost_nodsh && skip "remote OST with nodsh"
10416
10417         reset_async
10418
10419         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
10420         set_nodes_failloc "$(osts_nodes)" 0x20e
10421         # Should simulate ENOMEM error which is recoverable and should be handled by timeout
10422         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
10423         RC=$?
10424
10425         set_nodes_failloc "$(osts_nodes)" 0
10426         if [[ $RC -eq 0 ]]; then
10427                 error "Must return error due to dropped pages, rc=$RC"
10428         fi
10429
10430         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
10431         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10432         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
10433                     grep -c writeback)
10434         if [[ $LOCKED -ne 0 ]]; then
10435                 error "Locked pages remain in cache, locked=$LOCKED"
10436         fi
10437
10438         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10439                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10440         fi
10441
10442         rm -f $DIR/$tfile
10443         echo "No pages locked after fsync"
10444
10445         return 0
10446 }
10447 run_test 118h "Verify timeout in handling recoverables errors  =========="
10448
10449 [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] && set_resend_count $OLD_RESENDCOUNT
10450
10451 test_118i() {
10452         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10453         remote_ost_nodsh && skip "remote OST with nodsh"
10454
10455         reset_async
10456
10457         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
10458         set_nodes_failloc "$(osts_nodes)" 0x20e
10459
10460         # Should simulate ENOMEM error which is recoverable and should be handled by timeout
10461         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
10462         PID=$!
10463         sleep 5
10464         set_nodes_failloc "$(osts_nodes)" 0
10465
10466         wait $PID
10467         RC=$?
10468         if [[ $RC -ne 0 ]]; then
10469                 error "got error, but should be not, rc=$RC"
10470         fi
10471
10472         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
10473         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10474         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
10475         if [[ $LOCKED -ne 0 ]]; then
10476                 error "Locked pages remain in cache, locked=$LOCKED"
10477         fi
10478
10479         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10480                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10481         fi
10482
10483         rm -f $DIR/$tfile
10484         echo "No pages locked after fsync"
10485
10486         return 0
10487 }
10488 run_test 118i "Fix error before timeout in recoverable error  =========="
10489
10490 [ "$SLOW" = "no" ] && set_resend_count 4
10491
10492 test_118j() {
10493         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10494         remote_ost_nodsh && skip "remote OST with nodsh"
10495
10496         reset_async
10497
10498         #define OBD_FAIL_OST_BRW_WRITE_BULK2     0x220
10499         set_nodes_failloc "$(osts_nodes)" 0x220
10500
10501         # return -EIO from OST
10502         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
10503         RC=$?
10504         set_nodes_failloc "$(osts_nodes)" 0x0
10505         if [[ $RC -eq 0 ]]; then
10506                 error "Must return error due to dropped pages, rc=$RC"
10507         fi
10508
10509         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
10510         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
10511         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
10512         if [[ $LOCKED -ne 0 ]]; then
10513                 error "Locked pages remain in cache, locked=$LOCKED"
10514         fi
10515
10516         # in recoverable error on OST we want resend and stay until it finished
10517         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
10518                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
10519         fi
10520
10521         rm -f $DIR/$tfile
10522         echo "No pages locked after fsync"
10523
10524         return 0
10525 }
10526 run_test 118j "Simulate unrecoverable OST side error =========="
10527
10528 test_118k()
10529 {
10530         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10531         remote_ost_nodsh && skip "remote OSTs with nodsh"
10532
10533         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
10534         set_nodes_failloc "$(osts_nodes)" 0x20e
10535         test_mkdir $DIR/$tdir
10536
10537         for ((i=0;i<10;i++)); do
10538                 (dd if=/dev/zero of=$DIR/$tdir/$tfile-$i bs=1M count=10 || \
10539                         error "dd to $DIR/$tdir/$tfile-$i failed" )&
10540                 SLEEPPID=$!
10541                 sleep 0.500s
10542                 kill $SLEEPPID
10543                 wait $SLEEPPID
10544         done
10545
10546         set_nodes_failloc "$(osts_nodes)" 0
10547         rm -rf $DIR/$tdir
10548 }
10549 run_test 118k "bio alloc -ENOMEM and IO TERM handling ========="
10550
10551 test_118l() # LU-646
10552 {
10553         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10554
10555         test_mkdir $DIR/$tdir
10556         $MULTIOP $DIR/$tdir Dy || error "fsync dir failed"
10557         rm -rf $DIR/$tdir
10558 }
10559 run_test 118l "fsync dir"
10560
10561 test_118m() # LU-3066
10562 {
10563         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10564
10565         test_mkdir $DIR/$tdir
10566         $MULTIOP $DIR/$tdir DY || error "fdatasync dir failed"
10567         rm -rf $DIR/$tdir
10568 }
10569 run_test 118m "fdatasync dir ========="
10570
10571 [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] && set_resend_count $OLD_RESENDCOUNT
10572
10573 test_118n()
10574 {
10575         local begin
10576         local end
10577
10578         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10579         remote_ost_nodsh && skip "remote OSTs with nodsh"
10580
10581         # Sleep to avoid a cached response.
10582         #define OBD_STATFS_CACHE_SECONDS 1
10583         sleep 2
10584
10585         # Inject a 10 second delay in the OST_STATFS handler.
10586         #define OBD_FAIL_OST_STATFS_DELAY 0x242
10587         set_nodes_failloc "$(osts_nodes)" 0x242
10588
10589         begin=$SECONDS
10590         stat --file-system $MOUNT > /dev/null
10591         end=$SECONDS
10592
10593         set_nodes_failloc "$(osts_nodes)" 0
10594
10595         if ((end - begin > 20)); then
10596             error "statfs took $((end - begin)) seconds, expected 10"
10597         fi
10598 }
10599 run_test 118n "statfs() sends OST_STATFS requests in parallel"
10600
10601 test_119a() # bug 11737
10602 {
10603         BSIZE=$((512 * 1024))
10604         directio write $DIR/$tfile 0 1 $BSIZE
10605         # We ask to read two blocks, which is more than a file size.
10606         # directio will indicate an error when requested and actual
10607         # sizes aren't equeal (a normal situation in this case) and
10608         # print actual read amount.
10609         NOB=`directio read $DIR/$tfile 0 2 $BSIZE | awk '/error/ {print $6}'`
10610         if [ "$NOB" != "$BSIZE" ]; then
10611                 error "read $NOB bytes instead of $BSIZE"
10612         fi
10613         rm -f $DIR/$tfile
10614 }
10615 run_test 119a "Short directIO read must return actual read amount"
10616
10617 test_119b() # bug 11737
10618 {
10619         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
10620
10621         $LFS setstripe -c 2 $DIR/$tfile || error "setstripe failed"
10622         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1 || error "dd failed"
10623         sync
10624         $MULTIOP $DIR/$tfile oO_RDONLY:O_DIRECT:r$((2048 * 1024)) ||
10625                 error "direct read failed"
10626         rm -f $DIR/$tfile
10627 }
10628 run_test 119b "Sparse directIO read must return actual read amount"
10629
10630 test_119c() # bug 13099
10631 {
10632         BSIZE=1048576
10633         directio write $DIR/$tfile 3 1 $BSIZE || error "direct write failed"
10634         directio readhole $DIR/$tfile 0 2 $BSIZE || error "reading hole failed"
10635         rm -f $DIR/$tfile
10636 }
10637 run_test 119c "Testing for direct read hitting hole"
10638
10639 test_119d() # bug 15950
10640 {
10641         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10642
10643         MAX_RPCS_IN_FLIGHT=`$LCTL get_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight`
10644         $LCTL set_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight 1
10645         BSIZE=1048576
10646         $LFS setstripe $DIR/$tfile -i 0 -c 1 || error "setstripe failed"
10647         $DIRECTIO write $DIR/$tfile 0 1 $BSIZE || error "first directio failed"
10648         #define OBD_FAIL_OSC_DIO_PAUSE           0x40d
10649         lctl set_param fail_loc=0x40d
10650         $DIRECTIO write $DIR/$tfile 1 4 $BSIZE &
10651         pid_dio=$!
10652         sleep 1
10653         cat $DIR/$tfile > /dev/null &
10654         lctl set_param fail_loc=0
10655         pid_reads=$!
10656         wait $pid_dio
10657         log "the DIO writes have completed, now wait for the reads (should not block very long)"
10658         sleep 2
10659         [ -n "`ps h -p $pid_reads -o comm`" ] && \
10660         error "the read rpcs have not completed in 2s"
10661         rm -f $DIR/$tfile
10662         $LCTL set_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight $MAX_RPCS_IN_FLIGHT
10663 }
10664 run_test 119d "The DIO path should try to send a new rpc once one is completed"
10665
10666 test_120a() {
10667         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10668         remote_mds_nodsh && skip "remote MDS with nodsh"
10669         test_mkdir -i0 -c1 $DIR/$tdir
10670         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10671                 skip_env "no early lock cancel on server"
10672
10673         lru_resize_disable mdc
10674         lru_resize_disable osc
10675         cancel_lru_locks mdc
10676         # asynchronous object destroy at MDT could cause bl ast to client
10677         cancel_lru_locks osc
10678
10679         stat $DIR/$tdir > /dev/null
10680         can1=$(do_facet mds1 \
10681                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10682                awk '/ldlm_cancel/ {print $2}')
10683         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10684                awk '/ldlm_bl_callback/ {print $2}')
10685         test_mkdir -i0 -c1 $DIR/$tdir/d1
10686         can2=$(do_facet mds1 \
10687                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10688                awk '/ldlm_cancel/ {print $2}')
10689         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10690                awk '/ldlm_bl_callback/ {print $2}')
10691         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
10692         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
10693         lru_resize_enable mdc
10694         lru_resize_enable osc
10695 }
10696 run_test 120a "Early Lock Cancel: mkdir test"
10697
10698 test_120b() {
10699         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10700         remote_mds_nodsh && skip "remote MDS with nodsh"
10701         test_mkdir $DIR/$tdir
10702         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10703                 skip_env "no early lock cancel on server"
10704
10705         lru_resize_disable mdc
10706         lru_resize_disable osc
10707         cancel_lru_locks mdc
10708         stat $DIR/$tdir > /dev/null
10709         can1=$(do_facet $SINGLEMDS \
10710                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10711                awk '/ldlm_cancel/ {print $2}')
10712         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10713                awk '/ldlm_bl_callback/ {print $2}')
10714         touch $DIR/$tdir/f1
10715         can2=$(do_facet $SINGLEMDS \
10716                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10717                awk '/ldlm_cancel/ {print $2}')
10718         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10719                awk '/ldlm_bl_callback/ {print $2}')
10720         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
10721         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
10722         lru_resize_enable mdc
10723         lru_resize_enable osc
10724 }
10725 run_test 120b "Early Lock Cancel: create test"
10726
10727 test_120c() {
10728         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10729         remote_mds_nodsh && skip "remote MDS with nodsh"
10730         test_mkdir -i0 -c1 $DIR/$tdir
10731         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10732                 skip "no early lock cancel on server"
10733
10734         lru_resize_disable mdc
10735         lru_resize_disable osc
10736         test_mkdir -i0 -c1 $DIR/$tdir/d1
10737         test_mkdir -i0 -c1 $DIR/$tdir/d2
10738         touch $DIR/$tdir/d1/f1
10739         cancel_lru_locks mdc
10740         stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 > /dev/null
10741         can1=$(do_facet mds1 \
10742                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10743                awk '/ldlm_cancel/ {print $2}')
10744         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10745                awk '/ldlm_bl_callback/ {print $2}')
10746         ln $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2
10747         can2=$(do_facet mds1 \
10748                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10749                awk '/ldlm_cancel/ {print $2}')
10750         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10751                awk '/ldlm_bl_callback/ {print $2}')
10752         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
10753         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
10754         lru_resize_enable mdc
10755         lru_resize_enable osc
10756 }
10757 run_test 120c "Early Lock Cancel: link test"
10758
10759 test_120d() {
10760         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10761         remote_mds_nodsh && skip "remote MDS with nodsh"
10762         test_mkdir -i0 -c1 $DIR/$tdir
10763         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10764                 skip_env "no early lock cancel on server"
10765
10766         lru_resize_disable mdc
10767         lru_resize_disable osc
10768         touch $DIR/$tdir
10769         cancel_lru_locks mdc
10770         stat $DIR/$tdir > /dev/null
10771         can1=$(do_facet mds1 \
10772                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10773                awk '/ldlm_cancel/ {print $2}')
10774         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10775                awk '/ldlm_bl_callback/ {print $2}')
10776         chmod a+x $DIR/$tdir
10777         can2=$(do_facet mds1 \
10778                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10779                awk '/ldlm_cancel/ {print $2}')
10780         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10781                awk '/ldlm_bl_callback/ {print $2}')
10782         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
10783         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
10784         lru_resize_enable mdc
10785         lru_resize_enable osc
10786 }
10787 run_test 120d "Early Lock Cancel: setattr test"
10788
10789 test_120e() {
10790         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10791         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10792                 skip_env "no early lock cancel on server"
10793         remote_mds_nodsh && skip "remote MDS with nodsh"
10794
10795         local dlmtrace_set=false
10796
10797         test_mkdir -i0 -c1 $DIR/$tdir
10798         lru_resize_disable mdc
10799         lru_resize_disable osc
10800         ! $LCTL get_param debug | grep -q dlmtrace &&
10801                 $LCTL set_param debug=+dlmtrace && dlmtrace_set=true
10802         dd if=/dev/zero of=$DIR/$tdir/f1 count=1
10803         cancel_lru_locks mdc
10804         cancel_lru_locks osc
10805         dd if=$DIR/$tdir/f1 of=/dev/null
10806         stat $DIR/$tdir $DIR/$tdir/f1 > /dev/null
10807         # XXX client can not do early lock cancel of OST lock
10808         # during unlink (LU-4206), so cancel osc lock now.
10809         sleep 2
10810         cancel_lru_locks osc
10811         can1=$(do_facet mds1 \
10812                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10813                awk '/ldlm_cancel/ {print $2}')
10814         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10815                awk '/ldlm_bl_callback/ {print $2}')
10816         unlink $DIR/$tdir/f1
10817         sleep 5
10818         can2=$(do_facet mds1 \
10819                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10820                awk '/ldlm_cancel/ {print $2}')
10821         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10822                awk '/ldlm_bl_callback/ {print $2}')
10823         [ $can1 -ne $can2 ] && error "$((can2 - can1)) cancel RPC occured" &&
10824                 $LCTL dk $TMP/cancel.debug.txt
10825         [ $blk1 -ne $blk2 ] && error "$((blk2 - blk1)) blocking RPC occured" &&
10826                 $LCTL dk $TMP/blocking.debug.txt
10827         $dlmtrace_set && $LCTL set_param debug=-dlmtrace
10828         lru_resize_enable mdc
10829         lru_resize_enable osc
10830 }
10831 run_test 120e "Early Lock Cancel: unlink test"
10832
10833 test_120f() {
10834         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10835         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10836                 skip_env "no early lock cancel on server"
10837         remote_mds_nodsh && skip "remote MDS with nodsh"
10838
10839         test_mkdir -i0 -c1 $DIR/$tdir
10840         lru_resize_disable mdc
10841         lru_resize_disable osc
10842         test_mkdir -i0 -c1 $DIR/$tdir/d1
10843         test_mkdir -i0 -c1 $DIR/$tdir/d2
10844         dd if=/dev/zero of=$DIR/$tdir/d1/f1 count=1
10845         dd if=/dev/zero of=$DIR/$tdir/d2/f2 count=1
10846         cancel_lru_locks mdc
10847         cancel_lru_locks osc
10848         dd if=$DIR/$tdir/d1/f1 of=/dev/null
10849         dd if=$DIR/$tdir/d2/f2 of=/dev/null
10850         stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2 > /dev/null
10851         # XXX client can not do early lock cancel of OST lock
10852         # during rename (LU-4206), so cancel osc lock now.
10853         sleep 2
10854         cancel_lru_locks osc
10855         can1=$(do_facet mds1 \
10856                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10857                awk '/ldlm_cancel/ {print $2}')
10858         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10859                awk '/ldlm_bl_callback/ {print $2}')
10860         mrename $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2
10861         sleep 5
10862         can2=$(do_facet mds1 \
10863                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10864                awk '/ldlm_cancel/ {print $2}')
10865         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10866                awk '/ldlm_bl_callback/ {print $2}')
10867         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
10868         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
10869         lru_resize_enable mdc
10870         lru_resize_enable osc
10871 }
10872 run_test 120f "Early Lock Cancel: rename test"
10873
10874 test_120g() {
10875         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10876         $LCTL get_param -n mdc.*.connect_flags | grep -q early_lock_cancel ||
10877                 skip_env "no early lock cancel on server"
10878         remote_mds_nodsh && skip "remote MDS with nodsh"
10879
10880         lru_resize_disable mdc
10881         lru_resize_disable osc
10882         count=10000
10883         echo create $count files
10884         test_mkdir $DIR/$tdir
10885         cancel_lru_locks mdc
10886         cancel_lru_locks osc
10887         t0=$(date +%s)
10888
10889         can0=$(do_facet $SINGLEMDS \
10890                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10891                awk '/ldlm_cancel/ {print $2}')
10892         blk0=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10893                awk '/ldlm_bl_callback/ {print $2}')
10894         createmany -o $DIR/$tdir/f $count
10895         sync
10896         can1=$(do_facet $SINGLEMDS \
10897                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10898                awk '/ldlm_cancel/ {print $2}')
10899         blk1=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10900                awk '/ldlm_bl_callback/ {print $2}')
10901         t1=$(date +%s)
10902         echo total: $((can1-can0)) cancels, $((blk1-blk0)) blockings
10903         echo rm $count files
10904         rm -r $DIR/$tdir
10905         sync
10906         can2=$(do_facet $SINGLEMDS \
10907                "$LCTL get_param -n ldlm.services.ldlm_canceld.stats" |
10908                awk '/ldlm_cancel/ {print $2}')
10909         blk2=$($LCTL get_param -n ldlm.services.ldlm_cbd.stats |
10910                awk '/ldlm_bl_callback/ {print $2}')
10911         t2=$(date +%s)
10912         echo total: $count removes in $((t2-t1))
10913         echo total: $((can2-can1)) cancels, $((blk2-blk1)) blockings
10914         sleep 2
10915         # wait for commitment of removal
10916         lru_resize_enable mdc
10917         lru_resize_enable osc
10918 }
10919 run_test 120g "Early Lock Cancel: performance test"
10920
10921 test_121() { #bug #10589
10922         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10923
10924         rm -rf $DIR/$tfile
10925         writes=$(LANG=C dd if=/dev/zero of=$DIR/$tfile count=1 2>&1 | awk -F '+' '/out$/ {print $1}')
10926 #define OBD_FAIL_LDLM_CANCEL_RACE        0x310
10927         lctl set_param fail_loc=0x310
10928         cancel_lru_locks osc > /dev/null
10929         reads=$(LANG=C dd if=$DIR/$tfile of=/dev/null 2>&1 | awk -F '+' '/in$/ {print $1}')
10930         lctl set_param fail_loc=0
10931         [[ $reads -eq $writes ]] ||
10932                 error "read $reads blocks, must be $writes blocks"
10933 }
10934 run_test 121 "read cancel race ========="
10935
10936 test_123a() { # was test 123, statahead(bug 11401)
10937         [ $PARALLEL == "yes" ] && skip "skip parallel run"
10938
10939         SLOWOK=0
10940         if ! grep -q "processor.*: 1" /proc/cpuinfo; then
10941                 log "testing UP system. Performance may be lower than expected."
10942                 SLOWOK=1
10943         fi
10944
10945         rm -rf $DIR/$tdir
10946         test_mkdir $DIR/$tdir
10947         NUMFREE=$(df -i -P $DIR | tail -n 1 | awk '{ print $4 }')
10948         [[ $NUMFREE -gt 100000 ]] && NUMFREE=100000 || NUMFREE=$((NUMFREE-1000))
10949         MULT=10
10950         for ((i=100, j=0; i<=$NUMFREE; j=$i, i=$((i * MULT)) )); do
10951                 createmany -o $DIR/$tdir/$tfile $j $((i - j))
10952
10953                 max=`lctl get_param -n llite.*.statahead_max | head -n 1`
10954                 lctl set_param -n llite.*.statahead_max 0
10955                 lctl get_param llite.*.statahead_max
10956                 cancel_lru_locks mdc
10957                 cancel_lru_locks osc
10958                 stime=`date +%s`
10959                 time ls -l $DIR/$tdir | wc -l
10960                 etime=`date +%s`
10961                 delta=$((etime - stime))
10962                 log "ls $i files without statahead: $delta sec"
10963                 lctl set_param llite.*.statahead_max=$max
10964
10965                 swrong=`lctl get_param -n llite.*.statahead_stats | grep "statahead wrong:" | awk '{print $3}'`
10966                 lctl get_param -n llite.*.statahead_max | grep '[0-9]'
10967                 cancel_lru_locks mdc
10968                 cancel_lru_locks osc
10969                 stime=`date +%s`
10970                 time ls -l $DIR/$tdir | wc -l
10971                 etime=`date +%s`
10972                 delta_sa=$((etime - stime))
10973                 log "ls $i files with statahead: $delta_sa sec"
10974                 lctl get_param -n llite.*.statahead_stats
10975                 ewrong=`lctl get_param -n llite.*.statahead_stats | grep "statahead wrong:" | awk '{print $3}'`
10976
10977                 [[ $swrong -lt $ewrong ]] &&
10978                         log "statahead was stopped, maybe too many locks held!"
10979                 [[ $delta -eq 0 || $delta_sa -eq 0 ]] && continue
10980
10981                 if [ $((delta_sa * 100)) -gt $((delta * 105)) -a $delta_sa -gt $((delta + 2)) ]; then
10982                     max=`lctl get_param -n llite.*.statahead_max | head -n 1`
10983                     lctl set_param -n llite.*.statahead_max 0
10984                     lctl get_param llite.*.statahead_max
10985                     cancel_lru_locks mdc
10986                     cancel_lru_locks osc
10987                     stime=`date +%s`
10988                     time ls -l $DIR/$tdir | wc -l
10989                     etime=`date +%s`
10990                     delta=$((etime - stime))
10991                     log "ls $i files again without statahead: $delta sec"
10992                     lctl set_param llite.*.statahead_max=$max
10993                     if [ $((delta_sa * 100)) -gt $((delta * 105)) -a $delta_sa -gt $((delta + 2)) ]; then
10994                         if [  $SLOWOK -eq 0 ]; then
10995                                 error "ls $i files is slower with statahead!"
10996                         else
10997                                 log "ls $i files is slower with statahead!"
10998                         fi
10999                         break
11000                     fi
11001                 fi
11002
11003                 [ $delta -gt 20 ] && break
11004                 [ $delta -gt 8 ] && MULT=$((50 / delta))
11005                 [ "$SLOW" = "no" -a $delta -gt 5 ] && break
11006         done
11007         log "ls done"
11008
11009         stime=`date +%s`
11010         rm -r $DIR/$tdir
11011         sync
11012         etime=`date +%s`
11013         delta=$((etime - stime))
11014         log "rm -r $DIR/$tdir/: $delta seconds"
11015         log "rm done"
11016         lctl get_param -n llite.*.statahead_stats
11017 }
11018 run_test 123a "verify statahead work"
11019
11020 test_123b () { # statahead(bug 15027)
11021         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11022
11023         test_mkdir $DIR/$tdir
11024         createmany -o $DIR/$tdir/$tfile-%d 1000
11025
11026         cancel_lru_locks mdc
11027         cancel_lru_locks osc
11028
11029 #define OBD_FAIL_MDC_GETATTR_ENQUEUE     0x803
11030         lctl set_param fail_loc=0x80000803
11031         ls -lR $DIR/$tdir > /dev/null
11032         log "ls done"
11033         lctl set_param fail_loc=0x0
11034         lctl get_param -n llite.*.statahead_stats
11035         rm -r $DIR/$tdir
11036         sync
11037
11038 }
11039 run_test 123b "not panic with network error in statahead enqueue (bug 15027)"
11040
11041 test_124a() {
11042         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11043         $LCTL get_param -n mdc.*.connect_flags | grep -q lru_resize ||
11044                 skip_env "no lru resize on server"
11045
11046         local NR=2000
11047
11048         test_mkdir $DIR/$tdir
11049
11050         log "create $NR files at $DIR/$tdir"
11051         createmany -o $DIR/$tdir/f $NR ||
11052                 error "failed to create $NR files in $DIR/$tdir"
11053
11054         cancel_lru_locks mdc
11055         ls -l $DIR/$tdir > /dev/null
11056
11057         local NSDIR=""
11058         local LRU_SIZE=0
11059         for VALUE in $($LCTL get_param ldlm.namespaces.*mdc-*.lru_size); do
11060                 local PARAM=$(echo ${VALUE[0]} | cut -d "=" -f1)
11061                 LRU_SIZE=$($LCTL get_param -n $PARAM)
11062                 if [[ $LRU_SIZE -gt $(default_lru_size) ]]; then
11063                         NSDIR=$(echo $PARAM | cut -d "." -f1-3)
11064                         log "NSDIR=$NSDIR"
11065                         log "NS=$(basename $NSDIR)"
11066                         break
11067                 fi
11068         done
11069
11070         if [[ -z "$NSDIR" || $LRU_SIZE -lt $(default_lru_size) ]]; then
11071                 skip "Not enough cached locks created!"
11072         fi
11073         log "LRU=$LRU_SIZE"
11074
11075         local SLEEP=30
11076
11077         # We know that lru resize allows one client to hold $LIMIT locks
11078         # for 10h. After that locks begin to be killed by client.
11079         local MAX_HRS=10
11080         local LIMIT=$($LCTL get_param -n $NSDIR.pool.limit)
11081         log "LIMIT=$LIMIT"
11082         if [ $LIMIT -lt $LRU_SIZE ]; then
11083                 skip "Limit is too small $LIMIT"
11084         fi
11085
11086         # Make LVF so higher that sleeping for $SLEEP is enough to _start_
11087         # killing locks. Some time was spent for creating locks. This means
11088         # that up to the moment of sleep finish we must have killed some of
11089         # them (10-100 locks). This depends on how fast ther were created.
11090         # Many of them were touched in almost the same moment and thus will
11091         # be killed in groups.
11092         local LVF=$(($MAX_HRS * 60 * 60 / $SLEEP * $LIMIT / $LRU_SIZE))
11093
11094         # Use $LRU_SIZE_B here to take into account real number of locks
11095         # created in the case of CMD, LRU_SIZE_B != $NR in most of cases
11096         local LRU_SIZE_B=$LRU_SIZE
11097         log "LVF=$LVF"
11098         local OLD_LVF=$($LCTL get_param -n $NSDIR.pool.lock_volume_factor)
11099         log "OLD_LVF=$OLD_LVF"
11100         $LCTL set_param -n $NSDIR.pool.lock_volume_factor $LVF
11101
11102         # Let's make sure that we really have some margin. Client checks
11103         # cached locks every 10 sec.
11104         SLEEP=$((SLEEP+20))
11105         log "Sleep ${SLEEP} sec"
11106         local SEC=0
11107         while ((SEC<$SLEEP)); do
11108                 echo -n "..."
11109                 sleep 5
11110                 SEC=$((SEC+5))
11111                 LRU_SIZE=$($LCTL get_param -n $NSDIR/lru_size)
11112                 echo -n "$LRU_SIZE"
11113         done
11114         echo ""
11115         $LCTL set_param -n $NSDIR.pool.lock_volume_factor $OLD_LVF
11116         local LRU_SIZE_A=$($LCTL get_param -n $NSDIR.lru_size)
11117
11118         [[ $LRU_SIZE_B -gt $LRU_SIZE_A ]] || {
11119                 error "No locks dropped in ${SLEEP}s. LRU size: $LRU_SIZE_A"
11120                 unlinkmany $DIR/$tdir/f $NR
11121                 return
11122         }
11123
11124         log "Dropped "$((LRU_SIZE_B-LRU_SIZE_A))" locks in ${SLEEP}s"
11125         log "unlink $NR files at $DIR/$tdir"
11126         unlinkmany $DIR/$tdir/f $NR
11127 }
11128 run_test 124a "lru resize ======================================="
11129
11130 get_max_pool_limit()
11131 {
11132         local limit=$($LCTL get_param \
11133                       -n ldlm.namespaces.*-MDT0000-mdc-*.pool.limit)
11134         local max=0
11135         for l in $limit; do
11136                 if [[ $l -gt $max ]]; then
11137                         max=$l
11138                 fi
11139         done
11140         echo $max
11141 }
11142
11143 test_124b() {
11144         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11145         $LCTL get_param -n mdc.*.connect_flags | grep -q lru_resize ||
11146                 skip_env "no lru resize on server"
11147
11148         LIMIT=$(get_max_pool_limit)
11149
11150         NR=$(($(default_lru_size)*20))
11151         if [[ $NR -gt $LIMIT ]]; then
11152                 log "Limit lock number by $LIMIT locks"
11153                 NR=$LIMIT
11154         fi
11155
11156         IFree=$(mdsrate_inodes_available)
11157         if [ $IFree -lt $NR ]; then
11158                 log "Limit lock number by $IFree inodes"
11159                 NR=$IFree
11160         fi
11161
11162         lru_resize_disable mdc
11163         test_mkdir -p $DIR/$tdir/disable_lru_resize
11164
11165         createmany -o $DIR/$tdir/disable_lru_resize/f $NR
11166         log "doing ls -la $DIR/$tdir/disable_lru_resize 3 times"
11167         cancel_lru_locks mdc
11168         stime=`date +%s`
11169         PID=""
11170         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
11171         PID="$PID $!"
11172         sleep 2
11173         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
11174         PID="$PID $!"
11175         sleep 2
11176         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
11177         PID="$PID $!"
11178         wait $PID
11179         etime=`date +%s`
11180         nolruresize_delta=$((etime-stime))
11181         log "ls -la time: $nolruresize_delta seconds"
11182         log "lru_size = $(lctl get_param -n ldlm.namespaces.*mdc*.lru_size)"
11183         unlinkmany $DIR/$tdir/disable_lru_resize/f $NR
11184
11185         lru_resize_enable mdc
11186         test_mkdir -p $DIR/$tdir/enable_lru_resize
11187
11188         createmany -o $DIR/$tdir/enable_lru_resize/f $NR
11189         log "doing ls -la $DIR/$tdir/enable_lru_resize 3 times"
11190         cancel_lru_locks mdc
11191         stime=`date +%s`
11192         PID=""
11193         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
11194         PID="$PID $!"
11195         sleep 2
11196         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
11197         PID="$PID $!"
11198         sleep 2
11199         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
11200         PID="$PID $!"
11201         wait $PID
11202         etime=`date +%s`
11203         lruresize_delta=$((etime-stime))
11204         log "ls -la time: $lruresize_delta seconds"
11205         log "lru_size = $(lctl get_param -n ldlm.namespaces.*mdc*.lru_size)"
11206
11207         if [ $lruresize_delta -gt $nolruresize_delta ]; then
11208                 log "ls -la is $(((lruresize_delta - $nolruresize_delta) * 100 / $nolruresize_delta))% slower with lru resize enabled"
11209         elif [ $nolruresize_delta -gt $lruresize_delta ]; then
11210                 log "ls -la is $(((nolruresize_delta - $lruresize_delta) * 100 / $nolruresize_delta))% faster with lru resize enabled"
11211         else
11212                 log "lru resize performs the same with no lru resize"
11213         fi
11214         unlinkmany $DIR/$tdir/enable_lru_resize/f $NR
11215 }
11216 run_test 124b "lru resize (performance test) ======================="
11217
11218 test_124c() {
11219         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11220         $LCTL get_param -n mdc.*.connect_flags | grep -q lru_resize ||
11221                 skip_env "no lru resize on server"
11222
11223         # cache ununsed locks on client
11224         local nr=100
11225         cancel_lru_locks mdc
11226         test_mkdir $DIR/$tdir
11227         createmany -o $DIR/$tdir/f $nr ||
11228                 error "failed to create $nr files in $DIR/$tdir"
11229         ls -l $DIR/$tdir > /dev/null
11230
11231         local nsdir="ldlm.namespaces.*-MDT0000-mdc-*"
11232         local unused=$($LCTL get_param -n $nsdir.lock_unused_count)
11233         local max_age=$($LCTL get_param -n $nsdir.lru_max_age)
11234         local recalc_p=$($LCTL get_param -n $nsdir.pool.recalc_period)
11235         echo "unused=$unused, max_age=$max_age, recalc_p=$recalc_p"
11236
11237         # set lru_max_age to 1 sec
11238         $LCTL set_param $nsdir.lru_max_age=1000 # milliseconds
11239         echo "sleep $((recalc_p * 2)) seconds..."
11240         sleep $((recalc_p * 2))
11241
11242         local remaining=$($LCTL get_param -n $nsdir.lock_unused_count)
11243         # restore lru_max_age
11244         $LCTL set_param -n $nsdir.lru_max_age $max_age
11245         [ $remaining -eq 0 ] || error "$remaining locks are not canceled"
11246         unlinkmany $DIR/$tdir/f $nr
11247 }
11248 run_test 124c "LRUR cancel very aged locks"
11249
11250 test_124d() {
11251         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11252         $LCTL get_param -n mdc.*.connect_flags | grep -q lru_resize ||
11253                 skip_env "no lru resize on server"
11254
11255         # cache ununsed locks on client
11256         local nr=100
11257
11258         lru_resize_disable mdc
11259         stack_trap "lru_resize_enable mdc" EXIT
11260
11261         cancel_lru_locks mdc
11262
11263         # asynchronous object destroy at MDT could cause bl ast to client
11264         test_mkdir $DIR/$tdir
11265         createmany -o $DIR/$tdir/f $nr ||
11266                 error "failed to create $nr files in $DIR/$tdir"
11267         stack_trap "unlinkmany $DIR/$tdir/f $nr" EXIT
11268
11269         ls -l $DIR/$tdir > /dev/null
11270
11271         local nsdir="ldlm.namespaces.*-MDT0000-mdc-*"
11272         local unused=$($LCTL get_param -n $nsdir.lock_unused_count)
11273         local max_age=$($LCTL get_param -n $nsdir.lru_max_age)
11274         local recalc_p=$($LCTL get_param -n $nsdir.pool.recalc_period)
11275
11276         echo "unused=$unused, max_age=$max_age, recalc_p=$recalc_p"
11277
11278         # set lru_max_age to 1 sec
11279         $LCTL set_param $nsdir.lru_max_age=1000 # milliseconds
11280         stack_trap "$LCTL set_param -n $nsdir.lru_max_age $max_age" EXIT
11281
11282         echo "sleep $((recalc_p * 2)) seconds..."
11283         sleep $((recalc_p * 2))
11284
11285         local remaining=$($LCTL get_param -n $nsdir.lock_unused_count)
11286
11287         [ $remaining -eq 0 ] || error "$remaining locks are not canceled"
11288 }
11289 run_test 124d "cancel very aged locks if lru-resize diasbaled"
11290
11291 test_125() { # 13358
11292         $LCTL get_param -n llite.*.client_type | grep -q local ||
11293                 skip "must run as local client"
11294         $LCTL get_param -n mdc.*-mdc-*.connect_flags | grep -q acl ||
11295                 skip_env "must have acl enabled"
11296         [ -z "$(which setfacl)" ] && skip_env "must have setfacl tool"
11297
11298         test_mkdir $DIR/$tdir
11299         $LFS setstripe -S 65536 -c -1 $DIR/$tdir || error "setstripe failed"
11300         setfacl -R -m u:bin:rwx $DIR/$tdir || error "setfacl $DIR/$tdir failed"
11301         ls -ld $DIR/$tdir || error "cannot access $DIR/$tdir"
11302 }
11303 run_test 125 "don't return EPROTO when a dir has a non-default striping and ACLs"
11304
11305 test_126() { # bug 12829/13455
11306         $GSS && skip_env "must run as gss disabled"
11307         $LCTL get_param -n llite.*.client_type | grep -q local ||
11308                 skip "must run as local client"
11309         [ "$UID" != 0 ] && skip "must run as root, not UID $UID"
11310
11311         $RUNAS -u 0 -g 1 touch $DIR/$tfile || error "touch failed"
11312         gid=`ls -n $DIR/$tfile | awk '{print $4}'`
11313         rm -f $DIR/$tfile
11314         [ $gid -eq "1" ] || error "gid is set to" $gid "instead of 1"
11315 }
11316 run_test 126 "check that the fsgid provided by the client is taken into account"
11317
11318 test_127a() { # bug 15521
11319         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11320
11321         $LFS setstripe -i 0 -c 1 $DIR/$tfile || error "setstripe failed"
11322         $LCTL set_param osc.*.stats=0
11323         FSIZE=$((2048 * 1024))
11324         dd if=/dev/zero of=$DIR/$tfile bs=$FSIZE count=1
11325         cancel_lru_locks osc
11326         dd if=$DIR/$tfile of=/dev/null bs=$FSIZE
11327
11328         $LCTL get_param osc.*0000-osc-*.stats | grep samples > $DIR/${tfile}.tmp
11329         while read NAME COUNT SAMP UNIT MIN MAX SUM SUMSQ; do
11330                 echo "got $COUNT $NAME"
11331                 [ ! $MIN ] && error "Missing min value for $NAME proc entry"
11332                 eval $NAME=$COUNT || error "Wrong proc format"
11333
11334                 case $NAME in
11335                         read_bytes|write_bytes)
11336                         [ $MIN -lt 4096 ] && error "min is too small: $MIN"
11337                         [ $MIN -gt $FSIZE ] && error "min is too big: $MIN"
11338                         [ $MAX -lt 4096 ] && error "max is too small: $MAX"
11339                         [ $MAX -gt $FSIZE ] && error "max is too big: $MAX"
11340                         [ $SUM -ne $FSIZE ] && error "sum is wrong: $SUM"
11341                         [ $SUMSQ -lt $(((FSIZE /4096) * (4096 * 4096))) ] &&
11342                                 error "sumsquare is too small: $SUMSQ"
11343                         [ $SUMSQ -gt $((FSIZE * FSIZE)) ] &&
11344                                 error "sumsquare is too big: $SUMSQ"
11345                         ;;
11346                         *) ;;
11347                 esac
11348         done < $DIR/${tfile}.tmp
11349
11350         #check that we actually got some stats
11351         [ "$read_bytes" ] || error "Missing read_bytes stats"
11352         [ "$write_bytes" ] || error "Missing write_bytes stats"
11353         [ "$read_bytes" != 0 ] || error "no read done"
11354         [ "$write_bytes" != 0 ] || error "no write done"
11355 }
11356 run_test 127a "verify the client stats are sane"
11357
11358 test_127b() { # bug LU-333
11359         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11360         local name count samp unit min max sum sumsq
11361
11362         $LCTL set_param llite.*.stats=0
11363
11364         # perform 2 reads and writes so MAX is different from SUM.
11365         dd if=/dev/zero of=$DIR/$tfile bs=$PAGE_SIZE count=1
11366         dd if=/dev/zero of=$DIR/$tfile bs=$PAGE_SIZE count=1
11367         cancel_lru_locks osc
11368         dd if=$DIR/$tfile of=/dev/null bs=$PAGE_SIZE count=1
11369         dd if=$DIR/$tfile of=/dev/null bs=$PAGE_SIZE count=1
11370
11371         $LCTL get_param llite.*.stats | grep samples > $TMP/$tfile.tmp
11372         while read name count samp unit min max sum sumsq; do
11373                 echo "got $count $name"
11374                 eval $name=$count || error "Wrong proc format"
11375
11376                 case $name in
11377                 read_bytes)
11378                         [ $count -ne 2 ] && error "count is not 2: $count"
11379                         [ $min -ne $PAGE_SIZE ] &&
11380                                 error "min is not $PAGE_SIZE: $min"
11381                         [ $max -ne $PAGE_SIZE ] &&
11382                                 error "max is incorrect: $max"
11383                         [ $sum -ne $((PAGE_SIZE * 2)) ] &&
11384                                 error "sum is wrong: $sum"
11385                         ;;
11386                 write_bytes)
11387                         [ $count -ne 2 ] && error "count is not 2: $count"
11388                         [ $min -ne $PAGE_SIZE ] &&
11389                                 error "min is not $PAGE_SIZE: $min"
11390                         [ $max -ne $PAGE_SIZE ] &&
11391                                 error "max is incorrect: $max"
11392                         [ $sum -ne $((PAGE_SIZE * 2)) ] &&
11393                                 error "sum is wrong: $sum"
11394                         ;;
11395                 *) ;;
11396                 esac
11397         done < $TMP/$tfile.tmp
11398
11399         #check that we actually got some stats
11400         [ "$read_bytes" ] || error "Missing read_bytes stats"
11401         [ "$write_bytes" ] || error "Missing write_bytes stats"
11402         [ "$read_bytes" != 0 ] || error "no read done"
11403         [ "$write_bytes" != 0 ] || error "no write done"
11404
11405         rm -f $TMP/${tfile}.tmp
11406 }
11407 run_test 127b "verify the llite client stats are sane"
11408
11409 test_127c() { # LU-12394
11410         [ "$OSTCOUNT" -lt "2" ] && skip_env "needs >= 2 OSTs"
11411         local size
11412         local bsize
11413         local reads
11414         local writes
11415         local count
11416
11417         $LCTL set_param llite.*.extents_stats=1
11418         stack_trap "$LCTL set_param llite.*.extents_stats=0" EXIT
11419
11420         # Use two stripes so there is enough space in default config
11421         $LFS setstripe -c 2 $DIR/$tfile
11422
11423         # Extent stats start at 0-4K and go in power of two buckets
11424         # LL_HIST_START = 12 --> 2^12 = 4K
11425         # We do 3K*2^i, so 3K, 6K, 12K, 24K... hitting each bucket.
11426         # We do not do buckets larger than 64 MiB to avoid ENOSPC issues on
11427         # small configs
11428         for size in 3K 6K 12K 24K 48K 96K 192K 384K 768K 1536K 3M 6M 12M 24M 48M;
11429                 do
11430                 # Write and read, 2x each, second time at a non-zero offset
11431                 dd if=/dev/zero of=$DIR/$tfile bs=$size count=1
11432                 dd if=/dev/zero of=$DIR/$tfile bs=$size count=1 seek=10
11433                 dd if=$DIR/$tfile of=/dev/null bs=$size count=1
11434                 dd if=$DIR/$tfile of=/dev/null bs=$size count=1 seek=10
11435                 rm -f $DIR/$tfile
11436         done
11437
11438         $LCTL get_param llite.*.extents_stats
11439
11440         count=2
11441         for bsize in 4K 8K 16K 32K 64K 128K 256K 512K 1M 2M 4M 8M 16M 32M 64M;
11442                 do
11443                 local bucket=$($LCTL get_param -n llite.*.extents_stats |
11444                                 grep -m 1 $bsize)
11445                 reads=$(echo $bucket | awk '{print $5}')
11446                 writes=$(echo $bucket | awk '{print $9}')
11447                 [ "$reads" -eq $count ] ||
11448                         error "$reads reads in < $bsize bucket, expect $count"
11449                 [ "$writes" -eq $count ] ||
11450                         error "$writes writes in < $bsize bucket, expect $count"
11451         done
11452
11453         # Test mmap write and read
11454         $LCTL set_param llite.*.extents_stats=c
11455         size=512
11456         dd if=/dev/zero of=$DIR/$tfile bs=${size}K count=1
11457         $MULTIOP $DIR/$tfile OSMRUc || error "$MULTIOP $DIR/$tfile failed"
11458         $MULTIOP $DIR/$tfile OSMWUc || error "$MULTIOP $DIR/$tfile failed"
11459
11460         $LCTL get_param llite.*.extents_stats
11461
11462         count=$(((size*1024) / PAGE_SIZE))
11463
11464         bsize=$((2 * PAGE_SIZE / 1024))K
11465
11466         bucket=$($LCTL get_param -n llite.*.extents_stats |
11467                         grep -m 1 $bsize)
11468         reads=$(echo $bucket | awk '{print $5}')
11469         writes=$(echo $bucket | awk '{print $9}')
11470         # mmap writes fault in the page first, creating an additonal read
11471         [ "$reads" -eq $((2 * count)) ] ||
11472                 error "$reads reads in < $bsize bucket, expect $count"
11473         [ "$writes" -eq $count ] ||
11474                 error "$writes writes in < $bsize bucket, expect $count"
11475 }
11476 run_test 127c "test llite extent stats with regular & mmap i/o"
11477
11478 test_128() { # bug 15212
11479         touch $DIR/$tfile
11480         $LFS 2>&1 <<-EOF | tee $TMP/$tfile.log
11481                 find $DIR/$tfile
11482                 find $DIR/$tfile
11483         EOF
11484
11485         result=$(grep error $TMP/$tfile.log)
11486         rm -f $DIR/$tfile $TMP/$tfile.log
11487         [ -z "$result" ] ||
11488                 error "consecutive find's under interactive lfs failed"
11489 }
11490 run_test 128 "interactive lfs for 2 consecutive find's"
11491
11492 set_dir_limits () {
11493         local mntdev
11494         local canondev
11495         local node
11496
11497         local ldproc=/proc/fs/ldiskfs
11498         local facets=$(get_facets MDS)
11499
11500         for facet in ${facets//,/ }; do
11501                 canondev=$(ldiskfs_canon \
11502                            *.$(convert_facet2label $facet).mntdev $facet)
11503                 do_facet $facet "test -e $ldproc/$canondev/max_dir_size" ||
11504                         ldproc=/sys/fs/ldiskfs
11505                 do_facet $facet "echo $1 >$ldproc/$canondev/max_dir_size"
11506                 do_facet $facet "echo $2 >$ldproc/$canondev/warning_dir_size"
11507         done
11508 }
11509
11510 check_mds_dmesg() {
11511         local facets=$(get_facets MDS)
11512         for facet in ${facets//,/ }; do
11513                 do_facet $facet "dmesg | tail -3 | grep -q $1" && return 0
11514         done
11515         return 1
11516 }
11517
11518 test_129() {
11519         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11520         [[ $MDS1_VERSION -ge $(version_code 2.5.56) ]] ||
11521                 skip "Need MDS version with at least 2.5.56"
11522         if [ "$mds1_FSTYPE" != ldiskfs ]; then
11523                 skip_env "ldiskfs only test"
11524         fi
11525         remote_mds_nodsh && skip "remote MDS with nodsh"
11526
11527         local ENOSPC=28
11528         local EFBIG=27
11529         local has_warning=false
11530
11531         rm -rf $DIR/$tdir
11532         mkdir -p $DIR/$tdir
11533
11534         # block size of mds1
11535         local maxsize=$(($($LCTL get_param -n mdc.*MDT0000*.blocksize) * 5))
11536         set_dir_limits $maxsize $maxsize
11537         local dirsize=$(stat -c%s "$DIR/$tdir")
11538         local nfiles=0
11539         while [[ $dirsize -le $maxsize ]]; do
11540                 $MULTIOP $DIR/$tdir/file_base_$nfiles Oc
11541                 rc=$?
11542                 if ! $has_warning; then
11543                         check_mds_dmesg '"is approaching"' && has_warning=true
11544                 fi
11545                 # check two errors:
11546                 # ENOSPC for new ext4 max_dir_size (kernel commit df981d03ee)
11547                 # EFBIG for previous versions included in ldiskfs series
11548                 if [ $rc -eq $EFBIG ] || [ $rc -eq $ENOSPC ]; then
11549                         set_dir_limits 0 0
11550                         echo "return code $rc received as expected"
11551
11552                         createmany -o $DIR/$tdir/file_extra_$nfiles. 5 ||
11553                                 error_exit "create failed w/o dir size limit"
11554
11555                         check_mds_dmesg '"has reached"' ||
11556                                 error_exit "reached message should be output"
11557
11558                         [ $has_warning = "false" ] &&
11559                                 error_exit "warning message should be output"
11560
11561                         dirsize=$(stat -c%s "$DIR/$tdir")
11562
11563                         [[ $dirsize -ge $maxsize ]] && return 0
11564                         error_exit "current dir size $dirsize, " \
11565                                    "previous limit $maxsize"
11566                 elif [ $rc -ne 0 ]; then
11567                         set_dir_limits 0 0
11568                         error_exit "return $rc received instead of expected " \
11569                                    "$EFBIG or $ENOSPC, files in dir $dirsize"
11570                 fi
11571                 nfiles=$((nfiles + 1))
11572                 dirsize=$(stat -c%s "$DIR/$tdir")
11573         done
11574
11575         set_dir_limits 0 0
11576         error "exceeded dir size limit $maxsize($MDSCOUNT) : $dirsize bytes"
11577 }
11578 run_test 129 "test directory size limit ========================"
11579
11580 OLDIFS="$IFS"
11581 cleanup_130() {
11582         trap 0
11583         IFS="$OLDIFS"
11584 }
11585
11586 test_130a() {
11587         local filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
11588         [ -n "$filefrag_op" ] && skip_env "filefrag does not support FIEMAP"
11589
11590         trap cleanup_130 EXIT RETURN
11591
11592         local fm_file=$DIR/$tfile
11593         $LFS setstripe -S 65536 -c 1 $fm_file || error "setstripe on $fm_file"
11594         dd if=/dev/zero of=$fm_file bs=65536 count=1 ||
11595                 error "dd failed for $fm_file"
11596
11597         # LU-1795: test filefrag/FIEMAP once, even if unsupported
11598         filefrag -ves $fm_file
11599         RC=$?
11600         [ "$(facet_fstype ost$(($($LFS getstripe -i $fm_file) + 1)))" = "zfs" ] &&
11601                 skip_env "ORI-366/LU-1941: FIEMAP unimplemented on ZFS"
11602         [ $RC != 0 ] && error "filefrag $fm_file failed"
11603
11604         filefrag_op=$(filefrag -ve -k $fm_file |
11605                         sed -n '/ext:/,/found/{/ext:/d; /found/d; p}')
11606         lun=$($LFS getstripe -i $fm_file)
11607
11608         start_blk=`echo $filefrag_op | cut -d: -f2 | cut -d. -f1`
11609         IFS=$'\n'
11610         tot_len=0
11611         for line in $filefrag_op
11612         do
11613                 frag_lun=`echo $line | cut -d: -f5`
11614                 ext_len=`echo $line | cut -d: -f4`
11615                 if (( $frag_lun != $lun )); then
11616                         cleanup_130
11617                         error "FIEMAP on 1-stripe file($fm_file) failed"
11618                         return
11619                 fi
11620                 (( tot_len += ext_len ))
11621         done
11622
11623         if (( lun != frag_lun || start_blk != 0 || tot_len != 64 )); then
11624                 cleanup_130
11625                 error "FIEMAP on 1-stripe file($fm_file) failed;"
11626                 return
11627         fi
11628
11629         cleanup_130
11630
11631         echo "FIEMAP on single striped file succeeded"
11632 }
11633 run_test 130a "FIEMAP (1-stripe file)"
11634
11635 test_130b() {
11636         [ "$OSTCOUNT" -lt "2" ] && skip_env "needs >= 2 OSTs"
11637
11638         local filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
11639         [ -n "$filefrag_op" ] && skip_env "filefrag does not support FIEMAP"
11640
11641         trap cleanup_130 EXIT RETURN
11642
11643         local fm_file=$DIR/$tfile
11644         $LFS setstripe -S 65536 -c $OSTCOUNT $fm_file ||
11645                         error "setstripe on $fm_file"
11646         [ "$(facet_fstype ost$(($($LFS getstripe -i $fm_file) + 1)))" = "zfs" ] &&
11647                 skip_env "ORI-366/LU-1941: FIEMAP unimplemented on ZFS"
11648
11649         dd if=/dev/zero of=$fm_file bs=1M count=$OSTCOUNT ||
11650                 error "dd failed on $fm_file"
11651
11652         filefrag -ves $fm_file || error "filefrag $fm_file failed"
11653         filefrag_op=$(filefrag -ve -k $fm_file |
11654                         sed -n '/ext:/,/found/{/ext:/d; /found/d; p}')
11655
11656         last_lun=$(echo $filefrag_op | cut -d: -f5 |
11657                 sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11658
11659         IFS=$'\n'
11660         tot_len=0
11661         num_luns=1
11662         for line in $filefrag_op
11663         do
11664                 frag_lun=$(echo $line | cut -d: -f5 |
11665                         sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11666                 ext_len=$(echo $line | cut -d: -f4)
11667                 if (( $frag_lun != $last_lun )); then
11668                         if (( tot_len != 1024 )); then
11669                                 cleanup_130
11670                                 error "FIEMAP on $fm_file failed; returned " \
11671                                 "len $tot_len for OST $last_lun instead of 1024"
11672                                 return
11673                         else
11674                                 (( num_luns += 1 ))
11675                                 tot_len=0
11676                         fi
11677                 fi
11678                 (( tot_len += ext_len ))
11679                 last_lun=$frag_lun
11680         done
11681         if (( num_luns != $OSTCOUNT || tot_len != 1024 )); then
11682                 cleanup_130
11683                 error "FIEMAP on $fm_file failed; returned wrong number of " \
11684                         "luns or wrong len for OST $last_lun"
11685                 return
11686         fi
11687
11688         cleanup_130
11689
11690         echo "FIEMAP on $OSTCOUNT-stripe file succeeded"
11691 }
11692 run_test 130b "FIEMAP ($OSTCOUNT-stripe file)"
11693
11694 test_130c() {
11695         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
11696
11697         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
11698         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP"
11699
11700         trap cleanup_130 EXIT RETURN
11701
11702         local fm_file=$DIR/$tfile
11703         $LFS setstripe -S 65536 -c 2 $fm_file || error "setstripe on $fm_file"
11704         [ "$(facet_fstype ost$(($($LFS getstripe -i $fm_file) + 1)))" = "zfs" ] &&
11705                 skip_env "ORI-366/LU-1941: FIEMAP unimplemented on ZFS"
11706
11707         dd if=/dev/zero of=$fm_file seek=1 bs=1M count=1 ||
11708                         error "dd failed on $fm_file"
11709
11710         filefrag -ves $fm_file || error "filefrag $fm_file failed"
11711         filefrag_op=$(filefrag -ve -k $fm_file |
11712                 sed -n '/ext:/,/found/{/ext:/d; /found/d; p}')
11713
11714         last_lun=$(echo $filefrag_op | cut -d: -f5 |
11715                 sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11716
11717         IFS=$'\n'
11718         tot_len=0
11719         num_luns=1
11720         for line in $filefrag_op
11721         do
11722                 frag_lun=$(echo $line | cut -d: -f5 |
11723                         sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11724                 ext_len=$(echo $line | cut -d: -f4)
11725                 if (( $frag_lun != $last_lun )); then
11726                         logical=`echo $line | cut -d: -f2 | cut -d. -f1`
11727                         if (( logical != 512 )); then
11728                                 cleanup_130
11729                                 error "FIEMAP on $fm_file failed; returned " \
11730                                 "logical start for lun $logical instead of 512"
11731                                 return
11732                         fi
11733                         if (( tot_len != 512 )); then
11734                                 cleanup_130
11735                                 error "FIEMAP on $fm_file failed; returned " \
11736                                 "len $tot_len for OST $last_lun instead of 1024"
11737                                 return
11738                         else
11739                                 (( num_luns += 1 ))
11740                                 tot_len=0
11741                         fi
11742                 fi
11743                 (( tot_len += ext_len ))
11744                 last_lun=$frag_lun
11745         done
11746         if (( num_luns != 2 || tot_len != 512 )); then
11747                 cleanup_130
11748                 error "FIEMAP on $fm_file failed; returned wrong number of " \
11749                         "luns or wrong len for OST $last_lun"
11750                 return
11751         fi
11752
11753         cleanup_130
11754
11755         echo "FIEMAP on 2-stripe file with hole succeeded"
11756 }
11757 run_test 130c "FIEMAP (2-stripe file with hole)"
11758
11759 test_130d() {
11760         [[ $OSTCOUNT -lt 3 ]] && skip_env "needs >= 3 OSTs"
11761
11762         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
11763         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP"
11764
11765         trap cleanup_130 EXIT RETURN
11766
11767         local fm_file=$DIR/$tfile
11768         $LFS setstripe -S 65536 -c $OSTCOUNT $fm_file ||
11769                         error "setstripe on $fm_file"
11770         [ "$(facet_fstype ost$(($($LFS getstripe -i $fm_file) + 1)))" = "zfs" ] &&
11771                 skip_env "ORI-366/LU-1941: FIEMAP unimplemented on ZFS"
11772
11773         local actual_stripe_count=$($LFS getstripe -c $fm_file)
11774         dd if=/dev/zero of=$fm_file bs=1M count=$actual_stripe_count ||
11775                 error "dd failed on $fm_file"
11776
11777         filefrag -ves $fm_file || error "filefrag $fm_file failed"
11778         filefrag_op=$(filefrag -ve -k $fm_file |
11779                         sed -n '/ext:/,/found/{/ext:/d; /found/d; p}')
11780
11781         last_lun=$(echo $filefrag_op | cut -d: -f5 |
11782                 sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11783
11784         IFS=$'\n'
11785         tot_len=0
11786         num_luns=1
11787         for line in $filefrag_op
11788         do
11789                 frag_lun=$(echo $line | cut -d: -f5 |
11790                         sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11791                 ext_len=$(echo $line | cut -d: -f4)
11792                 if (( $frag_lun != $last_lun )); then
11793                         if (( tot_len != 1024 )); then
11794                                 cleanup_130
11795                                 error "FIEMAP on $fm_file failed; returned " \
11796                                 "len $tot_len for OST $last_lun instead of 1024"
11797                                 return
11798                         else
11799                                 (( num_luns += 1 ))
11800                                 tot_len=0
11801                         fi
11802                 fi
11803                 (( tot_len += ext_len ))
11804                 last_lun=$frag_lun
11805         done
11806         if (( num_luns != actual_stripe_count || tot_len != 1024 )); then
11807                 cleanup_130
11808                 error "FIEMAP on $fm_file failed; returned wrong number of " \
11809                         "luns or wrong len for OST $last_lun"
11810                 return
11811         fi
11812
11813         cleanup_130
11814
11815         echo "FIEMAP on N-stripe file succeeded"
11816 }
11817 run_test 130d "FIEMAP (N-stripe file)"
11818
11819 test_130e() {
11820         [[ $OSTCOUNT -lt 2 ]] && skip_env "needs >= 2 OSTs"
11821
11822         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
11823         [ -n "$filefrag_op" ] && skip_env "filefrag does not support FIEMAP"
11824
11825         trap cleanup_130 EXIT RETURN
11826
11827         local fm_file=$DIR/$tfile
11828         $LFS setstripe -S 131072 -c 2 $fm_file || error "setstripe on $fm_file"
11829         [ "$(facet_fstype ost$(($($LFS getstripe -i $fm_file) + 1)))" = "zfs" ] &&
11830                 skip_env "ORI-366/LU-1941: FIEMAP unimplemented on ZFS"
11831
11832         NUM_BLKS=512
11833         EXPECTED_LEN=$(( (NUM_BLKS / 2) * 64 ))
11834         for ((i = 0; i < $NUM_BLKS; i++))
11835         do
11836                 dd if=/dev/zero of=$fm_file count=1 bs=64k seek=$((2*$i)) conv=notrunc > /dev/null 2>&1
11837         done
11838
11839         filefrag -ves $fm_file || error "filefrag $fm_file failed"
11840         filefrag_op=$(filefrag -ve -k $fm_file |
11841                         sed -n '/ext:/,/found/{/ext:/d; /found/d; p}')
11842
11843         last_lun=$(echo $filefrag_op | cut -d: -f5 |
11844                 sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11845
11846         IFS=$'\n'
11847         tot_len=0
11848         num_luns=1
11849         for line in $filefrag_op
11850         do
11851                 frag_lun=$(echo $line | cut -d: -f5 |
11852                         sed -e 's/^[ \t]*/0x/' | sed -e 's/0x0x/0x/')
11853                 ext_len=$(echo $line | cut -d: -f4)
11854                 if (( $frag_lun != $last_lun )); then
11855                         if (( tot_len != $EXPECTED_LEN )); then
11856                                 cleanup_130
11857                                 error "FIEMAP on $fm_file failed; returned " \
11858                                 "len $tot_len for OST $last_lun instead " \
11859                                 "of $EXPECTED_LEN"
11860                                 return
11861                         else
11862                                 (( num_luns += 1 ))
11863                                 tot_len=0
11864                         fi
11865                 fi
11866                 (( tot_len += ext_len ))
11867                 last_lun=$frag_lun
11868         done
11869         if (( num_luns != 2 || tot_len != $EXPECTED_LEN )); then
11870                 cleanup_130
11871                 error "FIEMAP on $fm_file failed; returned wrong number " \
11872                         "of luns or wrong len for OST $last_lun"
11873                 return
11874         fi
11875
11876         cleanup_130
11877
11878         echo "FIEMAP with continuation calls succeeded"
11879 }
11880 run_test 130e "FIEMAP (test continuation FIEMAP calls)"
11881
11882 test_130f() {
11883         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
11884         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP"
11885
11886         local fm_file=$DIR/$tfile
11887         $MULTIOP $fm_file oO_RDWR:O_CREAT:O_LOV_DELAY_CREATE:T33554432c ||
11888                 error "multiop create with lov_delay_create on $fm_file"
11889
11890         filefrag -ves $fm_file || error "filefrag $fm_file failed"
11891         filefrag_extents=$(filefrag -vek $fm_file |
11892                            awk '/extents? found/ { print $2 }')
11893         if [[ "$filefrag_extents" != "0" ]]; then
11894                 error "FIEMAP on $fm_file failed; " \
11895                       "returned $filefrag_extents expected 0"
11896         fi
11897
11898         rm -f $fm_file
11899 }
11900 run_test 130f "FIEMAP (unstriped file)"
11901
11902 # Test for writev/readv
11903 test_131a() {
11904         rwv -f $DIR/$tfile -w -n 3 524288 1048576 1572864 ||
11905                 error "writev test failed"
11906         rwv -f $DIR/$tfile -r -v -n 2 1572864 1048576 ||
11907                 error "readv failed"
11908         rm -f $DIR/$tfile
11909 }
11910 run_test 131a "test iov's crossing stripe boundary for writev/readv"
11911
11912 test_131b() {
11913         local fsize=$((524288 + 1048576 + 1572864))
11914         rwv -f $DIR/$tfile -w -a -n 3 524288 1048576 1572864 &&
11915                 $CHECKSTAT -t file $DIR/$tfile -s $fsize ||
11916                         error "append writev test failed"
11917
11918         ((fsize += 1572864 + 1048576))
11919         rwv -f $DIR/$tfile -w -a -n 2 1572864 1048576 &&
11920                 $CHECKSTAT -t file $DIR/$tfile -s $fsize ||
11921                         error "append writev test failed"
11922         rm -f $DIR/$tfile
11923 }
11924 run_test 131b "test append writev"
11925
11926 test_131c() {
11927         rwv -f $DIR/$tfile -w -d -n 1 1048576 || return 0
11928         error "NOT PASS"
11929 }
11930 run_test 131c "test read/write on file w/o objects"
11931
11932 test_131d() {
11933         rwv -f $DIR/$tfile -w -n 1 1572864
11934         NOB=`rwv -f $DIR/$tfile -r -n 3 524288 524288 1048576 | awk '/error/ {print $6}'`
11935         if [ "$NOB" != 1572864 ]; then
11936                 error "Short read filed: read $NOB bytes instead of 1572864"
11937         fi
11938         rm -f $DIR/$tfile
11939 }
11940 run_test 131d "test short read"
11941
11942 test_131e() {
11943         rwv -f $DIR/$tfile -w -s 1048576 -n 1 1048576
11944         rwv -f $DIR/$tfile -r -z -s 0 -n 1 524288 || \
11945         error "read hitting hole failed"
11946         rm -f $DIR/$tfile
11947 }
11948 run_test 131e "test read hitting hole"
11949
11950 check_stats() {
11951         local facet=$1
11952         local op=$2
11953         local want=${3:-0}
11954         local res
11955
11956         case $facet in
11957         mds*) res=$(do_facet $facet \
11958                    $LCTL get_param mdt.$FSNAME-MDT0000.md_stats | grep "$op")
11959                  ;;
11960         ost*) res=$(do_facet $facet \
11961                    $LCTL get_param obdfilter.$FSNAME-OST0000.stats | grep "$op")
11962                  ;;
11963         *) error "Wrong facet '$facet'" ;;
11964         esac
11965         [ "$res" ] || error "The counter for $op on $facet was not incremented"
11966         # if the argument $3 is zero, it means any stat increment is ok.
11967         if [[ $want -gt 0 ]]; then
11968                 local count=$(echo $res | awk '{ print $2 }')
11969                 [[ $count -ne $want ]] &&
11970                         error "The $op counter on $facet is $count, not $want"
11971         fi
11972 }
11973
11974 test_133a() {
11975         [ $PARALLEL == "yes" ] && skip "skip parallel run"
11976         remote_ost_nodsh && skip "remote OST with nodsh"
11977         remote_mds_nodsh && skip "remote MDS with nodsh"
11978         do_facet $SINGLEMDS $LCTL list_param mdt.*.rename_stats ||
11979                 skip_env "MDS doesn't support rename stats"
11980
11981         local testdir=$DIR/${tdir}/stats_testdir
11982
11983         mkdir -p $DIR/${tdir}
11984
11985         # clear stats.
11986         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
11987         do_facet ost1 $LCTL set_param obdfilter.*.stats=clear
11988
11989         # verify mdt stats first.
11990         mkdir ${testdir} || error "mkdir failed"
11991         check_stats $SINGLEMDS "mkdir" 1
11992         touch ${testdir}/${tfile} || error "touch failed"
11993         check_stats $SINGLEMDS "open" 1
11994         check_stats $SINGLEMDS "close" 1
11995         [ $MDS1_VERSION -ge $(version_code 2.8.54) ] && {
11996                 mknod ${testdir}/${tfile}-pipe p || error "mknod failed"
11997                 check_stats $SINGLEMDS "mknod" 2
11998         }
11999         rm -f ${testdir}/${tfile}-pipe || error "pipe remove failed"
12000         check_stats $SINGLEMDS "unlink" 1
12001         rm -f ${testdir}/${tfile} || error "file remove failed"
12002         check_stats $SINGLEMDS "unlink" 2
12003
12004         # remove working dir and check mdt stats again.
12005         rmdir ${testdir} || error "rmdir failed"
12006         check_stats $SINGLEMDS "rmdir" 1
12007
12008         local testdir1=$DIR/${tdir}/stats_testdir1
12009         mkdir -p ${testdir}
12010         mkdir -p ${testdir1}
12011         touch ${testdir1}/test1
12012         mv ${testdir1}/test1 ${testdir} || error "file crossdir rename"
12013         check_stats $SINGLEMDS "crossdir_rename" 1
12014
12015         mv ${testdir}/test1 ${testdir}/test0 || error "file samedir rename"
12016         check_stats $SINGLEMDS "samedir_rename" 1
12017
12018         rm -rf $DIR/${tdir}
12019 }
12020 run_test 133a "Verifying MDT stats ========================================"
12021
12022 test_133b() {
12023         local res
12024
12025         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12026         remote_ost_nodsh && skip "remote OST with nodsh"
12027         remote_mds_nodsh && skip "remote MDS with nodsh"
12028
12029         local testdir=$DIR/${tdir}/stats_testdir
12030
12031         mkdir -p ${testdir} || error "mkdir failed"
12032         touch ${testdir}/${tfile} || error "touch failed"
12033         cancel_lru_locks mdc
12034
12035         # clear stats.
12036         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
12037         do_facet ost1 $LCTL set_param obdfilter.*.stats=clear
12038
12039         # extra mdt stats verification.
12040         chmod 444 ${testdir}/${tfile} || error "chmod failed"
12041         check_stats $SINGLEMDS "setattr" 1
12042         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
12043         if [ $MDS1_VERSION -ne $(version_code 2.2.0) ]
12044         then            # LU-1740
12045                 ls -l ${testdir}/${tfile} > /dev/null|| error "ls failed"
12046                 check_stats $SINGLEMDS "getattr" 1
12047         fi
12048         rm -rf $DIR/${tdir}
12049
12050         # when DNE is enabled, MDT uses STATFS RPC to ping other targets
12051         # so the check below is not reliable
12052         [ $MDSCOUNT -eq 1 ] || return 0
12053
12054         # Sleep to avoid a cached response.
12055         #define OBD_STATFS_CACHE_SECONDS 1
12056         sleep 2
12057         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
12058         do_facet ost1 $LCTL set_param obdfilter.*.exports.*.stats=clear
12059         $LFS df || error "lfs failed"
12060         check_stats $SINGLEMDS "statfs" 1
12061
12062         # check aggregated statfs (LU-10018)
12063         [ $MDS1_VERSION -lt $(version_code 2.11.54) ] &&
12064                 return 0
12065         [ $CLIENT_VERSION -lt $(version_code 2.11.54) ] &&
12066                 return 0
12067         sleep 2
12068         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
12069         do_facet ost1 $LCTL set_param obdfilter.*.exports.*.stats=clear
12070         df $DIR
12071         check_stats $SINGLEMDS "statfs" 1
12072
12073         # We want to check that the client didn't send OST_STATFS to
12074         # ost1 but the MDT also uses OST_STATFS for precreate. So some
12075         # extra care is needed here.
12076         if remote_mds; then
12077                 local nid=$($LCTL list_nids | head -1 | sed  "s/\./\\\./g")
12078                 local param="obdfilter.$FSNAME-OST0000.exports.'$nid'.stats"
12079
12080                 res=$(do_facet ost1 $LCTL get_param $param | grep statfs)
12081                 [ "$res" ] && error "OST got STATFS"
12082         fi
12083
12084         return 0
12085 }
12086 run_test 133b "Verifying extra MDT stats =================================="
12087
12088 test_133c() {
12089         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12090         remote_ost_nodsh && skip "remote OST with nodsh"
12091         remote_mds_nodsh && skip "remote MDS with nodsh"
12092
12093         local testdir=$DIR/$tdir/stats_testdir
12094
12095         test_mkdir -p $testdir
12096
12097         # verify obdfilter stats.
12098         $LFS setstripe -c 1 -i 0 $testdir/$tfile
12099         sync
12100         cancel_lru_locks osc
12101         wait_delete_completed
12102
12103         # clear stats.
12104         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
12105         do_facet ost1 $LCTL set_param obdfilter.*.stats=clear
12106
12107         dd if=/dev/zero of=$testdir/$tfile conv=notrunc bs=512k count=1 ||
12108                 error "dd failed"
12109         sync
12110         cancel_lru_locks osc
12111         check_stats ost1 "write" 1
12112
12113         dd if=$testdir/$tfile of=/dev/null bs=1k count=1 || error "dd failed"
12114         check_stats ost1 "read" 1
12115
12116         > $testdir/$tfile || error "truncate failed"
12117         check_stats ost1 "punch" 1
12118
12119         rm -f $testdir/$tfile || error "file remove failed"
12120         wait_delete_completed
12121         check_stats ost1 "destroy" 1
12122
12123         rm -rf $DIR/$tdir
12124 }
12125 run_test 133c "Verifying OST stats ========================================"
12126
12127 order_2() {
12128         local value=$1
12129         local orig=$value
12130         local order=1
12131
12132         while [ $value -ge 2 ]; do
12133                 order=$((order*2))
12134                 value=$((value/2))
12135         done
12136
12137         if [ $orig -gt $order ]; then
12138                 order=$((order*2))
12139         fi
12140         echo $order
12141 }
12142
12143 size_in_KMGT() {
12144     local value=$1
12145     local size=('K' 'M' 'G' 'T');
12146     local i=0
12147     local size_string=$value
12148
12149     while [ $value -ge 1024 ]; do
12150         if [ $i -gt 3 ]; then
12151             #T is the biggest unit we get here, if that is bigger,
12152             #just return XXXT
12153             size_string=${value}T
12154             break
12155         fi
12156         value=$((value >> 10))
12157         if [ $value -lt 1024 ]; then
12158             size_string=${value}${size[$i]}
12159             break
12160         fi
12161         i=$((i + 1))
12162     done
12163
12164     echo $size_string
12165 }
12166
12167 get_rename_size() {
12168         local size=$1
12169         local context=${2:-.}
12170         local sample=$(do_facet $SINGLEMDS $LCTL \
12171                 get_param mdt.$FSNAME-MDT0000.rename_stats |
12172                 grep -A1 $context |
12173                 awk '/ '${size}'/ {print $4}' | sed -e "s/,//g")
12174         echo $sample
12175 }
12176
12177 test_133d() {
12178         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12179         remote_ost_nodsh && skip "remote OST with nodsh"
12180         remote_mds_nodsh && skip "remote MDS with nodsh"
12181         do_facet $SINGLEMDS $LCTL list_param mdt.*.rename_stats ||
12182                 skip_env "MDS doesn't support rename stats"
12183
12184         local testdir1=$DIR/${tdir}/stats_testdir1
12185         local testdir2=$DIR/${tdir}/stats_testdir2
12186         mkdir -p $DIR/${tdir}
12187
12188         do_facet $SINGLEMDS $LCTL set_param mdt.*.rename_stats=clear
12189
12190         lfs mkdir -i 0 -c 1 ${testdir1} || error "mkdir failed"
12191         lfs mkdir -i 0 -c 1 ${testdir2} || error "mkdir failed"
12192
12193         createmany -o $testdir1/test 512 || error "createmany failed"
12194
12195         # check samedir rename size
12196         mv ${testdir1}/test0 ${testdir1}/test_0
12197
12198         local testdir1_size=$(ls -l $DIR/${tdir} |
12199                 awk '/stats_testdir1/ {print $5}')
12200         local testdir2_size=$(ls -l $DIR/${tdir} |
12201                 awk '/stats_testdir2/ {print $5}')
12202
12203         testdir1_size=$(order_2 $testdir1_size)
12204         testdir2_size=$(order_2 $testdir2_size)
12205
12206         testdir1_size=$(size_in_KMGT $testdir1_size)
12207         testdir2_size=$(size_in_KMGT $testdir2_size)
12208
12209         echo "source rename dir size: ${testdir1_size}"
12210         echo "target rename dir size: ${testdir2_size}"
12211
12212         local cmd="do_facet $SINGLEMDS $LCTL "
12213         cmd+="get_param mdt.$FSNAME-MDT0000.rename_stats"
12214
12215         eval $cmd || error "$cmd failed"
12216         local samedir=$($cmd | grep 'same_dir')
12217         local same_sample=$(get_rename_size $testdir1_size)
12218         [ -z "$samedir" ] && error "samedir_rename_size count error"
12219         [[ $same_sample -eq 1 ]] ||
12220                 error "samedir_rename_size error $same_sample"
12221         echo "Check same dir rename stats success"
12222
12223         do_facet $SINGLEMDS $LCTL set_param mdt.*.rename_stats=clear
12224
12225         # check crossdir rename size
12226         mv ${testdir1}/test_0 ${testdir2}/test_0
12227
12228         testdir1_size=$(ls -l $DIR/${tdir} |
12229                 awk '/stats_testdir1/ {print $5}')
12230         testdir2_size=$(ls -l $DIR/${tdir} |
12231                 awk '/stats_testdir2/ {print $5}')
12232
12233         testdir1_size=$(order_2 $testdir1_size)
12234         testdir2_size=$(order_2 $testdir2_size)
12235
12236         testdir1_size=$(size_in_KMGT $testdir1_size)
12237         testdir2_size=$(size_in_KMGT $testdir2_size)
12238
12239         echo "source rename dir size: ${testdir1_size}"
12240         echo "target rename dir size: ${testdir2_size}"
12241
12242         eval $cmd || error "$cmd failed"
12243         local crossdir=$($cmd | grep 'crossdir')
12244         local src_sample=$(get_rename_size $testdir1_size crossdir_src)
12245         local tgt_sample=$(get_rename_size $testdir2_size crossdir_tgt)
12246         [ -z "$crossdir" ] && error "crossdir_rename_size count error"
12247         [[ $src_sample -eq 1 ]] ||
12248                 error "crossdir_rename_size error $src_sample"
12249         [[ $tgt_sample -eq 1 ]] ||
12250                 error "crossdir_rename_size error $tgt_sample"
12251         echo "Check cross dir rename stats success"
12252         rm -rf $DIR/${tdir}
12253 }
12254 run_test 133d "Verifying rename_stats ========================================"
12255
12256 test_133e() {
12257         remote_mds_nodsh && skip "remote MDS with nodsh"
12258         remote_ost_nodsh && skip "remote OST with nodsh"
12259         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12260
12261         local testdir=$DIR/${tdir}/stats_testdir
12262         local ctr f0 f1 bs=32768 count=42 sum
12263
12264         mkdir -p ${testdir} || error "mkdir failed"
12265
12266         $LFS setstripe -c 1 -i 0 ${testdir}/${tfile}
12267
12268         for ctr in {write,read}_bytes; do
12269                 sync
12270                 cancel_lru_locks osc
12271
12272                 do_facet ost1 $LCTL set_param -n \
12273                         "obdfilter.*.exports.clear=clear"
12274
12275                 if [ $ctr = write_bytes ]; then
12276                         f0=/dev/zero
12277                         f1=${testdir}/${tfile}
12278                 else
12279                         f0=${testdir}/${tfile}
12280                         f1=/dev/null
12281                 fi
12282
12283                 dd if=$f0 of=$f1 conv=notrunc bs=$bs count=$count || \
12284                         error "dd failed"
12285                 sync
12286                 cancel_lru_locks osc
12287
12288                 sum=$(do_facet ost1 $LCTL get_param \
12289                         "obdfilter.*.exports.*.stats" |
12290                         awk -v ctr=$ctr 'BEGIN { sum = 0 }
12291                                 $1 == ctr { sum += $7 }
12292                                 END { printf("%0.0f", sum) }')
12293
12294                 if ((sum != bs * count)); then
12295                         error "Bad $ctr sum, expected $((bs * count)), got $sum"
12296                 fi
12297         done
12298
12299         rm -rf $DIR/${tdir}
12300 }
12301 run_test 133e "Verifying OST {read,write}_bytes nid stats ================="
12302
12303 proc_regexp="/{proc,sys}/{fs,sys,kernel/debug}/{lustre,lnet}/"
12304
12305 # Some versions of find (4.5.11, 4.5.14) included in CentOS 7.3-7.5 do
12306 # not honor the -ignore_readdir_race option correctly. So we call
12307 # error_ignore() rather than error() in these cases. See LU-11152.
12308 error_133() {
12309         if (find --version; do_facet mds1 find --version) |
12310                 grep -q '\b4\.5\.1[1-4]\b'; then
12311                 error_ignore LU-11152 "$@"
12312         else
12313                 error "$@"
12314         fi
12315 }
12316
12317 test_133f() {
12318         # First without trusting modes.
12319         local proc_dirs=$(eval \ls -d $proc_regexp 2>/dev/null)
12320         echo "proc_dirs='$proc_dirs'"
12321         [ -n "$proc_dirs" ] || error "no proc_dirs on $HOSTNAME"
12322         find $proc_dirs -exec cat '{}' \; &> /dev/null
12323
12324         # Second verifying readability.
12325         $LCTL get_param -R '*' &> /dev/null
12326
12327         # Verifing writability with badarea_io.
12328         find $proc_dirs \
12329                 -ignore_readdir_race \
12330                 -type f \
12331                 -not -name force_lbug \
12332                 -not -name changelog_mask \
12333                 -exec badarea_io '{}' \; ||
12334                         error_133 "find $proc_dirs failed"
12335 }
12336 run_test 133f "Check reads/writes of client lustre proc files with bad area io"
12337
12338 test_133g() {
12339         remote_mds_nodsh && skip "remote MDS with nodsh"
12340         remote_ost_nodsh && skip "remote OST with nodsh"
12341
12342         # eventually, this can also be replaced with "lctl get_param -R",
12343         # but not until that option is always available on the server
12344         local facet
12345         for facet in mds1 ost1; do
12346                 [ $(lustre_version_code $facet) -le $(version_code 2.5.54) ] &&
12347                         skip_noexit "Too old lustre on $facet"
12348                 local facet_proc_dirs=$(do_facet $facet \
12349                                         \\\ls -d $proc_regexp 2>/dev/null)
12350                 echo "${facet}_proc_dirs='$facet_proc_dirs'"
12351                 [ -z "$facet_proc_dirs" ] && error "no proc_dirs on $facet"
12352                 do_facet $facet find $facet_proc_dirs \
12353                         ! -name req_history \
12354                         -exec cat '{}' \\\; &> /dev/null
12355
12356                 do_facet $facet find $facet_proc_dirs \
12357                         ! -name req_history \
12358                         -type f \
12359                         -exec cat '{}' \\\; &> /dev/null ||
12360                                 error "proc file read failed"
12361
12362                 do_facet $facet find $facet_proc_dirs \
12363                         -ignore_readdir_race \
12364                         -type f \
12365                         -not -name force_lbug \
12366                         -not -name changelog_mask \
12367                         -exec badarea_io '{}' \\\; ||
12368                                 error_133 "$facet find $facet_proc_dirs failed"
12369         done
12370
12371         # remount the FS in case writes/reads /proc break the FS
12372         cleanup || error "failed to unmount"
12373         setup || error "failed to setup"
12374         true
12375 }
12376 run_test 133g "Check reads/writes of server lustre proc files with bad area io"
12377
12378 test_133h() {
12379         remote_mds_nodsh && skip "remote MDS with nodsh"
12380         remote_ost_nodsh && skip "remote OST with nodsh"
12381         [[ $MDS1_VERSION -lt $(version_code 2.9.54) ]] &&
12382                 skip "Need MDS version at least 2.9.54"
12383
12384         local facet
12385
12386         for facet in client mds1 ost1; do
12387                 local facet_proc_dirs=$(do_facet $facet \
12388                                         \\\ls -d $proc_regexp 2> /dev/null)
12389                 [ -z "$facet_proc_dirs" ] && error "no proc_dirs on $facet"
12390                 echo "${facet}_proc_dirs='$facet_proc_dirs'"
12391                 # Get the list of files that are missing the terminating newline
12392                 local missing=($(do_facet $facet \
12393                         find ${facet_proc_dirs} -type f \|              \
12394                                 while read F\; do                       \
12395                                         awk -v FS='\v' -v RS='\v\v'     \
12396                                         "'END { if(NR>0 &&              \
12397                                         \\\$NF !~ /.*\\\n\$/)           \
12398                                                 print FILENAME}'"       \
12399                                         '\$F'\;                         \
12400                                 done 2>/dev/null))
12401                 [ ${#missing[*]} -eq 0 ] ||
12402                         error "files do not end with newline: ${missing[*]}"
12403         done
12404 }
12405 run_test 133h "Proc files should end with newlines"
12406
12407 test_134a() {
12408         remote_mds_nodsh && skip "remote MDS with nodsh"
12409         [[ $MDS1_VERSION -lt $(version_code 2.7.54) ]] &&
12410                 skip "Need MDS version at least 2.7.54"
12411
12412         mkdir -p $DIR/$tdir || error "failed to create $DIR/$tdir"
12413         cancel_lru_locks mdc
12414
12415         local nsdir="ldlm.namespaces.*-MDT0000-mdc-*"
12416         local unused=$($LCTL get_param -n $nsdir.lock_unused_count)
12417         [ $unused -eq 0 ] || error "$unused locks are not cleared"
12418
12419         local nr=1000
12420         createmany -o $DIR/$tdir/f $nr ||
12421                 error "failed to create $nr files in $DIR/$tdir"
12422         unused=$($LCTL get_param -n $nsdir.lock_unused_count)
12423
12424         #define OBD_FAIL_LDLM_WATERMARK_LOW     0x327
12425         do_facet mds1 $LCTL set_param fail_loc=0x327
12426         do_facet mds1 $LCTL set_param fail_val=500
12427         touch $DIR/$tdir/m
12428
12429         echo "sleep 10 seconds ..."
12430         sleep 10
12431         local lck_cnt=$($LCTL get_param -n $nsdir.lock_unused_count)
12432
12433         do_facet mds1 $LCTL set_param fail_loc=0
12434         do_facet mds1 $LCTL set_param fail_val=0
12435         [ $lck_cnt -lt $unused ] ||
12436                 error "No locks reclaimed, before:$unused, after:$lck_cnt"
12437
12438         rm $DIR/$tdir/m
12439         unlinkmany $DIR/$tdir/f $nr
12440 }
12441 run_test 134a "Server reclaims locks when reaching lock_reclaim_threshold"
12442
12443 test_134b() {
12444         remote_mds_nodsh && skip "remote MDS with nodsh"
12445         [[ $MDS1_VERSION -lt $(version_code 2.7.54) ]] &&
12446                 skip "Need MDS version at least 2.7.54"
12447
12448         mkdir -p $DIR/$tdir || error "failed to create $DIR/$tdir"
12449         cancel_lru_locks mdc
12450
12451         local low_wm=$(do_facet mds1 $LCTL get_param -n \
12452                         ldlm.lock_reclaim_threshold_mb)
12453         # disable reclaim temporarily
12454         do_facet mds1 $LCTL set_param ldlm.lock_reclaim_threshold_mb=0
12455
12456         #define OBD_FAIL_LDLM_WATERMARK_HIGH     0x328
12457         do_facet mds1 $LCTL set_param fail_loc=0x328
12458         do_facet mds1 $LCTL set_param fail_val=500
12459
12460         $LCTL set_param debug=+trace
12461
12462         local nr=600
12463         createmany -o $DIR/$tdir/f $nr &
12464         local create_pid=$!
12465
12466         echo "Sleep $TIMEOUT seconds ..."
12467         sleep $TIMEOUT
12468         if ! ps -p $create_pid  > /dev/null 2>&1; then
12469                 do_facet mds1 $LCTL set_param fail_loc=0
12470                 do_facet mds1 $LCTL set_param fail_val=0
12471                 do_facet mds1 $LCTL set_param \
12472                         ldlm.lock_reclaim_threshold_mb=${low_wm}m
12473                 error "createmany finished incorrectly!"
12474         fi
12475         do_facet mds1 $LCTL set_param fail_loc=0
12476         do_facet mds1 $LCTL set_param fail_val=0
12477         do_facet mds1 $LCTL set_param ldlm.lock_reclaim_threshold_mb=${low_wm}m
12478         wait $create_pid || return 1
12479
12480         unlinkmany $DIR/$tdir/f $nr
12481 }
12482 run_test 134b "Server rejects lock request when reaching lock_limit_mb"
12483
12484 test_140() { #bug-17379
12485         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12486
12487         test_mkdir $DIR/$tdir
12488         cd $DIR/$tdir || error "Changing to $DIR/$tdir"
12489         cp $(which stat) . || error "Copying stat to $DIR/$tdir"
12490
12491         # VFS limits max symlink depth to 5(4KSTACK) or 7(8KSTACK) or 8
12492         # For kernel > 3.5, bellow only tests consecutive symlink (MAX 40)
12493         local i=0
12494         while i=$((i + 1)); do
12495                 test_mkdir $i
12496                 cd $i || error "Changing to $i"
12497                 ln -s ../stat stat || error "Creating stat symlink"
12498                 # Read the symlink until ELOOP present,
12499                 # not LBUGing the system is considered success,
12500                 # we didn't overrun the stack.
12501                 $OPENFILE -f O_RDONLY stat >/dev/null 2>&1; ret=$?
12502                 if [ $ret -ne 0 ]; then
12503                         if [ $ret -eq 40 ]; then
12504                                 break  # -ELOOP
12505                         else
12506                                 error "Open stat symlink"
12507                                         return
12508                         fi
12509                 fi
12510         done
12511         i=$((i - 1))
12512         echo "The symlink depth = $i"
12513         [ $i -eq 5 ] || [ $i -eq 7 ] || [ $i -eq 8 ] || [ $i -eq 40 ] ||
12514                 error "Invalid symlink depth"
12515
12516         # Test recursive symlink
12517         ln -s symlink_self symlink_self
12518         $OPENFILE -f O_RDONLY symlink_self >/dev/null 2>&1; ret=$?
12519         echo "open symlink_self returns $ret"
12520         [ $ret -eq 40 ] || error "recursive symlink doesn't return -ELOOP"
12521 }
12522 run_test 140 "Check reasonable stack depth (shouldn't LBUG) ===="
12523
12524 test_150() {
12525         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12526
12527         local TF="$TMP/$tfile"
12528
12529         dd if=/dev/urandom of=$TF bs=6096 count=1 || error "dd failed"
12530         cp $TF $DIR/$tfile
12531         cancel_lru_locks $OSC
12532         cmp $TF $DIR/$tfile || error "$TMP/$tfile $DIR/$tfile differ"
12533         remount_client $MOUNT
12534         df -P $MOUNT
12535         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (remount)"
12536
12537         $TRUNCATE $TF 6000
12538         $TRUNCATE $DIR/$tfile 6000
12539         cancel_lru_locks $OSC
12540         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (truncate1)"
12541
12542         echo "12345" >>$TF
12543         echo "12345" >>$DIR/$tfile
12544         cancel_lru_locks $OSC
12545         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (append1)"
12546
12547         echo "12345" >>$TF
12548         echo "12345" >>$DIR/$tfile
12549         cancel_lru_locks $OSC
12550         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (append2)"
12551
12552         rm -f $TF
12553         true
12554 }
12555 run_test 150 "truncate/append tests"
12556
12557 #LU-2902 roc_hit was not able to read all values from lproc
12558 function roc_hit_init() {
12559         local list=$(comma_list $(osts_nodes))
12560         local dir=$DIR/$tdir-check
12561         local file=$dir/$tfile
12562         local BEFORE
12563         local AFTER
12564         local idx
12565
12566         test_mkdir $dir
12567         #use setstripe to do a write to every ost
12568         for i in $(seq 0 $((OSTCOUNT-1))); do
12569                 $LFS setstripe -c 1 -i $i $dir || error "$LFS setstripe $file failed"
12570                 dd if=/dev/urandom of=$file bs=4k count=4 2>&1 > /dev/null
12571                 idx=$(printf %04x $i)
12572                 BEFORE=$(get_osd_param $list *OST*$idx stats |
12573                         awk '$1 == "cache_access" {sum += $7}
12574                                 END { printf("%0.0f", sum) }')
12575
12576                 cancel_lru_locks osc
12577                 cat $file >/dev/null
12578
12579                 AFTER=$(get_osd_param $list *OST*$idx stats |
12580                         awk '$1 == "cache_access" {sum += $7}
12581                                 END { printf("%0.0f", sum) }')
12582
12583                 echo BEFORE:$BEFORE AFTER:$AFTER
12584                 if ! let "AFTER - BEFORE == 4"; then
12585                         rm -rf $dir
12586                         error "roc_hit is not safe to use"
12587                 fi
12588                 rm $file
12589         done
12590
12591         rm -rf $dir
12592 }
12593
12594 function roc_hit() {
12595         local list=$(comma_list $(osts_nodes))
12596         echo $(get_osd_param $list '' stats |
12597                 awk '$1 == "cache_hit" {sum += $7}
12598                         END { printf("%0.0f", sum) }')
12599 }
12600
12601 function set_cache() {
12602         local on=1
12603
12604         if [ "$2" == "off" ]; then
12605                 on=0;
12606         fi
12607         local list=$(comma_list $(osts_nodes))
12608         set_osd_param $list '' $1_cache_enable $on
12609
12610         cancel_lru_locks osc
12611 }
12612
12613 test_151() {
12614         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12615         remote_ost_nodsh && skip "remote OST with nodsh"
12616
12617         local CPAGES=3
12618         local list=$(comma_list $(osts_nodes))
12619
12620         # check whether obdfilter is cache capable at all
12621         if ! get_osd_param $list '' read_cache_enable >/dev/null; then
12622                 skip "not cache-capable obdfilter"
12623         fi
12624
12625         # check cache is enabled on all obdfilters
12626         if get_osd_param $list '' read_cache_enable | grep 0; then
12627                 skip "oss cache is disabled"
12628         fi
12629
12630         set_osd_param $list '' writethrough_cache_enable 1
12631
12632         # check write cache is enabled on all obdfilters
12633         if get_osd_param $list '' writethrough_cache_enable | grep 0; then
12634                 skip "oss write cache is NOT enabled"
12635         fi
12636
12637         roc_hit_init
12638
12639         #define OBD_FAIL_OBD_NO_LRU  0x609
12640         do_nodes $list $LCTL set_param fail_loc=0x609
12641
12642         # pages should be in the case right after write
12643         dd if=/dev/urandom of=$DIR/$tfile bs=4k count=$CPAGES ||
12644                 error "dd failed"
12645
12646         local BEFORE=$(roc_hit)
12647         cancel_lru_locks osc
12648         cat $DIR/$tfile >/dev/null
12649         local AFTER=$(roc_hit)
12650
12651         do_nodes $list $LCTL set_param fail_loc=0
12652
12653         if ! let "AFTER - BEFORE == CPAGES"; then
12654                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
12655         fi
12656
12657         # the following read invalidates the cache
12658         cancel_lru_locks osc
12659         set_osd_param $list '' read_cache_enable 0
12660         cat $DIR/$tfile >/dev/null
12661
12662         # now data shouldn't be found in the cache
12663         BEFORE=$(roc_hit)
12664         cancel_lru_locks osc
12665         cat $DIR/$tfile >/dev/null
12666         AFTER=$(roc_hit)
12667         if let "AFTER - BEFORE != 0"; then
12668                 error "IN CACHE: before: $BEFORE, after: $AFTER"
12669         fi
12670
12671         set_osd_param $list '' read_cache_enable 1
12672         rm -f $DIR/$tfile
12673 }
12674 run_test 151 "test cache on oss and controls ==============================="
12675
12676 test_152() {
12677         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12678
12679         local TF="$TMP/$tfile"
12680
12681         # simulate ENOMEM during write
12682 #define OBD_FAIL_OST_NOMEM      0x226
12683         lctl set_param fail_loc=0x80000226
12684         dd if=/dev/urandom of=$TF bs=6096 count=1 || error "dd failed"
12685         cp $TF $DIR/$tfile
12686         sync || error "sync failed"
12687         lctl set_param fail_loc=0
12688
12689         # discard client's cache
12690         cancel_lru_locks osc
12691
12692         # simulate ENOMEM during read
12693         lctl set_param fail_loc=0x80000226
12694         cmp $TF $DIR/$tfile || error "cmp failed"
12695         lctl set_param fail_loc=0
12696
12697         rm -f $TF
12698 }
12699 run_test 152 "test read/write with enomem ============================"
12700
12701 test_153() {
12702         $MULTIOP $DIR/$tfile Ow4096Ycu || error "multiop failed"
12703 }
12704 run_test 153 "test if fdatasync does not crash ======================="
12705
12706 dot_lustre_fid_permission_check() {
12707         local fid=$1
12708         local ffid=$MOUNT/.lustre/fid/$fid
12709         local test_dir=$2
12710
12711         echo "stat fid $fid"
12712         stat $ffid > /dev/null || error "stat $ffid failed."
12713         echo "touch fid $fid"
12714         touch $ffid || error "touch $ffid failed."
12715         echo "write to fid $fid"
12716         cat /etc/hosts > $ffid || error "write $ffid failed."
12717         echo "read fid $fid"
12718         diff /etc/hosts $ffid || error "read $ffid failed."
12719         echo "append write to fid $fid"
12720         cat /etc/hosts >> $ffid || error "append write $ffid failed."
12721         echo "rename fid $fid"
12722         mv $ffid $test_dir/$tfile.1 &&
12723                 error "rename $ffid to $tfile.1 should fail."
12724         touch $test_dir/$tfile.1
12725         mv $test_dir/$tfile.1 $ffid &&
12726                 error "rename $tfile.1 to $ffid should fail."
12727         rm -f $test_dir/$tfile.1
12728         echo "truncate fid $fid"
12729         $TRUNCATE $ffid 777 || error "truncate $ffid failed."
12730         echo "link fid $fid"
12731         ln -f $ffid $test_dir/tfile.lnk || error "link $ffid failed."
12732         if [[ $($LCTL get_param -n mdc.*-mdc-*.connect_flags) =~ acl ]]; then
12733                 echo "setfacl fid $fid"
12734                 setfacl -R -m u:bin:rwx $ffid || error "setfacl $ffid failed."
12735                 echo "getfacl fid $fid"
12736                 getfacl $ffid >/dev/null || error "getfacl $ffid failed."
12737         fi
12738         echo "unlink fid $fid"
12739         unlink $MOUNT/.lustre/fid/$fid && error "unlink $ffid should fail."
12740         echo "mknod fid $fid"
12741         mknod $ffid c 1 3 && error "mknod $ffid should fail."
12742
12743         fid=[0xf00000400:0x1:0x0]
12744         ffid=$MOUNT/.lustre/fid/$fid
12745
12746         echo "stat non-exist fid $fid"
12747         stat $ffid > /dev/null && error "stat non-exist $ffid should fail."
12748         echo "write to non-exist fid $fid"
12749         cat /etc/hosts > $ffid && error "write non-exist $ffid should fail."
12750         echo "link new fid $fid"
12751         ln $test_dir/$tfile $ffid && error "link $ffid should fail."
12752
12753         mkdir -p $test_dir/$tdir
12754         touch $test_dir/$tdir/$tfile
12755         fid=$($LFS path2fid $test_dir/$tdir)
12756         rc=$?
12757         [ $rc -ne 0 ] &&
12758                 error "error: could not get fid for $test_dir/$dir/$tfile."
12759
12760         ffid=$MOUNT/.lustre/fid/$fid
12761
12762         echo "ls $fid"
12763         ls $ffid > /dev/null || error "ls $ffid failed."
12764         echo "touch $fid/$tfile.1"
12765         touch $ffid/$tfile.1 || error "touch $ffid/$tfile.1 failed."
12766
12767         echo "touch $MOUNT/.lustre/fid/$tfile"
12768         touch $MOUNT/.lustre/fid/$tfile && \
12769                 error "touch $MOUNT/.lustre/fid/$tfile should fail."
12770
12771         echo "setxattr to $MOUNT/.lustre/fid"
12772         setfattr -n trusted.name1 -v value1 $MOUNT/.lustre/fid
12773
12774         echo "listxattr for $MOUNT/.lustre/fid"
12775         getfattr -d -m "^trusted" $MOUNT/.lustre/fid
12776
12777         echo "delxattr from $MOUNT/.lustre/fid"
12778         setfattr -x trusted.name1 $MOUNT/.lustre/fid
12779
12780         echo "touch invalid fid: $MOUNT/.lustre/fid/[0x200000400:0x2:0x3]"
12781         touch $MOUNT/.lustre/fid/[0x200000400:0x2:0x3] &&
12782                 error "touch invalid fid should fail."
12783
12784         echo "touch non-normal fid: $MOUNT/.lustre/fid/[0x1:0x2:0x0]"
12785         touch $MOUNT/.lustre/fid/[0x1:0x2:0x0] &&
12786                 error "touch non-normal fid should fail."
12787
12788         echo "rename $tdir to $MOUNT/.lustre/fid"
12789         mrename $test_dir/$tdir $MOUNT/.lustre/fid &&
12790                 error "rename to $MOUNT/.lustre/fid should fail."
12791
12792         if [ $MDS1_VERSION -ge $(version_code 2.3.51) ]
12793         then            # LU-3547
12794                 local old_obf_mode=$(stat --format="%a" $DIR/.lustre/fid)
12795                 local new_obf_mode=777
12796
12797                 echo "change mode of $DIR/.lustre/fid to $new_obf_mode"
12798                 chmod $new_obf_mode $DIR/.lustre/fid ||
12799                         error "chmod $new_obf_mode $DIR/.lustre/fid failed"
12800
12801                 local obf_mode=$(stat --format=%a $DIR/.lustre/fid)
12802                 [ $obf_mode -eq $new_obf_mode ] ||
12803                         error "stat $DIR/.lustre/fid returned wrong mode $obf_mode"
12804
12805                 echo "restore mode of $DIR/.lustre/fid to $old_obf_mode"
12806                 chmod $old_obf_mode $DIR/.lustre/fid ||
12807                         error "chmod $old_obf_mode $DIR/.lustre/fid failed"
12808         fi
12809
12810         $OPENFILE -f O_LOV_DELAY_CREATE:O_CREAT $test_dir/$tfile-2
12811         fid=$($LFS path2fid $test_dir/$tfile-2)
12812
12813         if [ $MDS1_VERSION -ge $(version_code 2.6.50) ]
12814         then # LU-5424
12815                 echo "cp /etc/passwd $MOUNT/.lustre/fid/$fid"
12816                 cp /etc/passwd $MOUNT/.lustre/fid/$fid ||
12817                         error "create lov data thru .lustre failed"
12818         fi
12819         echo "cp /etc/passwd $test_dir/$tfile-2"
12820         cp /etc/passwd $test_dir/$tfile-2 ||
12821                 error "copy to $test_dir/$tfile-2 failed."
12822         echo "diff /etc/passwd $MOUNT/.lustre/fid/$fid"
12823         diff /etc/passwd $MOUNT/.lustre/fid/$fid ||
12824                 error "diff /etc/passwd $MOUNT/.lustre/fid/$fid failed."
12825
12826         rm -rf $test_dir/tfile.lnk
12827         rm -rf $test_dir/$tfile-2
12828 }
12829
12830 test_154A() {
12831         [[ $MDS1_VERSION -lt $(version_code 2.4.1) ]] &&
12832                 skip "Need MDS version at least 2.4.1"
12833
12834         local tf=$DIR/$tfile
12835         touch $tf
12836
12837         local fid=$($LFS path2fid $tf)
12838         [ -z "$fid" ] && error "path2fid unable to get $tf FID"
12839
12840         # check that we get the same pathname back
12841         local found=$($LFS fid2path $MOUNT "$fid")
12842         [ -z "$found" ] && error "fid2path unable to get '$fid' path"
12843         [ "$found" == "$tf" ] ||
12844                 error "fid2path($fid=path2fid($tf)) = $found != $tf"
12845 }
12846 run_test 154A "lfs path2fid and fid2path basic checks"
12847
12848 test_154B() {
12849         [[ $MDS1_VERSION -lt $(version_code 2.4.1) ]] &&
12850                 skip "Need MDS version at least 2.4.1"
12851
12852         mkdir -p $DIR/$tdir || error "mkdir $tdir failed"
12853         touch $DIR/$tdir/$tfile || error "touch $DIR/$tdir/$tfile failed"
12854         local linkea=$($LL_DECODE_LINKEA $DIR/$tdir/$tfile | grep 'pfid')
12855         [ -z "$linkea" ] && error "decode linkea $DIR/$tdir/$tfile failed"
12856
12857         local name=$(echo $linkea | awk '/pfid/ {print $5}' | sed -e "s/'//g")
12858         local PFID=$(echo $linkea | awk '/pfid/ {print $3}' | sed -e "s/,//g")
12859
12860         # check that we get the same pathname
12861         echo "PFID: $PFID, name: $name"
12862         local FOUND=$($LFS fid2path $MOUNT "$PFID")
12863         [ -z "$FOUND" ] && error "fid2path unable to get $PFID path"
12864         [ "$FOUND/$name" != "$DIR/$tdir/$tfile" ] &&
12865                 error "ll_decode_linkea has $FOUND/$name != $DIR/$tdir/$tfile"
12866
12867         rm -rf $DIR/$tdir || error "Can not delete directory $DIR/$tdir"
12868 }
12869 run_test 154B "verify the ll_decode_linkea tool"
12870
12871 test_154a() {
12872         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12873         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
12874         [[ $MDS1_VERSION -ge $(version_code 2.2.51) ]] ||
12875                 skip "Need MDS version at least 2.2.51"
12876         [ -z "$(which setfacl)" ] && skip_env "must have setfacl tool"
12877
12878         cp /etc/hosts $DIR/$tfile
12879
12880         fid=$($LFS path2fid $DIR/$tfile)
12881         rc=$?
12882         [ $rc -ne 0 ] && error "error: could not get fid for $DIR/$tfile."
12883
12884         dot_lustre_fid_permission_check "$fid" $DIR ||
12885                 error "dot lustre permission check $fid failed"
12886
12887         ls -a $MOUNT | grep "\.lustre" && error ".lustre should not be listed"
12888
12889         rm -rf $MOUNT/.lustre && error ".lustre is not allowed to be unlinked"
12890
12891         touch $MOUNT/.lustre/file &&
12892                 error "creation is not allowed under .lustre"
12893
12894         mkdir $MOUNT/.lustre/dir &&
12895                 error "mkdir is not allowed under .lustre"
12896
12897         rm -rf $DIR/$tfile
12898 }
12899 run_test 154a "Open-by-FID"
12900
12901 test_154b() {
12902         [ $PARALLEL == "yes" ] && skip "skip parallel run"
12903         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
12904         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
12905         [[ $MDS1_VERSION -ge $(version_code 2.2.51) ]] ||
12906                 skip "Need MDS version at least 2.2.51"
12907
12908         local remote_dir=$DIR/$tdir/remote_dir
12909         local MDTIDX=1
12910         local rc=0
12911
12912         mkdir -p $DIR/$tdir
12913         $LFS mkdir -i $MDTIDX $remote_dir ||
12914                 error "create remote directory failed"
12915
12916         cp /etc/hosts $remote_dir/$tfile
12917
12918         fid=$($LFS path2fid $remote_dir/$tfile)
12919         rc=$?
12920         [ $rc -ne 0 ] && error "error: could not get fid for $remote_dir/$tfile"
12921
12922         dot_lustre_fid_permission_check "$fid" $remote_dir ||
12923                 error "dot lustre permission check $fid failed"
12924         rm -rf $DIR/$tdir
12925 }
12926 run_test 154b "Open-by-FID for remote directory"
12927
12928 test_154c() {
12929         [[ $MDS1_VERSION -lt $(version_code 2.4.1) ]] &&
12930                 skip "Need MDS version at least 2.4.1"
12931
12932         touch $DIR/$tfile.1 $DIR/$tfile.2 $DIR/$tfile.3
12933         local FID1=$($LFS path2fid $DIR/$tfile.1)
12934         local FID2=$($LFS path2fid $DIR/$tfile.2)
12935         local FID3=$($LFS path2fid $DIR/$tfile.3)
12936
12937         local N=1
12938         $LFS path2fid $DIR/$tfile.[123] | while read PATHNAME FID; do
12939                 [ "$PATHNAME" = "$DIR/$tfile.$N:" ] ||
12940                         error "path2fid pathname $PATHNAME != $DIR/$tfile.$N:"
12941                 local want=FID$N
12942                 [ "$FID" = "${!want}" ] ||
12943                         error "path2fid $PATHNAME FID $FID != FID$N ${!want}"
12944                 N=$((N + 1))
12945         done
12946
12947         $LFS fid2path $MOUNT "$FID1" "$FID2" "$FID3" | while read PATHNAME;
12948         do
12949                 [ "$PATHNAME" = "$DIR/$tfile.$N" ] ||
12950                         error "fid2path pathname $PATHNAME != $DIR/$tfile.$N:"
12951                 N=$((N + 1))
12952         done
12953 }
12954 run_test 154c "lfs path2fid and fid2path multiple arguments"
12955
12956 test_154d() {
12957         remote_mds_nodsh && skip "remote MDS with nodsh"
12958         [[ $MDS1_VERSION -lt $(version_code 2.5.53) ]] &&
12959                 skip "Need MDS version at least 2.5.53"
12960
12961         if remote_mds; then
12962                 nid=$($LCTL list_nids | sed  "s/\./\\\./g")
12963         else
12964                 nid="0@lo"
12965         fi
12966         local proc_ofile="mdt.*.exports.'$nid'.open_files"
12967         local fd
12968         local cmd
12969
12970         rm -f $DIR/$tfile
12971         touch $DIR/$tfile
12972
12973         local fid=$($LFS path2fid $DIR/$tfile)
12974         # Open the file
12975         fd=$(free_fd)
12976         cmd="exec $fd<$DIR/$tfile"
12977         eval $cmd
12978         local fid_list=$(do_facet $SINGLEMDS $LCTL get_param $proc_ofile)
12979         echo "$fid_list" | grep "$fid"
12980         rc=$?
12981
12982         cmd="exec $fd>/dev/null"
12983         eval $cmd
12984         if [ $rc -ne 0 ]; then
12985                 error "FID $fid not found in open files list $fid_list"
12986         fi
12987 }
12988 run_test 154d "Verify open file fid"
12989
12990 test_154e()
12991 {
12992         [[ $MDS1_VERSION -lt $(version_code 2.6.50) ]] &&
12993                 skip "Need MDS version at least 2.6.50"
12994
12995         if ls -a $MOUNT | grep -q '^\.lustre$'; then
12996                 error ".lustre returned by readdir"
12997         fi
12998 }
12999 run_test 154e ".lustre is not returned by readdir"
13000
13001 test_154f() {
13002         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
13003
13004         # create parent directory on a single MDT to avoid cross-MDT hardlinks
13005         test_mkdir -p -c1 $DIR/$tdir/d
13006         # test dirs inherit from its stripe
13007         mkdir -p $DIR/$tdir/d/foo1 || error "mkdir error"
13008         mkdir -p $DIR/$tdir/d/foo2 || error "mkdir error"
13009         cp /etc/hosts $DIR/$tdir/d/foo1/$tfile
13010         ln $DIR/$tdir/d/foo1/$tfile $DIR/$tdir/d/foo2/link
13011         touch $DIR/f
13012
13013         # get fid of parents
13014         local FID0=$($LFS path2fid $DIR/$tdir/d)
13015         local FID1=$($LFS path2fid $DIR/$tdir/d/foo1)
13016         local FID2=$($LFS path2fid $DIR/$tdir/d/foo2)
13017         local FID3=$($LFS path2fid $DIR)
13018
13019         # check that path2fid --parents returns expected <parent_fid>/name
13020         # 1) test for a directory (single parent)
13021         local parent=$($LFS path2fid --parents $DIR/$tdir/d/foo1)
13022         [ "$parent" == "$FID0/foo1" ] ||
13023                 error "expected parent: $FID0/foo1, got: $parent"
13024
13025         # 2) test for a file with nlink > 1 (multiple parents)
13026         parent=$($LFS path2fid --parents $DIR/$tdir/d/foo1/$tfile)
13027         echo "$parent" | grep -F "$FID1/$tfile" ||
13028                 error "$FID1/$tfile not returned in parent list"
13029         echo "$parent" | grep -F "$FID2/link" ||
13030                 error "$FID2/link not returned in parent list"
13031
13032         # 3) get parent by fid
13033         local file_fid=$($LFS path2fid $DIR/$tdir/d/foo1/$tfile)
13034         parent=$($LFS path2fid --parents $MOUNT/.lustre/fid/$file_fid)
13035         echo "$parent" | grep -F "$FID1/$tfile" ||
13036                 error "$FID1/$tfile not returned in parent list (by fid)"
13037         echo "$parent" | grep -F "$FID2/link" ||
13038                 error "$FID2/link not returned in parent list (by fid)"
13039
13040         # 4) test for entry in root directory
13041         parent=$($LFS path2fid --parents $DIR/f)
13042         echo "$parent" | grep -F "$FID3/f" ||
13043                 error "$FID3/f not returned in parent list"
13044
13045         # 5) test it on root directory
13046         [ -z "$($LFS path2fid --parents $MOUNT 2>/dev/null)" ] ||
13047                 error "$MOUNT should not have parents"
13048
13049         # enable xattr caching and check that linkea is correctly updated
13050         local save="$TMP/$TESTSUITE-$TESTNAME.parameters"
13051         save_lustre_params client "llite.*.xattr_cache" > $save
13052         lctl set_param llite.*.xattr_cache 1
13053
13054         # 6.1) linkea update on rename
13055         mv $DIR/$tdir/d/foo1/$tfile $DIR/$tdir/d/foo2/$tfile.moved
13056
13057         # get parents by fid
13058         parent=$($LFS path2fid --parents $MOUNT/.lustre/fid/$file_fid)
13059         # foo1 should no longer be returned in parent list
13060         echo "$parent" | grep -F "$FID1" &&
13061                 error "$FID1 should no longer be in parent list"
13062         # the new path should appear
13063         echo "$parent" | grep -F "$FID2/$tfile.moved" ||
13064                 error "$FID2/$tfile.moved is not in parent list"
13065
13066         # 6.2) linkea update on unlink
13067         rm -f $DIR/$tdir/d/foo2/link
13068         parent=$($LFS path2fid --parents $MOUNT/.lustre/fid/$file_fid)
13069         # foo2/link should no longer be returned in parent list
13070         echo "$parent" | grep -F "$FID2/link" &&
13071                 error "$FID2/link should no longer be in parent list"
13072         true
13073
13074         rm -f $DIR/f
13075         restore_lustre_params < $save
13076         rm -f $save
13077 }
13078 run_test 154f "get parent fids by reading link ea"
13079
13080 test_154g()
13081 {
13082         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
13083         [[ $MDS1_VERSION -ge $(version_code 2.6.92) &&
13084            $CLIENT_VERSION -gt $(version_code 2.6.99) ]] ||
13085                 skip "Need MDS version at least 2.6.92"
13086
13087         mkdir -p $DIR/$tdir
13088         llapi_fid_test -d $DIR/$tdir
13089 }
13090 run_test 154g "various llapi FID tests"
13091
13092 test_155_small_load() {
13093     local temp=$TMP/$tfile
13094     local file=$DIR/$tfile
13095
13096     dd if=/dev/urandom of=$temp bs=6096 count=1 || \
13097         error "dd of=$temp bs=6096 count=1 failed"
13098     cp $temp $file
13099     cancel_lru_locks $OSC
13100     cmp $temp $file || error "$temp $file differ"
13101
13102     $TRUNCATE $temp 6000
13103     $TRUNCATE $file 6000
13104     cmp $temp $file || error "$temp $file differ (truncate1)"
13105
13106     echo "12345" >>$temp
13107     echo "12345" >>$file
13108     cmp $temp $file || error "$temp $file differ (append1)"
13109
13110     echo "12345" >>$temp
13111     echo "12345" >>$file
13112     cmp $temp $file || error "$temp $file differ (append2)"
13113
13114     rm -f $temp $file
13115     true
13116 }
13117
13118 test_155_big_load() {
13119         remote_ost_nodsh && skip "remote OST with nodsh"
13120
13121         local temp=$TMP/$tfile
13122         local file=$DIR/$tfile
13123
13124         free_min_max
13125         local cache_size=$(do_facet ost$((MAXI+1)) \
13126                 "awk '/cache/ {sum+=\\\$4} END {print sum}' /proc/cpuinfo")
13127         local large_file_size=$((cache_size * 2))
13128
13129         echo "OSS cache size: $cache_size KB"
13130         echo "Large file size: $large_file_size KB"
13131
13132         [ $MAXV -le $large_file_size ] &&
13133                 skip_env "max available OST size needs > $large_file_size KB"
13134
13135         $LFS setstripe $file -c 1 -i $MAXI || error "$LFS setstripe $file failed"
13136
13137         dd if=/dev/urandom of=$temp bs=$large_file_size count=1k ||
13138                 error "dd of=$temp bs=$large_file_size count=1k failed"
13139         cp $temp $file
13140         ls -lh $temp $file
13141         cancel_lru_locks osc
13142         cmp $temp $file || error "$temp $file differ"
13143
13144         rm -f $temp $file
13145         true
13146 }
13147
13148 save_writethrough() {
13149         local facets=$(get_facets OST)
13150
13151         save_lustre_params $facets "osd-*.*.writethrough_cache_enable" > $1
13152 }
13153
13154 test_155a() {
13155         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13156
13157         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
13158
13159         save_writethrough $p
13160
13161         set_cache read on
13162         set_cache writethrough on
13163         test_155_small_load
13164         restore_lustre_params < $p
13165         rm -f $p
13166 }
13167 run_test 155a "Verify small file correctness: read cache:on write_cache:on"
13168
13169 test_155b() {
13170         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13171
13172         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
13173
13174         save_writethrough $p
13175
13176         set_cache read on
13177         set_cache writethrough off
13178         test_155_small_load
13179         restore_lustre_params < $p
13180         rm -f $p
13181 }
13182 run_test 155b "Verify small file correctness: read cache:on write_cache:off"
13183
13184 test_155c() {
13185         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13186
13187         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
13188
13189         save_writethrough $p
13190
13191         set_cache read off
13192         set_cache writethrough on
13193         test_155_small_load
13194         restore_lustre_params < $p
13195         rm -f $p
13196 }
13197 run_test 155c "Verify small file correctness: read cache:off write_cache:on"
13198
13199 test_155d() {
13200         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13201
13202         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
13203
13204         save_writethrough $p
13205
13206         set_cache read off
13207         set_cache writethrough off
13208         test_155_small_load
13209         restore_lustre_params < $p
13210         rm -f $p
13211 }
13212 run_test 155d "Verify small file correctness: read cache:off write_cache:off"
13213
13214 test_155e() {
13215         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13216
13217         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
13218
13219         save_writethrough $p
13220
13221         set_cache read on
13222         set_cache writethrough on
13223         test_155_big_load
13224         restore_lustre_params < $p
13225         rm -f $p
13226 }
13227 run_test 155e "Verify big file correctness: read cache:on write_cache:on"
13228
13229 test_155f() {
13230         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13231
13232         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
13233
13234         save_writethrough $p
13235
13236         set_cache read on
13237         set_cache writethrough off
13238         test_155_big_load
13239         restore_lustre_params < $p
13240         rm -f $p
13241 }
13242 run_test 155f "Verify big file correctness: read cache:on write_cache:off"
13243
13244 test_155g() {
13245         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13246
13247         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
13248
13249         save_writethrough $p
13250
13251         set_cache read off
13252         set_cache writethrough on
13253         test_155_big_load
13254         restore_lustre_params < $p
13255         rm -f $p
13256 }
13257 run_test 155g "Verify big file correctness: read cache:off write_cache:on"
13258
13259 test_155h() {
13260         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13261
13262         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
13263
13264         save_writethrough $p
13265
13266         set_cache read off
13267         set_cache writethrough off
13268         test_155_big_load
13269         restore_lustre_params < $p
13270         rm -f $p
13271 }
13272 run_test 155h "Verify big file correctness: read cache:off write_cache:off"
13273
13274 test_156() {
13275         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13276         remote_ost_nodsh && skip "remote OST with nodsh"
13277         [ $OST1_VERSION -lt $(version_code 2.6.93) ] &&
13278                 skip "stats not implemented on old servers"
13279         [ "$ost1_FSTYPE" = "zfs" ] &&
13280                 skip "LU-1956/LU-2261: stats not implemented on OSD ZFS"
13281
13282         local CPAGES=3
13283         local BEFORE
13284         local AFTER
13285         local file="$DIR/$tfile"
13286         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
13287
13288         save_writethrough $p
13289         roc_hit_init
13290
13291         log "Turn on read and write cache"
13292         set_cache read on
13293         set_cache writethrough on
13294
13295         log "Write data and read it back."
13296         log "Read should be satisfied from the cache."
13297         dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
13298         BEFORE=$(roc_hit)
13299         cancel_lru_locks osc
13300         cat $file >/dev/null
13301         AFTER=$(roc_hit)
13302         if ! let "AFTER - BEFORE == CPAGES"; then
13303                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
13304         else
13305                 log "cache hits:: before: $BEFORE, after: $AFTER"
13306         fi
13307
13308         log "Read again; it should be satisfied from the cache."
13309         BEFORE=$AFTER
13310         cancel_lru_locks osc
13311         cat $file >/dev/null
13312         AFTER=$(roc_hit)
13313         if ! let "AFTER - BEFORE == CPAGES"; then
13314                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
13315         else
13316                 log "cache hits:: before: $BEFORE, after: $AFTER"
13317         fi
13318
13319         log "Turn off the read cache and turn on the write cache"
13320         set_cache read off
13321         set_cache writethrough on
13322
13323         log "Read again; it should be satisfied from the cache."
13324         BEFORE=$(roc_hit)
13325         cancel_lru_locks osc
13326         cat $file >/dev/null
13327         AFTER=$(roc_hit)
13328         if ! let "AFTER - BEFORE == CPAGES"; then
13329                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
13330         else
13331                 log "cache hits:: before: $BEFORE, after: $AFTER"
13332         fi
13333
13334         log "Read again; it should not be satisfied from the cache."
13335         BEFORE=$AFTER
13336         cancel_lru_locks osc
13337         cat $file >/dev/null
13338         AFTER=$(roc_hit)
13339         if ! let "AFTER - BEFORE == 0"; then
13340                 error "IN CACHE: before: $BEFORE, after: $AFTER"
13341         else
13342                 log "cache hits:: before: $BEFORE, after: $AFTER"
13343         fi
13344
13345         log "Write data and read it back."
13346         log "Read should be satisfied from the cache."
13347         dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
13348         BEFORE=$(roc_hit)
13349         cancel_lru_locks osc
13350         cat $file >/dev/null
13351         AFTER=$(roc_hit)
13352         if ! let "AFTER - BEFORE == CPAGES"; then
13353                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
13354         else
13355                 log "cache hits:: before: $BEFORE, after: $AFTER"
13356         fi
13357
13358         log "Read again; it should not be satisfied from the cache."
13359         BEFORE=$AFTER
13360         cancel_lru_locks osc
13361         cat $file >/dev/null
13362         AFTER=$(roc_hit)
13363         if ! let "AFTER - BEFORE == 0"; then
13364                 error "IN CACHE: before: $BEFORE, after: $AFTER"
13365         else
13366                 log "cache hits:: before: $BEFORE, after: $AFTER"
13367         fi
13368
13369         log "Turn off read and write cache"
13370         set_cache read off
13371         set_cache writethrough off
13372
13373         log "Write data and read it back"
13374         log "It should not be satisfied from the cache."
13375         rm -f $file
13376         dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
13377         cancel_lru_locks osc
13378         BEFORE=$(roc_hit)
13379         cat $file >/dev/null
13380         AFTER=$(roc_hit)
13381         if ! let "AFTER - BEFORE == 0"; then
13382                 error_ignore bz20762 "IN CACHE: before: $BEFORE, after: $AFTER"
13383         else
13384                 log "cache hits:: before: $BEFORE, after: $AFTER"
13385         fi
13386
13387         log "Turn on the read cache and turn off the write cache"
13388         set_cache read on
13389         set_cache writethrough off
13390
13391         log "Write data and read it back"
13392         log "It should not be satisfied from the cache."
13393         rm -f $file
13394         dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
13395         BEFORE=$(roc_hit)
13396         cancel_lru_locks osc
13397         cat $file >/dev/null
13398         AFTER=$(roc_hit)
13399         if ! let "AFTER - BEFORE == 0"; then
13400                 error_ignore bz20762 "IN CACHE: before: $BEFORE, after: $AFTER"
13401         else
13402                 log "cache hits:: before: $BEFORE, after: $AFTER"
13403         fi
13404
13405         log "Read again; it should be satisfied from the cache."
13406         BEFORE=$(roc_hit)
13407         cancel_lru_locks osc
13408         cat $file >/dev/null
13409         AFTER=$(roc_hit)
13410         if ! let "AFTER - BEFORE == CPAGES"; then
13411                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
13412         else
13413                 log "cache hits:: before: $BEFORE, after: $AFTER"
13414         fi
13415
13416         restore_lustre_params < $p
13417         rm -f $p $file
13418 }
13419 run_test 156 "Verification of tunables"
13420
13421 test_160a() {
13422         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13423         remote_mds_nodsh && skip "remote MDS with nodsh"
13424         [ $MDS1_VERSION -ge $(version_code 2.2.0) ] ||
13425                 skip "Need MDS version at least 2.2.0"
13426
13427         changelog_register || error "changelog_register failed"
13428         local cl_user="${CL_USERS[$SINGLEMDS]%% *}"
13429         changelog_users $SINGLEMDS | grep -q $cl_user ||
13430                 error "User $cl_user not found in changelog_users"
13431
13432         # change something
13433         test_mkdir -p $DIR/$tdir/pics/2008/zachy
13434         changelog_clear 0 || error "changelog_clear failed"
13435         touch $DIR/$tdir/pics/2008/zachy/$tfile                 # open 1
13436         cp /etc/hosts $DIR/$tdir/pics/2008/zachy/pic1.jpg       # open 2
13437         mv $DIR/$tdir/pics/2008/zachy $DIR/$tdir/pics/zach
13438         ln $DIR/$tdir/pics/zach/pic1.jpg $DIR/$tdir/pics/2008/portland.jpg
13439         ln -s $DIR/$tdir/pics/2008/portland.jpg $DIR/$tdir/pics/desktop.jpg
13440         rm $DIR/$tdir/pics/desktop.jpg
13441
13442         changelog_dump | tail -10
13443
13444         echo "verifying changelog mask"
13445         changelog_chmask "-MKDIR"
13446         changelog_chmask "-CLOSE"
13447
13448         test_mkdir -p $DIR/$tdir/pics/zach/sofia                # not logged
13449         echo "zzzzzz" > $DIR/$tdir/pics/zach/file               # not logged
13450
13451         changelog_chmask "+MKDIR"
13452         changelog_chmask "+CLOSE"
13453
13454         test_mkdir -p $DIR/$tdir/pics/2008/sofia                # mkdir 1
13455         echo "zzzzzz" > $DIR/$tdir/pics/zach/file               # open 3
13456
13457         changelog_dump | tail -10
13458         MKDIRS=$(changelog_dump | grep -c "MKDIR")
13459         CLOSES=$(changelog_dump | grep -c "CLOSE")
13460         [ $MKDIRS -eq 1 ] || error "MKDIR changelog mask count $MKDIRS != 1"
13461         [ $CLOSES -eq 3 ] || error "CLOSE changelog mask count $CLOSES != 3"
13462
13463         # verify contents
13464         echo "verifying target fid"
13465         local fidc=$(changelog_extract_field "CREAT" "$tfile" "t=")
13466         local fidf=$($LFS path2fid $DIR/$tdir/pics/zach/$tfile)
13467         [ "$fidc" == "$fidf" ] ||
13468                 error "changelog '$tfile' fid $fidc != file fid $fidf"
13469         echo "verifying parent fid"
13470         # The FID returned from the Changelog may be the directory shard on
13471         # a different MDT, and not the FID returned by path2fid on the parent.
13472         # Instead of comparing FIDs, verify that fid2path(fidp) is correct,
13473         # since this is what will matter when recreating this file in the tree.
13474         local fidp=$(changelog_extract_field "CREAT" "$tfile" "p=")
13475         local pathp=$($LFS fid2path $MOUNT "$fidp")
13476         [ "${pathp%/}" == "$DIR/$tdir/pics/zach" ] ||
13477                 error "changelog fid2path($fidc) $pathp != $DIR/$tdir/pics/zach"
13478
13479         echo "getting records for $cl_user"
13480         changelog_users $SINGLEMDS
13481         local user_rec1=$(changelog_user_rec $SINGLEMDS $cl_user)
13482         local nclr=3
13483         __changelog_clear $SINGLEMDS $cl_user +$nclr ||
13484                 error "changelog_clear failed"
13485         local user_rec2=$(changelog_user_rec $SINGLEMDS $cl_user)
13486         echo "verifying user clear: $user_rec1 + $nclr == $user_rec2"
13487         [ $user_rec2 == $((user_rec1 + nclr)) ] ||
13488                 error "user index expect $user_rec1 + $nclr != $user_rec2"
13489
13490         local min0_rec=$(changelog_users $SINGLEMDS |
13491                 awk 'min == "" || $2 < min { min = $2 }; END { print min }')
13492         local first_rec=$($LFS changelog $(facet_svc $SINGLEMDS) |
13493                           awk '{ print $1; exit; }')
13494
13495         changelog_dump | tail -n 5
13496         echo "verifying user min purge: $min0_rec + 1 == $first_rec"
13497         [ $first_rec == $((min0_rec + 1)) ] ||
13498                 error "first index should be $min0_rec + 1 not $first_rec"
13499
13500         # LU-3446 changelog index reset on MDT restart
13501         local cur_rec1=$(changelog_users $SINGLEMDS |
13502                          awk '/^current.index:/ { print $NF }')
13503         changelog_clear 0 ||
13504                 error "clear all changelog records for $cl_user failed"
13505         stop $SINGLEMDS || error "Fail to stop $SINGLEMDS"
13506         start $SINGLEMDS $(mdsdevname ${SINGLEMDS//mds/}) $MDS_MOUNT_OPTS ||
13507                 error "Fail to start $SINGLEMDS"
13508         local cur_rec2=$(changelog_users $SINGLEMDS |
13509                          awk '/^current.index:/ { print $NF }')
13510         echo "verifying index survives MDT restart: $cur_rec1 == $cur_rec2"
13511         [ $cur_rec1 == $cur_rec2 ] ||
13512                 error "current index should be $cur_rec1 not $cur_rec2"
13513
13514         echo "verifying users from this test are deregistered"
13515         changelog_deregister || error "changelog_deregister failed"
13516         changelog_users $SINGLEMDS | grep -q $cl_user &&
13517                 error "User '$cl_user' still in changelog_users"
13518
13519         # lctl get_param -n mdd.*.changelog_users
13520         # current index: 144
13521         # ID    index (idle seconds)
13522         # cl3   144 (2)
13523         if ! changelog_users $SINGLEMDS | grep "^cl"; then
13524                 # this is the normal case where all users were deregistered
13525                 # make sure no new records are added when no users are present
13526                 local last_rec1=$(changelog_users $SINGLEMDS |
13527                                   awk '/^current.index:/ { print $NF }')
13528                 touch $DIR/$tdir/chloe
13529                 local last_rec2=$(changelog_users $SINGLEMDS |
13530                                   awk '/^current.index:/ { print $NF }')
13531                 echo "verify changelogs are off: $last_rec1 == $last_rec2"
13532                 [ $last_rec1 == $last_rec2 ] || error "changelogs not off"
13533         else
13534                 # any changelog users must be leftovers from a previous test
13535                 changelog_users $SINGLEMDS
13536                 echo "other changelog users; can't verify off"
13537         fi
13538 }
13539 run_test 160a "changelog sanity"
13540
13541 test_160b() { # LU-3587
13542         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13543         remote_mds_nodsh && skip "remote MDS with nodsh"
13544         [ $MDS1_VERSION -ge $(version_code 2.2.0) ] ||
13545                 skip "Need MDS version at least 2.2.0"
13546
13547         changelog_register || error "changelog_register failed"
13548         local cl_user="${CL_USERS[$SINGLEMDS]%% *}"
13549         changelog_users $SINGLEMDS | grep -q $cl_user ||
13550                 error "User '$cl_user' not found in changelog_users"
13551
13552         local longname1=$(str_repeat a 255)
13553         local longname2=$(str_repeat b 255)
13554
13555         cd $DIR
13556         echo "creating very long named file"
13557         touch $longname1 || error "create of '$longname1' failed"
13558         echo "renaming very long named file"
13559         mv $longname1 $longname2
13560
13561         changelog_dump | grep RENME | tail -n 5
13562         rm -f $longname2
13563 }
13564 run_test 160b "Verify that very long rename doesn't crash in changelog"
13565
13566 test_160c() {
13567         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13568         remote_mds_nodsh && skip "remote MDS with nodsh"
13569
13570         [[ $MDS1_VERSION -gt $(version_code 2.5.57) ]] ||
13571                 [[ $MDS1_VERSION -gt $(version_code 2.5.1) &&
13572                    $MDS1_VERSION -lt $(version_code 2.5.50) ]] ||
13573                 skip "Need MDS version at least 2.5.58 or 2.5.2+"
13574
13575         local rc=0
13576
13577         # Registration step
13578         changelog_register || error "changelog_register failed"
13579
13580         rm -rf $DIR/$tdir
13581         mkdir -p $DIR/$tdir
13582         $MCREATE $DIR/$tdir/foo_160c
13583         changelog_chmask "-TRUNC"
13584         $TRUNCATE $DIR/$tdir/foo_160c 200
13585         changelog_chmask "+TRUNC"
13586         $TRUNCATE $DIR/$tdir/foo_160c 199
13587         changelog_dump | tail -n 5
13588         local truncs=$(changelog_dump | tail -n 5 | grep -c TRUNC)
13589         [ $truncs -eq 1 ] || error "TRUNC changelog mask count $truncs != 1"
13590 }
13591 run_test 160c "verify that changelog log catch the truncate event"
13592
13593 test_160d() {
13594         remote_mds_nodsh && skip "remote MDS with nodsh"
13595         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
13596         [ $PARALLEL == "yes" ] && skip "skip parallel run"
13597         [[ $MDS1_VERSION -ge $(version_code 2.7.60) ]] ||
13598                 skip "Need MDS version at least 2.7.60"
13599
13600         # Registration step
13601         changelog_register || error "changelog_register failed"
13602
13603         mkdir -p $DIR/$tdir/migrate_dir
13604         changelog_clear 0 || error "changelog_clear failed"
13605
13606         $LFS migrate -m 1 $DIR/$tdir/migrate_dir || error "migrate fails"
13607         changelog_dump | tail -n 5
13608         local migrates=$(changelog_dump | grep -c "MIGRT")
13609         [ $migrates -eq 1 ] || error "MIGRATE changelog count $migrates != 1"
13610 }
13611 run_test 160d "verify that changelog log catch the migrate event"
13612
13613 test_160e() {
13614         remote_mds_nodsh && skip "remote MDS with nodsh"
13615
13616         # Create a user
13617         changelog_register || error "changelog_register failed"
13618
13619         # Delete a future user (expect fail)
13620         local MDT0=$(facet_svc $SINGLEMDS)
13621         do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister "cl77"
13622         local rc=$?
13623
13624         if [ $rc -eq 0 ]; then
13625                 error "Deleted non-existant user cl77"
13626         elif [ $rc -ne 2 ]; then
13627                 error "changelog_deregister failed with $rc, expect 2 (ENOENT)"
13628         fi
13629
13630         # Clear to a bad index (1 billion should be safe)
13631         $LFS changelog_clear $MDT0 "${CL_USERS[$SINGLEMDS]%% *}" 1000000000
13632         rc=$?
13633
13634         if [ $rc -eq 0 ]; then
13635                 error "Successfully cleared to invalid CL index"
13636         elif [ $rc -ne 22 ]; then
13637                 error "changelog_clear failed with $rc, expected 22 (EINVAL)"
13638         fi
13639 }
13640 run_test 160e "changelog negative testing (should return errors)"
13641
13642 test_160f() {
13643         remote_mds_nodsh && skip "remote MDS with nodsh" && return
13644         [[ $MDS1_VERSION -ge $(version_code 2.10.56) ]] ||
13645                 skip "Need MDS version at least 2.10.56"
13646
13647         local mdts=$(comma_list $(mdts_nodes))
13648
13649         # Create a user
13650         changelog_register || error "first changelog_register failed"
13651         changelog_register || error "second changelog_register failed"
13652         local cl_users
13653         declare -A cl_user1
13654         declare -A cl_user2
13655         local user_rec1
13656         local user_rec2
13657         local i
13658
13659         # generate some changelog records to accumulate on each MDT
13660         test_mkdir -c $MDSCOUNT $DIR/$tdir || error "test_mkdir $tdir failed"
13661         createmany -m $DIR/$tdir/$tfile $((MDSCOUNT * 2)) ||
13662                 error "create $DIR/$tdir/$tfile failed"
13663
13664         # check changelogs have been generated
13665         local nbcl=$(changelog_dump | wc -l)
13666         [[ $nbcl -eq 0 ]] && error "no changelogs found"
13667
13668         for param in "changelog_max_idle_time=10" \
13669                      "changelog_gc=1" \
13670                      "changelog_min_gc_interval=2" \
13671                      "changelog_min_free_cat_entries=3"; do
13672                 local MDT0=$(facet_svc $SINGLEMDS)
13673                 local var="${param%=*}"
13674                 local old=$(do_facet mds1 "$LCTL get_param -n mdd.$MDT0.$var")
13675
13676                 stack_trap "do_nodes $mdts $LCTL set_param mdd.*.$var=$old" EXIT
13677                 do_nodes $mdts $LCTL set_param mdd.*.$param
13678         done
13679
13680         # force cl_user2 to be idle (1st part)
13681         sleep 9
13682
13683         # simulate changelog catalog almost full
13684         #define OBD_FAIL_CAT_FREE_RECORDS       0x1313
13685         do_nodes $mdts $LCTL set_param fail_loc=0x1313 fail_val=3
13686
13687         for i in $(seq $MDSCOUNT); do
13688                 cl_users=(${CL_USERS[mds$i]})
13689                 cl_user1[mds$i]="${cl_users[0]}"
13690                 cl_user2[mds$i]="${cl_users[1]}"
13691
13692                 [ -n "${cl_user1[mds$i]}" ] ||
13693                         error "mds$i: no user registered"
13694                 [ -n "${cl_user2[mds$i]}" ] ||
13695                         error "mds$i: only ${cl_user2[mds$i]} is registered"
13696
13697                 user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13698                 [ -n "$user_rec1" ] ||
13699                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13700                 __changelog_clear mds$i ${cl_user1[mds$i]} +2
13701                 user_rec2=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13702                 [ -n "$user_rec2" ] ||
13703                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13704                 echo "mds$i: verifying user ${cl_user1[mds$i]} clear: " \
13705                      "$user_rec1 + 2 == $user_rec2"
13706                 [ $((user_rec1 + 2)) == $user_rec2 ] ||
13707                         error "mds$i: user ${cl_user1[mds$i]} index expected " \
13708                               "$user_rec1 + 2, but is $user_rec2"
13709                 user_rec2=$(changelog_user_rec mds$i ${cl_user2[mds$i]})
13710                 [ -n "$user_rec2" ] ||
13711                         error "mds$i: User ${cl_user2[mds$i]} not registered"
13712                 [ $user_rec1 == $user_rec2 ] ||
13713                         error "mds$i: user ${cl_user2[mds$i]} index expected " \
13714                               "$user_rec1, but is $user_rec2"
13715         done
13716
13717         # force cl_user2 to be idle (2nd part) and to reach
13718         # changelog_max_idle_time
13719         sleep 2
13720
13721         # generate one more changelog to trigger fail_loc
13722         createmany -m $DIR/$tdir/${tfile}bis $((MDSCOUNT * 2)) ||
13723                 error "create $DIR/$tdir/${tfile}bis failed"
13724
13725         # ensure gc thread is done
13726         for i in $(mdts_nodes); do
13727                 wait_update $i \
13728                         "ps -e -o comm= | grep chlg_gc_thread" "" 20 ||
13729                         error "$i: GC-thread not done"
13730         done
13731
13732         local first_rec
13733         for i in $(seq $MDSCOUNT); do
13734                 # check cl_user1 still registered
13735                 changelog_users mds$i | grep -q "${cl_user1[mds$i]}" ||
13736                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13737                 # check cl_user2 unregistered
13738                 changelog_users mds$i | grep -q "${cl_user2[mds$i]}" &&
13739                         error "mds$i: User ${cl_user2[mds$i]} still registered"
13740
13741                 # check changelogs are present and starting at $user_rec1 + 1
13742                 user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13743                 [ -n "$user_rec1" ] ||
13744                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13745                 first_rec=$($LFS changelog $(facet_svc mds$i) |
13746                             awk '{ print $1; exit; }')
13747
13748                 echo "mds$i: verifying first index $user_rec1 + 1 == $first_rec"
13749                 [ $((user_rec1 + 1)) == $first_rec ] ||
13750                         error "mds$i: first index should be $user_rec1 + 1, " \
13751                               "but is $first_rec"
13752         done
13753 }
13754 run_test 160f "changelog garbage collect (timestamped users)"
13755
13756 test_160g() {
13757         remote_mds_nodsh && skip "remote MDS with nodsh"
13758         [[ $MDS1_VERSION -ge $(version_code 2.10.56) ]] ||
13759                 skip "Need MDS version at least 2.10.56"
13760
13761         local mdts=$(comma_list $(mdts_nodes))
13762
13763         #define OBD_FAIL_TIME_IN_CHLOG_USER     0x1314
13764         do_nodes $mdts $LCTL set_param fail_loc=0x1314
13765
13766         # Create a user
13767         changelog_register || error "first changelog_register failed"
13768         changelog_register || error "second changelog_register failed"
13769         local cl_users
13770         declare -A cl_user1
13771         declare -A cl_user2
13772         local user_rec1
13773         local user_rec2
13774         local i
13775
13776         # generate some changelog records to accumulate on each MDT
13777         test_mkdir -c $MDSCOUNT $DIR/$tdir || error "mkdir $tdir failed"
13778         createmany -m $DIR/$tdir/$tfile $((MDSCOUNT * 2)) ||
13779                 error "create $DIR/$tdir/$tfile failed"
13780
13781         # check changelogs have been generated
13782         local nbcl=$(changelog_dump | wc -l)
13783         [[ $nbcl -eq 0 ]] && error "no changelogs found"
13784
13785         # reduce the max_idle_indexes value to make sure we exceed it
13786         max_ndx=$((nbcl / 2 - 1))
13787
13788         for param in "changelog_max_idle_indexes=$max_ndx" \
13789                      "changelog_gc=1" \
13790                      "changelog_min_gc_interval=2" \
13791                      "changelog_min_free_cat_entries=3"; do
13792                 local MDT0=$(facet_svc $SINGLEMDS)
13793                 local var="${param%=*}"
13794                 local old=$(do_facet mds1 "$LCTL get_param -n mdd.$MDT0.$var")
13795
13796                 stack_trap "do_nodes $mdts $LCTL set_param mdd.*.$var=$old" EXIT
13797                 do_nodes $mdts $LCTL set_param mdd.*.$param ||
13798                         error "unable to set mdd.*.$param"
13799         done
13800
13801         # simulate changelog catalog almost full
13802         #define OBD_FAIL_CAT_FREE_RECORDS       0x1313
13803         do_nodes $mdts $LCTL set_param fail_loc=0x1313 fail_val=3
13804
13805         for i in $(seq $MDSCOUNT); do
13806                 cl_users=(${CL_USERS[mds$i]})
13807                 cl_user1[mds$i]="${cl_users[0]}"
13808                 cl_user2[mds$i]="${cl_users[1]}"
13809
13810                 [ -n "${cl_user1[mds$i]}" ] ||
13811                         error "mds$i: no user registered"
13812                 [ -n "${cl_user2[mds$i]}" ] ||
13813                         error "mds$i: only ${cl_user1[mds$i]} is registered"
13814
13815                 user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13816                 [ -n "$user_rec1" ] ||
13817                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13818                 __changelog_clear mds$i ${cl_user1[mds$i]} +2
13819                 user_rec2=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13820                 [ -n "$user_rec2" ] ||
13821                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13822                 echo "mds$i: verifying user ${cl_user1[mds$i]} clear: " \
13823                      "$user_rec1 + 2 == $user_rec2"
13824                 [ $((user_rec1 + 2)) == $user_rec2 ] ||
13825                         error "mds$i: user ${cl_user1[mds$i]} index expected " \
13826                               "$user_rec1 + 2, but is $user_rec2"
13827                 user_rec2=$(changelog_user_rec mds$i ${cl_user2[mds$i]})
13828                 [ -n "$user_rec2" ] ||
13829                         error "mds$i: User ${cl_user2[mds$i]} not registered"
13830                 [ $user_rec1 == $user_rec2 ] ||
13831                         error "mds$i: user ${cl_user2[mds$i]} index expected " \
13832                               "$user_rec1, but is $user_rec2"
13833         done
13834
13835         # ensure we are past the previous changelog_min_gc_interval set above
13836         sleep 2
13837
13838         # generate one more changelog to trigger fail_loc
13839         createmany -m $DIR/$tdir/${tfile}bis $((MDSCOUNT * 2)) ||
13840                 error "create $DIR/$tdir/${tfile}bis failed"
13841
13842         # ensure gc thread is done
13843         for i in $(mdts_nodes); do
13844                 wait_update $i \
13845                         "ps -e -o comm= | grep chlg_gc_thread" "" 20 ||
13846                         error "$i: GC-thread not done"
13847         done
13848
13849         local first_rec
13850         for i in $(seq $MDSCOUNT); do
13851                 # check cl_user1 still registered
13852                 changelog_users mds$i | grep -q "${cl_user1[mds$i]}" ||
13853                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13854                 # check cl_user2 unregistered
13855                 changelog_users mds$i | grep -q "${cl_user2[mds$i]}" &&
13856                         error "mds$i: User ${cl_user2[mds$i]} still registered"
13857
13858                 # check changelogs are present and starting at $user_rec1 + 1
13859                 user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13860                 [ -n "$user_rec1" ] ||
13861                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13862                 first_rec=$($LFS changelog $(facet_svc mds$i) |
13863                             awk '{ print $1; exit; }')
13864
13865                 echo "mds$i: verifying first index $user_rec1 + 1 == $first_rec"
13866                 [ $((user_rec1 + 1)) == $first_rec ] ||
13867                         error "mds$i: first index should be $user_rec1 + 1, " \
13868                               "but is $first_rec"
13869         done
13870 }
13871 run_test 160g "changelog garbage collect (old users)"
13872
13873 test_160h() {
13874         remote_mds_nodsh && skip "remote MDS with nodsh" && return
13875         [[ $MDS1_VERSION -ge $(version_code 2.10.56) ]] ||
13876                 skip "Need MDS version at least 2.10.56"
13877
13878         local mdts=$(comma_list $(mdts_nodes))
13879
13880         # Create a user
13881         changelog_register || error "first changelog_register failed"
13882         changelog_register || error "second changelog_register failed"
13883         local cl_users
13884         declare -A cl_user1
13885         declare -A cl_user2
13886         local user_rec1
13887         local user_rec2
13888         local i
13889
13890         # generate some changelog records to accumulate on each MDT
13891         test_mkdir -c $MDSCOUNT $DIR/$tdir || error "test_mkdir $tdir failed"
13892         createmany -m $DIR/$tdir/$tfile $((MDSCOUNT * 2)) ||
13893                 error "create $DIR/$tdir/$tfile failed"
13894
13895         # check changelogs have been generated
13896         local nbcl=$(changelog_dump | wc -l)
13897         [[ $nbcl -eq 0 ]] && error "no changelogs found"
13898
13899         for param in "changelog_max_idle_time=10" \
13900                      "changelog_gc=1" \
13901                      "changelog_min_gc_interval=2"; do
13902                 local MDT0=$(facet_svc $SINGLEMDS)
13903                 local var="${param%=*}"
13904                 local old=$(do_facet mds1 "$LCTL get_param -n mdd.$MDT0.$var")
13905
13906                 stack_trap "do_nodes $mdts $LCTL set_param mdd.*.$var=$old" EXIT
13907                 do_nodes $mdts $LCTL set_param mdd.*.$param
13908         done
13909
13910         # force cl_user2 to be idle (1st part)
13911         sleep 9
13912
13913         for i in $(seq $MDSCOUNT); do
13914                 cl_users=(${CL_USERS[mds$i]})
13915                 cl_user1[mds$i]="${cl_users[0]}"
13916                 cl_user2[mds$i]="${cl_users[1]}"
13917
13918                 [ -n "${cl_user1[mds$i]}" ] ||
13919                         error "mds$i: no user registered"
13920                 [ -n "${cl_user2[mds$i]}" ] ||
13921                         error "mds$i: only ${cl_user2[mds$i]} is registered"
13922
13923                 user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13924                 [ -n "$user_rec1" ] ||
13925                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13926                 __changelog_clear mds$i ${cl_user1[mds$i]} +2
13927                 user_rec2=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
13928                 [ -n "$user_rec2" ] ||
13929                         error "mds$i: User ${cl_user1[mds$i]} not registered"
13930                 echo "mds$i: verifying user ${cl_user1[mds$i]} clear: " \
13931                      "$user_rec1 + 2 == $user_rec2"
13932                 [ $((user_rec1 + 2)) == $user_rec2 ] ||
13933                         error "mds$i: user ${cl_user1[mds$i]} index expected " \
13934                               "$user_rec1 + 2, but is $user_rec2"
13935                 user_rec2=$(changelog_user_rec mds$i ${cl_user2[mds$i]})
13936                 [ -n "$user_rec2" ] ||
13937                         error "mds$i: User ${cl_user2[mds$i]} not registered"
13938                 [ $user_rec1 == $user_rec2 ] ||
13939                         error "mds$i: user ${cl_user2[mds$i]} index expected " \
13940                               "$user_rec1, but is $user_rec2"
13941         done
13942
13943         # force cl_user2 to be idle (2nd part) and to reach
13944         # changelog_max_idle_time
13945         sleep 2
13946
13947         # force each GC-thread start and block then
13948         # one per MDT/MDD, set fail_val accordingly
13949         #define OBD_FAIL_FORCE_GC_THREAD 0x1316
13950         do_nodes $mdts $LCTL set_param fail_loc=0x1316
13951
13952         # generate more changelogs to trigger fail_loc
13953         createmany -m $DIR/$tdir/${tfile}bis $((MDSCOUNT * 2)) ||
13954                 error "create $DIR/$tdir/${tfile}bis failed"
13955
13956         # stop MDT to stop GC-thread, should be done in back-ground as it will
13957         # block waiting for the thread to be released and exit
13958         declare -A stop_pids
13959         for i in $(seq $MDSCOUNT); do
13960                 stop mds$i &
13961                 stop_pids[mds$i]=$!
13962         done
13963
13964         for i in $(mdts_nodes); do
13965                 local facet
13966                 local nb=0
13967                 local facets=$(facets_up_on_host $i)
13968
13969                 for facet in ${facets//,/ }; do
13970                         if [[ $facet == mds* ]]; then
13971                                 nb=$((nb + 1))
13972                         fi
13973                 done
13974                 # ensure each MDS's gc threads are still present and all in "R"
13975                 # state (OBD_FAIL_FORCE_GC_THREAD effect!)
13976                 [[ $(do_node $i pgrep chlg_gc_thread | wc -l) -eq $nb ]] ||
13977                         error "$i: expected $nb GC-thread"
13978                 wait_update $i \
13979                         "ps -C chlg_gc_thread -o state --no-headers | uniq" \
13980                         "R" 20 ||
13981                         error "$i: GC-thread not found in R-state"
13982                 # check umounts of each MDT on MDS have reached kthread_stop()
13983                 [[ $(do_node $i pgrep umount | wc -l) -eq $nb ]] ||
13984                         error "$i: expected $nb umount"
13985                 wait_update $i \
13986                         "ps -C umount -o state --no-headers | uniq" "D" 20 ||
13987                         error "$i: umount not found in D-state"
13988         done
13989
13990         # release all GC-threads
13991         do_nodes $mdts $LCTL set_param fail_loc=0
13992
13993         # wait for MDT stop to complete
13994         for i in $(seq $MDSCOUNT); do
13995                 wait ${stop_pids[mds$i]} || error "mds$i: stop failed"
13996         done
13997
13998         # XXX
13999         # may try to check if any orphan changelog records are present
14000         # via ldiskfs/zfs and llog_reader...
14001
14002         # re-start/mount MDTs
14003         for i in $(seq $MDSCOUNT); do
14004                 start mds$i $(mdsdevname $i) $MDS_MOUNT_OPTS ||
14005                         error "Fail to start mds$i"
14006         done
14007
14008         local first_rec
14009         for i in $(seq $MDSCOUNT); do
14010                 # check cl_user1 still registered
14011                 changelog_users mds$i | grep -q "${cl_user1[mds$i]}" ||
14012                         error "mds$i: User ${cl_user1[mds$i]} not registered"
14013                 # check cl_user2 unregistered
14014                 changelog_users mds$i | grep -q "${cl_user2[mds$i]}" &&
14015                         error "mds$i: User ${cl_user2[mds$i]} still registered"
14016
14017                 # check changelogs are present and starting at $user_rec1 + 1
14018                 user_rec1=$(changelog_user_rec mds$i ${cl_user1[mds$i]})
14019                 [ -n "$user_rec1" ] ||
14020                         error "mds$i: User ${cl_user1[mds$i]} not registered"
14021                 first_rec=$($LFS changelog $(facet_svc mds$i) |
14022                             awk '{ print $1; exit; }')
14023
14024                 echo "mds$i: verifying first index $user_rec1 + 1 == $first_rec"
14025                 [ $((user_rec1 + 1)) == $first_rec ] ||
14026                         error "mds$i: first index should be $user_rec1 + 1, " \
14027                               "but is $first_rec"
14028         done
14029 }
14030 run_test 160h "changelog gc thread stop upon umount, orphan records delete " \
14031               "during mount"
14032
14033 test_160i() {
14034
14035         local mdts=$(comma_list $(mdts_nodes))
14036
14037         changelog_register || error "first changelog_register failed"
14038
14039         # generate some changelog records to accumulate on each MDT
14040         test_mkdir -c $MDSCOUNT $DIR/$tdir || error "mkdir $tdir failed"
14041         createmany -m $DIR/$tdir/$tfile $((MDSCOUNT * 2)) ||
14042                 error "create $DIR/$tdir/$tfile failed"
14043
14044         # check changelogs have been generated
14045         local nbcl=$(changelog_dump | wc -l)
14046         [[ $nbcl -eq 0 ]] && error "no changelogs found"
14047
14048         # simulate race between register and unregister
14049         # XXX as fail_loc is set per-MDS, with DNE configs the race
14050         # simulation will only occur for one MDT per MDS and for the
14051         # others the normal race scenario will take place
14052         #define CFS_FAIL_CHLOG_USER_REG_UNREG_RACE          0x1315
14053         do_nodes $mdts $LCTL set_param fail_loc=0x10001315
14054         do_nodes $mdts $LCTL set_param fail_val=1
14055
14056         # unregister 1st user
14057         changelog_deregister &
14058         local pid1=$!
14059         # wait some time for deregister work to reach race rdv
14060         sleep 2
14061         # register 2nd user
14062         changelog_register || error "2nd user register failed"
14063
14064         wait $pid1 || error "1st user deregister failed"
14065
14066         local i
14067         local last_rec
14068         declare -A LAST_REC
14069         for i in $(seq $MDSCOUNT); do
14070                 if changelog_users mds$i | grep "^cl"; then
14071                         # make sure new records are added with one user present
14072                         LAST_REC[mds$i]=$(changelog_users $SINGLEMDS |
14073                                           awk '/^current.index:/ { print $NF }')
14074                 else
14075                         error "mds$i has no user registered"
14076                 fi
14077         done
14078
14079         # generate more changelog records to accumulate on each MDT
14080         createmany -m $DIR/$tdir/${tfile}bis $((MDSCOUNT * 2)) ||
14081                 error "create $DIR/$tdir/${tfile}bis failed"
14082
14083         for i in $(seq $MDSCOUNT); do
14084                 last_rec=$(changelog_users $SINGLEMDS |
14085                            awk '/^current.index:/ { print $NF }')
14086                 echo "verify changelogs are on: $last_rec != ${LAST_REC[mds$i]}"
14087                 [ $last_rec != ${LAST_REC[mds$i]} ] ||
14088                         error "changelogs are off on mds$i"
14089         done
14090 }
14091 run_test 160i "changelog user register/unregister race"
14092
14093 test_160j() {
14094         remote_mds_nodsh && skip "remote MDS with nodsh"
14095         [[ $MDS1_VERSION -lt $(version_code 2.12.56) ]] &&
14096                 skip "Need MDS version at least 2.12.56"
14097
14098         mount_client $MOUNT2 || error "mount_client on $MOUNT2 failed"
14099
14100         changelog_register || error "first changelog_register failed"
14101
14102         # generate some changelog
14103         test_mkdir -c $MDSCOUNT $DIR/$tdir || error "mkdir $tdir failed"
14104         createmany -m $DIR/$tdir/${tfile}bis $((MDSCOUNT * 2)) ||
14105                 error "create $DIR/$tdir/${tfile}bis failed"
14106
14107         # open the changelog device
14108         exec 3>/dev/changelog-$FSNAME-MDT0000
14109         exec 4</dev/changelog-$FSNAME-MDT0000
14110
14111         # umount the first lustre mount
14112         umount $MOUNT
14113
14114         # read changelog
14115         cat <&4 >/dev/null || error "read changelog failed"
14116
14117         # clear changelog
14118         local cl_user="${CL_USERS[$SINGLEMDS]%% *}"
14119         changelog_users $SINGLEMDS | grep -q $cl_user ||
14120                 error "User $cl_user not found in changelog_users"
14121
14122         printf 'clear:'$cl_user':0' >&3
14123
14124         # close
14125         exec 3>&-
14126         exec 4<&-
14127
14128         # cleanup
14129         changelog_deregister || error "changelog_deregister failed"
14130
14131         umount $MOUNT2
14132         mount_client $MOUNT || error "mount_client on $MOUNT failed"
14133 }
14134 run_test 160j "client can be umounted  while its chanangelog is being used"
14135
14136 test_161a() {
14137         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14138
14139         test_mkdir -c1 $DIR/$tdir
14140         cp /etc/hosts $DIR/$tdir/$tfile
14141         test_mkdir -c1 $DIR/$tdir/foo1
14142         test_mkdir -c1 $DIR/$tdir/foo2
14143         ln $DIR/$tdir/$tfile $DIR/$tdir/foo1/sofia
14144         ln $DIR/$tdir/$tfile $DIR/$tdir/foo2/zachary
14145         ln $DIR/$tdir/$tfile $DIR/$tdir/foo1/luna
14146         ln $DIR/$tdir/$tfile $DIR/$tdir/foo2/thor
14147         local FID=$($LFS path2fid $DIR/$tdir/$tfile | tr -d '[]')
14148         if [ "$($LFS fid2path $DIR $FID | wc -l)" != "5" ]; then
14149                 $LFS fid2path $DIR $FID
14150                 error "bad link ea"
14151         fi
14152         # middle
14153         rm $DIR/$tdir/foo2/zachary
14154         # last
14155         rm $DIR/$tdir/foo2/thor
14156         # first
14157         rm $DIR/$tdir/$tfile
14158         # rename
14159         mv $DIR/$tdir/foo1/sofia $DIR/$tdir/foo2/maggie
14160         [ "$($LFS fid2path $FSNAME --link 1 $FID)" != "$tdir/foo2/maggie" ] &&
14161                 { $LFS fid2path $DIR $FID; error "bad link rename"; }
14162         rm $DIR/$tdir/foo2/maggie
14163
14164         # overflow the EA
14165         local longname=$tfile.avg_len_is_thirty_two_
14166         stack_trap "unlinkmany $DIR/$tdir/foo2/$longname 1000 || \
14167                 error_noexit 'failed to unlink many hardlinks'" EXIT
14168         createmany -l$DIR/$tdir/foo1/luna $DIR/$tdir/foo2/$longname 1000 ||
14169                 error "failed to hardlink many files"
14170         links=$($LFS fid2path $DIR $FID | wc -l)
14171         echo -n "${links}/1000 links in link EA"
14172         [[ $links -gt 60 ]] || error "expected at least 60 links in link EA"
14173 }
14174 run_test 161a "link ea sanity"
14175
14176 test_161b() {
14177         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14178         [ $MDSCOUNT -lt 2 ] && skip_env "skipping remote directory test"
14179
14180         local MDTIDX=1
14181         local remote_dir=$DIR/$tdir/remote_dir
14182
14183         mkdir -p $DIR/$tdir
14184         $LFS mkdir -i $MDTIDX $remote_dir ||
14185                 error "create remote directory failed"
14186
14187         cp /etc/hosts $remote_dir/$tfile
14188         mkdir -p $remote_dir/foo1
14189         mkdir -p $remote_dir/foo2
14190         ln $remote_dir/$tfile $remote_dir/foo1/sofia
14191         ln $remote_dir/$tfile $remote_dir/foo2/zachary
14192         ln $remote_dir/$tfile $remote_dir/foo1/luna
14193         ln $remote_dir/$tfile $remote_dir/foo2/thor
14194
14195         local FID=$($LFS path2fid $remote_dir/$tfile | tr -d '[' |
14196                      tr -d ']')
14197         if [ "$($LFS fid2path $DIR $FID | wc -l)" != "5" ]; then
14198                 $LFS fid2path $DIR $FID
14199                 error "bad link ea"
14200         fi
14201         # middle
14202         rm $remote_dir/foo2/zachary
14203         # last
14204         rm $remote_dir/foo2/thor
14205         # first
14206         rm $remote_dir/$tfile
14207         # rename
14208         mv $remote_dir/foo1/sofia $remote_dir/foo2/maggie
14209         local link_path=$($LFS fid2path $FSNAME --link 1 $FID)
14210         if [ "$DIR/$link_path" != "$remote_dir/foo2/maggie" ]; then
14211                 $LFS fid2path $DIR $FID
14212                 error "bad link rename"
14213         fi
14214         rm $remote_dir/foo2/maggie
14215
14216         # overflow the EA
14217         local longname=filename_avg_len_is_thirty_two_
14218         createmany -l$remote_dir/foo1/luna $remote_dir/foo2/$longname 1000 ||
14219                 error "failed to hardlink many files"
14220         links=$($LFS fid2path $DIR $FID | wc -l)
14221         echo -n "${links}/1000 links in link EA"
14222         [[ ${links} -gt 60 ]] ||
14223                 error "expected at least 60 links in link EA"
14224         unlinkmany $remote_dir/foo2/$longname 1000 ||
14225         error "failed to unlink many hardlinks"
14226 }
14227 run_test 161b "link ea sanity under remote directory"
14228
14229 test_161c() {
14230         remote_mds_nodsh && skip "remote MDS with nodsh"
14231         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14232         [[ $MDS1_VERSION -lt $(version_code 2.1.5) ]] &&
14233                 skip "Need MDS version at least 2.1.5"
14234
14235         # define CLF_RENAME_LAST 0x0001
14236         # rename overwrite a target having nlink = 1 (changelog flag 0x1)
14237         changelog_register || error "changelog_register failed"
14238
14239         rm -rf $DIR/$tdir
14240         test_mkdir -i $((MDSCOUNT - 1)) $DIR/$tdir
14241         touch $DIR/$tdir/foo_161c
14242         touch $DIR/$tdir/bar_161c
14243         mv -f $DIR/$tdir/foo_161c $DIR/$tdir/bar_161c
14244         changelog_dump | grep RENME | tail -n 5
14245         local flags=$(changelog_dump | grep "RENME.*bar_161c" | cut -f5 -d' ')
14246         changelog_clear 0 || error "changelog_clear failed"
14247         if [ x$flags != "x0x1" ]; then
14248                 error "flag $flags is not 0x1"
14249         fi
14250
14251         echo "rename overwrite target with nlink = 1, changelog flags=$flags"
14252         # rename overwrite a target having nlink > 1 (changelog flag 0x0)
14253         touch $DIR/$tdir/foo_161c
14254         touch $DIR/$tdir/bar_161c
14255         ln $DIR/$tdir/bar_161c $DIR/$tdir/foobar_161c
14256         mv -f $DIR/$tdir/foo_161c $DIR/$tdir/bar_161c
14257         changelog_dump | grep RENME | tail -n 5
14258         flags=$(changelog_dump | grep "RENME.*bar_161c" | cut -f5 -d' ')
14259         changelog_clear 0 || error "changelog_clear failed"
14260         if [ x$flags != "x0x0" ]; then
14261                 error "flag $flags is not 0x0"
14262         fi
14263         echo "rename overwrite a target having nlink > 1," \
14264                 "changelog record has flags of $flags"
14265
14266         # rename doesn't overwrite a target (changelog flag 0x0)
14267         touch $DIR/$tdir/foo_161c
14268         mv -f $DIR/$tdir/foo_161c $DIR/$tdir/foo2_161c
14269         changelog_dump | grep RENME | tail -n 5
14270         flags=$(changelog_dump | grep RENME | tail -1 | cut -f5 -d' ')
14271         changelog_clear 0 || error "changelog_clear failed"
14272         if [ x$flags != "x0x0" ]; then
14273                 error "flag $flags is not 0x0"
14274         fi
14275         echo "rename doesn't overwrite a target," \
14276                 "changelog record has flags of $flags"
14277
14278         # define CLF_UNLINK_LAST 0x0001
14279         # unlink a file having nlink = 1 (changelog flag 0x1)
14280         rm -f $DIR/$tdir/foo2_161c
14281         changelog_dump | grep UNLNK | tail -n 5
14282         flags=$(changelog_dump | grep UNLNK | tail -1 | cut -f5 -d' ')
14283         changelog_clear 0 || error "changelog_clear failed"
14284         if [ x$flags != "x0x1" ]; then
14285                 error "flag $flags is not 0x1"
14286         fi
14287         echo "unlink a file having nlink = 1," \
14288                 "changelog record has flags of $flags"
14289
14290         # unlink a file having nlink > 1 (changelog flag 0x0)
14291         ln -f $DIR/$tdir/bar_161c $DIR/$tdir/foobar_161c
14292         rm -f $DIR/$tdir/foobar_161c
14293         changelog_dump | grep UNLNK | tail -n 5
14294         flags=$(changelog_dump | grep UNLNK | tail -1 | cut -f5 -d' ')
14295         changelog_clear 0 || error "changelog_clear failed"
14296         if [ x$flags != "x0x0" ]; then
14297                 error "flag $flags is not 0x0"
14298         fi
14299         echo "unlink a file having nlink > 1, changelog record flags '$flags'"
14300 }
14301 run_test 161c "check CL_RENME[UNLINK] changelog record flags"
14302
14303 test_161d() {
14304         remote_mds_nodsh && skip "remote MDS with nodsh"
14305         [ -n "$FILESET" ] && skip "Not functional for FILESET set"
14306
14307         local pid
14308         local fid
14309
14310         changelog_register || error "changelog_register failed"
14311
14312         # work in a standalone dir to avoid locking on $DIR/$MOUNT to
14313         # interfer with $MOUNT/.lustre/fid/ access
14314         mkdir $DIR/$tdir
14315         [[ $? -eq 0 ]] || error "mkdir failed"
14316
14317         #define OBD_FAIL_LLITE_CREATE_NODE_PAUSE 0x140c | OBD_FAIL_ONCE
14318         $LCTL set_param fail_loc=0x8000140c
14319         # 5s pause
14320         $LCTL set_param fail_val=5
14321
14322         # create file
14323         echo foofoo > $DIR/$tdir/$tfile &
14324         pid=$!
14325
14326         # wait for create to be delayed
14327         sleep 2
14328
14329         ps -p $pid
14330         [[ $? -eq 0 ]] || error "create should be blocked"
14331
14332         local tempfile="$(mktemp --tmpdir $tfile.XXXXXX)"
14333         stack_trap "rm -f $tempfile"
14334         fid=$(changelog_extract_field "CREAT" "$tfile" "t=")
14335         cat $MOUNT/.lustre/fid/$fid 2>/dev/null >$tempfile || error "cat failed"
14336         # some delay may occur during ChangeLog publishing and file read just
14337         # above, that could allow file write to happen finally
14338         [[ -s $tempfile ]] && echo "file should be empty"
14339
14340         $LCTL set_param fail_loc=0
14341
14342         wait $pid
14343         [[ $? -eq 0 ]] || error "create failed"
14344 }
14345 run_test 161d "create with concurrent .lustre/fid access"
14346
14347 check_path() {
14348         local expected="$1"
14349         shift
14350         local fid="$2"
14351
14352         local path
14353         path=$($LFS fid2path "$@")
14354         local rc=$?
14355
14356         if [ $rc -ne 0 ]; then
14357                 error "path looked up of '$expected' failed: rc=$rc"
14358         elif [ "$path" != "$expected" ]; then
14359                 error "path looked up '$path' instead of '$expected'"
14360         else
14361                 echo "FID '$fid' resolves to path '$path' as expected"
14362         fi
14363 }
14364
14365 test_162a() { # was test_162
14366         test_mkdir -p -c1 $DIR/$tdir/d2
14367         touch $DIR/$tdir/d2/$tfile
14368         touch $DIR/$tdir/d2/x1
14369         touch $DIR/$tdir/d2/x2
14370         test_mkdir -p -c1 $DIR/$tdir/d2/a/b/c
14371         test_mkdir -p -c1 $DIR/$tdir/d2/p/q/r
14372         # regular file
14373         local fid=$($LFS path2fid $DIR/$tdir/d2/$tfile | tr -d '[]')
14374         check_path "$tdir/d2/$tfile" $FSNAME "$fid" --link 0
14375
14376         # softlink
14377         ln -s $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/p/q/r/slink
14378         fid=$($LFS path2fid $DIR/$tdir/d2/p/q/r/slink | tr -d '[]')
14379         check_path "$tdir/d2/p/q/r/slink" $FSNAME "$fid" --link 0
14380
14381         # softlink to wrong file
14382         ln -s /this/is/garbage $DIR/$tdir/d2/p/q/r/slink.wrong
14383         fid=$($LFS path2fid $DIR/$tdir/d2/p/q/r/slink.wrong | tr -d '[]')
14384         check_path "$tdir/d2/p/q/r/slink.wrong" $FSNAME "$fid" --link 0
14385
14386         # hardlink
14387         ln $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/p/q/r/hlink
14388         mv $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/a/b/c/new_file
14389         fid=$($LFS path2fid $DIR/$tdir/d2/a/b/c/new_file | tr -d '[]')
14390         # fid2path dir/fsname should both work
14391         check_path "$tdir/d2/a/b/c/new_file" $FSNAME "$fid" --link 1
14392         check_path "$DIR/$tdir/d2/p/q/r/hlink" $DIR "$fid" --link 0
14393
14394         # hardlink count: check that there are 2 links
14395         local nlinks=$($LFS fid2path $DIR "$fid" | wc -l)
14396         [ $nlinks -eq 2 ] || error "expect 2 links, found $nlinks"
14397
14398         # hardlink indexing: remove the first link
14399         rm $DIR/$tdir/d2/p/q/r/hlink
14400         check_path "$tdir/d2/a/b/c/new_file" $FSNAME $fid --link 0
14401 }
14402 run_test 162a "path lookup sanity"
14403
14404 test_162b() {
14405         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14406         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
14407
14408         mkdir $DIR/$tdir
14409         $LFS setdirstripe -i0 -c$MDSCOUNT -H all_char $DIR/$tdir/striped_dir ||
14410                                 error "create striped dir failed"
14411
14412         local FID=$($LFS getdirstripe $DIR/$tdir/striped_dir |
14413                                         tail -n 1 | awk '{print $2}')
14414         stat $MOUNT/.lustre/fid/$FID && error "sub_stripe can be accessed"
14415
14416         touch $DIR/$tdir/striped_dir/f{0..4} || error "touch f0..4 failed"
14417         mkdir $DIR/$tdir/striped_dir/d{0..4} || error "mkdir d0..4 failed"
14418
14419         # regular file
14420         for ((i=0;i<5;i++)); do
14421                 FID=$($LFS path2fid $DIR/$tdir/striped_dir/f$i | tr -d '[]') ||
14422                         error "get fid for f$i failed"
14423                 check_path "$tdir/striped_dir/f$i" $FSNAME $FID --link 0
14424
14425                 FID=$($LFS path2fid $DIR/$tdir/striped_dir/d$i | tr -d '[]') ||
14426                         error "get fid for d$i failed"
14427                 check_path "$tdir/striped_dir/d$i" $FSNAME $FID --link 0
14428         done
14429
14430         return 0
14431 }
14432 run_test 162b "striped directory path lookup sanity"
14433
14434 # LU-4239: Verify fid2path works with paths 100 or more directories deep
14435 test_162c() {
14436         [[ $MDS1_VERSION -lt $(version_code 2.7.51) ]] &&
14437                 skip "Need MDS version at least 2.7.51"
14438
14439         local lpath=$tdir.local
14440         local rpath=$tdir.remote
14441
14442         test_mkdir $DIR/$lpath
14443         test_mkdir $DIR/$rpath
14444
14445         for ((i = 0; i <= 101; i++)); do
14446                 lpath="$lpath/$i"
14447                 mkdir $DIR/$lpath
14448                 FID=$($LFS path2fid $DIR/$lpath | tr -d '[]') ||
14449                         error "get fid for local directory $DIR/$lpath failed"
14450                 check_path "$DIR/$lpath" $MOUNT $FID --link 0
14451
14452                 rpath="$rpath/$i"
14453                 test_mkdir $DIR/$rpath
14454                 FID=$($LFS path2fid $DIR/$rpath | tr -d '[]') ||
14455                         error "get fid for remote directory $DIR/$rpath failed"
14456                 check_path "$DIR/$rpath" $MOUNT $FID --link 0
14457         done
14458
14459         return 0
14460 }
14461 run_test 162c "fid2path works with paths 100 or more directories deep"
14462
14463 test_169() {
14464         # do directio so as not to populate the page cache
14465         log "creating a 10 Mb file"
14466         $MULTIOP $DIR/$tfile oO_CREAT:O_DIRECT:O_RDWR:w$((10*1048576))c || error "multiop failed while creating a file"
14467         log "starting reads"
14468         dd if=$DIR/$tfile of=/dev/null bs=4096 &
14469         log "truncating the file"
14470         $MULTIOP $DIR/$tfile oO_TRUNC:c || error "multiop failed while truncating the file"
14471         log "killing dd"
14472         kill %+ || true # reads might have finished
14473         echo "wait until dd is finished"
14474         wait
14475         log "removing the temporary file"
14476         rm -rf $DIR/$tfile || error "tmp file removal failed"
14477 }
14478 run_test 169 "parallel read and truncate should not deadlock"
14479
14480 test_170() {
14481         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14482
14483         $LCTL clear     # bug 18514
14484         $LCTL debug_daemon start $TMP/${tfile}_log_good
14485         touch $DIR/$tfile
14486         $LCTL debug_daemon stop
14487         sed -e "s/^...../a/g" $TMP/${tfile}_log_good > $TMP/${tfile}_log_bad ||
14488                 error "sed failed to read log_good"
14489
14490         $LCTL debug_daemon start $TMP/${tfile}_log_good
14491         rm -rf $DIR/$tfile
14492         $LCTL debug_daemon stop
14493
14494         $LCTL df $TMP/${tfile}_log_bad > $TMP/${tfile}_log_bad.out 2>&1 ||
14495                error "lctl df log_bad failed"
14496
14497         local bad_line=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $9}')
14498         local good_line1=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $5}')
14499
14500         $LCTL df $TMP/${tfile}_log_good > $TMP/${tfile}_log_good.out 2>&1
14501         local good_line2=$(tail -n 1 $TMP/${tfile}_log_good.out | awk '{print $5}')
14502
14503         [ "$bad_line" ] && [ "$good_line1" ] && [ "$good_line2" ] ||
14504                 error "bad_line good_line1 good_line2 are empty"
14505
14506         cat $TMP/${tfile}_log_good >> $TMP/${tfile}_logs_corrupt
14507         cat $TMP/${tfile}_log_bad >> $TMP/${tfile}_logs_corrupt
14508         cat $TMP/${tfile}_log_good >> $TMP/${tfile}_logs_corrupt
14509
14510         $LCTL df $TMP/${tfile}_logs_corrupt > $TMP/${tfile}_log_bad.out 2>&1
14511         local bad_line_new=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $9}')
14512         local good_line_new=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $5}')
14513
14514         [ "$bad_line_new" ] && [ "$good_line_new" ] ||
14515                 error "bad_line_new good_line_new are empty"
14516
14517         local expected_good=$((good_line1 + good_line2*2))
14518
14519         rm -f $TMP/${tfile}*
14520         # LU-231, short malformed line may not be counted into bad lines
14521         if [ $bad_line -ne $bad_line_new ] &&
14522                    [ $bad_line -ne $((bad_line_new - 1)) ]; then
14523                 error "expected $bad_line bad lines, but got $bad_line_new"
14524                 return 1
14525         fi
14526
14527         if [ $expected_good -ne $good_line_new ]; then
14528                 error "expected $expected_good good lines, but got $good_line_new"
14529                 return 2
14530         fi
14531         true
14532 }
14533 run_test 170 "test lctl df to handle corrupted log ====================="
14534
14535 test_171() { # bug20592
14536         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14537
14538         #define OBD_FAIL_PTLRPC_DUMP_LOG         0x50e
14539         $LCTL set_param fail_loc=0x50e
14540         $LCTL set_param fail_val=3000
14541         multiop_bg_pause $DIR/$tfile O_s || true
14542         local MULTIPID=$!
14543         kill -USR1 $MULTIPID
14544         # cause log dump
14545         sleep 3
14546         wait $MULTIPID
14547         if dmesg | grep "recursive fault"; then
14548                 error "caught a recursive fault"
14549         fi
14550         $LCTL set_param fail_loc=0
14551         true
14552 }
14553 run_test 171 "test libcfs_debug_dumplog_thread stuck in do_exit() ======"
14554
14555 # it would be good to share it with obdfilter-survey/iokit-libecho code
14556 setup_obdecho_osc () {
14557         local rc=0
14558         local ost_nid=$1
14559         local obdfilter_name=$2
14560         echo "Creating new osc for $obdfilter_name on $ost_nid"
14561         # make sure we can find loopback nid
14562         $LCTL add_uuid $ost_nid $ost_nid >/dev/null 2>&1
14563
14564         [ $rc -eq 0 ] && { $LCTL attach osc ${obdfilter_name}_osc     \
14565                            ${obdfilter_name}_osc_UUID || rc=2; }
14566         [ $rc -eq 0 ] && { $LCTL --device ${obdfilter_name}_osc setup \
14567                            ${obdfilter_name}_UUID  $ost_nid || rc=3; }
14568         return $rc
14569 }
14570
14571 cleanup_obdecho_osc () {
14572         local obdfilter_name=$1
14573         $LCTL --device ${obdfilter_name}_osc cleanup >/dev/null
14574         $LCTL --device ${obdfilter_name}_osc detach  >/dev/null
14575         return 0
14576 }
14577
14578 obdecho_test() {
14579         local OBD=$1
14580         local node=$2
14581         local pages=${3:-64}
14582         local rc=0
14583         local id
14584
14585         local count=10
14586         local obd_size=$(get_obd_size $node $OBD)
14587         local page_size=$(get_page_size $node)
14588         if [[ -n "$obd_size" ]]; then
14589                 local new_count=$((obd_size / (pages * page_size / 1024)))
14590                 [[ $new_count -ge $count ]] || count=$new_count
14591         fi
14592
14593         do_facet $node "$LCTL attach echo_client ec ec_uuid" || rc=1
14594         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec setup $OBD" ||
14595                            rc=2; }
14596         if [ $rc -eq 0 ]; then
14597             id=$(do_facet $node "$LCTL --device ec create 1"  | awk '/object id/ {print $6}')
14598             [ ${PIPESTATUS[0]} -eq 0 -a -n "$id" ] || rc=3
14599         fi
14600         echo "New object id is $id"
14601         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec getattr $id" ||
14602                            rc=4; }
14603         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec "                 \
14604                            "test_brw $count w v $pages $id" || rc=4; }
14605         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec destroy $id 1" ||
14606                            rc=4; }
14607         [ $rc -eq 0 ] || [ $rc -gt 2 ] &&
14608                 { do_facet $node "$LCTL --device ec cleanup" || rc=5; }
14609         [ $rc -eq 0 ] || [ $rc -gt 1 ] &&
14610                 { do_facet $node "$LCTL --device ec detach" || rc=6; }
14611         [ $rc -ne 0 ] && echo "obecho_create_test failed: $rc"
14612         return $rc
14613 }
14614
14615 test_180a() {
14616         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14617
14618         if ! module_loaded obdecho; then
14619                 load_module obdecho/obdecho &&
14620                         stack_trap "rmmod obdecho" EXIT ||
14621                         error "unable to load obdecho on client"
14622         fi
14623
14624         local osc=$($LCTL dl | grep -v mdt | awk '$3 == "osc" {print $4; exit}')
14625         local host=$($LCTL get_param -n osc.$osc.import |
14626                      awk '/current_connection:/ { print $2 }' )
14627         local target=$($LCTL get_param -n osc.$osc.import |
14628                        awk '/target:/ { print $2 }' )
14629         target=${target%_UUID}
14630
14631         if [ -n "$target" ]; then
14632                 setup_obdecho_osc $host $target &&
14633                         stack_trap "cleanup_obdecho_osc $target" EXIT ||
14634                         { error "obdecho setup failed with $?"; return; }
14635
14636                 obdecho_test ${target}_osc client ||
14637                         error "obdecho_test failed on ${target}_osc"
14638         else
14639                 $LCTL get_param osc.$osc.import
14640                 error "there is no osc.$osc.import target"
14641         fi
14642 }
14643 run_test 180a "test obdecho on osc"
14644
14645 test_180b() {
14646         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14647         remote_ost_nodsh && skip "remote OST with nodsh"
14648
14649         do_rpc_nodes $(facet_active_host ost1) load_module obdecho/obdecho &&
14650                 stack_trap "do_facet ost1 rmmod obdecho" EXIT ||
14651                 error "failed to load module obdecho"
14652
14653         local target=$(do_facet ost1 $LCTL dl |
14654                        awk '/obdfilter/ { print $4; exit; }')
14655
14656         if [ -n "$target" ]; then
14657                 obdecho_test $target ost1 || error "obdecho_test failed with $?"
14658         else
14659                 do_facet ost1 $LCTL dl
14660                 error "there is no obdfilter target on ost1"
14661         fi
14662 }
14663 run_test 180b "test obdecho directly on obdfilter"
14664
14665 test_180c() { # LU-2598
14666         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14667         remote_ost_nodsh && skip "remote OST with nodsh"
14668         [[ $MDS1_VERSION -lt $(version_code 2.4.0) ]] &&
14669                 skip "Need MDS version at least 2.4.0"
14670
14671         do_rpc_nodes $(facet_active_host ost1) load_module obdecho/obdecho &&
14672                 stack_trap "do_facet ost1 rmmod obdecho" EXIT ||
14673                 error "failed to load module obdecho"
14674
14675         local target=$(do_facet ost1 $LCTL dl |
14676                        awk '/obdfilter/ { print $4; exit; }')
14677
14678         if [ -n "$target" ]; then
14679                 local pages=16384 # 64MB bulk I/O RPC size
14680
14681                 obdecho_test "$target" ost1 "$pages" ||
14682                         error "obdecho_test with pages=$pages failed with $?"
14683         else
14684                 do_facet ost1 $LCTL dl
14685                 error "there is no obdfilter target on ost1"
14686         fi
14687 }
14688 run_test 180c "test huge bulk I/O size on obdfilter, don't LASSERT"
14689
14690 test_181() { # bug 22177
14691         test_mkdir $DIR/$tdir
14692         # create enough files to index the directory
14693         createmany -o $DIR/$tdir/foobar 4000
14694         # print attributes for debug purpose
14695         lsattr -d .
14696         # open dir
14697         multiop_bg_pause $DIR/$tdir D_Sc || return 1
14698         MULTIPID=$!
14699         # remove the files & current working dir
14700         unlinkmany $DIR/$tdir/foobar 4000
14701         rmdir $DIR/$tdir
14702         kill -USR1 $MULTIPID
14703         wait $MULTIPID
14704         stat $DIR/$tdir && error "open-unlinked dir was not removed!"
14705         return 0
14706 }
14707 run_test 181 "Test open-unlinked dir ========================"
14708
14709 test_182() {
14710         local fcount=1000
14711         local tcount=10
14712
14713         mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
14714
14715         $LCTL set_param mdc.*.rpc_stats=clear
14716
14717         for (( i = 0; i < $tcount; i++ )) ; do
14718                 mkdir $DIR/$tdir/$i
14719         done
14720
14721         for (( i = 0; i < $tcount; i++ )) ; do
14722                 createmany -o $DIR/$tdir/$i/f- $fcount &
14723         done
14724         wait
14725
14726         for (( i = 0; i < $tcount; i++ )) ; do
14727                 unlinkmany $DIR/$tdir/$i/f- $fcount &
14728         done
14729         wait
14730
14731         $LCTL get_param mdc.*.rpc_stats
14732
14733         rm -rf $DIR/$tdir
14734 }
14735 run_test 182 "Test parallel modify metadata operations ================"
14736
14737 test_183() { # LU-2275
14738         [ $PARALLEL == "yes" ] && skip "skip parallel run"
14739         remote_mds_nodsh && skip "remote MDS with nodsh"
14740         [[ $MDS1_VERSION -lt $(version_code 2.3.56) ]] &&
14741                 skip "Need MDS version at least 2.3.56"
14742
14743         mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
14744         echo aaa > $DIR/$tdir/$tfile
14745
14746 #define OBD_FAIL_MDS_NEGATIVE_POSITIVE  0x148
14747         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x148
14748
14749         ls -l $DIR/$tdir && error "ls succeeded, should have failed"
14750         cat $DIR/$tdir/$tfile && error "cat succeeded, should have failed"
14751
14752         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
14753
14754         # Flush negative dentry cache
14755         touch $DIR/$tdir/$tfile
14756
14757         # We are not checking for any leaked references here, they'll
14758         # become evident next time we do cleanup with module unload.
14759         rm -rf $DIR/$tdir
14760 }
14761 run_test 183 "No crash or request leak in case of strange dispositions ========"
14762
14763 # test suite 184 is for LU-2016, LU-2017
14764 test_184a() {
14765         check_swap_layouts_support
14766
14767         dir0=$DIR/$tdir/$testnum
14768         test_mkdir -p -c1 $dir0
14769         ref1=/etc/passwd
14770         ref2=/etc/group
14771         file1=$dir0/f1
14772         file2=$dir0/f2
14773         $LFS setstripe -c1 $file1
14774         cp $ref1 $file1
14775         $LFS setstripe -c2 $file2
14776         cp $ref2 $file2
14777         gen1=$($LFS getstripe -g $file1)
14778         gen2=$($LFS getstripe -g $file2)
14779
14780         $LFS swap_layouts $file1 $file2 || error "swap of file layout failed"
14781         gen=$($LFS getstripe -g $file1)
14782         [[ $gen1 != $gen ]] ||
14783                 "Layout generation on $file1 does not change"
14784         gen=$($LFS getstripe -g $file2)
14785         [[ $gen2 != $gen ]] ||
14786                 "Layout generation on $file2 does not change"
14787
14788         cmp $ref1 $file2 || error "content compare failed ($ref1 != $file2)"
14789         cmp $ref2 $file1 || error "content compare failed ($ref2 != $file1)"
14790
14791         lfsck_verify_pfid $file1 $file2 || error "PFID are not transferred"
14792 }
14793 run_test 184a "Basic layout swap"
14794
14795 test_184b() {
14796         check_swap_layouts_support
14797
14798         dir0=$DIR/$tdir/$testnum
14799         mkdir -p $dir0 || error "creating dir $dir0"
14800         file1=$dir0/f1
14801         file2=$dir0/f2
14802         file3=$dir0/f3
14803         dir1=$dir0/d1
14804         dir2=$dir0/d2
14805         mkdir $dir1 $dir2
14806         $LFS setstripe -c1 $file1
14807         $LFS setstripe -c2 $file2
14808         $LFS setstripe -c1 $file3
14809         chown $RUNAS_ID $file3
14810         gen1=$($LFS getstripe -g $file1)
14811         gen2=$($LFS getstripe -g $file2)
14812
14813         $LFS swap_layouts $dir1 $dir2 &&
14814                 error "swap of directories layouts should fail"
14815         $LFS swap_layouts $dir1 $file1 &&
14816                 error "swap of directory and file layouts should fail"
14817         $RUNAS $LFS swap_layouts $file1 $file2 &&
14818                 error "swap of file we cannot write should fail"
14819         $LFS swap_layouts $file1 $file3 &&
14820                 error "swap of file with different owner should fail"
14821         /bin/true # to clear error code
14822 }
14823 run_test 184b "Forbidden layout swap (will generate errors)"
14824
14825 test_184c() {
14826         local cmpn_arg=$(cmp -n 2>&1 | grep "invalid option")
14827         [ -n "$cmpn_arg" ] && skip_env "cmp does not support -n"
14828         check_swap_layouts_support
14829
14830         local dir0=$DIR/$tdir/$testnum
14831         mkdir -p $dir0 || error "creating dir $dir0"
14832
14833         local ref1=$dir0/ref1
14834         local ref2=$dir0/ref2
14835         local file1=$dir0/file1
14836         local file2=$dir0/file2
14837         # create a file large enough for the concurrent test
14838         dd if=/dev/urandom of=$ref1 bs=1M count=$((RANDOM % 50 + 20))
14839         dd if=/dev/urandom of=$ref2 bs=1M count=$((RANDOM % 50 + 20))
14840         echo "ref file size: ref1($(stat -c %s $ref1))," \
14841              "ref2($(stat -c %s $ref2))"
14842
14843         cp $ref2 $file2
14844         dd if=$ref1 of=$file1 bs=16k &
14845         local DD_PID=$!
14846
14847         # Make sure dd starts to copy file
14848         while [ ! -f $file1 ]; do sleep 0.1; done
14849
14850         $LFS swap_layouts $file1 $file2
14851         local rc=$?
14852         wait $DD_PID
14853         [[ $? == 0 ]] || error "concurrent write on $file1 failed"
14854         [[ $rc == 0 ]] || error "swap of $file1 and $file2 failed"
14855
14856         # how many bytes copied before swapping layout
14857         local copied=$(stat -c %s $file2)
14858         local remaining=$(stat -c %s $ref1)
14859         remaining=$((remaining - copied))
14860         echo "Copied $copied bytes before swapping layout..."
14861
14862         cmp -n $copied $file1 $ref2 | grep differ &&
14863                 error "Content mismatch [0, $copied) of ref2 and file1"
14864         cmp -n $copied $file2 $ref1 ||
14865                 error "Content mismatch [0, $copied) of ref1 and file2"
14866         cmp -i $copied:$copied -n $remaining $file1 $ref1 ||
14867                 error "Content mismatch [$copied, EOF) of ref1 and file1"
14868
14869         # clean up
14870         rm -f $ref1 $ref2 $file1 $file2
14871 }
14872 run_test 184c "Concurrent write and layout swap"
14873
14874 test_184d() {
14875         check_swap_layouts_support
14876         [ -z "$(which getfattr 2>/dev/null)" ] &&
14877                 skip_env "no getfattr command"
14878
14879         local file1=$DIR/$tdir/$tfile-1
14880         local file2=$DIR/$tdir/$tfile-2
14881         local file3=$DIR/$tdir/$tfile-3
14882         local lovea1
14883         local lovea2
14884
14885         mkdir -p $DIR/$tdir
14886         touch $file1 || error "create $file1 failed"
14887         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE $file2 ||
14888                 error "create $file2 failed"
14889         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE $file3 ||
14890                 error "create $file3 failed"
14891         lovea1=$(get_layout_param $file1)
14892
14893         $LFS swap_layouts $file2 $file3 ||
14894                 error "swap $file2 $file3 layouts failed"
14895         $LFS swap_layouts $file1 $file2 ||
14896                 error "swap $file1 $file2 layouts failed"
14897
14898         lovea2=$(get_layout_param $file2)
14899         echo "$lovea1"
14900         echo "$lovea2"
14901         [ "$lovea1" == "$lovea2" ] || error "lovea $lovea1 != $lovea2"
14902
14903         lovea1=$(getfattr -n trusted.lov $file1 | grep ^trusted)
14904         [[ -z "$lovea1" ]] || error "$file1 shouldn't have lovea"
14905 }
14906 run_test 184d "allow stripeless layouts swap"
14907
14908 test_184e() {
14909         [[ $MDS1_VERSION -ge $(version_code 2.6.94) ]] ||
14910                 skip "Need MDS version at least 2.6.94"
14911         check_swap_layouts_support
14912         [ -z "$(which getfattr 2>/dev/null)" ] &&
14913                 skip_env "no getfattr command"
14914
14915         local file1=$DIR/$tdir/$tfile-1
14916         local file2=$DIR/$tdir/$tfile-2
14917         local file3=$DIR/$tdir/$tfile-3
14918         local lovea
14919
14920         mkdir -p $DIR/$tdir
14921         touch $file1 || error "create $file1 failed"
14922         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE $file2 ||
14923                 error "create $file2 failed"
14924         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE $file3 ||
14925                 error "create $file3 failed"
14926
14927         $LFS swap_layouts $file1 $file2 ||
14928                 error "swap $file1 $file2 layouts failed"
14929
14930         lovea=$(getfattr -n trusted.lov $file1 | grep ^trusted)
14931         [[ -z "$lovea" ]] || error "$file1 shouldn't have lovea"
14932
14933         echo 123 > $file1 || error "Should be able to write into $file1"
14934
14935         $LFS swap_layouts $file1 $file3 ||
14936                 error "swap $file1 $file3 layouts failed"
14937
14938         echo 123 > $file1 || error "Should be able to write into $file1"
14939
14940         rm -rf $file1 $file2 $file3
14941 }
14942 run_test 184e "Recreate layout after stripeless layout swaps"
14943
14944 test_184f() {
14945         # Create a file with name longer than sizeof(struct stat) ==
14946         # 144 to see if we can get chars from the file name to appear
14947         # in the returned striping. Note that 'f' == 0x66.
14948         local file=$(for ((i = 0; i < 200; i++)); do echo -n f; done)
14949
14950         mkdir -p $DIR/$tdir
14951         mcreate $DIR/$tdir/$file
14952         if lfs find --stripe-count 0x6666 $DIR/$tdir | grep $file; then
14953                 error "IOC_MDC_GETFILEINFO returned garbage striping"
14954         fi
14955 }
14956 run_test 184f "IOC_MDC_GETFILEINFO for files with long names but no striping"
14957
14958 test_185() { # LU-2441
14959         # LU-3553 - no volatile file support in old servers
14960         [[ $MDS1_VERSION -ge $(version_code 2.3.60) ]] ||
14961                 skip "Need MDS version at least 2.3.60"
14962
14963         mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
14964         touch $DIR/$tdir/spoo
14965         local mtime1=$(stat -c "%Y" $DIR/$tdir)
14966         local fid=$($MULTIOP $DIR/$tdir VFw4096c) ||
14967                 error "cannot create/write a volatile file"
14968         [ "$FILESET" == "" ] &&
14969         $CHECKSTAT -t file $MOUNT/.lustre/fid/$fid 2>/dev/null &&
14970                 error "FID is still valid after close"
14971
14972         multiop_bg_pause $DIR/$tdir vVw4096_c
14973         local multi_pid=$!
14974
14975         local OLD_IFS=$IFS
14976         IFS=":"
14977         local fidv=($fid)
14978         IFS=$OLD_IFS
14979         # assume that the next FID for this client is sequential, since stdout
14980         # is unfortunately eaten by multiop_bg_pause
14981         local n=$((${fidv[1]} + 1))
14982         local next_fid="${fidv[0]}:$(printf "0x%x" $n):${fidv[2]}"
14983         if [ "$FILESET" == "" ]; then
14984                 $CHECKSTAT -t file $MOUNT/.lustre/fid/$next_fid ||
14985                         error "FID is missing before close"
14986         fi
14987         kill -USR1 $multi_pid
14988         # 1 second delay, so if mtime change we will see it
14989         sleep 1
14990         local mtime2=$(stat -c "%Y" $DIR/$tdir)
14991         [[ $mtime1 == $mtime2 ]] || error "mtime has changed"
14992 }
14993 run_test 185 "Volatile file support"
14994
14995 function create_check_volatile() {
14996         local idx=$1
14997         local tgt
14998
14999         $MULTIOP $MOUNT/.lustre/fid V${idx}Fw4096_c >&/tmp/${tfile}.fid &
15000         local PID=$!
15001         sleep 1
15002         local FID=$(cat /tmp/${tfile}.fid)
15003         [ "$FID" == "" ] && error "can't get FID for volatile"
15004         $CHECKSTAT -t file $MOUNT/.lustre/fid/$FID || error "can't stat $FID"
15005         tgt=$($LFS getstripe -m $MOUNT/.lustre/fid/$FID)
15006         [ "$tgt" != "$idx" ] && error "wrong MDS $tgt, expected $idx"
15007         kill -USR1 $PID
15008         wait
15009         sleep 1
15010         cancel_lru_locks mdc # flush opencache
15011         $CHECKSTAT -t file $MOUNT/.lustre/fid/$FID && error "can stat $FID"
15012         return 0
15013 }
15014
15015 test_185a(){
15016         # LU-12516 - volatile creation via .lustre
15017         [[ $MDS1_VERSION -ge $(version_code 2.12.55) ]] ||
15018                 skip "Need MDS version at least 2.3.55"
15019
15020         create_check_volatile 0
15021         [ $MDSCOUNT -lt 2 ] && return 0
15022
15023         # DNE case
15024         create_check_volatile 1
15025
15026         return 0
15027 }
15028 run_test 185a "Volatile file creation in .lustre/fid/"
15029
15030 test_187a() {
15031         remote_mds_nodsh && skip "remote MDS with nodsh"
15032         [ $MDS1_VERSION -lt $(version_code 2.3.0) ] &&
15033                 skip "Need MDS version at least 2.3.0"
15034
15035         local dir0=$DIR/$tdir/$testnum
15036         mkdir -p $dir0 || error "creating dir $dir0"
15037
15038         local file=$dir0/file1
15039         dd if=/dev/urandom of=$file count=10 bs=1M conv=fsync
15040         local dv1=$($LFS data_version $file)
15041         dd if=/dev/urandom of=$file seek=10 count=1 bs=1M conv=fsync
15042         local dv2=$($LFS data_version $file)
15043         [[ $dv1 != $dv2 ]] ||
15044                 error "data version did not change on write $dv1 == $dv2"
15045
15046         # clean up
15047         rm -f $file1
15048 }
15049 run_test 187a "Test data version change"
15050
15051 test_187b() {
15052         remote_mds_nodsh && skip "remote MDS with nodsh"
15053         [ $MDS1_VERSION -lt $(version_code 2.3.0) ] &&
15054                 skip "Need MDS version at least 2.3.0"
15055
15056         local dir0=$DIR/$tdir/$testnum
15057         mkdir -p $dir0 || error "creating dir $dir0"
15058
15059         declare -a DV=$($MULTIOP $dir0 Vw1000xYw1000xY | cut -f3 -d" ")
15060         [[ ${DV[0]} != ${DV[1]} ]] ||
15061                 error "data version did not change on write"\
15062                       " ${DV[0]} == ${DV[1]}"
15063
15064         # clean up
15065         rm -f $file1
15066 }
15067 run_test 187b "Test data version change on volatile file"
15068
15069 test_200() {
15070         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15071         remote_mgs_nodsh && skip "remote MGS with nodsh"
15072         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
15073
15074         local POOL=${POOL:-cea1}
15075         local POOL_ROOT=${POOL_ROOT:-$DIR/d200.pools}
15076         local POOL_DIR_NAME=${POOL_DIR_NAME:-dir_tst}
15077         # Pool OST targets
15078         local first_ost=0
15079         local last_ost=$(($OSTCOUNT - 1))
15080         local ost_step=2
15081         local ost_list=$(seq $first_ost $ost_step $last_ost)
15082         local ost_range="$first_ost $last_ost $ost_step"
15083         local test_path=$POOL_ROOT/$POOL_DIR_NAME
15084         local file_dir=$POOL_ROOT/file_tst
15085         local subdir=$test_path/subdir
15086         local rc=0
15087
15088         if ! combined_mgs_mds ; then
15089                 mount_mgs_client
15090         fi
15091
15092         while : ; do
15093                 # former test_200a test_200b
15094                 pool_add $POOL                          || { rc=$? ; break; }
15095                 pool_add_targets  $POOL $ost_range      || { rc=$? ; break; }
15096                 # former test_200c test_200d
15097                 mkdir -p $test_path
15098                 pool_set_dir      $POOL $test_path      || { rc=$? ; break; }
15099                 pool_check_dir    $POOL $test_path      || { rc=$? ; break; }
15100                 mkdir -p $subdir
15101                 pool_check_dir    $POOL $subdir         || { rc=$? ; break; }
15102                 pool_dir_rel_path $POOL $POOL_DIR_NAME $POOL_ROOT \
15103                                                         || { rc=$? ; break; }
15104                 # former test_200e test_200f
15105                 local files=$((OSTCOUNT*3))
15106                 pool_alloc_files  $POOL $test_path $files "$ost_list" \
15107                                                         || { rc=$? ; break; }
15108                 pool_create_files $POOL $file_dir $files "$ost_list" \
15109                                                         || { rc=$? ; break; }
15110                 # former test_200g test_200h
15111                 pool_lfs_df $POOL                       || { rc=$? ; break; }
15112                 pool_file_rel_path $POOL $test_path     || { rc=$? ; break; }
15113
15114                 # former test_201a test_201b test_201c
15115                 pool_remove_first_target $POOL          || { rc=$? ; break; }
15116
15117                 local f=$test_path/$tfile
15118                 pool_remove_all_targets $POOL $f        || { rc=$? ; break; }
15119                 pool_remove $POOL $f                    || { rc=$? ; break; }
15120                 break
15121         done
15122
15123         destroy_test_pools
15124
15125         if ! combined_mgs_mds ; then
15126                 umount_mgs_client
15127         fi
15128         return $rc
15129 }
15130 run_test 200 "OST pools"
15131
15132 # usage: default_attr <count | size | offset>
15133 default_attr() {
15134         $LCTL get_param -n lov.$FSNAME-clilov-\*.stripe${1}
15135 }
15136
15137 # usage: check_default_stripe_attr
15138 check_default_stripe_attr() {
15139         ACTUAL=$($LFS getstripe $* $DIR/$tdir)
15140         case $1 in
15141         --stripe-count|-c)
15142                 [ -n "$2" ] && EXPECTED=0 || EXPECTED=$(default_attr count);;
15143         --stripe-size|-S)
15144                 [ -n "$2" ] && EXPECTED=0 || EXPECTED=$(default_attr size);;
15145         --stripe-index|-i)
15146                 EXPECTED=-1;;
15147         *)
15148                 error "unknown getstripe attr '$1'"
15149         esac
15150
15151         [ $ACTUAL == $EXPECTED ] ||
15152                 error "$DIR/$tdir has $1 '$ACTUAL', not '$EXPECTED'"
15153 }
15154
15155 test_204a() {
15156         test_mkdir $DIR/$tdir
15157         $LFS setstripe --stripe-count 0 --stripe-size 0 --stripe-index -1 $DIR/$tdir
15158
15159         check_default_stripe_attr --stripe-count
15160         check_default_stripe_attr --stripe-size
15161         check_default_stripe_attr --stripe-index
15162 }
15163 run_test 204a "Print default stripe attributes"
15164
15165 test_204b() {
15166         test_mkdir $DIR/$tdir
15167         $LFS setstripe --stripe-count 1 $DIR/$tdir
15168
15169         check_default_stripe_attr --stripe-size
15170         check_default_stripe_attr --stripe-index
15171 }
15172 run_test 204b "Print default stripe size and offset"
15173
15174 test_204c() {
15175         test_mkdir $DIR/$tdir
15176         $LFS setstripe --stripe-size 65536 $DIR/$tdir
15177
15178         check_default_stripe_attr --stripe-count
15179         check_default_stripe_attr --stripe-index
15180 }
15181 run_test 204c "Print default stripe count and offset"
15182
15183 test_204d() {
15184         test_mkdir $DIR/$tdir
15185         $LFS setstripe --stripe-index 0 $DIR/$tdir
15186
15187         check_default_stripe_attr --stripe-count
15188         check_default_stripe_attr --stripe-size
15189 }
15190 run_test 204d "Print default stripe count and size"
15191
15192 test_204e() {
15193         test_mkdir $DIR/$tdir
15194         $LFS setstripe -d $DIR/$tdir
15195
15196         check_default_stripe_attr --stripe-count --raw
15197         check_default_stripe_attr --stripe-size --raw
15198         check_default_stripe_attr --stripe-index --raw
15199 }
15200 run_test 204e "Print raw stripe attributes"
15201
15202 test_204f() {
15203         test_mkdir $DIR/$tdir
15204         $LFS setstripe --stripe-count 1 $DIR/$tdir
15205
15206         check_default_stripe_attr --stripe-size --raw
15207         check_default_stripe_attr --stripe-index --raw
15208 }
15209 run_test 204f "Print raw stripe size and offset"
15210
15211 test_204g() {
15212         test_mkdir $DIR/$tdir
15213         $LFS setstripe --stripe-size 65536 $DIR/$tdir
15214
15215         check_default_stripe_attr --stripe-count --raw
15216         check_default_stripe_attr --stripe-index --raw
15217 }
15218 run_test 204g "Print raw stripe count and offset"
15219
15220 test_204h() {
15221         test_mkdir $DIR/$tdir
15222         $LFS setstripe --stripe-index 0 $DIR/$tdir
15223
15224         check_default_stripe_attr --stripe-count --raw
15225         check_default_stripe_attr --stripe-size --raw
15226 }
15227 run_test 204h "Print raw stripe count and size"
15228
15229 # Figure out which job scheduler is being used, if any,
15230 # or use a fake one
15231 if [ -n "$SLURM_JOB_ID" ]; then # SLURM
15232         JOBENV=SLURM_JOB_ID
15233 elif [ -n "$LSB_JOBID" ]; then # Load Sharing Facility
15234         JOBENV=LSB_JOBID
15235 elif [ -n "$PBS_JOBID" ]; then # PBS/Maui/Moab
15236         JOBENV=PBS_JOBID
15237 elif [ -n "$LOADL_STEPID" ]; then # LoadLeveller
15238         JOBENV=LOADL_STEP_ID
15239 elif [ -n "$JOB_ID" ]; then # Sun Grid Engine
15240         JOBENV=JOB_ID
15241 else
15242         $LCTL list_param jobid_name > /dev/null 2>&1
15243         if [ $? -eq 0 ]; then
15244                 JOBENV=nodelocal
15245         else
15246                 JOBENV=FAKE_JOBID
15247         fi
15248 fi
15249 LUSTRE_JOBID_SIZE=31 # plus NUL terminator
15250
15251 verify_jobstats() {
15252         local cmd=($1)
15253         shift
15254         local facets="$@"
15255
15256 # we don't really need to clear the stats for this test to work, since each
15257 # command has a unique jobid, but it makes debugging easier if needed.
15258 #       for facet in $facets; do
15259 #               local dev=$(convert_facet2label $facet)
15260 #               # clear old jobstats
15261 #               do_facet $facet lctl set_param *.$dev.job_stats="clear"
15262 #       done
15263
15264         # use a new JobID for each test, or we might see an old one
15265         [ "$JOBENV" = "FAKE_JOBID" ] &&
15266                 FAKE_JOBID=id.$testnum.$(basename ${cmd[0]}).$RANDOM
15267
15268         JOBVAL=${!JOBENV:0:$LUSTRE_JOBID_SIZE}
15269
15270         [ "$JOBENV" = "nodelocal" ] && {
15271                 FAKE_JOBID=id.$testnum.%e.$RANDOM
15272                 $LCTL set_param jobid_name=$FAKE_JOBID
15273                 JOBVAL=${FAKE_JOBID/\%e/$(basename ${cmd[0]})}
15274         }
15275
15276         log "Test: ${cmd[*]}"
15277         log "Using JobID environment $($LCTL get_param -n jobid_var)=$JOBVAL"
15278
15279         if [ $JOBENV = "FAKE_JOBID" ]; then
15280                 FAKE_JOBID=$JOBVAL ${cmd[*]}
15281         else
15282                 ${cmd[*]}
15283         fi
15284
15285         # all files are created on OST0000
15286         for facet in $facets; do
15287                 local stats="*.$(convert_facet2label $facet).job_stats"
15288
15289                 # strip out libtool wrappers for in-tree executables
15290                 if [ $(do_facet $facet lctl get_param $stats |
15291                        sed -e 's/\.lt-/./' | grep -c $JOBVAL) -ne 1 ]; then
15292                         do_facet $facet lctl get_param $stats
15293                         error "No jobstats for $JOBVAL found on $facet::$stats"
15294                 fi
15295         done
15296 }
15297
15298 jobstats_set() {
15299         local new_jobenv=$1
15300
15301         set_persistent_param_and_check client "jobid_var" \
15302                 "$FSNAME.sys.jobid_var" $new_jobenv
15303 }
15304
15305 test_205() { # Job stats
15306         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15307         [[ $MDS1_VERSION -ge $(version_code 2.7.1) ]] ||
15308                 skip "Need MDS version with at least 2.7.1"
15309         remote_mgs_nodsh && skip "remote MGS with nodsh"
15310         remote_mds_nodsh && skip "remote MDS with nodsh"
15311         remote_ost_nodsh && skip "remote OST with nodsh"
15312         [ -z "$(lctl get_param -n mdc.*.connect_flags | grep jobstats)" ] &&
15313                 skip "Server doesn't support jobstats"
15314         [[ $JOBID_VAR = disable ]] && skip_env "jobstats is disabled"
15315
15316         local old_jobenv=$($LCTL get_param -n jobid_var)
15317         [ $old_jobenv != $JOBENV ] && jobstats_set $JOBENV
15318
15319         if [[ $PERM_CMD == *"set_param -P"* ]]; then
15320                 stack_trap "do_facet mgs $PERM_CMD jobid_var=$old_jobenv" EXIT
15321         else
15322                 stack_trap "do_facet mgs $PERM_CMD \
15323                         $FSNAME.sys.jobid_var=$old_jobenv" EXIT
15324         fi
15325         changelog_register
15326
15327         local old_interval=$(do_facet $SINGLEMDS lctl get_param -n \
15328                                 mdt.*.job_cleanup_interval | head -n 1)
15329         local new_interval=5
15330         do_facet $SINGLEMDS \
15331                 $LCTL set_param mdt.*.job_cleanup_interval=$new_interval
15332         stack_trap "do_facet $SINGLEMDS \
15333                 $LCTL set_param mdt.*.job_cleanup_interval=$old_interval" EXIT
15334         local start=$SECONDS
15335
15336         local cmd
15337         # mkdir
15338         cmd="mkdir $DIR/$tdir"
15339         verify_jobstats "$cmd" "$SINGLEMDS"
15340         # rmdir
15341         cmd="rmdir $DIR/$tdir"
15342         verify_jobstats "$cmd" "$SINGLEMDS"
15343         # mkdir on secondary MDT
15344         if [ $MDSCOUNT -gt 1 ]; then
15345                 cmd="lfs mkdir -i 1 $DIR/$tdir.remote"
15346                 verify_jobstats "$cmd" "mds2"
15347         fi
15348         # mknod
15349         cmd="mknod $DIR/$tfile c 1 3"
15350         verify_jobstats "$cmd" "$SINGLEMDS"
15351         # unlink
15352         cmd="rm -f $DIR/$tfile"
15353         verify_jobstats "$cmd" "$SINGLEMDS"
15354         # create all files on OST0000 so verify_jobstats can find OST stats
15355         # open & close
15356         cmd="$LFS setstripe -i 0 -c 1 $DIR/$tfile"
15357         verify_jobstats "$cmd" "$SINGLEMDS"
15358         # setattr
15359         cmd="touch $DIR/$tfile"
15360         verify_jobstats "$cmd" "$SINGLEMDS ost1"
15361         # write
15362         cmd="dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 oflag=sync"
15363         verify_jobstats "$cmd" "ost1"
15364         # read
15365         cancel_lru_locks osc
15366         cmd="dd if=$DIR/$tfile of=/dev/null bs=1M count=1 iflag=direct"
15367         verify_jobstats "$cmd" "ost1"
15368         # truncate
15369         cmd="$TRUNCATE $DIR/$tfile 0"
15370         verify_jobstats "$cmd" "$SINGLEMDS ost1"
15371         # rename
15372         cmd="mv -f $DIR/$tfile $DIR/$tdir.rename"
15373         verify_jobstats "$cmd" "$SINGLEMDS"
15374         # jobstats expiry - sleep until old stats should be expired
15375         local left=$((new_interval + 5 - (SECONDS - start)))
15376         [ $left -ge 0 ] && wait_update_facet $SINGLEMDS \
15377                 "lctl get_param *.*.job_stats | grep -c 'job_id.*mkdir'" \
15378                         "0" $left
15379         cmd="mkdir $DIR/$tdir.expire"
15380         verify_jobstats "$cmd" "$SINGLEMDS"
15381         [ $(do_facet $SINGLEMDS lctl get_param *.*.job_stats |
15382             grep -c "job_id.*mkdir") -gt 1 ] && error "old jobstats not expired"
15383
15384         # Ensure that jobid are present in changelog (if supported by MDS)
15385         if [ $MDS1_VERSION -ge $(version_code 2.6.52) ];then
15386                 changelog_dump | tail -10
15387                 jobids=$(changelog_dump | tail -9 | grep -c "j=")
15388                 [ $jobids -eq 9 ] ||
15389                         error "Wrong changelog jobid count $jobids != 9"
15390
15391                 # LU-5862
15392                 JOBENV="disable"
15393                 jobstats_set $JOBENV
15394                 touch $DIR/$tfile
15395                 changelog_dump | grep $tfile
15396                 jobids=$(changelog_dump | grep $tfile | tail -1 | grep -c "j=")
15397                 [ $jobids -eq 0 ] ||
15398                         error "Unexpected jobids when jobid_var=$JOBENV"
15399         fi
15400
15401         lctl set_param jobid_var=USER jobid_name="S.%j.%e.%u.%h.E"
15402         JOBENV="JOBCOMPLEX"
15403         JOBCOMPLEX="S.$USER.touch.$(id -u).$(hostname).E"
15404
15405         verify_jobstats "touch $DIR/$tfile" $SINGLEMDS
15406 }
15407 run_test 205 "Verify job stats"
15408
15409 # LU-1480, LU-1773 and LU-1657
15410 test_206() {
15411         mkdir -p $DIR/$tdir
15412         $LFS setstripe -c -1 $DIR/$tdir
15413 #define OBD_FAIL_LOV_INIT 0x1403
15414         $LCTL set_param fail_loc=0xa0001403
15415         $LCTL set_param fail_val=1
15416         touch $DIR/$tdir/$tfile || true
15417 }
15418 run_test 206 "fail lov_init_raid0() doesn't lbug"
15419
15420 test_207a() {
15421         dd if=/dev/zero of=$DIR/$tfile bs=4k count=$((RANDOM%10+1))
15422         local fsz=`stat -c %s $DIR/$tfile`
15423         cancel_lru_locks mdc
15424
15425         # do not return layout in getattr intent
15426 #define OBD_FAIL_MDS_NO_LL_GETATTR 0x170
15427         $LCTL set_param fail_loc=0x170
15428         local sz=`stat -c %s $DIR/$tfile`
15429
15430         [ $fsz -eq $sz ] || error "file size expected $fsz, actual $sz"
15431
15432         rm -rf $DIR/$tfile
15433 }
15434 run_test 207a "can refresh layout at glimpse"
15435
15436 test_207b() {
15437         dd if=/dev/zero of=$DIR/$tfile bs=4k count=$((RANDOM%10+1))
15438         local cksum=`md5sum $DIR/$tfile`
15439         local fsz=`stat -c %s $DIR/$tfile`
15440         cancel_lru_locks mdc
15441         cancel_lru_locks osc
15442
15443         # do not return layout in getattr intent
15444 #define OBD_FAIL_MDS_NO_LL_OPEN 0x171
15445         $LCTL set_param fail_loc=0x171
15446
15447         # it will refresh layout after the file is opened but before read issues
15448         echo checksum is "$cksum"
15449         echo "$cksum" |md5sum -c --quiet || error "file differs"
15450
15451         rm -rf $DIR/$tfile
15452 }
15453 run_test 207b "can refresh layout at open"
15454
15455 test_208() {
15456         # FIXME: in this test suite, only RD lease is used. This is okay
15457         # for now as only exclusive open is supported. After generic lease
15458         # is done, this test suite should be revised. - Jinshan
15459
15460         remote_mds_nodsh && skip "remote MDS with nodsh"
15461         [[ $MDS1_VERSION -ge $(version_code 2.4.52) ]] ||
15462                 skip "Need MDS version at least 2.4.52"
15463
15464         echo "==== test 1: verify get lease work"
15465         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:eRE+eU || error "get lease error"
15466
15467         echo "==== test 2: verify lease can be broken by upcoming open"
15468         $MULTIOP $DIR/$tfile oO_RDONLY:eR_E-eUc &
15469         local PID=$!
15470         sleep 1
15471
15472         $MULTIOP $DIR/$tfile oO_RDONLY:c
15473         kill -USR1 $PID && wait $PID || error "break lease error"
15474
15475         echo "==== test 3: verify lease can't be granted if an open already exists"
15476         $MULTIOP $DIR/$tfile oO_RDONLY:_c &
15477         local PID=$!
15478         sleep 1
15479
15480         $MULTIOP $DIR/$tfile oO_RDONLY:eReUc && error "apply lease should fail"
15481         kill -USR1 $PID && wait $PID || error "open file error"
15482
15483         echo "==== test 4: lease can sustain over recovery"
15484         $MULTIOP $DIR/$tfile oO_RDONLY:eR_E+eUc &
15485         PID=$!
15486         sleep 1
15487
15488         fail mds1
15489
15490         kill -USR1 $PID && wait $PID || error "lease broken over recovery"
15491
15492         echo "==== test 5: lease broken can't be regained by replay"
15493         $MULTIOP $DIR/$tfile oO_RDONLY:eR_E-eUc &
15494         PID=$!
15495         sleep 1
15496
15497         # open file to break lease and then recovery
15498         $MULTIOP $DIR/$tfile oO_RDWR:c || error "open file error"
15499         fail mds1
15500
15501         kill -USR1 $PID && wait $PID || error "lease not broken over recovery"
15502
15503         rm -f $DIR/$tfile
15504 }
15505 run_test 208 "Exclusive open"
15506
15507 test_209() {
15508         [ -z "$(lctl get_param -n mdc.*.connect_flags | grep disp_stripe)" ] &&
15509                 skip_env "must have disp_stripe"
15510
15511         touch $DIR/$tfile
15512         sync; sleep 5; sync;
15513
15514         echo 3 > /proc/sys/vm/drop_caches
15515         req_before=$(awk '/ptlrpc_cache / { print $2 }' /proc/slabinfo)
15516
15517         # open/close 500 times
15518         for i in $(seq 500); do
15519                 cat $DIR/$tfile
15520         done
15521
15522         echo 3 > /proc/sys/vm/drop_caches
15523         req_after=$(awk '/ptlrpc_cache / { print $2 }' /proc/slabinfo)
15524
15525         echo "before: $req_before, after: $req_after"
15526         [ $((req_after - req_before)) -ge 300 ] &&
15527                 error "open/close requests are not freed"
15528         return 0
15529 }
15530 run_test 209 "read-only open/close requests should be freed promptly"
15531
15532 test_212() {
15533         size=`date +%s`
15534         size=$((size % 8192 + 1))
15535         dd if=/dev/urandom of=$DIR/f212 bs=1k count=$size
15536         sendfile $DIR/f212 $DIR/f212.xyz || error "sendfile wrong"
15537         rm -f $DIR/f212 $DIR/f212.xyz
15538 }
15539 run_test 212 "Sendfile test ============================================"
15540
15541 test_213() {
15542         dd if=/dev/zero of=$DIR/$tfile bs=4k count=4
15543         cancel_lru_locks osc
15544         lctl set_param fail_loc=0x8000040f
15545         # generate a read lock
15546         cat $DIR/$tfile > /dev/null
15547         # write to the file, it will try to cancel the above read lock.
15548         cat /etc/hosts >> $DIR/$tfile
15549 }
15550 run_test 213 "OSC lock completion and cancel race don't crash - bug 18829"
15551
15552 test_214() { # for bug 20133
15553         mkdir -p $DIR/$tdir/d214c || error "mkdir $DIR/$tdir/d214c failed"
15554         for (( i=0; i < 340; i++ )) ; do
15555                 touch $DIR/$tdir/d214c/a$i
15556         done
15557
15558         ls -l $DIR/$tdir || error "ls -l $DIR/d214p failed"
15559         mv $DIR/$tdir/d214c $DIR/ || error "mv $DIR/d214p/d214c $DIR/ failed"
15560         ls $DIR/d214c || error "ls $DIR/d214c failed"
15561         rm -rf $DIR/$tdir || error "rm -rf $DIR/d214* failed"
15562         rm -rf $DIR/d214* || error "rm -rf $DIR/d214* failed"
15563 }
15564 run_test 214 "hash-indexed directory test - bug 20133"
15565
15566 # having "abc" as 1st arg, creates $TMP/lnet_abc.out and $TMP/lnet_abc.sys
15567 create_lnet_proc_files() {
15568         lctl get_param -n $1 >$TMP/lnet_$1.sys || error "cannot read lnet.$1"
15569 }
15570
15571 # counterpart of create_lnet_proc_files
15572 remove_lnet_proc_files() {
15573         rm -f $TMP/lnet_$1.sys
15574 }
15575
15576 # uses 1st arg as trailing part of filename, 2nd arg as description for reports,
15577 # 3rd arg as regexp for body
15578 check_lnet_proc_stats() {
15579         local l=$(cat "$TMP/lnet_$1" |wc -l)
15580         [ $l = 1 ] || (cat "$TMP/lnet_$1" && error "$2 is not of 1 line: $l")
15581
15582         grep -E "$3" "$TMP/lnet_$1" || (cat "$TMP/lnet_$1" && error "$2 misformatted")
15583 }
15584
15585 # uses 1st arg as trailing part of filename, 2nd arg as description for reports,
15586 # 3rd arg as regexp for body, 4th arg as regexp for 1st line, 5th arg is
15587 # optional and can be regexp for 2nd line (lnet.routes case)
15588 check_lnet_proc_entry() {
15589         local blp=2          # blp stands for 'position of 1st line of body'
15590         [ -z "$5" ] || blp=3 # lnet.routes case
15591
15592         local l=$(cat "$TMP/lnet_$1" |wc -l)
15593         # subtracting one from $blp because the body can be empty
15594         [ "$l" -ge "$(($blp - 1))" ] || (cat "$TMP/lnet_$1" && error "$2 is too short: $l")
15595
15596         sed -n '1 p' "$TMP/lnet_$1" |grep -E "$4" >/dev/null ||
15597                 (cat "$TMP/lnet_$1" && error "1st line of $2 misformatted")
15598
15599         [ "$5" = "" ] || sed -n '2 p' "$TMP/lnet_$1" |grep -E "$5" >/dev/null ||
15600                 (cat "$TMP/lnet_$1" && error "2nd line of $2 misformatted")
15601
15602         # bail out if any unexpected line happened
15603         sed -n "$blp p" "$TMP/lnet_$1" | grep -Ev "$3"
15604         [ "$?" != 0 ] || error "$2 misformatted"
15605 }
15606
15607 test_215() { # for bugs 18102, 21079, 21517
15608         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15609
15610         local N='(0|[1-9][0-9]*)'       # non-negative numeric
15611         local P='[1-9][0-9]*'           # positive numeric
15612         local I='(0|-?[1-9][0-9]*|NA)'  # any numeric (0 | >0 | <0) or NA if no value
15613         local NET='[a-z][a-z0-9]*'      # LNET net like o2ib2
15614         local ADDR='[0-9.]+'            # LNET addr like 10.0.0.1
15615         local NID="$ADDR@$NET"          # LNET nid like 10.0.0.1@o2ib2
15616
15617         local L1 # regexp for 1st line
15618         local L2 # regexp for 2nd line (optional)
15619         local BR # regexp for the rest (body)
15620
15621         # lnet.stats should look as 11 space-separated non-negative numerics
15622         BR="^$N $N $N $N $N $N $N $N $N $N $N$"
15623         create_lnet_proc_files "stats"
15624         check_lnet_proc_stats "stats.sys" "lnet.stats" "$BR"
15625         remove_lnet_proc_files "stats"
15626
15627         # lnet.routes should look like this:
15628         # Routing disabled/enabled
15629         # net hops priority state router
15630         # where net is a string like tcp0, hops > 0, priority >= 0,
15631         # state is up/down,
15632         # router is a string like 192.168.1.1@tcp2
15633         L1="^Routing (disabled|enabled)$"
15634         L2="^net +hops +priority +state +router$"
15635         BR="^$NET +$N +(0|1) +(up|down) +$NID$"
15636         create_lnet_proc_files "routes"
15637         check_lnet_proc_entry "routes.sys" "lnet.routes" "$BR" "$L1" "$L2"
15638         remove_lnet_proc_files "routes"
15639
15640         # lnet.routers should look like this:
15641         # ref rtr_ref alive_cnt state last_ping ping_sent deadline down_ni router
15642         # where ref > 0, rtr_ref > 0, alive_cnt >= 0, state is up/down,
15643         # last_ping >= 0, ping_sent is boolean (0/1), deadline and down_ni are
15644         # numeric (0 or >0 or <0), router is a string like 192.168.1.1@tcp2
15645         L1="^ref +rtr_ref +alive +router$"
15646         BR="^$P +$P +(up|down) +$NID$"
15647         create_lnet_proc_files "routers"
15648         check_lnet_proc_entry "routers.sys" "lnet.routers" "$BR" "$L1"
15649         remove_lnet_proc_files "routers"
15650
15651         # lnet.peers should look like this:
15652         # nid refs state last max rtr min tx min queue
15653         # where nid is a string like 192.168.1.1@tcp2, refs > 0,
15654         # state is up/down/NA, max >= 0. last, rtr, min, tx, min are
15655         # numeric (0 or >0 or <0), queue >= 0.
15656         L1="^nid +refs +state +last +max +rtr +min +tx +min +queue$"
15657         BR="^$NID +$P +(up|down|NA) +$I +$N +$I +$I +$I +$I +$N$"
15658         create_lnet_proc_files "peers"
15659         check_lnet_proc_entry "peers.sys" "lnet.peers" "$BR" "$L1"
15660         remove_lnet_proc_files "peers"
15661
15662         # lnet.buffers  should look like this:
15663         # pages count credits min
15664         # where pages >=0, count >=0, credits and min are numeric (0 or >0 or <0)
15665         L1="^pages +count +credits +min$"
15666         BR="^ +$N +$N +$I +$I$"
15667         create_lnet_proc_files "buffers"
15668         check_lnet_proc_entry "buffers.sys" "lnet.buffers" "$BR" "$L1"
15669         remove_lnet_proc_files "buffers"
15670
15671         # lnet.nis should look like this:
15672         # nid status alive refs peer rtr max tx min
15673         # where nid is a string like 192.168.1.1@tcp2, status is up/down,
15674         # alive is numeric (0 or >0 or <0), refs >= 0, peer >= 0,
15675         # rtr >= 0, max >=0, tx and min are numeric (0 or >0 or <0).
15676         L1="^nid +status +alive +refs +peer +rtr +max +tx +min$"
15677         BR="^$NID +(up|down) +$I +$N +$N +$N +$N +$I +$I$"
15678         create_lnet_proc_files "nis"
15679         check_lnet_proc_entry "nis.sys" "lnet.nis" "$BR" "$L1"
15680         remove_lnet_proc_files "nis"
15681
15682         # can we successfully write to lnet.stats?
15683         lctl set_param -n stats=0 || error "cannot write to lnet.stats"
15684 }
15685 run_test 215 "lnet exists and has proper content - bugs 18102, 21079, 21517"
15686
15687 test_216() { # bug 20317
15688         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15689         remote_ost_nodsh && skip "remote OST with nodsh"
15690
15691         local node
15692         local facets=$(get_facets OST)
15693         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
15694
15695         save_lustre_params client "osc.*.contention_seconds" > $p
15696         save_lustre_params $facets \
15697                 "ldlm.namespaces.filter-*.max_nolock_bytes" >> $p
15698         save_lustre_params $facets \
15699                 "ldlm.namespaces.filter-*.contended_locks" >> $p
15700         save_lustre_params $facets \
15701                 "ldlm.namespaces.filter-*.contention_seconds" >> $p
15702         clear_stats osc.*.osc_stats
15703
15704         # agressive lockless i/o settings
15705         do_nodes $(comma_list $(osts_nodes)) \
15706                 "lctl set_param -n ldlm.namespaces.*.max_nolock_bytes=2000000 \
15707                         ldlm.namespaces.filter-*.contended_locks=0 \
15708                         ldlm.namespaces.filter-*.contention_seconds=60"
15709         lctl set_param -n osc.*.contention_seconds=60
15710
15711         $DIRECTIO write $DIR/$tfile 0 10 4096
15712         $CHECKSTAT -s 40960 $DIR/$tfile
15713
15714         # disable lockless i/o
15715         do_nodes $(comma_list $(osts_nodes)) \
15716                 "lctl set_param -n ldlm.namespaces.filter-*.max_nolock_bytes=0 \
15717                         ldlm.namespaces.filter-*.contended_locks=32 \
15718                         ldlm.namespaces.filter-*.contention_seconds=0"
15719         lctl set_param -n osc.*.contention_seconds=0
15720         clear_stats osc.*.osc_stats
15721
15722         dd if=/dev/zero of=$DIR/$tfile count=0
15723         $CHECKSTAT -s 0 $DIR/$tfile
15724
15725         restore_lustre_params <$p
15726         rm -f $p
15727         rm $DIR/$tfile
15728 }
15729 run_test 216 "check lockless direct write updates file size and kms correctly"
15730
15731 test_217() { # bug 22430
15732         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15733
15734         local node
15735         local nid
15736
15737         for node in $(nodes_list); do
15738                 nid=$(host_nids_address $node $NETTYPE)
15739                 if [[ $nid = *-* ]] ; then
15740                         echo "lctl ping $(h2nettype $nid)"
15741                         lctl ping $(h2nettype $nid)
15742                 else
15743                         echo "skipping $node (no hyphen detected)"
15744                 fi
15745         done
15746 }
15747 run_test 217 "check lctl ping for hostnames with hiphen ('-')"
15748
15749 test_218() {
15750        # do directio so as not to populate the page cache
15751        log "creating a 10 Mb file"
15752        $MULTIOP $DIR/$tfile oO_CREAT:O_DIRECT:O_RDWR:w$((10*1048576))c || error "multiop failed while creating a file"
15753        log "starting reads"
15754        dd if=$DIR/$tfile of=/dev/null bs=4096 &
15755        log "truncating the file"
15756        $MULTIOP $DIR/$tfile oO_TRUNC:c || error "multiop failed while truncating the file"
15757        log "killing dd"
15758        kill %+ || true # reads might have finished
15759        echo "wait until dd is finished"
15760        wait
15761        log "removing the temporary file"
15762        rm -rf $DIR/$tfile || error "tmp file removal failed"
15763 }
15764 run_test 218 "parallel read and truncate should not deadlock"
15765
15766 test_219() {
15767         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15768
15769         # write one partial page
15770         dd if=/dev/zero of=$DIR/$tfile bs=1024 count=1
15771         # set no grant so vvp_io_commit_write will do sync write
15772         $LCTL set_param fail_loc=0x411
15773         # write a full page at the end of file
15774         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 seek=1 conv=notrunc
15775
15776         $LCTL set_param fail_loc=0
15777         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 seek=3
15778         $LCTL set_param fail_loc=0x411
15779         dd if=/dev/zero of=$DIR/$tfile bs=1024 count=1 seek=2 conv=notrunc
15780
15781         # LU-4201
15782         dd if=/dev/zero of=$DIR/$tfile-2 bs=1024 count=1
15783         $CHECKSTAT -s 1024 $DIR/$tfile-2 || error "checkstat wrong size"
15784 }
15785 run_test 219 "LU-394: Write partial won't cause uncontiguous pages vec at LND"
15786
15787 test_220() { #LU-325
15788         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15789         remote_ost_nodsh && skip "remote OST with nodsh"
15790         remote_mds_nodsh && skip "remote MDS with nodsh"
15791         remote_mgs_nodsh && skip "remote MGS with nodsh"
15792
15793         local OSTIDX=0
15794
15795         # create on MDT0000 so the last_id and next_id are correct
15796         mkdir $DIR/$tdir
15797         local OST=$($LFS df $DIR | awk '/OST:'$OSTIDX'/ { print $1 }')
15798         OST=${OST%_UUID}
15799
15800         # on the mdt's osc
15801         local mdtosc_proc1=$(get_mdtosc_proc_path $SINGLEMDS $OST)
15802         local last_id=$(do_facet $SINGLEMDS lctl get_param -n \
15803                         osp.$mdtosc_proc1.prealloc_last_id)
15804         local next_id=$(do_facet $SINGLEMDS lctl get_param -n \
15805                         osp.$mdtosc_proc1.prealloc_next_id)
15806
15807         $LFS df -i
15808
15809         if ! combined_mgs_mds ; then
15810                 mount_mgs_client
15811         fi
15812
15813         do_facet ost$((OSTIDX + 1)) lctl set_param fail_val=-1
15814         #define OBD_FAIL_OST_ENOINO              0x229
15815         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=0x229
15816         create_pool $FSNAME.$TESTNAME || return 1
15817         do_facet mgs $LCTL pool_add $FSNAME.$TESTNAME $OST || return 2
15818
15819         $LFS setstripe $DIR/$tdir -i $OSTIDX -c 1 -p $FSNAME.$TESTNAME
15820
15821         MDSOBJS=$((last_id - next_id))
15822         echo "preallocated objects on MDS is $MDSOBJS" "($last_id - $next_id)"
15823
15824         blocks=$($LFS df $MOUNT | awk '($1 == '$OSTIDX') { print $4 }')
15825         echo "OST still has $count kbytes free"
15826
15827         echo "create $MDSOBJS files @next_id..."
15828         createmany -o $DIR/$tdir/f $MDSOBJS || return 3
15829
15830         local last_id2=$(do_facet mds${MDSIDX} lctl get_param -n \
15831                         osp.$mdtosc_proc1.prealloc_last_id)
15832         local next_id2=$(do_facet mds${MDSIDX} lctl get_param -n \
15833                         osp.$mdtosc_proc1.prealloc_next_id)
15834
15835         echo "after creation, last_id=$last_id2, next_id=$next_id2"
15836         $LFS df -i
15837
15838         echo "cleanup..."
15839
15840         do_facet ost$((OSTIDX + 1)) lctl set_param fail_val=0
15841         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=0
15842
15843         do_facet mgs $LCTL pool_remove $FSNAME.$TESTNAME $OST ||
15844                 error "$LCTL pool_remove $FSNAME.$TESTNAME $OST failed"
15845         do_facet mgs $LCTL pool_destroy $FSNAME.$TESTNAME ||
15846                 error "$LCTL pool_destroy $FSNAME.$TESTNAME failed"
15847         echo "unlink $MDSOBJS files @$next_id..."
15848         unlinkmany $DIR/$tdir/f $MDSOBJS || error "unlinkmany failed"
15849
15850         if ! combined_mgs_mds ; then
15851                 umount_mgs_client
15852         fi
15853 }
15854 run_test 220 "preallocated MDS objects still used if ENOSPC from OST"
15855
15856 test_221() {
15857         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15858
15859         dd if=`which date` of=$MOUNT/date oflag=sync
15860         chmod +x $MOUNT/date
15861
15862         #define OBD_FAIL_LLITE_FAULT_TRUNC_RACE  0x1401
15863         $LCTL set_param fail_loc=0x80001401
15864
15865         $MOUNT/date > /dev/null
15866         rm -f $MOUNT/date
15867 }
15868 run_test 221 "make sure fault and truncate race to not cause OOM"
15869
15870 test_222a () {
15871         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15872
15873         rm -rf $DIR/$tdir
15874         test_mkdir $DIR/$tdir
15875         $LFS setstripe -c 1 -i 0 $DIR/$tdir
15876         createmany -o $DIR/$tdir/$tfile 10
15877         cancel_lru_locks mdc
15878         cancel_lru_locks osc
15879         #define OBD_FAIL_LDLM_AGL_DELAY           0x31a
15880         $LCTL set_param fail_loc=0x31a
15881         ls -l $DIR/$tdir > /dev/null || error "AGL for ls failed"
15882         $LCTL set_param fail_loc=0
15883         rm -r $DIR/$tdir
15884 }
15885 run_test 222a "AGL for ls should not trigger CLIO lock failure"
15886
15887 test_222b () {
15888         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15889
15890         rm -rf $DIR/$tdir
15891         test_mkdir $DIR/$tdir
15892         $LFS setstripe -c 1 -i 0 $DIR/$tdir
15893         createmany -o $DIR/$tdir/$tfile 10
15894         cancel_lru_locks mdc
15895         cancel_lru_locks osc
15896         #define OBD_FAIL_LDLM_AGL_DELAY           0x31a
15897         $LCTL set_param fail_loc=0x31a
15898         rm -r $DIR/$tdir || error "AGL for rmdir failed"
15899         $LCTL set_param fail_loc=0
15900 }
15901 run_test 222b "AGL for rmdir should not trigger CLIO lock failure"
15902
15903 test_223 () {
15904         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15905
15906         rm -rf $DIR/$tdir
15907         test_mkdir $DIR/$tdir
15908         $LFS setstripe -c 1 -i 0 $DIR/$tdir
15909         createmany -o $DIR/$tdir/$tfile 10
15910         cancel_lru_locks mdc
15911         cancel_lru_locks osc
15912         #define OBD_FAIL_LDLM_AGL_NOLOCK          0x31b
15913         $LCTL set_param fail_loc=0x31b
15914         ls -l $DIR/$tdir > /dev/null || error "reenqueue failed"
15915         $LCTL set_param fail_loc=0
15916         rm -r $DIR/$tdir
15917 }
15918 run_test 223 "osc reenqueue if without AGL lock granted ======================="
15919
15920 test_224a() { # LU-1039, MRP-303
15921         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15922
15923         #define OBD_FAIL_PTLRPC_CLIENT_BULK_CB   0x508
15924         $LCTL set_param fail_loc=0x508
15925         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 conv=fsync
15926         $LCTL set_param fail_loc=0
15927         df $DIR
15928 }
15929 run_test 224a "Don't panic on bulk IO failure"
15930
15931 test_224b() { # LU-1039, MRP-303
15932         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15933
15934         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1
15935         cancel_lru_locks osc
15936         #define OBD_FAIL_PTLRPC_CLIENT_BULK_CB2   0x515
15937         $LCTL set_param fail_loc=0x515
15938         dd of=/dev/null if=$DIR/$tfile bs=4096 count=1
15939         $LCTL set_param fail_loc=0
15940         df $DIR
15941 }
15942 run_test 224b "Don't panic on bulk IO failure"
15943
15944 test_224c() { # LU-6441
15945         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15946         remote_mds_nodsh && skip "remote MDS with nodsh"
15947
15948         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
15949         save_writethrough $p
15950         set_cache writethrough on
15951
15952         local pages_per_rpc=$($LCTL get_param \
15953                                 osc.*.max_pages_per_rpc)
15954         local at_max=$($LCTL get_param -n at_max)
15955         local timeout=$($LCTL get_param -n timeout)
15956         local test_at="at_max"
15957         local param_at="$FSNAME.sys.at_max"
15958         local test_timeout="timeout"
15959         local param_timeout="$FSNAME.sys.timeout"
15960
15961         $LCTL set_param -n osc.*.max_pages_per_rpc=1024
15962
15963         set_persistent_param_and_check client "$test_at" "$param_at" 0
15964         set_persistent_param_and_check client "$test_timeout" "$param_timeout" 5
15965
15966         #define OBD_FAIL_PTLRPC_CLIENT_BULK_CB3 0x520
15967         do_facet ost1 "$LCTL set_param fail_loc=0x520"
15968         $LFS setstripe -c 1 -i 0 $DIR/$tfile
15969         dd if=/dev/zero of=$DIR/$tfile bs=8MB count=1
15970         sync
15971         do_facet ost1 "$LCTL set_param fail_loc=0"
15972
15973         set_persistent_param_and_check client "$test_at" "$param_at" $at_max
15974         set_persistent_param_and_check client "$test_timeout" "$param_timeout" \
15975                 $timeout
15976
15977         $LCTL set_param -n $pages_per_rpc
15978         restore_lustre_params < $p
15979         rm -f $p
15980 }
15981 run_test 224c "Don't hang if one of md lost during large bulk RPC"
15982
15983 MDSSURVEY=${MDSSURVEY:-$(which mds-survey 2>/dev/null || true)}
15984 test_225a () {
15985         [ $PARALLEL == "yes" ] && skip "skip parallel run"
15986         if [ -z ${MDSSURVEY} ]; then
15987                 skip_env "mds-survey not found"
15988         fi
15989         [ $MDS1_VERSION -ge $(version_code 2.2.51) ] ||
15990                 skip "Need MDS version at least 2.2.51"
15991
15992         local mds=$(facet_host $SINGLEMDS)
15993         local target=$(do_nodes $mds 'lctl dl' |
15994                        awk '{ if ($2 == "UP" && $3 == "mdt") { print $4 }}')
15995
15996         local cmd1="file_count=1000 thrhi=4"
15997         local cmd2="dir_count=2 layer=mdd stripe_count=0"
15998         local cmd3="rslt_loc=${TMP} targets=\"$mds:$target\" $MDSSURVEY"
15999         local cmd="$cmd1 $cmd2 $cmd3"
16000
16001         rm -f ${TMP}/mds_survey*
16002         echo + $cmd
16003         eval $cmd || error "mds-survey with zero-stripe failed"
16004         cat ${TMP}/mds_survey*
16005         rm -f ${TMP}/mds_survey*
16006 }
16007 run_test 225a "Metadata survey sanity with zero-stripe"
16008
16009 test_225b () {
16010         if [ -z ${MDSSURVEY} ]; then
16011                 skip_env "mds-survey not found"
16012         fi
16013         [ $MDS1_VERSION -ge $(version_code 2.2.51) ] ||
16014                 skip "Need MDS version at least 2.2.51"
16015         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16016         remote_mds_nodsh && skip "remote MDS with nodsh"
16017         if [ $($LCTL dl | grep -c osc) -eq 0 ]; then
16018                 skip_env "Need to mount OST to test"
16019         fi
16020
16021         local mds=$(facet_host $SINGLEMDS)
16022         local target=$(do_nodes $mds 'lctl dl' |
16023                        awk '{ if ($2 == "UP" && $3 == "mdt") { print $4 }}')
16024
16025         local cmd1="file_count=1000 thrhi=4"
16026         local cmd2="dir_count=2 layer=mdd stripe_count=1"
16027         local cmd3="rslt_loc=${TMP} targets=\"$mds:$target\" $MDSSURVEY"
16028         local cmd="$cmd1 $cmd2 $cmd3"
16029
16030         rm -f ${TMP}/mds_survey*
16031         echo + $cmd
16032         eval $cmd || error "mds-survey with stripe_count failed"
16033         cat ${TMP}/mds_survey*
16034         rm -f ${TMP}/mds_survey*
16035 }
16036 run_test 225b "Metadata survey sanity with stripe_count = 1"
16037
16038 mcreate_path2fid () {
16039         local mode=$1
16040         local major=$2
16041         local minor=$3
16042         local name=$4
16043         local desc=$5
16044         local path=$DIR/$tdir/$name
16045         local fid
16046         local rc
16047         local fid_path
16048
16049         $MCREATE --mode=$1 --major=$2 --minor=$3 $path ||
16050                 error "cannot create $desc"
16051
16052         fid=$($LFS path2fid $path | tr -d '[' | tr -d ']')
16053         rc=$?
16054         [ $rc -ne 0 ] && error "cannot get fid of a $desc"
16055
16056         fid_path=$($LFS fid2path $MOUNT $fid)
16057         rc=$?
16058         [ $rc -ne 0 ] && error "cannot get path of $desc by $DIR $path $fid"
16059
16060         [ "$path" == "$fid_path" ] ||
16061                 error "fid2path returned $fid_path, expected $path"
16062
16063         echo "pass with $path and $fid"
16064 }
16065
16066 test_226a () {
16067         rm -rf $DIR/$tdir
16068         mkdir -p $DIR/$tdir
16069
16070         mcreate_path2fid 0010666 0 0 fifo "FIFO"
16071         mcreate_path2fid 0020666 1 3 null "character special file (null)"
16072         mcreate_path2fid 0020666 1 255 none "character special file (no device)"
16073         mcreate_path2fid 0040666 0 0 dir "directory"
16074         mcreate_path2fid 0060666 7 0 loop0 "block special file (loop)"
16075         mcreate_path2fid 0100666 0 0 file "regular file"
16076         mcreate_path2fid 0120666 0 0 link "symbolic link"
16077         mcreate_path2fid 0140666 0 0 sock "socket"
16078 }
16079 run_test 226a "call path2fid and fid2path on files of all type"
16080
16081 test_226b () {
16082         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16083
16084         local MDTIDX=1
16085
16086         rm -rf $DIR/$tdir
16087         mkdir -p $DIR/$tdir
16088         $LFS setdirstripe -i $MDTIDX $DIR/$tdir/remote_dir ||
16089                 error "create remote directory failed"
16090         mcreate_path2fid 0010666 0 0 "remote_dir/fifo" "FIFO"
16091         mcreate_path2fid 0020666 1 3 "remote_dir/null" \
16092                                 "character special file (null)"
16093         mcreate_path2fid 0020666 1 255 "remote_dir/none" \
16094                                 "character special file (no device)"
16095         mcreate_path2fid 0040666 0 0 "remote_dir/dir" "directory"
16096         mcreate_path2fid 0060666 7 0 "remote_dir/loop0" \
16097                                 "block special file (loop)"
16098         mcreate_path2fid 0100666 0 0 "remote_dir/file" "regular file"
16099         mcreate_path2fid 0120666 0 0 "remote_dir/link" "symbolic link"
16100         mcreate_path2fid 0140666 0 0 "remote_dir/sock" "socket"
16101 }
16102 run_test 226b "call path2fid and fid2path on files of all type under remote dir"
16103
16104 # LU-1299 Executing or running ldd on a truncated executable does not
16105 # cause an out-of-memory condition.
16106 test_227() {
16107         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16108         [ -z "$(which ldd)" ] && skip_env "should have ldd tool"
16109
16110         dd if=$(which date) of=$MOUNT/date bs=1k count=1
16111         chmod +x $MOUNT/date
16112
16113         $MOUNT/date > /dev/null
16114         ldd $MOUNT/date > /dev/null
16115         rm -f $MOUNT/date
16116 }
16117 run_test 227 "running truncated executable does not cause OOM"
16118
16119 # LU-1512 try to reuse idle OI blocks
16120 test_228a() {
16121         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16122         remote_mds_nodsh && skip "remote MDS with nodsh"
16123         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip_env "ldiskfs only test"
16124
16125         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
16126         local myDIR=$DIR/$tdir
16127
16128         mkdir -p $myDIR
16129         #define OBD_FAIL_SEQ_EXHAUST             0x1002
16130         $LCTL set_param fail_loc=0x80001002
16131         createmany -o $myDIR/t- 10000
16132         $LCTL set_param fail_loc=0
16133         # The guard is current the largest FID holder
16134         touch $myDIR/guard
16135         local SEQ=$($LFS path2fid $myDIR/guard | awk -F ':' '{print $1}' |
16136                     tr -d '[')
16137         local IDX=$(($SEQ % 64))
16138
16139         do_facet $SINGLEMDS sync
16140         # Make sure journal flushed.
16141         sleep 6
16142         local blk1=$(do_facet $SINGLEMDS \
16143                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
16144                      grep Blockcount | awk '{print $4}')
16145
16146         # Remove old files, some OI blocks will become idle.
16147         unlinkmany $myDIR/t- 10000
16148         # Create new files, idle OI blocks should be reused.
16149         createmany -o $myDIR/t- 2000
16150         do_facet $SINGLEMDS sync
16151         # Make sure journal flushed.
16152         sleep 6
16153         local blk2=$(do_facet $SINGLEMDS \
16154                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
16155                      grep Blockcount | awk '{print $4}')
16156
16157         [ $blk1 == $blk2 ] || error "old blk1=$blk1, new blk2=$blk2, unmatched!"
16158 }
16159 run_test 228a "try to reuse idle OI blocks"
16160
16161 test_228b() {
16162         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16163         remote_mds_nodsh && skip "remote MDS with nodsh"
16164         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip_env "ldiskfs only test"
16165
16166         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
16167         local myDIR=$DIR/$tdir
16168
16169         mkdir -p $myDIR
16170         #define OBD_FAIL_SEQ_EXHAUST             0x1002
16171         $LCTL set_param fail_loc=0x80001002
16172         createmany -o $myDIR/t- 10000
16173         $LCTL set_param fail_loc=0
16174         # The guard is current the largest FID holder
16175         touch $myDIR/guard
16176         local SEQ=$($LFS path2fid $myDIR/guard | awk -F ':' '{print $1}' |
16177                     tr -d '[')
16178         local IDX=$(($SEQ % 64))
16179
16180         do_facet $SINGLEMDS sync
16181         # Make sure journal flushed.
16182         sleep 6
16183         local blk1=$(do_facet $SINGLEMDS \
16184                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
16185                      grep Blockcount | awk '{print $4}')
16186
16187         # Remove old files, some OI blocks will become idle.
16188         unlinkmany $myDIR/t- 10000
16189
16190         # stop the MDT
16191         stop $SINGLEMDS || error "Fail to stop MDT."
16192         # remount the MDT
16193         start $SINGLEMDS $MDT_DEV $MDS_MOUNT_OPTS || error "Fail to start MDT."
16194
16195         df $MOUNT || error "Fail to df."
16196         # Create new files, idle OI blocks should be reused.
16197         createmany -o $myDIR/t- 2000
16198         do_facet $SINGLEMDS sync
16199         # Make sure journal flushed.
16200         sleep 6
16201         local blk2=$(do_facet $SINGLEMDS \
16202                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
16203                      grep Blockcount | awk '{print $4}')
16204
16205         [ $blk1 == $blk2 ] || error "old blk1=$blk1, new blk2=$blk2, unmatched!"
16206 }
16207 run_test 228b "idle OI blocks can be reused after MDT restart"
16208
16209 #LU-1881
16210 test_228c() {
16211         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16212         remote_mds_nodsh && skip "remote MDS with nodsh"
16213         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip_env "ldiskfs only test"
16214
16215         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
16216         local myDIR=$DIR/$tdir
16217
16218         mkdir -p $myDIR
16219         #define OBD_FAIL_SEQ_EXHAUST             0x1002
16220         $LCTL set_param fail_loc=0x80001002
16221         # 20000 files can guarantee there are index nodes in the OI file
16222         createmany -o $myDIR/t- 20000
16223         $LCTL set_param fail_loc=0
16224         # The guard is current the largest FID holder
16225         touch $myDIR/guard
16226         local SEQ=$($LFS path2fid $myDIR/guard | awk -F ':' '{print $1}' |
16227                     tr -d '[')
16228         local IDX=$(($SEQ % 64))
16229
16230         do_facet $SINGLEMDS sync
16231         # Make sure journal flushed.
16232         sleep 6
16233         local blk1=$(do_facet $SINGLEMDS \
16234                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
16235                      grep Blockcount | awk '{print $4}')
16236
16237         # Remove old files, some OI blocks will become idle.
16238         unlinkmany $myDIR/t- 20000
16239         rm -f $myDIR/guard
16240         # The OI file should become empty now
16241
16242         # Create new files, idle OI blocks should be reused.
16243         createmany -o $myDIR/t- 2000
16244         do_facet $SINGLEMDS sync
16245         # Make sure journal flushed.
16246         sleep 6
16247         local blk2=$(do_facet $SINGLEMDS \
16248                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
16249                      grep Blockcount | awk '{print $4}')
16250
16251         [ $blk1 == $blk2 ] || error "old blk1=$blk1, new blk2=$blk2, unmatched!"
16252 }
16253 run_test 228c "NOT shrink the last entry in OI index node to recycle idle leaf"
16254
16255 test_229() { # LU-2482, LU-3448
16256         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16257         [ $OSTCOUNT -lt 2 ] && skip_env "needs >= 2 OSTs"
16258         [ $MDS1_VERSION -lt $(version_code 2.4.53) ] &&
16259                 skip "No HSM $(lustre_build_version $SINGLEMDS) MDS < 2.4.53"
16260
16261         rm -f $DIR/$tfile
16262
16263         # Create a file with a released layout and stripe count 2.
16264         $MULTIOP $DIR/$tfile H2c ||
16265                 error "failed to create file with released layout"
16266
16267         $LFS getstripe -v $DIR/$tfile
16268
16269         local pattern=$($LFS getstripe -L $DIR/$tfile)
16270         [ X"$pattern" = X"released" ] || error "pattern error ($pattern)"
16271
16272         local stripe_count=$($LFS getstripe -c $DIR/$tfile) ||
16273                 error "getstripe"
16274         [ $stripe_count -eq 2 ] || error "stripe count not 2 ($stripe_count)"
16275         stat $DIR/$tfile || error "failed to stat released file"
16276
16277         chown $RUNAS_ID $DIR/$tfile ||
16278                 error "chown $RUNAS_ID $DIR/$tfile failed"
16279
16280         chgrp $RUNAS_ID $DIR/$tfile ||
16281                 error "chgrp $RUNAS_ID $DIR/$tfile failed"
16282
16283         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
16284         rm $DIR/$tfile || error "failed to remove released file"
16285 }
16286 run_test 229 "getstripe/stat/rm/attr changes work on released files"
16287
16288 test_230a() {
16289         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16290         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16291         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16292                 skip "Need MDS version at least 2.11.52"
16293
16294         local MDTIDX=1
16295
16296         test_mkdir $DIR/$tdir
16297         test_mkdir -i0 -c1 $DIR/$tdir/test_230_local
16298         local mdt_idx=$($LFS getstripe -m $DIR/$tdir/test_230_local)
16299         [ $mdt_idx -ne 0 ] &&
16300                 error "create local directory on wrong MDT $mdt_idx"
16301
16302         $LFS mkdir -i $MDTIDX $DIR/$tdir/test_230 ||
16303                         error "create remote directory failed"
16304         local mdt_idx=$($LFS getstripe -m $DIR/$tdir/test_230)
16305         [ $mdt_idx -ne $MDTIDX ] &&
16306                 error "create remote directory on wrong MDT $mdt_idx"
16307
16308         createmany -o $DIR/$tdir/test_230/t- 10 ||
16309                 error "create files on remote directory failed"
16310         mdt_idx=$($LFS getstripe -m $DIR/$tdir/test_230/t-0)
16311         [ $mdt_idx -ne $MDTIDX ] && error "create files on wrong MDT $mdt_idx"
16312         rm -r $DIR/$tdir || error "unlink remote directory failed"
16313 }
16314 run_test 230a "Create remote directory and files under the remote directory"
16315
16316 test_230b() {
16317         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16318         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16319         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16320                 skip "Need MDS version at least 2.11.52"
16321
16322         local MDTIDX=1
16323         local mdt_index
16324         local i
16325         local file
16326         local pid
16327         local stripe_count
16328         local migrate_dir=$DIR/$tdir/migrate_dir
16329         local other_dir=$DIR/$tdir/other_dir
16330
16331         test_mkdir $DIR/$tdir
16332         test_mkdir -i0 -c1 $migrate_dir
16333         test_mkdir -i0 -c1 $other_dir
16334         for ((i=0; i<10; i++)); do
16335                 mkdir -p $migrate_dir/dir_${i}
16336                 createmany -o $migrate_dir/dir_${i}/f 10 ||
16337                         error "create files under remote dir failed $i"
16338         done
16339
16340         cp /etc/passwd $migrate_dir/$tfile
16341         cp /etc/passwd $other_dir/$tfile
16342         chattr +SAD $migrate_dir
16343         chattr +SAD $migrate_dir/$tfile
16344
16345         local old_dir_flag=$(lsattr -a $migrate_dir | awk '/\/\.$/ {print $1}')
16346         local old_file_flag=$(lsattr $migrate_dir/$tfile | awk '{print $1}')
16347         local old_dir_mode=$(stat -c%f $migrate_dir)
16348         local old_file_mode=$(stat -c%f $migrate_dir/$tfile)
16349
16350         mkdir -p $migrate_dir/dir_default_stripe2
16351         $LFS setstripe -c 2 $migrate_dir/dir_default_stripe2
16352         $LFS setstripe -c 2 $migrate_dir/${tfile}_stripe2
16353
16354         mkdir -p $other_dir
16355         ln $migrate_dir/$tfile $other_dir/luna
16356         ln $migrate_dir/$tfile $migrate_dir/sofia
16357         ln $other_dir/$tfile $migrate_dir/david
16358         ln -s $migrate_dir/$tfile $other_dir/zachary
16359         ln -s $migrate_dir/$tfile $migrate_dir/${tfile}_ln
16360         ln -s $other_dir/$tfile $migrate_dir/${tfile}_ln_other
16361
16362         $LFS migrate -m $MDTIDX $migrate_dir ||
16363                 error "fails on migrating remote dir to MDT1"
16364
16365         echo "migratate to MDT1, then checking.."
16366         for ((i = 0; i < 10; i++)); do
16367                 for file in $(find $migrate_dir/dir_${i}); do
16368                         mdt_index=$($LFS getstripe -m $file)
16369                         [ $mdt_index == $MDTIDX ] ||
16370                                 error "$file is not on MDT${MDTIDX}"
16371                 done
16372         done
16373
16374         # the multiple link file should still in MDT0
16375         mdt_index=$($LFS getstripe -m $migrate_dir/$tfile)
16376         [ $mdt_index == 0 ] ||
16377                 error "$file is not on MDT${MDTIDX}"
16378
16379         local new_dir_flag=$(lsattr -a $migrate_dir | awk '/\/\.$/ {print $1}')
16380         [ "$old_dir_flag" = "$new_dir_flag" ] ||
16381                 error " expect $old_dir_flag get $new_dir_flag"
16382
16383         local new_file_flag=$(lsattr $migrate_dir/$tfile | awk '{print $1}')
16384         [ "$old_file_flag" = "$new_file_flag" ] ||
16385                 error " expect $old_file_flag get $new_file_flag"
16386
16387         local new_dir_mode=$(stat -c%f $migrate_dir)
16388         [ "$old_dir_mode" = "$new_dir_mode" ] ||
16389                 error "expect mode $old_dir_mode get $new_dir_mode"
16390
16391         local new_file_mode=$(stat -c%f $migrate_dir/$tfile)
16392         [ "$old_file_mode" = "$new_file_mode" ] ||
16393                 error "expect mode $old_file_mode get $new_file_mode"
16394
16395         diff /etc/passwd $migrate_dir/$tfile ||
16396                 error "$tfile different after migration"
16397
16398         diff /etc/passwd $other_dir/luna ||
16399                 error "luna different after migration"
16400
16401         diff /etc/passwd $migrate_dir/sofia ||
16402                 error "sofia different after migration"
16403
16404         diff /etc/passwd $migrate_dir/david ||
16405                 error "david different after migration"
16406
16407         diff /etc/passwd $other_dir/zachary ||
16408                 error "zachary different after migration"
16409
16410         diff /etc/passwd $migrate_dir/${tfile}_ln ||
16411                 error "${tfile}_ln different after migration"
16412
16413         diff /etc/passwd $migrate_dir/${tfile}_ln_other ||
16414                 error "${tfile}_ln_other different after migration"
16415
16416         stripe_count=$($LFS getstripe -c $migrate_dir/dir_default_stripe2)
16417         [ $stripe_count = 2 ] ||
16418                 error "dir strpe_count $d != 2 after migration."
16419
16420         stripe_count=$($LFS getstripe -c $migrate_dir/${tfile}_stripe2)
16421         [ $stripe_count = 2 ] ||
16422                 error "file strpe_count $d != 2 after migration."
16423
16424         #migrate back to MDT0
16425         MDTIDX=0
16426
16427         $LFS migrate -m $MDTIDX $migrate_dir ||
16428                 error "fails on migrating remote dir to MDT0"
16429
16430         echo "migrate back to MDT0, checking.."
16431         for file in $(find $migrate_dir); do
16432                 mdt_index=$($LFS getstripe -m $file)
16433                 [ $mdt_index == $MDTIDX ] ||
16434                         error "$file is not on MDT${MDTIDX}"
16435         done
16436
16437         local new_dir_flag=$(lsattr -a $migrate_dir | awk '/\/\.$/ {print $1}')
16438         [ "$old_dir_flag" = "$new_dir_flag" ] ||
16439                 error " expect $old_dir_flag get $new_dir_flag"
16440
16441         local new_file_flag=$(lsattr $migrate_dir/$tfile | awk '{print $1}')
16442         [ "$old_file_flag" = "$new_file_flag" ] ||
16443                 error " expect $old_file_flag get $new_file_flag"
16444
16445         local new_dir_mode=$(stat -c%f $migrate_dir)
16446         [ "$old_dir_mode" = "$new_dir_mode" ] ||
16447                 error "expect mode $old_dir_mode get $new_dir_mode"
16448
16449         local new_file_mode=$(stat -c%f $migrate_dir/$tfile)
16450         [ "$old_file_mode" = "$new_file_mode" ] ||
16451                 error "expect mode $old_file_mode get $new_file_mode"
16452
16453         diff /etc/passwd ${migrate_dir}/$tfile ||
16454                 error "$tfile different after migration"
16455
16456         diff /etc/passwd ${other_dir}/luna ||
16457                 error "luna different after migration"
16458
16459         diff /etc/passwd ${migrate_dir}/sofia ||
16460                 error "sofia different after migration"
16461
16462         diff /etc/passwd ${other_dir}/zachary ||
16463                 error "zachary different after migration"
16464
16465         diff /etc/passwd $migrate_dir/${tfile}_ln ||
16466                 error "${tfile}_ln different after migration"
16467
16468         diff /etc/passwd $migrate_dir/${tfile}_ln_other ||
16469                 error "${tfile}_ln_other different after migration"
16470
16471         stripe_count=$($LFS getstripe -c ${migrate_dir}/dir_default_stripe2)
16472         [ $stripe_count = 2 ] ||
16473                 error "dir strpe_count $d != 2 after migration."
16474
16475         stripe_count=$($LFS getstripe -c ${migrate_dir}/${tfile}_stripe2)
16476         [ $stripe_count = 2 ] ||
16477                 error "file strpe_count $d != 2 after migration."
16478
16479         rm -rf $DIR/$tdir || error "rm dir failed after migration"
16480 }
16481 run_test 230b "migrate directory"
16482
16483 test_230c() {
16484         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16485         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16486         remote_mds_nodsh && skip "remote MDS with nodsh"
16487         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16488                 skip "Need MDS version at least 2.11.52"
16489
16490         local MDTIDX=1
16491         local total=3
16492         local mdt_index
16493         local file
16494         local migrate_dir=$DIR/$tdir/migrate_dir
16495
16496         #If migrating directory fails in the middle, all entries of
16497         #the directory is still accessiable.
16498         test_mkdir $DIR/$tdir
16499         test_mkdir -i0 -c1 $migrate_dir
16500         test_mkdir -i1 -c1 $DIR/$tdir/remote_dir
16501         stat $migrate_dir
16502         createmany -o $migrate_dir/f $total ||
16503                 error "create files under ${migrate_dir} failed"
16504
16505         # fail after migrating top dir, and this will fail only once, so the
16506         # first sub file migration will fail (currently f3), others succeed.
16507         #OBD_FAIL_MIGRATE_ENTRIES       0x1801
16508         do_facet mds1 lctl set_param fail_loc=0x1801
16509         local t=$(ls $migrate_dir | wc -l)
16510         $LFS migrate --mdt-index $MDTIDX $migrate_dir &&
16511                 error "migrate should fail"
16512         local u=$(ls $migrate_dir | wc -l)
16513         [ "$u" == "$t" ] || error "$u != $t during migration"
16514
16515         # add new dir/file should succeed
16516         mkdir $migrate_dir/dir ||
16517                 error "mkdir failed under migrating directory"
16518         touch $migrate_dir/file ||
16519                 error "create file failed under migrating directory"
16520
16521         # add file with existing name should fail
16522         for file in $migrate_dir/f*; do
16523                 stat $file > /dev/null || error "stat $file failed"
16524                 $OPENFILE -f O_CREAT:O_EXCL $file &&
16525                         error "open(O_CREAT|O_EXCL) $file should fail"
16526                 $MULTIOP $file m && error "create $file should fail"
16527                 touch $DIR/$tdir/remote_dir/$tfile ||
16528                         error "touch $tfile failed"
16529                 ln $DIR/$tdir/remote_dir/$tfile $file &&
16530                         error "link $file should fail"
16531                 mdt_index=$($LFS getstripe -m $file)
16532                 if [ $mdt_index == 0 ]; then
16533                         # file failed to migrate is not allowed to rename to
16534                         mv $DIR/$tdir/remote_dir/$tfile $file &&
16535                                 error "rename to $file should fail"
16536                 else
16537                         mv $DIR/$tdir/remote_dir/$tfile $file ||
16538                                 error "rename to $file failed"
16539                 fi
16540                 echo hello >> $file || error "write $file failed"
16541         done
16542
16543         # resume migration with different options should fail
16544         $LFS migrate -m 0 $migrate_dir &&
16545                 error "migrate -m 0 $migrate_dir should fail"
16546
16547         $LFS migrate -m $MDTIDX -c 2 $migrate_dir &&
16548                 error "migrate -c 2 $migrate_dir should fail"
16549
16550         # resume migration should succeed
16551         $LFS migrate -m $MDTIDX $migrate_dir ||
16552                 error "migrate $migrate_dir failed"
16553
16554         echo "Finish migration, then checking.."
16555         for file in $(find $migrate_dir); do
16556                 mdt_index=$($LFS getstripe -m $file)
16557                 [ $mdt_index == $MDTIDX ] ||
16558                         error "$file is not on MDT${MDTIDX}"
16559         done
16560
16561         rm -rf $DIR/$tdir || error "rm dir failed after migration"
16562 }
16563 run_test 230c "check directory accessiblity if migration failed"
16564
16565 test_230d() {
16566         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16567         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16568         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16569                 skip "Need MDS version at least 2.11.52"
16570         # LU-11235
16571         [ "$mds1_FSTYPE" == "zfs" ] && skip "skip ZFS backend"
16572
16573         local migrate_dir=$DIR/$tdir/migrate_dir
16574         local old_index
16575         local new_index
16576         local old_count
16577         local new_count
16578         local new_hash
16579         local mdt_index
16580         local i
16581         local j
16582
16583         old_index=$((RANDOM % MDSCOUNT))
16584         old_count=$((MDSCOUNT - old_index))
16585         new_index=$((RANDOM % MDSCOUNT))
16586         new_count=$((MDSCOUNT - new_index))
16587         new_hash="all_char"
16588
16589         [ $old_count -gt 1 ] && old_count=$((old_count - RANDOM % old_count))
16590         [ $new_count -gt 1 ] && new_count=$((new_count - RANDOM % new_count))
16591
16592         test_mkdir $DIR/$tdir
16593         test_mkdir -i $old_index -c $old_count $migrate_dir
16594
16595         for ((i=0; i<100; i++)); do
16596                 test_mkdir -i0 -c1 $migrate_dir/dir_${i}
16597                 createmany -o $migrate_dir/dir_${i}/f 100 ||
16598                         error "create files under remote dir failed $i"
16599         done
16600
16601         echo -n "Migrate from MDT$old_index "
16602         [ $old_count -gt 1 ] && echo -n "... MDT$((old_index + old_count - 1)) "
16603         echo -n "to MDT$new_index"
16604         [ $new_count -gt 1 ] && echo -n " ... MDT$((new_index + new_count - 1))"
16605         echo
16606
16607         echo "$LFS migrate -m$new_index -c$new_count -H $new_hash $migrate_dir"
16608         $LFS migrate -m $new_index -c $new_count -H $new_hash $migrate_dir ||
16609                 error "migrate remote dir error"
16610
16611         echo "Finish migration, then checking.."
16612         for file in $(find $migrate_dir); do
16613                 mdt_index=$($LFS getstripe -m $file)
16614                 if [ $mdt_index -lt $new_index ] ||
16615                    [ $mdt_index -gt $((new_index + new_count - 1)) ]; then
16616                         error "$file is on MDT$mdt_index"
16617                 fi
16618         done
16619
16620         rm -rf $DIR/$tdir || error "rm dir failed after migration"
16621 }
16622 run_test 230d "check migrate big directory"
16623
16624 test_230e() {
16625         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16626         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16627         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16628                 skip "Need MDS version at least 2.11.52"
16629
16630         local i
16631         local j
16632         local a_fid
16633         local b_fid
16634
16635         mkdir -p $DIR/$tdir
16636         mkdir $DIR/$tdir/migrate_dir
16637         mkdir $DIR/$tdir/other_dir
16638         touch $DIR/$tdir/migrate_dir/a
16639         ln $DIR/$tdir/migrate_dir/a $DIR/$tdir/other_dir/b
16640         ls $DIR/$tdir/other_dir
16641
16642         $LFS migrate -m 1 $DIR/$tdir/migrate_dir ||
16643                 error "migrate dir fails"
16644
16645         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir)
16646         [ $mdt_index == 1 ] || error "migrate_dir is not on MDT1"
16647
16648         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir/a)
16649         [ $mdt_index == 0 ] || error "a is not on MDT0"
16650
16651         $LFS migrate -m 1 $DIR/$tdir/other_dir ||
16652                 error "migrate dir fails"
16653
16654         mdt_index=$($LFS getstripe -m $DIR/$tdir/other_dir)
16655         [ $mdt_index == 1 ] || error "other_dir is not on MDT1"
16656
16657         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir/a)
16658         [ $mdt_index == 1 ] || error "a is not on MDT1"
16659
16660         mdt_index=$($LFS getstripe -m $DIR/$tdir/other_dir/b)
16661         [ $mdt_index == 1 ] || error "b is not on MDT1"
16662
16663         a_fid=$($LFS path2fid $DIR/$tdir/migrate_dir/a)
16664         b_fid=$($LFS path2fid $DIR/$tdir/other_dir/b)
16665
16666         [ "$a_fid" = "$b_fid" ] || error "different fid after migration"
16667
16668         rm -rf $DIR/$tdir || error "rm dir failed after migration"
16669 }
16670 run_test 230e "migrate mulitple local link files"
16671
16672 test_230f() {
16673         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16674         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16675         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16676                 skip "Need MDS version at least 2.11.52"
16677
16678         local a_fid
16679         local ln_fid
16680
16681         mkdir -p $DIR/$tdir
16682         mkdir $DIR/$tdir/migrate_dir
16683         $LFS mkdir -i1 $DIR/$tdir/other_dir
16684         touch $DIR/$tdir/migrate_dir/a
16685         ln $DIR/$tdir/migrate_dir/a $DIR/$tdir/other_dir/ln1
16686         ln $DIR/$tdir/migrate_dir/a $DIR/$tdir/other_dir/ln2
16687         ls $DIR/$tdir/other_dir
16688
16689         # a should be migrated to MDT1, since no other links on MDT0
16690         $LFS migrate -m 1 $DIR/$tdir/migrate_dir ||
16691                 error "#1 migrate dir fails"
16692         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir)
16693         [ $mdt_index == 1 ] || error "migrate_dir is not on MDT1"
16694         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir/a)
16695         [ $mdt_index == 1 ] || error "a is not on MDT1"
16696
16697         # a should stay on MDT1, because it is a mulitple link file
16698         $LFS migrate -m 0 $DIR/$tdir/migrate_dir ||
16699                 error "#2 migrate dir fails"
16700         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir/a)
16701         [ $mdt_index == 1 ] || error "a is not on MDT1"
16702
16703         $LFS migrate -m 1 $DIR/$tdir/migrate_dir ||
16704                 error "#3 migrate dir fails"
16705
16706         a_fid=$($LFS path2fid $DIR/$tdir/migrate_dir/a)
16707         ln_fid=$($LFS path2fid $DIR/$tdir/other_dir/ln1)
16708         [ "$a_fid" = "$ln_fid" ] || error "different fid after migrate to MDT1"
16709
16710         rm -rf $DIR/$tdir/other_dir/ln1 || error "unlink ln1 fails"
16711         rm -rf $DIR/$tdir/other_dir/ln2 || error "unlink ln2 fails"
16712
16713         # a should be migrated to MDT0, since no other links on MDT1
16714         $LFS migrate -m 0 $DIR/$tdir/migrate_dir ||
16715                 error "#4 migrate dir fails"
16716         mdt_index=$($LFS getstripe -m $DIR/$tdir/migrate_dir/a)
16717         [ $mdt_index == 0 ] || error "a is not on MDT0"
16718
16719         rm -rf $DIR/$tdir || error "rm dir failed after migration"
16720 }
16721 run_test 230f "migrate mulitple remote link files"
16722
16723 test_230g() {
16724         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16725         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16726         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16727                 skip "Need MDS version at least 2.11.52"
16728
16729         mkdir -p $DIR/$tdir/migrate_dir
16730
16731         $LFS migrate -m 1000 $DIR/$tdir/migrate_dir &&
16732                 error "migrating dir to non-exist MDT succeeds"
16733         true
16734 }
16735 run_test 230g "migrate dir to non-exist MDT"
16736
16737 test_230h() {
16738         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16739         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16740         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16741                 skip "Need MDS version at least 2.11.52"
16742
16743         local mdt_index
16744
16745         mkdir -p $DIR/$tdir/migrate_dir
16746
16747         $LFS migrate -m1 $DIR &&
16748                 error "migrating mountpoint1 should fail"
16749
16750         $LFS migrate -m1 $DIR/$tdir/.. &&
16751                 error "migrating mountpoint2 should fail"
16752
16753         # same as mv
16754         $LFS migrate -m1 $DIR/$tdir/migrate_dir/.. &&
16755                 error "migrating $tdir/migrate_dir/.. should fail"
16756
16757         true
16758 }
16759 run_test 230h "migrate .. and root"
16760
16761 test_230i() {
16762         [ $PARALLEL == "yes" ] && skip "skip parallel run"
16763         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
16764         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16765                 skip "Need MDS version at least 2.11.52"
16766
16767         mkdir -p $DIR/$tdir/migrate_dir
16768
16769         $LFS migrate -m 1 $DIR/$tdir/migrate_dir/ ||
16770                 error "migration fails with a tailing slash"
16771
16772         $LFS migrate -m 0 $DIR/$tdir/migrate_dir// ||
16773                 error "migration fails with two tailing slashes"
16774 }
16775 run_test 230i "lfs migrate -m tolerates trailing slashes"
16776
16777 test_230j() {
16778         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
16779         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
16780                 skip "Need MDS version at least 2.11.52"
16781
16782         $LFS mkdir -m 0 -c 1 $DIR/$tdir || error "mkdir $tdir failed"
16783         $LFS setstripe -E 1M -L mdt $DIR/$tdir/$tfile ||
16784                 error "create $tfile failed"
16785         cat /etc/passwd > $DIR/$tdir/$tfile
16786
16787         $LFS migrate -m 1 $DIR/$tdir
16788
16789         cmp /etc/passwd $DIR/$tdir/$tfile ||
16790                 error "DoM file mismatch after migration"
16791 }
16792 run_test 230j "DoM file data not changed after dir migration"
16793
16794 test_230k() {
16795         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs"
16796         [ $MDS1_VERSION -lt $(version_code 2.11.56) ] &&
16797                 skip "Need MDS version at least 2.11.56"
16798
16799         local total=20
16800         local files_on_starting_mdt=0
16801
16802         $LFS mkdir -i -1 -c 2 $DIR/$tdir || error "mkdir failed"
16803         $LFS getdirstripe $DIR/$tdir
16804         for i in $(seq $total); do
16805                 echo $((i*i - i)) > $DIR/$tdir/$tfile.$i || error "write failed"
16806                 [[ $($LFS getstripe -m $DIR/$tdir/$tfile.$i) -eq 0 ]] &&
16807                         files_on_starting_mdt=$((files_on_starting_mdt + 1))
16808         done
16809
16810         echo "$files_on_starting_mdt files on MDT0"
16811
16812         $LFS migrate -m 1,3 $DIR/$tdir || error "migrate -m 1,3 failed"
16813         $LFS getdirstripe $DIR/$tdir
16814
16815         files_on_starting_mdt=0
16816         for i in $(seq $total); do
16817                 $(echo $((i*i - i)) | cmp $DIR/$tdir/$tfile.$i -) ||
16818                         error "file $tfile.$i mismatch after migration"
16819                 [[ $($LFS getstripe -m $DIR/$tdir/$tfile.$i) -eq 1 ]] &&
16820                         files_on_starting_mdt=$((files_on_starting_mdt + 1))
16821         done
16822
16823         echo "$files_on_starting_mdt files on MDT1 after migration"
16824         [[ $files_on_starting_mdt -eq $total ]] && error "all files on MDT1"
16825
16826         $LFS migrate -m 0 -c 2 $DIR/$tdir || error "migrate -m 0 -c 2 failed"
16827         $LFS getdirstripe $DIR/$tdir
16828
16829         files_on_starting_mdt=0
16830         for i in $(seq $total); do
16831                 $(echo $((i*i - i)) | cmp $DIR/$tdir/$tfile.$i -) ||
16832                         error "file $tfile.$i mismatch after 2nd migration"
16833                 [[ $($LFS getstripe -m $DIR/$tdir/$tfile.$i) -eq 0 ]] &&
16834                         files_on_starting_mdt=$((files_on_starting_mdt + 1))
16835         done
16836
16837         echo "$files_on_starting_mdt files on MDT0 after 2nd migration"
16838         [[ $files_on_starting_mdt -eq $total ]] && error "all files on MDT0"
16839
16840         true
16841 }
16842 run_test 230k "file data not changed after dir migration"
16843
16844 test_230l() {
16845         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
16846         [ $MDS1_VERSION -lt $(version_code 2.11.56) ] &&
16847                 skip "Need MDS version at least 2.11.56"
16848
16849         $LFS mkdir -i 0 -c 1 $DIR/$tdir || error "mkdir failed"
16850         createmany -o $DIR/$tdir/f___________________________________ 1000 ||
16851                 error "create files under remote dir failed $i"
16852         $LFS migrate -m 1 $DIR/$tdir || error "migrate failed"
16853 }
16854 run_test 230l "readdir between MDTs won't crash"
16855
16856 test_231a()
16857 {
16858         # For simplicity this test assumes that max_pages_per_rpc
16859         # is the same across all OSCs
16860         local max_pages=$($LCTL get_param -n osc.*.max_pages_per_rpc | head -n1)
16861         local bulk_size=$((max_pages * PAGE_SIZE))
16862         local brw_size=$(do_facet ost1 $LCTL get_param -n obdfilter.*.brw_size |
16863                                        head -n 1)
16864
16865         mkdir -p $DIR/$tdir
16866         $LFS setstripe -S ${brw_size}M $DIR/$tdir ||
16867                 error "failed to set stripe with -S ${brw_size}M option"
16868
16869         # clear the OSC stats
16870         $LCTL set_param osc.*.stats=0 &>/dev/null
16871         stop_writeback
16872
16873         # Client writes $bulk_size - there must be 1 rpc for $max_pages.
16874         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=$bulk_size count=1 \
16875                 oflag=direct &>/dev/null || error "dd failed"
16876
16877         sync; sleep 1; sync # just to be safe
16878         local nrpcs=$($LCTL get_param osc.*.stats |awk '/ost_write/ {print $2}')
16879         if [ x$nrpcs != "x1" ]; then
16880                 $LCTL get_param osc.*.stats
16881                 error "found $nrpcs ost_write RPCs, not 1 as expected"
16882         fi
16883
16884         start_writeback
16885         # Drop the OSC cache, otherwise we will read from it
16886         cancel_lru_locks osc
16887
16888         # clear the OSC stats
16889         $LCTL set_param osc.*.stats=0 &>/dev/null
16890
16891         # Client reads $bulk_size.
16892         dd if=$DIR/$tdir/$tfile of=/dev/null bs=$bulk_size count=1 \
16893                 iflag=direct &>/dev/null || error "dd failed"
16894
16895         nrpcs=$($LCTL get_param osc.*.stats | awk '/ost_read/ { print $2 }')
16896         if [ x$nrpcs != "x1" ]; then
16897                 $LCTL get_param osc.*.stats
16898                 error "found $nrpcs ost_read RPCs, not 1 as expected"
16899         fi
16900 }
16901 run_test 231a "checking that reading/writing of BRW RPC size results in one RPC"
16902
16903 test_231b() {
16904         mkdir -p $DIR/$tdir
16905         local i
16906         for i in {0..1023}; do
16907                 dd if=/dev/zero of=$DIR/$tdir/$tfile conv=notrunc \
16908                         seek=$((2 * i)) bs=4096 count=1 &>/dev/null ||
16909                         error "dd of=$DIR/$tdir/$tfile seek=$((2 * i)) failed"
16910         done
16911         sync
16912 }
16913 run_test 231b "must not assert on fully utilized OST request buffer"
16914
16915 test_232a() {
16916         mkdir -p $DIR/$tdir
16917         $LFS setstripe -c1 -i0 $DIR/$tdir/$tfile
16918
16919         #define OBD_FAIL_LDLM_OST_LVB            0x31c
16920         do_facet ost1 $LCTL set_param fail_loc=0x31c
16921
16922         # ignore dd failure
16923         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=1 || true
16924
16925         do_facet ost1 $LCTL set_param fail_loc=0
16926         umount_client $MOUNT || error "umount failed"
16927         mount_client $MOUNT || error "mount failed"
16928         stop ost1 || error "cannot stop ost1"
16929         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS || error "cannot start ost1"
16930 }
16931 run_test 232a "failed lock should not block umount"
16932
16933 test_232b() {
16934         [ $MDS1_VERSION -ge $(version_code 2.10.58) ] ||
16935                 skip "Need MDS version at least 2.10.58"
16936
16937         mkdir -p $DIR/$tdir
16938         $LFS setstripe -c1 -i0 $DIR/$tdir/$tfile
16939         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=1
16940         sync
16941         cancel_lru_locks osc
16942
16943         #define OBD_FAIL_LDLM_OST_LVB            0x31c
16944         do_facet ost1 $LCTL set_param fail_loc=0x31c
16945
16946         # ignore failure
16947         $LFS data_version $DIR/$tdir/$tfile || true
16948
16949         do_facet ost1 $LCTL set_param fail_loc=0
16950         umount_client $MOUNT || error "umount failed"
16951         mount_client $MOUNT || error "mount failed"
16952         stop ost1 || error "cannot stop ost1"
16953         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS || error "cannot start ost1"
16954 }
16955 run_test 232b "failed data version lock should not block umount"
16956
16957 test_233a() {
16958         [ $MDS1_VERSION -ge $(version_code 2.3.64) ] ||
16959                 skip "Need MDS version at least 2.3.64"
16960         [ -n "$FILESET" ] && skip_env "SKIP due to FILESET set"
16961
16962         local fid=$($LFS path2fid $MOUNT)
16963
16964         stat $MOUNT/.lustre/fid/$fid > /dev/null ||
16965                 error "cannot access $MOUNT using its FID '$fid'"
16966 }
16967 run_test 233a "checking that OBF of the FS root succeeds"
16968
16969 test_233b() {
16970         [ $MDS1_VERSION -ge $(version_code 2.5.90) ] ||
16971                 skip "Need MDS version at least 2.5.90"
16972         [ -n "$FILESET" ] && skip_env "SKIP due to FILESET set"
16973
16974         local fid=$($LFS path2fid $MOUNT/.lustre)
16975
16976         stat $MOUNT/.lustre/fid/$fid > /dev/null ||
16977                 error "cannot access $MOUNT/.lustre using its FID '$fid'"
16978
16979         fid=$($LFS path2fid $MOUNT/.lustre/fid)
16980         stat $MOUNT/.lustre/fid/$fid > /dev/null ||
16981                 error "cannot access $MOUNT/.lustre/fid using its FID '$fid'"
16982 }
16983 run_test 233b "checking that OBF of the FS .lustre succeeds"
16984
16985 test_234() {
16986         local p="$TMP/sanityN-$TESTNAME.parameters"
16987         save_lustre_params client "llite.*.xattr_cache" > $p
16988         lctl set_param llite.*.xattr_cache 1 ||
16989                 skip_env "xattr cache is not supported"
16990
16991         mkdir -p $DIR/$tdir || error "mkdir failed"
16992         touch $DIR/$tdir/$tfile || error "touch failed"
16993         # OBD_FAIL_LLITE_XATTR_ENOMEM
16994         $LCTL set_param fail_loc=0x1405
16995         getfattr -n user.attr $DIR/$tdir/$tfile &&
16996                 error "getfattr should have failed with ENOMEM"
16997         $LCTL set_param fail_loc=0x0
16998         rm -rf $DIR/$tdir
16999
17000         restore_lustre_params < $p
17001         rm -f $p
17002 }
17003 run_test 234 "xattr cache should not crash on ENOMEM"
17004
17005 test_235() {
17006         [ $MDS1_VERSION -lt $(version_code 2.4.52) ] &&
17007                 skip "Need MDS version at least 2.4.52"
17008
17009         flock_deadlock $DIR/$tfile
17010         local RC=$?
17011         case $RC in
17012                 0)
17013                 ;;
17014                 124) error "process hangs on a deadlock"
17015                 ;;
17016                 *) error "error executing flock_deadlock $DIR/$tfile"
17017                 ;;
17018         esac
17019 }
17020 run_test 235 "LU-1715: flock deadlock detection does not work properly"
17021
17022 #LU-2935
17023 test_236() {
17024         check_swap_layouts_support
17025
17026         local ref1=/etc/passwd
17027         local ref2=/etc/group
17028         local file1=$DIR/$tdir/f1
17029         local file2=$DIR/$tdir/f2
17030
17031         test_mkdir -c1 $DIR/$tdir
17032         $LFS setstripe -c 1 $file1 || error "cannot setstripe on '$file1': rc = $?"
17033         cp $ref1 $file1 || error "cp $ref1 $file1 failed: rc = $?"
17034         $LFS setstripe -c 2 $file2 || error "cannot setstripe on '$file2': rc = $?"
17035         cp $ref2 $file2 || error "cp $ref2 $file2 failed: rc = $?"
17036         local fd=$(free_fd)
17037         local cmd="exec $fd<>$file2"
17038         eval $cmd
17039         rm $file2
17040         $LFS swap_layouts $file1 /proc/self/fd/${fd} ||
17041                 error "cannot swap layouts of '$file1' and /proc/self/fd/${fd}"
17042         cmd="exec $fd>&-"
17043         eval $cmd
17044         cmp $ref2 $file1 || error "content compare failed ($ref2 != $file1)"
17045
17046         #cleanup
17047         rm -rf $DIR/$tdir
17048 }
17049 run_test 236 "Layout swap on open unlinked file"
17050
17051 # LU-4659 linkea consistency
17052 test_238() {
17053         [[ $MDS1_VERSION -gt $(version_code 2.5.57) ]] ||
17054                 [[ $MDS1_VERSION -gt $(version_code 2.5.1) &&
17055                    $MDS1_VERSION -lt $(version_code 2.5.50) ]] ||
17056                 skip "Need MDS version at least 2.5.58 or 2.5.2+"
17057
17058         touch $DIR/$tfile
17059         ln $DIR/$tfile $DIR/$tfile.lnk
17060         touch $DIR/$tfile.new
17061         mv $DIR/$tfile.new $DIR/$tfile
17062         local fid1=$($LFS path2fid $DIR/$tfile)
17063         local fid2=$($LFS path2fid $DIR/$tfile.lnk)
17064         local path1=$($LFS fid2path $FSNAME "$fid1")
17065         [ $tfile == $path1 ] || error "linkea inconsistent: $tfile $fid1 $path1"
17066         local path2=$($LFS fid2path $FSNAME "$fid2")
17067         [ $tfile.lnk == $path2 ] ||
17068                 error "linkea inconsistent: $tfile.lnk $fid2 $path2!"
17069         rm -f $DIR/$tfile*
17070 }
17071 run_test 238 "Verify linkea consistency"
17072
17073 test_239A() { # was test_239
17074         [ $MDS1_VERSION -lt $(version_code 2.5.60) ] &&
17075                 skip "Need MDS version at least 2.5.60"
17076
17077         local list=$(comma_list $(mdts_nodes))
17078
17079         mkdir -p $DIR/$tdir
17080         createmany -o $DIR/$tdir/f- 5000
17081         unlinkmany $DIR/$tdir/f- 5000
17082         [ $MDS1_VERSION -gt $(version_code 2.10.4) ] &&
17083                 do_nodes $list "lctl set_param -n osp.*.force_sync=1"
17084         changes=$(do_nodes $list "lctl get_param -n osp.*MDT*.sync_changes \
17085                         osp.*MDT*.sync_in_flight" | calc_sum)
17086         [ "$changes" -eq 0 ] || error "$changes not synced"
17087 }
17088 run_test 239A "osp_sync test"
17089
17090 test_239a() { #LU-5297
17091         remote_mds_nodsh && skip "remote MDS with nodsh"
17092
17093         touch $DIR/$tfile
17094         #define OBD_FAIL_OSP_CHECK_INVALID_REC     0x2100
17095         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x2100
17096         chgrp $RUNAS_GID $DIR/$tfile
17097         wait_delete_completed
17098 }
17099 run_test 239a "process invalid osp sync record correctly"
17100
17101 test_239b() { #LU-5297
17102         remote_mds_nodsh && skip "remote MDS with nodsh"
17103
17104         touch $DIR/$tfile1
17105         #define OBD_FAIL_OSP_CHECK_ENOMEM     0x2101
17106         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x2101
17107         chgrp $RUNAS_GID $DIR/$tfile1
17108         wait_delete_completed
17109         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
17110         touch $DIR/$tfile2
17111         chgrp $RUNAS_GID $DIR/$tfile2
17112         wait_delete_completed
17113 }
17114 run_test 239b "process osp sync record with ENOMEM error correctly"
17115
17116 test_240() {
17117         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
17118         remote_mds_nodsh && skip "remote MDS with nodsh"
17119
17120         mkdir -p $DIR/$tdir
17121
17122         $LFS mkdir -i 0 $DIR/$tdir/d0 ||
17123                 error "failed to mkdir $DIR/$tdir/d0 on MDT0"
17124         $LFS mkdir -i 1 $DIR/$tdir/d0/d1 ||
17125                 error "failed to mkdir $DIR/$tdir/d0/d1 on MDT1"
17126
17127         umount_client $MOUNT || error "umount failed"
17128         #define OBD_FAIL_TGT_DELAY_CONDITIONAL   0x713
17129         do_facet mds2 lctl set_param fail_loc=0x713 fail_val=1
17130         mount_client $MOUNT || error "failed to mount client"
17131
17132         echo "stat $DIR/$tdir/d0/d1, should not fail/ASSERT"
17133         stat $DIR/$tdir/d0/d1 || error "fail to stat $DIR/$tdir/d0/d1"
17134 }
17135 run_test 240 "race between ldlm enqueue and the connection RPC (no ASSERT)"
17136
17137 test_241_bio() {
17138         local count=$1
17139         local bsize=$2
17140
17141         for LOOP in $(seq $count); do
17142                 dd if=$DIR/$tfile of=/dev/null bs=$bsize count=1 2>/dev/null
17143                 cancel_lru_locks $OSC || true
17144         done
17145 }
17146
17147 test_241_dio() {
17148         local count=$1
17149         local bsize=$2
17150
17151         for LOOP in $(seq $1); do
17152                 dd if=$DIR/$tfile of=/dev/null bs=$bsize count=1 iflag=direct \
17153                         2>/dev/null
17154         done
17155 }
17156
17157 test_241a() { # was test_241
17158         local bsize=$PAGE_SIZE
17159
17160         (( bsize < 40960 )) && bsize=40960
17161         dd if=/dev/zero of=$DIR/$tfile count=1 bs=$bsize
17162         ls -la $DIR/$tfile
17163         cancel_lru_locks $OSC
17164         test_241_bio 1000 $bsize &
17165         PID=$!
17166         test_241_dio 1000 $bsize
17167         wait $PID
17168 }
17169 run_test 241a "bio vs dio"
17170
17171 test_241b() {
17172         local bsize=$PAGE_SIZE
17173
17174         (( bsize < 40960 )) && bsize=40960
17175         dd if=/dev/zero of=$DIR/$tfile count=1 bs=$bsize
17176         ls -la $DIR/$tfile
17177         test_241_dio 1000 $bsize &
17178         PID=$!
17179         test_241_dio 1000 $bsize
17180         wait $PID
17181 }
17182 run_test 241b "dio vs dio"
17183
17184 test_242() {
17185         remote_mds_nodsh && skip "remote MDS with nodsh"
17186
17187         mkdir -p $DIR/$tdir
17188         touch $DIR/$tdir/$tfile
17189
17190         #define OBD_FAIL_MDS_READPAGE_PACK      0x105
17191         do_facet mds1 lctl set_param fail_loc=0x105
17192         /bin/ls $DIR/$tdir && error "ls $DIR/$tdir should fail"
17193
17194         do_facet mds1 lctl set_param fail_loc=0
17195         /bin/ls $DIR/$tdir || error "ls $DIR/$tdir failed"
17196 }
17197 run_test 242 "mdt_readpage failure should not cause directory unreadable"
17198
17199 test_243()
17200 {
17201         test_mkdir $DIR/$tdir
17202         group_lock_test -d $DIR/$tdir || error "A group lock test failed"
17203 }
17204 run_test 243 "various group lock tests"
17205
17206 test_244a()
17207 {
17208         test_mkdir $DIR/$tdir
17209         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=35
17210         sendfile_grouplock $DIR/$tdir/$tfile || \
17211                 error "sendfile+grouplock failed"
17212         rm -rf $DIR/$tdir
17213 }
17214 run_test 244a "sendfile with group lock tests"
17215
17216 test_244b()
17217 {
17218         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
17219
17220         local threads=50
17221         local size=$((1024*1024))
17222
17223         test_mkdir $DIR/$tdir
17224         for i in $(seq 1 $threads); do
17225                 local file=$DIR/$tdir/file_$((i / 10))
17226                 $MULTIOP $file OG1234w$size_$((i % 3))w$size_$((i % 4))g1234c &
17227                 local pids[$i]=$!
17228         done
17229         for i in $(seq 1 $threads); do
17230                 wait ${pids[$i]}
17231         done
17232 }
17233 run_test 244b "multi-threaded write with group lock"
17234
17235 test_245() {
17236         local flagname="multi_mod_rpcs"
17237         local connect_data_name="max_mod_rpcs"
17238         local out
17239
17240         # check if multiple modify RPCs flag is set
17241         out=$($LCTL get_param mdc.$FSNAME-MDT0000-*.import |
17242                 grep "connect_flags:")
17243         echo "$out"
17244
17245         echo "$out" | grep -qw $flagname
17246         if [ $? -ne 0 ]; then
17247                 echo "connect flag $flagname is not set"
17248                 return
17249         fi
17250
17251         # check if multiple modify RPCs data is set
17252         out=$($LCTL get_param mdc.$FSNAME-MDT0000-*.import)
17253         echo "$out"
17254
17255         echo "$out" | grep -qw $connect_data_name ||
17256                 error "import should have connect data $connect_data_name"
17257 }
17258 run_test 245 "check mdc connection flag/data: multiple modify RPCs"
17259
17260 test_246() { # LU-7371
17261         remote_ost_nodsh && skip "remote OST with nodsh"
17262         [ $OST1_VERSION -lt $(version_code 2.7.62) ] &&
17263                 skip "Need OST version >= 2.7.62"
17264
17265         do_facet ost1 $LCTL set_param fail_val=4095
17266 #define OBD_FAIL_OST_READ_SIZE          0x234
17267         do_facet ost1 $LCTL set_param fail_loc=0x234
17268         $LFS setstripe $DIR/$tfile -i 0 -c 1
17269         dd if=/dev/zero of=$DIR/$tfile bs=4095 count=1 > /dev/null 2>&1
17270         cancel_lru_locks $FSNAME-OST0000
17271         dd if=$DIR/$tfile of=/dev/null bs=1048576 || error "Read failed"
17272 }
17273 run_test 246 "Read file of size 4095 should return right length"
17274
17275 cleanup_247() {
17276         local submount=$1
17277
17278         trap 0
17279         umount_client $submount
17280         rmdir $submount
17281 }
17282
17283 test_247a() {
17284         lctl get_param -n mdc.$FSNAME-MDT0000*.import |
17285                 grep -q subtree ||
17286                 skip_env "Fileset feature is not supported"
17287
17288         local submount=${MOUNT}_$tdir
17289
17290         mkdir $MOUNT/$tdir
17291         mkdir -p $submount || error "mkdir $submount failed"
17292         FILESET="$FILESET/$tdir" mount_client $submount ||
17293                 error "mount $submount failed"
17294         trap "cleanup_247 $submount" EXIT
17295         echo foo > $submount/$tfile || error "write $submount/$tfile failed"
17296         [ $(cat $MOUNT/$tdir/$tfile) = "foo" ] ||
17297                 error "read $MOUNT/$tdir/$tfile failed"
17298         cleanup_247 $submount
17299 }
17300 run_test 247a "mount subdir as fileset"
17301
17302 test_247b() {
17303         lctl get_param -n mdc.$FSNAME-MDT0000*.import | grep -q subtree ||
17304                 skip_env "Fileset feature is not supported"
17305
17306         local submount=${MOUNT}_$tdir
17307
17308         rm -rf $MOUNT/$tdir
17309         mkdir -p $submount || error "mkdir $submount failed"
17310         SKIP_FILESET=1
17311         FILESET="$FILESET/$tdir" mount_client $submount &&
17312                 error "mount $submount should fail"
17313         rmdir $submount
17314 }
17315 run_test 247b "mount subdir that dose not exist"
17316
17317 test_247c() {
17318         lctl get_param -n mdc.$FSNAME-MDT0000*.import | grep -q subtree ||
17319                 skip_env "Fileset feature is not supported"
17320
17321         local submount=${MOUNT}_$tdir
17322
17323         mkdir -p $MOUNT/$tdir/dir1
17324         mkdir -p $submount || error "mkdir $submount failed"
17325         trap "cleanup_247 $submount" EXIT
17326         FILESET="$FILESET/$tdir" mount_client $submount ||
17327                 error "mount $submount failed"
17328         local fid=$($LFS path2fid $MOUNT/)
17329         $LFS fid2path $submount $fid && error "fid2path should fail"
17330         cleanup_247 $submount
17331 }
17332 run_test 247c "running fid2path outside root"
17333
17334 test_247d() {
17335         lctl get_param -n mdc.$FSNAME-MDT0000*.import | grep -q subtree ||
17336                 skip "Fileset feature is not supported"
17337
17338         local submount=${MOUNT}_$tdir
17339
17340         mkdir -p $MOUNT/$tdir/dir1
17341         mkdir -p $submount || error "mkdir $submount failed"
17342         FILESET="$FILESET/$tdir" mount_client $submount ||
17343                 error "mount $submount failed"
17344         trap "cleanup_247 $submount" EXIT
17345         local fid=$($LFS path2fid $submount/dir1)
17346         $LFS fid2path $submount $fid || error "fid2path should succeed"
17347         cleanup_247 $submount
17348 }
17349 run_test 247d "running fid2path inside root"
17350
17351 # LU-8037
17352 test_247e() {
17353         lctl get_param -n mdc.$FSNAME-MDT0000*.import |
17354                 grep -q subtree ||
17355                 skip "Fileset feature is not supported"
17356
17357         local submount=${MOUNT}_$tdir
17358
17359         mkdir $MOUNT/$tdir
17360         mkdir -p $submount || error "mkdir $submount failed"
17361         FILESET="$FILESET/.." mount_client $submount &&
17362                 error "mount $submount should fail"
17363         rmdir $submount
17364 }
17365 run_test 247e "mount .. as fileset"
17366
17367 test_248() {
17368         local fast_read_sav=$($LCTL get_param -n llite.*.fast_read 2>/dev/null)
17369         [ -z "$fast_read_sav" ] && skip "no fast read support"
17370
17371         # create a large file for fast read verification
17372         dd if=/dev/zero of=$DIR/$tfile bs=1M count=128 > /dev/null 2>&1
17373
17374         # make sure the file is created correctly
17375         $CHECKSTAT -s $((128*1024*1024)) $DIR/$tfile ||
17376                 { rm -f $DIR/$tfile; skip "file creation error"; }
17377
17378         echo "Test 1: verify that fast read is 4 times faster on cache read"
17379
17380         # small read with fast read enabled
17381         $LCTL set_param -n llite.*.fast_read=1
17382         local t_fast=$(dd if=$DIR/$tfile of=/dev/null bs=4k 2>&1 |
17383                 egrep -o '([[:digit:]\.\,e-]+) s' | cut -d's' -f1 |
17384                 sed -e 's/,/./' -e 's/[eE]+*/\*10\^/')
17385         # small read with fast read disabled
17386         $LCTL set_param -n llite.*.fast_read=0
17387         local t_slow=$(dd if=$DIR/$tfile of=/dev/null bs=4k 2>&1 |
17388                 egrep -o '([[:digit:]\.\,e-]+) s' | cut -d's' -f1 |
17389                 sed -e 's/,/./' -e 's/[eE]+*/\*10\^/')
17390
17391         # verify that fast read is 4 times faster for cache read
17392         [ $(bc <<< "4 * $t_fast < $t_slow") -eq 1 ] ||
17393                 error_not_in_vm "fast read was not 4 times faster: " \
17394                            "$t_fast vs $t_slow"
17395
17396         echo "Test 2: verify the performance between big and small read"
17397         $LCTL set_param -n llite.*.fast_read=1
17398
17399         # 1k non-cache read
17400         cancel_lru_locks osc
17401         local t_1k=$(dd if=$DIR/$tfile of=/dev/null bs=1k 2>&1 |
17402                 egrep -o '([[:digit:]\.\,e-]+) s' | cut -d's' -f1 |
17403                 sed -e 's/,/./' -e 's/[eE]+*/\*10\^/')
17404
17405         # 1M non-cache read
17406         cancel_lru_locks osc
17407         local t_1m=$(dd if=$DIR/$tfile of=/dev/null bs=1k 2>&1 |
17408                 egrep -o '([[:digit:]\.\,e-]+) s' | cut -d's' -f1 |
17409                 sed -e 's/,/./' -e 's/[eE]+*/\*10\^/')
17410
17411         # verify that big IO is not 4 times faster than small IO
17412         [ $(bc <<< "4 * $t_1k >= $t_1m") -eq 1 ] ||
17413                 error_not_in_vm "bigger IO is way too fast: $t_1k vs $t_1m"
17414
17415         $LCTL set_param -n llite.*.fast_read=$fast_read_sav
17416         rm -f $DIR/$tfile
17417 }
17418 run_test 248 "fast read verification"
17419
17420 test_249() { # LU-7890
17421         [ $MDS1_VERSION -lt $(version_code 2.8.53) ] &&
17422                 skip "Need at least version 2.8.54"
17423
17424         rm -f $DIR/$tfile
17425         $LFS setstripe -c 1 $DIR/$tfile
17426         # Offset 2T == 4k * 512M
17427         dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 seek=512M ||
17428                 error "dd to 2T offset failed"
17429 }
17430 run_test 249 "Write above 2T file size"
17431
17432 test_250() {
17433         [ "$(facet_fstype ost$(($($LFS getstripe -i $DIR/$tfile) + 1)))" = "zfs" ] \
17434          && skip "no 16TB file size limit on ZFS"
17435
17436         $LFS setstripe -c 1 $DIR/$tfile
17437         # ldiskfs extent file size limit is (16TB - 4KB - 1) bytes
17438         local size=$((16 * 1024 * 1024 * 1024 * 1024 - 4096 - 1))
17439         $TRUNCATE $DIR/$tfile $size || error "truncate $tfile to $size failed"
17440         dd if=/dev/zero of=$DIR/$tfile bs=10 count=1 oflag=append \
17441                 conv=notrunc,fsync && error "append succeeded"
17442         return 0
17443 }
17444 run_test 250 "Write above 16T limit"
17445
17446 test_251() {
17447         $LFS setstripe -c -1 -S 1048576 $DIR/$tfile
17448
17449         #define OBD_FAIL_LLITE_LOST_LAYOUT 0x1407
17450         #Skip once - writing the first stripe will succeed
17451         $LCTL set_param fail_loc=0xa0001407 fail_val=1
17452         $MULTIOP $DIR/$tfile o:O_RDWR:w2097152c 2>&1 | grep -q "short write" &&
17453                 error "short write happened"
17454
17455         $LCTL set_param fail_loc=0xa0001407 fail_val=1
17456         $MULTIOP $DIR/$tfile or2097152c 2>&1 | grep -q "short read" &&
17457                 error "short read happened"
17458
17459         rm -f $DIR/$tfile
17460 }
17461 run_test 251 "Handling short read and write correctly"
17462
17463 test_252() {
17464         remote_mds_nodsh && skip "remote MDS with nodsh"
17465         remote_ost_nodsh && skip "remote OST with nodsh"
17466         if [ "$ost1_FSTYPE" != ldiskfs ] || [ "$mds1_FSTYPE" != ldiskfs ]; then
17467                 skip_env "ldiskfs only test"
17468         fi
17469
17470         local tgt
17471         local dev
17472         local out
17473         local uuid
17474         local num
17475         local gen
17476
17477         # check lr_reader on OST0000
17478         tgt=ost1
17479         dev=$(facet_device $tgt)
17480         out=$(do_facet $tgt $LR_READER $dev)
17481         [ $? -eq 0 ] || error "$LR_READER failed on target $tgt device $dev"
17482         echo "$out"
17483         uuid=$(echo "$out" | grep -i uuid | awk '{ print $2 }')
17484         [ "$uuid" == "$(ostuuid_from_index 0)" ] ||
17485                 error "Invalid uuid returned by $LR_READER on target $tgt"
17486         echo -e "uuid returned by $LR_READER is '$uuid'\n"
17487
17488         # check lr_reader -c on MDT0000
17489         tgt=mds1
17490         dev=$(facet_device $tgt)
17491         if ! do_facet $tgt $LR_READER -h | grep -q OPTIONS; then
17492                 skip "$LR_READER does not support additional options"
17493         fi
17494         out=$(do_facet $tgt $LR_READER -c $dev)
17495         [ $? -eq 0 ] || error "$LR_READER failed on target $tgt device $dev"
17496         echo "$out"
17497         num=$(echo "$out" | grep -c "mdtlov")
17498         [ "$num" -eq $((MDSCOUNT - 1)) ] ||
17499                 error "Invalid number of mdtlov clients returned by $LR_READER"
17500         echo -e "Number of mdtlov clients returned by $LR_READER is '$num'\n"
17501
17502         # check lr_reader -cr on MDT0000
17503         out=$(do_facet $tgt $LR_READER -cr $dev)
17504         [ $? -eq 0 ] || error "$LR_READER failed on target $tgt device $dev"
17505         echo "$out"
17506         echo "$out" | grep -q "^reply_data:$" ||
17507                 error "$LR_READER should have returned 'reply_data' section"
17508         num=$(echo "$out" | grep -c "client_generation")
17509         echo -e "Number of reply data returned by $LR_READER is '$num'\n"
17510 }
17511 run_test 252 "check lr_reader tool"
17512
17513 test_253() {
17514         [ $PARALLEL == "yes" ] && skip "skip parallel run"
17515         remote_mds_nodsh && skip "remote MDS with nodsh"
17516         remote_mgs_nodsh && skip "remote MGS with nodsh"
17517
17518         local ostidx=0
17519         local rc=0
17520         local ost_name=$(ostname_from_index $ostidx)
17521
17522         # on the mdt's osc
17523         local mdtosc_proc1=$(get_mdtosc_proc_path $SINGLEMDS $ost_name)
17524         do_facet $SINGLEMDS $LCTL get_param -n \
17525                 osp.$mdtosc_proc1.reserved_mb_high ||
17526                 skip  "remote MDS does not support reserved_mb_high"
17527
17528         rm -rf $DIR/$tdir
17529         wait_mds_ost_sync
17530         wait_delete_completed
17531         mkdir $DIR/$tdir
17532
17533         if ! combined_mgs_mds ; then
17534                 mount_mgs_client
17535         fi
17536         pool_add $TESTNAME || error "Pool creation failed"
17537         pool_add_targets $TESTNAME 0 || error "Pool add targets failed"
17538
17539         $LFS setstripe $DIR/$tdir -i $ostidx -c 1 -p $FSNAME.$TESTNAME ||
17540                 error "Setstripe failed"
17541
17542         dd if=/dev/zero of=$DIR/$tdir/$tfile.0 bs=1M count=10
17543
17544         local wms=$(ost_watermarks_set_enospc $tfile $ostidx |
17545                     grep "watermarks")
17546         stack_trap "ost_watermarks_clear_enospc $tfile $ostidx $wms" EXIT
17547
17548         local oa_status=$(do_facet $SINGLEMDS $LCTL get_param -n \
17549                         osp.$mdtosc_proc1.prealloc_status)
17550         echo "prealloc_status $oa_status"
17551
17552         dd if=/dev/zero of=$DIR/$tdir/$tfile.1 bs=1M count=1 &&
17553                 error "File creation should fail"
17554
17555         #object allocation was stopped, but we still able to append files
17556         dd if=/dev/zero of=$DIR/$tdir/$tfile.0 bs=1M seek=6 count=5 \
17557                 oflag=append || error "Append failed"
17558
17559         rm -f $DIR/$tdir/$tfile.0
17560
17561         # For this test, we want to delete the files we created to go out of
17562         # space but leave the watermark, so we remain nearly out of space
17563         ost_watermarks_enospc_delete_files $tfile $ostidx
17564
17565         wait_delete_completed
17566
17567         sleep_maxage
17568
17569         for i in $(seq 10 12); do
17570                 dd if=/dev/zero of=$DIR/$tdir/$tfile.$i bs=1M count=1 \
17571                         2>/dev/null || error "File creation failed after rm"
17572         done
17573
17574         oa_status=$(do_facet $SINGLEMDS $LCTL get_param -n \
17575                         osp.$mdtosc_proc1.prealloc_status)
17576         echo "prealloc_status $oa_status"
17577
17578         if (( oa_status != 0 )); then
17579                 error "Object allocation still disable after rm"
17580         fi
17581
17582         if ! combined_mgs_mds ; then
17583                 umount_mgs_client
17584         fi
17585 }
17586 run_test 253 "Check object allocation limit"
17587
17588 test_254() {
17589         [ $PARALLEL == "yes" ] && skip "skip parallel run"
17590         remote_mds_nodsh && skip "remote MDS with nodsh"
17591         do_facet $SINGLEMDS $LCTL get_param -n mdd.$MDT0.changelog_size ||
17592                 skip "MDS does not support changelog_size"
17593
17594         local cl_user
17595         local MDT0=$(facet_svc $SINGLEMDS)
17596
17597         changelog_register || error "changelog_register failed"
17598
17599         changelog_clear 0 || error "changelog_clear failed"
17600
17601         local size1=$(do_facet $SINGLEMDS \
17602                       $LCTL get_param -n mdd.$MDT0.changelog_size)
17603         echo "Changelog size $size1"
17604
17605         rm -rf $DIR/$tdir
17606         $LFS mkdir -i 0 $DIR/$tdir
17607         # change something
17608         mkdir -p $DIR/$tdir/pics/2008/zachy
17609         touch $DIR/$tdir/pics/2008/zachy/timestamp
17610         cp /etc/hosts $DIR/$tdir/pics/2008/zachy/pic1.jpg
17611         mv $DIR/$tdir/pics/2008/zachy $DIR/$tdir/pics/zach
17612         ln $DIR/$tdir/pics/zach/pic1.jpg $DIR/$tdir/pics/2008/portland.jpg
17613         ln -s $DIR/$tdir/pics/2008/portland.jpg $DIR/$tdir/pics/desktop.jpg
17614         rm $DIR/$tdir/pics/desktop.jpg
17615
17616         local size2=$(do_facet $SINGLEMDS \
17617                       $LCTL get_param -n mdd.$MDT0.changelog_size)
17618         echo "Changelog size after work $size2"
17619
17620         (( $size2 > $size1 )) ||
17621                 error "new Changelog size=$size2 less than old size=$size1"
17622 }
17623 run_test 254 "Check changelog size"
17624
17625 ladvise_no_type()
17626 {
17627         local type=$1
17628         local file=$2
17629
17630         lfs ladvise -a invalid $file 2>&1 | grep "Valid types" |
17631                 awk -F: '{print $2}' | grep $type > /dev/null
17632         if [ $? -ne 0 ]; then
17633                 return 0
17634         fi
17635         return 1
17636 }
17637
17638 ladvise_no_ioctl()
17639 {
17640         local file=$1
17641
17642         lfs ladvise -a willread $file > /dev/null 2>&1
17643         if [ $? -eq 0 ]; then
17644                 return 1
17645         fi
17646
17647         lfs ladvise -a willread $file 2>&1 |
17648                 grep "Inappropriate ioctl for device" > /dev/null
17649         if [ $? -eq 0 ]; then
17650                 return 0
17651         fi
17652         return 1
17653 }
17654
17655 percent() {
17656         bc <<<"scale=2; ($1 - $2) * 100 / $2"
17657 }
17658
17659 # run a random read IO workload
17660 # usage: random_read_iops <filename> <filesize> <iosize>
17661 random_read_iops() {
17662         local file=$1
17663         local fsize=$2
17664         local iosize=${3:-4096}
17665
17666         $READS -f $file -s $fsize -b $iosize -n $((fsize / iosize)) -t 60 |
17667                 sed -e '/^$/d' -e 's#.*s, ##' -e 's#MB/s##'
17668 }
17669
17670 drop_file_oss_cache() {
17671         local file="$1"
17672         local nodes="$2"
17673
17674         $LFS ladvise -a dontneed $file 2>/dev/null ||
17675                 do_nodes $nodes "echo 3 > /proc/sys/vm/drop_caches"
17676 }
17677
17678 ladvise_willread_performance()
17679 {
17680         local repeat=10
17681         local average_origin=0
17682         local average_cache=0
17683         local average_ladvise=0
17684
17685         for ((i = 1; i <= $repeat; i++)); do
17686                 echo "Iter $i/$repeat: reading without willread hint"
17687                 cancel_lru_locks osc
17688                 drop_file_oss_cache $DIR/$tfile $(comma_list $(osts_nodes))
17689                 local speed_origin=$(random_read_iops $DIR/$tfile $size)
17690                 echo "Iter $i/$repeat: uncached speed: $speed_origin"
17691                 average_origin=$(bc <<<"$average_origin + $speed_origin")
17692
17693                 cancel_lru_locks osc
17694                 local speed_cache=$(random_read_iops $DIR/$tfile $size)
17695                 echo "Iter $i/$repeat: OSS cache speed: $speed_cache"
17696                 average_cache=$(bc <<<"$average_cache + $speed_cache")
17697
17698                 cancel_lru_locks osc
17699                 drop_file_oss_cache $DIR/$tfile $(comma_list $(osts_nodes))
17700                 $LFS ladvise -a willread $DIR/$tfile || error "ladvise failed"
17701                 local speed_ladvise=$(random_read_iops $DIR/$tfile $size)
17702                 echo "Iter $i/$repeat: ladvise speed: $speed_ladvise"
17703                 average_ladvise=$(bc <<<"$average_ladvise + $speed_ladvise")
17704         done
17705         average_origin=$(bc <<<"scale=2; $average_origin / $repeat")
17706         average_cache=$(bc <<<"scale=2; $average_cache / $repeat")
17707         average_ladvise=$(bc <<<"scale=2; $average_ladvise / $repeat")
17708
17709         speedup_cache=$(percent $average_cache $average_origin)
17710         speedup_ladvise=$(percent $average_ladvise $average_origin)
17711
17712         echo "Average uncached read: $average_origin"
17713         echo "Average speedup with OSS cached read: " \
17714                 "$average_cache = +$speedup_cache%"
17715         echo "Average speedup with ladvise willread: " \
17716                 "$average_ladvise = +$speedup_ladvise%"
17717
17718         local lowest_speedup=20
17719         if [ ${average_cache%.*} -lt $lowest_speedup ]; then
17720                 echo "Speedup with OSS cached read less than $lowest_speedup%," \
17721                         "got $average_cache%. Skipping ladvise willread check."
17722                 return 0
17723         fi
17724
17725         # the test won't work on ZFS until it supports 'ladvise dontneed', but
17726         # it is still good to run until then to exercise 'ladvise willread'
17727         ! $LFS ladvise -a dontneed $DIR/$tfile &&
17728                 [ "$ost1_FSTYPE" = "zfs" ] &&
17729                 echo "osd-zfs does not support dontneed or drop_caches" &&
17730                 return 0
17731
17732         lowest_speedup=$(bc <<<"scale=2; $average_cache / 2")
17733         [ ${average_ladvise%.*} -gt $lowest_speedup ] ||
17734                 error_not_in_vm "Speedup with willread is less than " \
17735                         "$lowest_speedup%, got $average_ladvise%"
17736 }
17737
17738 test_255a() {
17739         [ $OST1_VERSION -lt $(version_code 2.8.54) ] &&
17740                 skip "lustre < 2.8.54 does not support ladvise "
17741         remote_ost_nodsh && skip "remote OST with nodsh"
17742
17743         lfs setstripe -c -1 -i 0 $DIR/$tfile || error "$tfile failed"
17744
17745         ladvise_no_type willread $DIR/$tfile &&
17746                 skip "willread ladvise is not supported"
17747
17748         ladvise_no_ioctl $DIR/$tfile &&
17749                 skip "ladvise ioctl is not supported"
17750
17751         local size_mb=100
17752         local size=$((size_mb * 1048576))
17753         dd if=/dev/zero of=$DIR/$tfile bs=1048576 count=$size_mb ||
17754                 error "dd to $DIR/$tfile failed"
17755
17756         lfs ladvise -a willread $DIR/$tfile ||
17757                 error "Ladvise failed with no range argument"
17758
17759         lfs ladvise -a willread -s 0 $DIR/$tfile ||
17760                 error "Ladvise failed with no -l or -e argument"
17761
17762         lfs ladvise -a willread -e 1 $DIR/$tfile ||
17763                 error "Ladvise failed with only -e argument"
17764
17765         lfs ladvise -a willread -l 1 $DIR/$tfile ||
17766                 error "Ladvise failed with only -l argument"
17767
17768         lfs ladvise -a willread -s 2 -e 1 $DIR/$tfile &&
17769                 error "End offset should not be smaller than start offset"
17770
17771         lfs ladvise -a willread -s 2 -e 2 $DIR/$tfile &&
17772                 error "End offset should not be equal to start offset"
17773
17774         lfs ladvise -a willread -s $size -l 1 $DIR/$tfile ||
17775                 error "Ladvise failed with overflowing -s argument"
17776
17777         lfs ladvise -a willread -s 1 -e $((size + 1)) $DIR/$tfile ||
17778                 error "Ladvise failed with overflowing -e argument"
17779
17780         lfs ladvise -a willread -s 1 -l $size $DIR/$tfile ||
17781                 error "Ladvise failed with overflowing -l argument"
17782
17783         lfs ladvise -a willread -l 1 -e 2 $DIR/$tfile &&
17784                 error "Ladvise succeeded with conflicting -l and -e arguments"
17785
17786         echo "Synchronous ladvise should wait"
17787         local delay=4
17788 #define OBD_FAIL_OST_LADVISE_PAUSE       0x237
17789         do_nodes $(comma_list $(osts_nodes)) \
17790                 $LCTL set_param fail_val=$delay fail_loc=0x237
17791
17792         local start_ts=$SECONDS
17793         lfs ladvise -a willread $DIR/$tfile ||
17794                 error "Ladvise failed with no range argument"
17795         local end_ts=$SECONDS
17796         local inteval_ts=$((end_ts - start_ts))
17797
17798         if [ $inteval_ts -lt $(($delay - 1)) ]; then
17799                 error "Synchronous advice didn't wait reply"
17800         fi
17801
17802         echo "Asynchronous ladvise shouldn't wait"
17803         local start_ts=$SECONDS
17804         lfs ladvise -a willread -b $DIR/$tfile ||
17805                 error "Ladvise failed with no range argument"
17806         local end_ts=$SECONDS
17807         local inteval_ts=$((end_ts - start_ts))
17808
17809         if [ $inteval_ts -gt $(($delay / 2)) ]; then
17810                 error "Asynchronous advice blocked"
17811         fi
17812
17813         do_nodes $(comma_list $(osts_nodes)) $LCTL set_param fail_loc=0
17814         ladvise_willread_performance
17815 }
17816 run_test 255a "check 'lfs ladvise -a willread'"
17817
17818 facet_meminfo() {
17819         local facet=$1
17820         local info=$2
17821
17822         do_facet $facet "cat /proc/meminfo | grep ^${info}:" | awk '{print $2}'
17823 }
17824
17825 test_255b() {
17826         [ $OST1_VERSION -lt $(version_code 2.8.54) ] &&
17827                 skip "lustre < 2.8.54 does not support ladvise "
17828         remote_ost_nodsh && skip "remote OST with nodsh"
17829
17830         lfs setstripe -c 1 -i 0 $DIR/$tfile
17831
17832         ladvise_no_type dontneed $DIR/$tfile &&
17833                 skip "dontneed ladvise is not supported"
17834
17835         ladvise_no_ioctl $DIR/$tfile &&
17836                 skip "ladvise ioctl is not supported"
17837
17838         ! $LFS ladvise -a dontneed $DIR/$tfile &&
17839                 [ "$ost1_FSTYPE" = "zfs" ] &&
17840                 skip "zfs-osd does not support 'ladvise dontneed'"
17841
17842         local size_mb=100
17843         local size=$((size_mb * 1048576))
17844         # In order to prevent disturbance of other processes, only check 3/4
17845         # of the memory usage
17846         local kibibytes=$((size_mb * 1024 * 3 / 4))
17847
17848         dd if=/dev/zero of=$DIR/$tfile bs=1048576 count=$size_mb ||
17849                 error "dd to $DIR/$tfile failed"
17850
17851         #force write to complete before dropping OST cache & checking memory
17852         sync
17853
17854         local total=$(facet_meminfo ost1 MemTotal)
17855         echo "Total memory: $total KiB"
17856
17857         do_facet ost1 "sync && echo 3 > /proc/sys/vm/drop_caches"
17858         local before_read=$(facet_meminfo ost1 Cached)
17859         echo "Cache used before read: $before_read KiB"
17860
17861         lfs ladvise -a willread $DIR/$tfile ||
17862                 error "Ladvise willread failed"
17863         local after_read=$(facet_meminfo ost1 Cached)
17864         echo "Cache used after read: $after_read KiB"
17865
17866         lfs ladvise -a dontneed $DIR/$tfile ||
17867                 error "Ladvise dontneed again failed"
17868         local no_read=$(facet_meminfo ost1 Cached)
17869         echo "Cache used after dontneed ladvise: $no_read KiB"
17870
17871         if [ $total -lt $((before_read + kibibytes)) ]; then
17872                 echo "Memory is too small, abort checking"
17873                 return 0
17874         fi
17875
17876         if [ $((before_read + kibibytes)) -gt $after_read ]; then
17877                 error "Ladvise willread should use more memory" \
17878                         "than $kibibytes KiB"
17879         fi
17880
17881         if [ $((no_read + kibibytes)) -gt $after_read ]; then
17882                 error "Ladvise dontneed should release more memory" \
17883                         "than $kibibytes KiB"
17884         fi
17885 }
17886 run_test 255b "check 'lfs ladvise -a dontneed'"
17887
17888 test_255c() {
17889         [ $OST1_VERSION -lt $(version_code 2.10.50) ] &&
17890                 skip "lustre < 2.10.50 does not support lockahead"
17891
17892         local count
17893         local new_count
17894         local difference
17895         local i
17896         local rc
17897
17898         test_mkdir -p $DIR/$tdir
17899         $LFS setstripe -i 0 -c 1 $DIR/$tdir
17900
17901         #test 10 returns only success/failure
17902         i=10
17903         lockahead_test -d $DIR/$tdir -t $i -f $tfile
17904         rc=$?
17905         if [ $rc -eq 255 ]; then
17906                 error "Ladvise test${i} failed, ${rc}"
17907         fi
17908
17909         #test 11 counts lock enqueue requests, all others count new locks
17910         i=11
17911         count=$(do_facet ost1 \
17912                 $LCTL get_param -n ost.OSS.ost.stats)
17913         count=$(echo "$count" | grep ldlm_extent_enqueue | awk '{ print $2 }')
17914
17915         lockahead_test -d $DIR/$tdir -t $i -f $tfile
17916         rc=$?
17917         if [ $rc -eq 255 ]; then
17918                 error "Ladvise test${i} failed, ${rc}"
17919         fi
17920
17921         new_count=$(do_facet ost1 \
17922                 $LCTL get_param -n ost.OSS.ost.stats)
17923         new_count=$(echo "$new_count" | grep ldlm_extent_enqueue | \
17924                    awk '{ print $2 }')
17925
17926         difference="$((new_count - count))"
17927         if [ $difference -ne $rc ]; then
17928                 error "Ladvise test${i}, bad enqueue count, returned " \
17929                       "${rc}, actual ${difference}"
17930         fi
17931
17932         for i in $(seq 12 21); do
17933                 # If we do not do this, we run the risk of having too many
17934                 # locks and starting lock cancellation while we are checking
17935                 # lock counts.
17936                 cancel_lru_locks osc
17937
17938                 count=$($LCTL get_param -n \
17939                        ldlm.namespaces.$FSNAME-OST0000*osc-[-0-9a-f]*.lock_unused_count)
17940
17941                 lockahead_test -d $DIR/$tdir -t $i -f $tfile
17942                 rc=$?
17943                 if [ $rc -eq 255 ]; then
17944                         error "Ladvise test ${i} failed, ${rc}"
17945                 fi
17946
17947                 new_count=$($LCTL get_param -n \
17948                        ldlm.namespaces.$FSNAME-OST0000*osc-[-0-9a-f]*.lock_unused_count)
17949                 difference="$((new_count - count))"
17950
17951                 # Test 15 output is divided by 100 to map down to valid return
17952                 if [ $i -eq 15 ]; then
17953                         rc="$((rc * 100))"
17954                 fi
17955
17956                 if [ $difference -ne $rc ]; then
17957                         error "Ladvise test ${i}, bad lock count, returned " \
17958                               "${rc}, actual ${difference}"
17959                 fi
17960         done
17961
17962         #test 22 returns only success/failure
17963         i=22
17964         lockahead_test -d $DIR/$tdir -t $i -f $tfile
17965         rc=$?
17966         if [ $rc -eq 255 ]; then
17967                 error "Ladvise test${i} failed, ${rc}"
17968         fi
17969 }
17970 run_test 255c "suite of ladvise lockahead tests"
17971
17972 test_256() {
17973         [ $PARALLEL == "yes" ] && skip "skip parallel run"
17974         remote_mds_nodsh && skip "remote MDS with nodsh"
17975         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip "ldiskfs only test"
17976         changelog_users $SINGLEMDS | grep "^cl" &&
17977                 skip "active changelog user"
17978
17979         local cl_user
17980         local cat_sl
17981         local mdt_dev
17982
17983         mdt_dev=$(mdsdevname 1)
17984         echo $mdt_dev
17985
17986         changelog_register || error "changelog_register failed"
17987
17988         rm -rf $DIR/$tdir
17989         mkdir -p $DIR/$tdir
17990
17991         changelog_clear 0 || error "changelog_clear failed"
17992
17993         # change something
17994         touch $DIR/$tdir/{1..10}
17995
17996         # stop the MDT
17997         stop $SINGLEMDS || error "Fail to stop MDT"
17998
17999         # remount the MDT
18000
18001         start $SINGLEMDS $mdt_dev $MDS_MOUNT_OPTS || error "Fail to start MDT"
18002
18003         #after mount new plainllog is used
18004         touch $DIR/$tdir/{11..19}
18005         local tmpfile="$(mktemp --tmpdir -u $tfile.XXXXXX)"
18006         stack_trap "rm -f $tmpfile"
18007         cat_sl=$(do_facet $SINGLEMDS "sync; \
18008                  $DEBUGFS -c -R 'dump changelog_catalog $tmpfile' $mdt_dev; \
18009                  llog_reader $tmpfile | grep -c type=1064553b")
18010         do_facet $SINGLEMDS llog_reader $tmpfile
18011
18012         [ $cat_sl != 2 ] && error "Changelog catalog has $cat_sl != 2 slots"
18013
18014         changelog_clear 0 || error "changelog_clear failed"
18015
18016         cat_sl=$(do_facet $SINGLEMDS "sync; \
18017                  $DEBUGFS -c -R 'dump changelog_catalog $tmpfile' $mdt_dev; \
18018                  llog_reader $tmpfile | grep -c type=1064553b")
18019
18020         if (( cat_sl == 2 )); then
18021                 error "Empty plain llog was not deleted from changelog catalog"
18022         elif (( cat_sl != 1 )); then
18023                 error "Active plain llog shouldn't be deleted from catalog"
18024         fi
18025 }
18026 run_test 256 "Check llog delete for empty and not full state"
18027
18028 test_257() {
18029         remote_mds_nodsh && skip "remote MDS with nodsh"
18030         [[ $MDS1_VERSION -lt $(version_code 2.8.55) ]] &&
18031                 skip "Need MDS version at least 2.8.55"
18032
18033         test_mkdir $DIR/$tdir
18034
18035         setfattr -n trusted.name1 -v value1 $DIR/$tdir ||
18036                 error "setfattr -n trusted.name1=value1 $DIR/$tdir failed"
18037         stat $DIR/$tdir
18038
18039 #define OBD_FAIL_MDS_XATTR_REP                  0x161
18040         local mdtidx=$($LFS getstripe -m $DIR/$tdir)
18041         local facet=mds$((mdtidx + 1))
18042         set_nodes_failloc $(facet_active_host $facet) 0x80000161
18043         getfattr -n trusted.name1 $DIR/$tdir 2> /dev/null
18044
18045         stop $facet || error "stop MDS failed"
18046         start $facet $(mdsdevname $((mdtidx + 1))) $MDS_MOUNT_OPTS ||
18047                 error "start MDS fail"
18048         wait_recovery_complete $facet
18049 }
18050 run_test 257 "xattr locks are not lost"
18051
18052 # Verify we take the i_mutex when security requires it
18053 test_258a() {
18054 #define OBD_FAIL_IMUTEX_SEC 0x141c
18055         $LCTL set_param fail_loc=0x141c
18056         touch $DIR/$tfile
18057         chmod u+s $DIR/$tfile
18058         chmod a+rwx $DIR/$tfile
18059         $RUNAS dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 oflag=append
18060         RC=$?
18061         if [ $RC -ne 0 ]; then
18062                 error "error, failed to take i_mutex, rc=$?"
18063         fi
18064         rm -f $DIR/$tfile
18065 }
18066 run_test 258a "verify i_mutex security behavior when suid attributes is set"
18067
18068 # Verify we do NOT take the i_mutex in the normal case
18069 test_258b() {
18070 #define OBD_FAIL_IMUTEX_NOSEC 0x141d
18071         $LCTL set_param fail_loc=0x141d
18072         touch $DIR/$tfile
18073         chmod a+rwx $DIR
18074         chmod a+rw $DIR/$tfile
18075         $RUNAS dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 oflag=append
18076         RC=$?
18077         if [ $RC -ne 0 ]; then
18078                 error "error, took i_mutex unnecessarily, rc=$?"
18079         fi
18080         rm -f $DIR/$tfile
18081
18082 }
18083 run_test 258b "verify i_mutex security behavior"
18084
18085 test_259() {
18086         local file=$DIR/$tfile
18087         local before
18088         local after
18089
18090         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip "ldiskfs only test"
18091
18092         stack_trap "rm -f $file" EXIT
18093
18094         wait_delete_completed
18095         before=$(do_facet ost1 "$LCTL get_param -n osd-*.*OST0000.kbytesfree")
18096         echo "before: $before"
18097
18098         $LFS setstripe -i 0 -c 1 $file
18099         dd if=/dev/zero of=$file bs=1M count=10 || error "couldn't write"
18100         sync_all_data
18101         after=$(do_facet ost1 "$LCTL get_param -n osd-*.*OST0000.kbytesfree")
18102         echo "after write: $after"
18103
18104 #define OBD_FAIL_OSD_FAIL_AT_TRUNCATE          0x2301
18105         do_facet ost1 $LCTL set_param fail_loc=0x2301
18106         $TRUNCATE $file 0
18107         after=$(do_facet ost1 "$LCTL get_param -n osd-*.*OST0000.kbytesfree")
18108         echo "after truncate: $after"
18109
18110         stop ost1
18111         do_facet ost1 $LCTL set_param fail_loc=0
18112         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS || error "cannot start ost1"
18113         sleep 2
18114         after=$(do_facet ost1 "$LCTL get_param -n osd-*.*OST0000.kbytesfree")
18115         echo "after restart: $after"
18116         [ $((after - before)) -ge $(fs_log_size ost1) ] &&
18117                 error "missing truncate?"
18118
18119         return 0
18120 }
18121 run_test 259 "crash at delayed truncate"
18122
18123 test_260() {
18124 #define OBD_FAIL_MDC_CLOSE               0x806
18125         $LCTL set_param fail_loc=0x80000806
18126         touch $DIR/$tfile
18127
18128 }
18129 run_test 260 "Check mdc_close fail"
18130
18131 ### Data-on-MDT sanity tests ###
18132 test_270a() {
18133         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18134                 skip "Need MDS version at least 2.10.55 for DoM"
18135
18136         # create DoM file
18137         local dom=$DIR/$tdir/dom_file
18138         local tmp=$DIR/$tdir/tmp_file
18139
18140         mkdir -p $DIR/$tdir
18141
18142         # basic checks for DoM component creation
18143         $LFS setstripe -E 1024K -E 2048K -L mdt $dom 2>/dev/null &&
18144                 error "Can set MDT layout to non-first entry"
18145
18146         $LFS setstripe -E 1024K -L mdt -E 2048K -L mdt $dom 2>/dev/null &&
18147                 error "Can define multiple entries as MDT layout"
18148
18149         $LFS setstripe -E 1M -L mdt $dom || error "Can't create DoM layout"
18150
18151         [ $($LFS getstripe -L $dom) == "mdt" ] || error "bad pattern"
18152         [ $($LFS getstripe -c $dom) == 0 ] || error "bad stripe count"
18153         [ $($LFS getstripe -S $dom) == 1048576 ] || error "bad stripe size"
18154
18155         local mdtidx=$($LFS getstripe -m $dom)
18156         local mdtname=MDT$(printf %04x $mdtidx)
18157         local facet=mds$((mdtidx + 1))
18158         local space_check=1
18159
18160         # Skip free space checks with ZFS
18161         [ "$(facet_fstype $facet)" == "zfs" ] && space_check=0
18162
18163         # write
18164         sync
18165         local size_tmp=$((65536 * 3))
18166         local mdtfree1=$(do_facet $facet \
18167                          lctl get_param -n osd*.*$mdtname.kbytesfree)
18168
18169         dd if=/dev/urandom of=$tmp bs=1024 count=$((size_tmp / 1024))
18170         # check also direct IO along write
18171         # IO size must be a multiple of PAGE_SIZE on all platforms (ARM=64KB)
18172         dd if=$tmp of=$dom bs=65536 count=$((size_tmp / 65536)) oflag=direct
18173         sync
18174         cmp $tmp $dom || error "file data is different"
18175         [ $(stat -c%s $dom) == $size_tmp ] ||
18176                 error "bad size after write: $(stat -c%s $dom) != $size_tmp"
18177         if [ $space_check == 1 ]; then
18178                 local mdtfree2=$(do_facet $facet \
18179                                  lctl get_param -n osd*.*$mdtname.kbytesfree)
18180
18181                 # increase in usage from by $size_tmp
18182                 [ $(($mdtfree1 - $mdtfree2)) -ge $((size_tmp / 1024)) ] ||
18183                         error "MDT free space wrong after write: " \
18184                               "$mdtfree1 >= $mdtfree2 + $size_tmp/1024"
18185         fi
18186
18187         # truncate
18188         local size_dom=10000
18189
18190         $TRUNCATE $dom $size_dom
18191         [ $(stat -c%s $dom) == $size_dom ] ||
18192                 error "bad size after truncate: $(stat -c%s $dom) != $size_dom"
18193         if [ $space_check == 1 ]; then
18194                 mdtfree1=$(do_facet $facet \
18195                                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18196                 # decrease in usage from $size_tmp to new $size_dom
18197                 [ $(($mdtfree1 - $mdtfree2)) -ge \
18198                   $(((size_tmp - size_dom) / 1024)) ] ||
18199                         error "MDT free space is wrong after truncate: " \
18200                               "$mdtfree1 >= $mdtfree2 + ($size_tmp - $size_dom) / 1024"
18201         fi
18202
18203         # append
18204         cat $tmp >> $dom
18205         sync
18206         size_dom=$((size_dom + size_tmp))
18207         [ $(stat -c%s $dom) == $size_dom ] ||
18208                 error "bad size after append: $(stat -c%s $dom) != $size_dom"
18209         if [ $space_check == 1 ]; then
18210                 mdtfree2=$(do_facet $facet \
18211                                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18212                 # increase in usage by $size_tmp from previous
18213                 [ $(($mdtfree1 - $mdtfree2)) -ge $((size_tmp / 1024)) ] ||
18214                         error "MDT free space is wrong after append: " \
18215                               "$mdtfree1 >= $mdtfree2 + $size_tmp/1024"
18216         fi
18217
18218         # delete
18219         rm $dom
18220         if [ $space_check == 1 ]; then
18221                 mdtfree1=$(do_facet $facet \
18222                                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18223                 # decrease in usage by $size_dom from previous
18224                 [ $(($mdtfree1 - $mdtfree2)) -ge $((size_dom / 1024)) ] ||
18225                         error "MDT free space is wrong after removal: " \
18226                               "$mdtfree1 >= $mdtfree2 + $size_dom/1024"
18227         fi
18228
18229         # combined striping
18230         $LFS setstripe -E 1024K -L mdt -E EOF $dom ||
18231                 error "Can't create DoM + OST striping"
18232
18233         size_tmp=2031616 # must be a multiple of PAGE_SIZE=65536 on ARM
18234         dd if=/dev/urandom of=$tmp bs=1024 count=$((size_tmp / 1024))
18235         # check also direct IO along write
18236         dd if=$tmp of=$dom bs=65536 count=$((size_tmp / 65536)) oflag=direct
18237         sync
18238         cmp $tmp $dom || error "file data is different"
18239         [ $(stat -c%s $dom) == $size_tmp ] ||
18240                 error "bad size after write: $(stat -c%s $dom) != $size_tmp"
18241         rm $dom $tmp
18242
18243         return 0
18244 }
18245 run_test 270a "DoM: basic functionality tests"
18246
18247 test_270b() {
18248         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18249                 skip "Need MDS version at least 2.10.55"
18250
18251         local dom=$DIR/$tdir/dom_file
18252         local max_size=1048576
18253
18254         mkdir -p $DIR/$tdir
18255         $LFS setstripe -E $max_size -L mdt $dom
18256
18257         # truncate over the limit
18258         $TRUNCATE $dom $(($max_size + 1)) &&
18259                 error "successful truncate over the maximum size"
18260         # write over the limit
18261         dd if=/dev/zero of=$dom bs=$max_size seek=1 count=1 &&
18262                 error "successful write over the maximum size"
18263         # append over the limit
18264         dd if=/dev/zero of=$dom bs=$(($max_size - 3)) count=1
18265         echo "12345" >> $dom && error "successful append over the maximum size"
18266         rm $dom
18267
18268         return 0
18269 }
18270 run_test 270b "DoM: maximum size overflow checks for DoM-only file"
18271
18272 test_270c() {
18273         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18274                 skip "Need MDS version at least 2.10.55"
18275
18276         mkdir -p $DIR/$tdir
18277         $LFS setstripe -E 1024K -L mdt $DIR/$tdir
18278
18279         # check files inherit DoM EA
18280         touch $DIR/$tdir/first
18281         [ $($LFS getstripe -L $DIR/$tdir/first) == "mdt" ] ||
18282                 error "bad pattern"
18283         [ $($LFS getstripe -c $DIR/$tdir/first) == 0 ] ||
18284                 error "bad stripe count"
18285         [ $($LFS getstripe -S $DIR/$tdir/first) == 1048576 ] ||
18286                 error "bad stripe size"
18287
18288         # check directory inherits DoM EA and uses it as default
18289         mkdir $DIR/$tdir/subdir
18290         touch $DIR/$tdir/subdir/second
18291         [ $($LFS getstripe -L $DIR/$tdir/subdir/second) == "mdt" ] ||
18292                 error "bad pattern in sub-directory"
18293         [ $($LFS getstripe -c $DIR/$tdir/subdir/second) == 0 ] ||
18294                 error "bad stripe count in sub-directory"
18295         [ $($LFS getstripe -S $DIR/$tdir/subdir/second) == 1048576 ] ||
18296                 error "bad stripe size in sub-directory"
18297         return 0
18298 }
18299 run_test 270c "DoM: DoM EA inheritance tests"
18300
18301 test_270d() {
18302         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18303                 skip "Need MDS version at least 2.10.55"
18304
18305         mkdir -p $DIR/$tdir
18306         $LFS setstripe -E 1024K -L mdt $DIR/$tdir
18307
18308         # inherit default DoM striping
18309         mkdir $DIR/$tdir/subdir
18310         touch $DIR/$tdir/subdir/f1
18311
18312         # change default directory striping
18313         $LFS setstripe -c 1 $DIR/$tdir/subdir
18314         touch $DIR/$tdir/subdir/f2
18315         [ $($LFS getstripe -c $DIR/$tdir/subdir/f2) == 1 ] ||
18316                 error "wrong default striping in file 2"
18317         [ $($LFS getstripe -L $DIR/$tdir/subdir/f2) == "raid0" ] ||
18318                 error "bad pattern in file 2"
18319         return 0
18320 }
18321 run_test 270d "DoM: change striping from DoM to RAID0"
18322
18323 test_270e() {
18324         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18325                 skip "Need MDS version at least 2.10.55"
18326
18327         mkdir -p $DIR/$tdir/dom
18328         mkdir -p $DIR/$tdir/norm
18329         DOMFILES=20
18330         NORMFILES=10
18331         $LFS setstripe -E 1M -L mdt $DIR/$tdir/dom
18332         $LFS setstripe -i 0 -S 2M $DIR/$tdir/norm
18333
18334         createmany -o $DIR/$tdir/dom/dom- $DOMFILES
18335         createmany -o $DIR/$tdir/norm/norm- $NORMFILES
18336
18337         # find DoM files by layout
18338         NUM=$($LFS find -L mdt -type f $DIR/$tdir 2>/dev/null | wc -l)
18339         [ $NUM -eq  $DOMFILES ] ||
18340                 error "lfs find -L: found $NUM, expected $DOMFILES"
18341         echo "Test 1: lfs find 20 DOM files by layout: OK"
18342
18343         # there should be 1 dir with default DOM striping
18344         NUM=$($LFS find -L mdt -type d $DIR/$tdir 2>/dev/null | wc -l)
18345         [ $NUM -eq  1 ] ||
18346                 error "lfs find -L: found $NUM, expected 1 dir"
18347         echo "Test 2: lfs find 1 DOM dir by layout: OK"
18348
18349         # find DoM files by stripe size
18350         NUM=$($LFS find -S -1200K -type f $DIR/$tdir 2>/dev/null | wc -l)
18351         [ $NUM -eq  $DOMFILES ] ||
18352                 error "lfs find -S: found $NUM, expected $DOMFILES"
18353         echo "Test 4: lfs find 20 DOM files by stripe size: OK"
18354
18355         # find files by stripe offset except DoM files
18356         NUM=$($LFS find -i 0 -type f $DIR/$tdir 2>/dev/null | wc -l)
18357         [ $NUM -eq  $NORMFILES ] ||
18358                 error "lfs find -i: found $NUM, expected $NORMFILES"
18359         echo "Test 5: lfs find no DOM files by stripe index: OK"
18360         return 0
18361 }
18362 run_test 270e "DoM: lfs find with DoM files test"
18363
18364 test_270f() {
18365         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18366                 skip "Need MDS version at least 2.10.55"
18367
18368         local mdtname=${FSNAME}-MDT0000-mdtlov
18369         local dom=$DIR/$tdir/dom_file
18370         local dom_limit_saved=$(do_facet mds1 $LCTL get_param -n \
18371                                                 lod.$mdtname.dom_stripesize)
18372         local dom_limit=131072
18373
18374         do_facet mds1 $LCTL set_param -n lod.$mdtname.dom_stripesize=$dom_limit
18375         local dom_current=$(do_facet mds1 $LCTL get_param -n \
18376                                                 lod.$mdtname.dom_stripesize)
18377         [ ${dom_limit} -eq ${dom_current} ] ||
18378                 error "Cannot change per-MDT DoM stripe limit to $dom_limit"
18379
18380         $LFS mkdir -i 0 -c 1 $DIR/$tdir
18381         $LFS setstripe -d $DIR/$tdir
18382         $LFS setstripe -E $dom_limit -L mdt $DIR/$tdir ||
18383                 error "Can't set directory default striping"
18384
18385         # exceed maximum stripe size
18386         $LFS setstripe -E $((dom_limit * 2)) -L mdt $dom ||
18387                 error "Can't create file with $((dom_limit * 2)) DoM stripe"
18388         [ $($LFS getstripe -S $dom) -eq $((dom_limit * 2)) ] &&
18389                 error "Able to create DoM component size more than LOD limit"
18390
18391         do_facet mds1 $LCTL set_param -n lod.$mdtname.dom_stripesize=0
18392         dom_current=$(do_facet mds1 $LCTL get_param -n \
18393                                                 lod.$mdtname.dom_stripesize)
18394         [ 0 -eq ${dom_current} ] ||
18395                 error "Can't set zero DoM stripe limit"
18396         rm $dom
18397
18398         # attempt to create DoM file on server with disabled DoM should
18399         # remove DoM entry from layout and be succeed
18400         $LFS setstripe -E $dom_limit -L mdt -E -1 $dom ||
18401                 error "Can't create DoM file (DoM is disabled)"
18402         [ $($LFS getstripe -L $dom) == "mdt" ] &&
18403                 error "File has DoM component while DoM is disabled"
18404         rm $dom
18405
18406         # attempt to create DoM file with only DoM stripe should return error
18407         $LFS setstripe -E $dom_limit -L mdt $dom &&
18408                 error "Able to create DoM-only file while DoM is disabled"
18409
18410         # too low values to be aligned with smallest stripe size 64K
18411         do_facet mds1 $LCTL set_param -n lod.$mdtname.dom_stripesize=30000
18412         dom_current=$(do_facet mds1 $LCTL get_param -n \
18413                                                 lod.$mdtname.dom_stripesize)
18414         [ 30000 -eq ${dom_current} ] &&
18415                 error "Can set too small DoM stripe limit"
18416
18417         # 64K is a minimal stripe size in Lustre, expect limit of that size
18418         [ 65536 -eq ${dom_current} ] ||
18419                 error "Limit is not set to 64K but ${dom_current}"
18420
18421         do_facet mds1 $LCTL set_param -n lod.$mdtname.dom_stripesize=2147483648
18422         dom_current=$(do_facet mds1 $LCTL get_param -n \
18423                                                 lod.$mdtname.dom_stripesize)
18424         echo $dom_current
18425         [ 2147483648 -eq ${dom_current} ] &&
18426                 error "Can set too large DoM stripe limit"
18427
18428         do_facet mds1 $LCTL set_param -n \
18429                                 lod.$mdtname.dom_stripesize=$((dom_limit * 2))
18430         $LFS setstripe -E $((dom_limit * 2)) -L mdt $dom ||
18431                 error "Can't create DoM component size after limit change"
18432         do_facet mds1 $LCTL set_param -n \
18433                                 lod.$mdtname.dom_stripesize=$((dom_limit / 2))
18434         $LFS setstripe -E $dom_limit -L mdt ${dom}_big ||
18435                 error "Can't create DoM file after limit decrease"
18436         [ $($LFS getstripe -S ${dom}_big) -eq $((dom_limit / 2)) ] ||
18437                 error "Can create big DoM component after limit decrease"
18438         touch ${dom}_def ||
18439                 error "Can't create file with old default layout"
18440
18441         do_facet mds1 $LCTL set_param -n lod.*.dom_stripesize=$dom_limit_saved
18442         return 0
18443 }
18444 run_test 270f "DoM: maximum DoM stripe size checks"
18445
18446 test_271a() {
18447         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18448                 skip "Need MDS version at least 2.10.55"
18449
18450         local dom=$DIR/$tdir/dom
18451
18452         mkdir -p $DIR/$tdir
18453
18454         $LFS setstripe -E 1024K -L mdt $dom
18455
18456         lctl set_param -n mdc.*.stats=clear
18457         dd if=/dev/zero of=$dom bs=4096 count=1 || return 1
18458         cat $dom > /dev/null
18459         local reads=$(lctl get_param -n mdc.*.stats | grep -c ost_read)
18460         [ $reads -eq 0 ] || error "Unexpected $reads READ RPCs"
18461         ls $dom
18462         rm -f $dom
18463 }
18464 run_test 271a "DoM: data is cached for read after write"
18465
18466 test_271b() {
18467         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18468                 skip "Need MDS version at least 2.10.55"
18469
18470         local dom=$DIR/$tdir/dom
18471
18472         mkdir -p $DIR/$tdir
18473
18474         $LFS setstripe -E 1024K -L mdt -E EOF $dom
18475
18476         lctl set_param -n mdc.*.stats=clear
18477         dd if=/dev/zero of=$dom bs=4096 count=1 || return 1
18478         cancel_lru_locks mdc
18479         $CHECKSTAT -t file -s 4096 $dom || error "stat #1 fails"
18480         # second stat to check size is cached on client
18481         $CHECKSTAT -t file -s 4096 $dom || error "stat #2 fails"
18482         local gls=$(lctl get_param -n mdc.*.stats | grep -c ldlm_glimpse)
18483         [ $gls -eq 0 ] || error "Unexpected $gls glimpse RPCs"
18484         rm -f $dom
18485 }
18486 run_test 271b "DoM: no glimpse RPC for stat (DoM only file)"
18487
18488 test_271ba() {
18489         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18490                 skip "Need MDS version at least 2.10.55"
18491
18492         local dom=$DIR/$tdir/dom
18493
18494         mkdir -p $DIR/$tdir
18495
18496         $LFS setstripe -E 1024K -L mdt -E EOF $dom
18497
18498         lctl set_param -n mdc.*.stats=clear
18499         lctl set_param -n osc.*.stats=clear
18500         dd if=/dev/zero of=$dom bs=2048K count=1 || return 1
18501         cancel_lru_locks mdc
18502         $CHECKSTAT -t file -s 2097152 $dom || error "stat"
18503         # second stat to check size is cached on client
18504         $CHECKSTAT -t file -s 2097152 $dom || error "stat"
18505         local gls=$(lctl get_param -n mdc.*.stats | grep -c ldlm_glimpse)
18506         [ $gls == 0 ] || error "Unexpected $gls glimpse RPCs"
18507         local gls=$(lctl get_param -n osc.*.stats | grep -c ldlm_glimpse)
18508         [ $gls == 0 ] || error "Unexpected $gls OSC glimpse RPCs"
18509         rm -f $dom
18510 }
18511 run_test 271ba "DoM: no glimpse RPC for stat (combined file)"
18512
18513
18514 get_mdc_stats() {
18515         local mdtidx=$1
18516         local param=$2
18517         local mdt=MDT$(printf %04x $mdtidx)
18518
18519         if [ -z $param ]; then
18520                 lctl get_param -n mdc.*$mdt*.stats
18521         else
18522                 lctl get_param -n mdc.*$mdt*.stats | awk "/$param/"'{print $2}'
18523         fi
18524 }
18525
18526 test_271c() {
18527         [ $MDS1_VERSION -lt $(version_code 2.10.55) ] &&
18528                 skip "Need MDS version at least 2.10.55"
18529
18530         local dom=$DIR/$tdir/dom
18531
18532         mkdir -p $DIR/$tdir
18533
18534         $LFS setstripe -E 1024K -L mdt $DIR/$tdir
18535
18536         local mdtidx=$($LFS getstripe -m $DIR/$tdir)
18537         local facet=mds$((mdtidx + 1))
18538
18539         cancel_lru_locks mdc
18540         do_facet $facet lctl set_param -n mdt.*.dom_lock=0
18541         createmany -o $dom 1000
18542         lctl set_param -n mdc.*.stats=clear
18543         smalliomany -w $dom 1000 200
18544         get_mdc_stats $mdtidx
18545         local enq=$(get_mdc_stats $mdtidx ldlm_ibits_enqueue)
18546         # Each file has 1 open, 1 IO enqueues, total 2000
18547         # but now we have also +1 getxattr for security.capability, total 3000
18548         [ $enq -ge 2000 ] || error "Too few enqueues $enq, expected > 2000"
18549         unlinkmany $dom 1000
18550
18551         cancel_lru_locks mdc
18552         do_facet $facet lctl set_param -n mdt.*.dom_lock=1
18553         createmany -o $dom 1000
18554         lctl set_param -n mdc.*.stats=clear
18555         smalliomany -w $dom 1000 200
18556         local enq_2=$(get_mdc_stats $mdtidx ldlm_ibits_enqueue)
18557         # Expect to see reduced amount of RPCs by 1000 due to single enqueue
18558         # for OPEN and IO lock.
18559         [ $((enq - enq_2)) -ge 1000 ] ||
18560                 error "Too many enqueues $enq_2, expected about $((enq - 1000))"
18561         unlinkmany $dom 1000
18562         return 0
18563 }
18564 run_test 271c "DoM: IO lock at open saves enqueue RPCs"
18565
18566 cleanup_271def_tests() {
18567         trap 0
18568         rm -f $1
18569 }
18570
18571 test_271d() {
18572         [ $MDS1_VERSION -lt $(version_code 2.10.57) ] &&
18573                 skip "Need MDS version at least 2.10.57"
18574
18575         local dom=$DIR/$tdir/dom
18576         local tmp=$TMP/$tfile
18577         trap "cleanup_271def_tests $tmp" EXIT
18578
18579         mkdir -p $DIR/$tdir
18580
18581         $LFS setstripe -E 1024K -L mdt $DIR/$tdir
18582
18583         local mdtidx=$($LFS getstripe --mdt-index $DIR/$tdir)
18584
18585         cancel_lru_locks mdc
18586         dd if=/dev/urandom of=$tmp bs=1000 count=1
18587         dd if=$tmp of=$dom bs=1000 count=1
18588         cancel_lru_locks mdc
18589
18590         cat /etc/hosts >> $tmp
18591         lctl set_param -n mdc.*.stats=clear
18592
18593         # append data to the same file it should update local page
18594         echo "Append to the same page"
18595         cat /etc/hosts >> $dom
18596         local num=$(get_mdc_stats $mdtidx ost_read)
18597         local ra=$(get_mdc_stats $mdtidx req_active)
18598         local rw=$(get_mdc_stats $mdtidx req_waittime)
18599
18600         [ -z $num ] || error "$num READ RPC occured"
18601         [ $ra == $rw ] || error "$((ra - rw)) resend occured"
18602         echo "... DONE"
18603
18604         # compare content
18605         cmp $tmp $dom || error "file miscompare"
18606
18607         cancel_lru_locks mdc
18608         lctl set_param -n mdc.*.stats=clear
18609
18610         echo "Open and read file"
18611         cat $dom > /dev/null
18612         local num=$(get_mdc_stats $mdtidx ost_read)
18613         local ra=$(get_mdc_stats $mdtidx req_active)
18614         local rw=$(get_mdc_stats $mdtidx req_waittime)
18615
18616         [ -z $num ] || error "$num READ RPC occured"
18617         [ $ra == $rw ] || error "$((ra - rw)) resend occured"
18618         echo "... DONE"
18619
18620         # compare content
18621         cmp $tmp $dom || error "file miscompare"
18622
18623         return 0
18624 }
18625 run_test 271d "DoM: read on open (1K file in reply buffer)"
18626
18627 test_271f() {
18628         [ $MDS1_VERSION -lt $(version_code 2.10.57) ] &&
18629                 skip "Need MDS version at least 2.10.57"
18630
18631         local dom=$DIR/$tdir/dom
18632         local tmp=$TMP/$tfile
18633         trap "cleanup_271def_tests $tmp" EXIT
18634
18635         mkdir -p $DIR/$tdir
18636
18637         $LFS setstripe -E 1024K -L mdt $DIR/$tdir
18638
18639         local mdtidx=$($LFS getstripe --mdt-index $DIR/$tdir)
18640
18641         cancel_lru_locks mdc
18642         dd if=/dev/urandom of=$tmp bs=265000 count=1
18643         dd if=$tmp of=$dom bs=265000 count=1
18644         cancel_lru_locks mdc
18645         cat /etc/hosts >> $tmp
18646         lctl set_param -n mdc.*.stats=clear
18647
18648         echo "Append to the same page"
18649         cat /etc/hosts >> $dom
18650         local num=$(get_mdc_stats $mdtidx ost_read)
18651         local ra=$(get_mdc_stats $mdtidx req_active)
18652         local rw=$(get_mdc_stats $mdtidx req_waittime)
18653
18654         [ -z $num ] || error "$num READ RPC occured"
18655         [ $ra == $rw ] || error "$((ra - rw)) resend occured"
18656         echo "... DONE"
18657
18658         # compare content
18659         cmp $tmp $dom || error "file miscompare"
18660
18661         cancel_lru_locks mdc
18662         lctl set_param -n mdc.*.stats=clear
18663
18664         echo "Open and read file"
18665         cat $dom > /dev/null
18666         local num=$(get_mdc_stats $mdtidx ost_read)
18667         local ra=$(get_mdc_stats $mdtidx req_active)
18668         local rw=$(get_mdc_stats $mdtidx req_waittime)
18669
18670         [ -z $num ] && num=0
18671         [ $num -eq 1 ] || error "expect 1 READ RPC, $num occured"
18672         [ $ra == $rw ] || error "$((ra - rw)) resend occured"
18673         echo "... DONE"
18674
18675         # compare content
18676         cmp $tmp $dom || error "file miscompare"
18677
18678         return 0
18679 }
18680 run_test 271f "DoM: read on open (200K file and read tail)"
18681
18682 test_271g() {
18683         [[ $($LCTL get_param mdc.*.import) =~ async_discard ]] ||
18684                 skip "Skipping due to old client or server version"
18685
18686         $LFS setstripe -E 1024K -L mdt -E EOF $DIR1/$tfile
18687         # to get layout
18688         $CHECKSTAT -t file $DIR1/$tfile
18689
18690         $MULTIOP $DIR1/$tfile Ow40960_w4096c &
18691         MULTIOP_PID=$!
18692         sleep 1
18693         #define OBD_FAIL_LDLM_CANCEL_BL_CB_RACE
18694         $LCTL set_param fail_loc=0x80000314
18695         rm $DIR1/$tfile || error "Unlink fails"
18696         RC=$?
18697         kill -USR1 $MULTIOP_PID && wait $MULTIOP_PID || error "multiop failure"
18698         [ $RC -eq 0 ] || error "Failed write to stale object"
18699 }
18700 run_test 271g "Discard DoM data vs client flush race"
18701
18702 test_272a() {
18703         [ $MDS1_VERSION -lt $(version_code 2.11.50) ] &&
18704                 skip "Need MDS version at least 2.11.50"
18705
18706         local dom=$DIR/$tdir/dom
18707         mkdir -p $DIR/$tdir
18708
18709         $LFS setstripe -E 256K -L mdt -E -1 -c1 $dom
18710         dd if=/dev/urandom of=$dom bs=512K count=1 ||
18711                 error "failed to write data into $dom"
18712         local old_md5=$(md5sum $dom)
18713
18714         $LFS migrate -E 256K -L mdt -E -1 -c2 $dom ||
18715                 error "failed to migrate to the same DoM component"
18716
18717         local new_md5=$(md5sum $dom)
18718
18719         [ "$old_md5" == "$new_md5" ] ||
18720                 error "md5sum differ: $old_md5, $new_md5"
18721
18722         [ $($LFS getstripe -c $dom) -eq 2 ] ||
18723                 error "migrate stripe count bad: $(LFS getstripe -c $dom) != 2"
18724 }
18725 run_test 272a "DoM migration: new layout with the same DOM component"
18726
18727 test_272b() {
18728         [ $MDS1_VERSION -lt $(version_code 2.11.50) ] &&
18729                 skip "Need MDS version at least 2.11.50"
18730
18731         local dom=$DIR/$tdir/dom
18732         mkdir -p $DIR/$tdir
18733         $LFS setstripe -E 1M -L mdt -E -1 -c1 $dom
18734
18735         local mdtidx=$($LFS getstripe -m $dom)
18736         local mdtname=MDT$(printf %04x $mdtidx)
18737         local facet=mds$((mdtidx + 1))
18738
18739         local mdtfree1=$(do_facet $facet \
18740                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18741         dd if=/dev/urandom of=$dom bs=2M count=1 ||
18742                 error "failed to write data into $dom"
18743         local old_md5=$(md5sum $dom)
18744         cancel_lru_locks mdc
18745         local mdtfree1=$(do_facet $facet \
18746                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18747
18748         $LFS migrate -c2 $dom ||
18749                 error "failed to migrate to the new composite layout"
18750         [ $($LFS getstripe -L $dom) != 'mdt' ] ||
18751                 error "MDT stripe was not removed"
18752
18753         cancel_lru_locks mdc
18754         local new_md5=$(md5sum $dom)
18755         [ "$old_md5" == "$new_md5" ] ||
18756                 error "$old_md5 != $new_md5"
18757
18758         # Skip free space checks with ZFS
18759         if [ "$(facet_fstype $facet)" != "zfs" ]; then
18760                 local mdtfree2=$(do_facet $facet \
18761                                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18762                 [ $mdtfree2 -gt $mdtfree1 ] ||
18763                         error "MDT space is not freed after migration"
18764         fi
18765         return 0
18766 }
18767 run_test 272b "DoM migration: DOM file to the OST-striped file (plain)"
18768
18769 test_272c() {
18770         [ $MDS1_VERSION -lt $(version_code 2.11.50) ] &&
18771                 skip "Need MDS version at least 2.11.50"
18772
18773         local dom=$DIR/$tdir/$tfile
18774         mkdir -p $DIR/$tdir
18775         $LFS setstripe -E 1M -L mdt -E -1 -c1 $dom
18776
18777         local mdtidx=$($LFS getstripe -m $dom)
18778         local mdtname=MDT$(printf %04x $mdtidx)
18779         local facet=mds$((mdtidx + 1))
18780
18781         dd if=/dev/urandom of=$dom bs=2M count=1 oflag=direct ||
18782                 error "failed to write data into $dom"
18783         local old_md5=$(md5sum $dom)
18784         cancel_lru_locks mdc
18785         local mdtfree1=$(do_facet $facet \
18786                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18787
18788         $LFS migrate -E 2M -c1 -E -1 -c2 $dom ||
18789                 error "failed to migrate to the new composite layout"
18790         [ $($LFS getstripe -L $dom) == 'mdt' ] &&
18791                 error "MDT stripe was not removed"
18792
18793         cancel_lru_locks mdc
18794         local new_md5=$(md5sum $dom)
18795         [ "$old_md5" == "$new_md5" ] ||
18796                 error "$old_md5 != $new_md5"
18797
18798         # Skip free space checks with ZFS
18799         if [ "$(facet_fstype $facet)" != "zfs" ]; then
18800                 local mdtfree2=$(do_facet $facet \
18801                                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18802                 [ $mdtfree2 -gt $mdtfree1 ] ||
18803                         error "MDS space is not freed after migration"
18804         fi
18805         return 0
18806 }
18807 run_test 272c "DoM migration: DOM file to the OST-striped file (composite)"
18808
18809 test_272d() {
18810         [ $MDS1_VERSION -lt $(version_code 2.12.55) ] &&
18811                 skip "Need MDS version at least 2.12.55"
18812
18813         local dom=$DIR/$tdir/$tfile
18814         mkdir -p $DIR/$tdir
18815         $LFS setstripe -E 1M -L mdt -E -1 -c1 $dom
18816
18817         local mdtidx=$($LFS getstripe -m $dom)
18818         local mdtname=MDT$(printf %04x $mdtidx)
18819         local facet=mds$((mdtidx + 1))
18820
18821         dd if=/dev/urandom of=$dom bs=2M count=1 oflag=direct ||
18822                 error "failed to write data into $dom"
18823         local old_md5=$(md5sum $dom)
18824         cancel_lru_locks mdc
18825         local mdtfree1=$(do_facet $facet \
18826                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18827
18828         $LFS mirror extend -N -E 2M -c1 -E -1 -c2 $dom ||
18829                 error "failed mirroring to the new composite layout"
18830         $LFS mirror resync $dom ||
18831                 error "failed mirror resync"
18832         $LFS mirror split --mirror-id 1 -d $dom ||
18833                 error "failed mirror split"
18834
18835         [ $($LFS getstripe -L $dom) != 'mdt' ] ||
18836                 error "MDT stripe was not removed"
18837
18838         cancel_lru_locks mdc
18839         local new_md5=$(md5sum $dom)
18840         [ "$old_md5" == "$new_md5" ] ||
18841                 error "$old_md5 != $new_md5"
18842
18843         # Skip free space checks with ZFS
18844         if [ "$(facet_fstype $facet)" != "zfs" ]; then
18845                 local mdtfree2=$(do_facet $facet \
18846                                 lctl get_param -n osd*.*$mdtname.kbytesfree)
18847                 [ $mdtfree2 -gt $mdtfree1 ] ||
18848                         error "MDS space is not freed after DOM mirror deletion"
18849         fi
18850         return 0
18851 }
18852 run_test 272d "DoM mirroring: OST-striped mirror to DOM file"
18853
18854 test_272e() {
18855         [ $MDS1_VERSION -lt $(version_code 2.12.55) ] &&
18856                 skip "Need MDS version at least 2.12.55"
18857
18858         local dom=$DIR/$tdir/$tfile
18859         mkdir -p $DIR/$tdir
18860         $LFS setstripe -c 2 $dom
18861
18862         dd if=/dev/urandom of=$dom bs=512K count=1 oflag=direct ||
18863                 error "failed to write data into $dom"
18864         local old_md5=$(md5sum $dom)
18865         cancel_lru_locks mdc
18866
18867         $LFS mirror extend -N -E 1M -L mdt -E eof -c2 $dom ||
18868                 error "failed mirroring to the DOM layout"
18869         $LFS mirror resync $dom ||
18870                 error "failed mirror resync"
18871         $LFS mirror split --mirror-id 1 -d $dom ||
18872                 error "failed mirror split"
18873
18874         [ $($LFS getstripe -L $dom) != 'mdt' ] ||
18875                 error "MDT stripe was not removed"
18876
18877         cancel_lru_locks mdc
18878         local new_md5=$(md5sum $dom)
18879         [ "$old_md5" == "$new_md5" ] ||
18880                 error "$old_md5 != $new_md5"
18881
18882         return 0
18883 }
18884 run_test 272e "DoM mirroring: DOM mirror to the OST-striped file"
18885
18886 test_272f() {
18887         [ $MDS1_VERSION -lt $(version_code 2.12.55) ] &&
18888                 skip "Need MDS version at least 2.12.55"
18889
18890         local dom=$DIR/$tdir/$tfile
18891         mkdir -p $DIR/$tdir
18892         $LFS setstripe -c 2 $dom
18893
18894         dd if=/dev/urandom of=$dom bs=512K count=1 oflag=direct ||
18895                 error "failed to write data into $dom"
18896         local old_md5=$(md5sum $dom)
18897         cancel_lru_locks mdc
18898
18899         $LFS migrate -E 1M -L mdt -E eof -c2 -v $dom ||
18900                 error "failed migrating to the DOM file"
18901
18902         cancel_lru_locks mdc
18903         local new_md5=$(md5sum $dom)
18904         [ "$old_md5" != "$new_md5" ] &&
18905                 error "$old_md5 != $new_md5"
18906
18907         return 0
18908 }
18909 run_test 272f "DoM migration: OST-striped file to DOM file"
18910
18911 test_273a() {
18912         [ $MDS1_VERSION -lt $(version_code 2.11.50) ] &&
18913                 skip "Need MDS version at least 2.11.50"
18914
18915         # Layout swap cannot be done if either file has DOM component,
18916         # this will never be supported, migration should be used instead
18917
18918         local dom=$DIR/$tdir/$tfile
18919         mkdir -p $DIR/$tdir
18920
18921         $LFS setstripe -c2 ${dom}_plain
18922         $LFS setstripe -E 1M -L mdt -E -1 -c2 ${dom}_dom
18923         $LFS swap_layouts ${dom}_plain ${dom}_dom &&
18924                 error "can swap layout with DoM component"
18925         $LFS swap_layouts ${dom}_dom ${dom}_plain &&
18926                 error "can swap layout with DoM component"
18927
18928         $LFS setstripe -E 1M -c1 -E -1 -c2 ${dom}_comp
18929         $LFS swap_layouts ${dom}_comp ${dom}_dom &&
18930                 error "can swap layout with DoM component"
18931         $LFS swap_layouts ${dom}_dom ${dom}_comp &&
18932                 error "can swap layout with DoM component"
18933         return 0
18934 }
18935 run_test 273a "DoM: layout swapping should fail with DOM"
18936
18937 test_275() {
18938         remote_ost_nodsh && skip "remote OST with nodsh"
18939         [ $OST1_VERSION -lt $(version_code 2.10.57) ] &&
18940                 skip "Need OST version >= 2.10.57"
18941
18942         local file=$DIR/$tfile
18943         local oss
18944
18945         oss=$(comma_list $(osts_nodes))
18946
18947         dd if=/dev/urandom of=$file bs=1M count=2 ||
18948                 error "failed to create a file"
18949         cancel_lru_locks osc
18950
18951         #lock 1
18952         dd if=$file of=/dev/null bs=1M count=1 iflag=direct ||
18953                 error "failed to read a file"
18954
18955 #define OBD_FAIL_LDLM_PAUSE_CANCEL2      0x31f
18956         $LCTL set_param fail_loc=0x8000031f
18957
18958         cancel_lru_locks osc &
18959         sleep 1
18960
18961 #define OBD_FAIL_LDLM_PROLONG_PAUSE      0x32b
18962         do_nodes $oss $LCTL set_param fail_loc=0x8000032b
18963         #IO takes another lock, but matches the PENDING one
18964         #and places it to the IO RPC
18965         dd if=$file of=/dev/null bs=1M count=1 iflag=direct ||
18966                 error "failed to read a file with PENDING lock"
18967 }
18968 run_test 275 "Read on a canceled duplicate lock"
18969
18970 test_276() {
18971         remote_ost_nodsh && skip "remote OST with nodsh"
18972         local pid
18973
18974         do_facet ost1 "(while true; do \
18975                 $LCTL get_param obdfilter.*.filesfree > /dev/null 2>&1; \
18976                 done) & pid=\\\$!; echo \\\$pid > $TMP/sanity_276_pid" &
18977         pid=$!
18978
18979         for LOOP in $(seq 20); do
18980                 stop ost1
18981                 start ost1 $(ostdevname 1) $OST_MOUNT_OPTS
18982         done
18983         kill -9 $pid
18984         do_facet ost1 "pid=\\\$(cat $TMP/sanity_276_pid); kill -9 \\\$pid; \
18985                 rm $TMP/sanity_276_pid"
18986 }
18987 run_test 276 "Race between mount and obd_statfs"
18988
18989 test_277() {
18990         $LCTL set_param ldlm.namespaces.*.lru_size=0
18991         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1
18992         local cached_mb=$($LCTL get_param llite.*.max_cached_mb |
18993                         grep ^used_mb | awk '{print $2}')
18994         [ $cached_mb -eq 1 ] || error "expected mb 1 got $cached_mb"
18995         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 \
18996                 oflag=direct conv=notrunc
18997         cached_mb=$($LCTL get_param llite.*.max_cached_mb |
18998                         grep ^used_mb | awk '{print $2}')
18999         [ $cached_mb -eq 0 ] || error "expected mb 0 got $cached_mb"
19000 }
19001 run_test 277 "Direct IO shall drop page cache"
19002
19003 test_278() {
19004         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
19005         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
19006         [[ "$(facet_host mds1)" != "$(facet_host mds2)" ]] &&
19007                 skip "needs the same host for mdt1 mdt2" && return
19008
19009         local pid1
19010         local pid2
19011
19012 #define OBD_FAIL_OBD_STOP_MDS_RACE     0x60b
19013         do_facet mds2 $LCTL set_param fail_loc=0x8000060c
19014         stop mds2 &
19015         pid2=$!
19016
19017         stop mds1
19018
19019         echo "Starting MDTs"
19020         start mds1 $(mdsdevname 1) $MDS_MOUNT_OPTS
19021         wait $pid2
19022 #For the error assertion will happen. lu_env_get_key(..., &mdt_thread_key)
19023 #will return NULL
19024         do_facet mds2 $LCTL set_param fail_loc=0
19025
19026         start mds2 $(mdsdevname 2) $MDS_MOUNT_OPTS
19027         wait_recovery_complete mds2
19028 }
19029 run_test 278 "Race starting MDS between MDTs stop/start"
19030
19031 cleanup_test_300() {
19032         trap 0
19033         umask $SAVE_UMASK
19034 }
19035 test_striped_dir() {
19036         local mdt_index=$1
19037         local stripe_count
19038         local stripe_index
19039
19040         mkdir -p $DIR/$tdir
19041
19042         SAVE_UMASK=$(umask)
19043         trap cleanup_test_300 RETURN EXIT
19044
19045         $LFS setdirstripe -i $mdt_index -c 2 -H all_char -o 755 \
19046                                                 $DIR/$tdir/striped_dir ||
19047                 error "set striped dir error"
19048
19049         local mode=$(stat -c%a $DIR/$tdir/striped_dir)
19050         [ "$mode" = "755" ] || error "expect 755 got $mode"
19051
19052         $LFS getdirstripe $DIR/$tdir/striped_dir > /dev/null 2>&1 ||
19053                 error "getdirstripe failed"
19054         stripe_count=$($LFS getdirstripe -c $DIR/$tdir/striped_dir)
19055         if [ "$stripe_count" != "2" ]; then
19056                 error "1:stripe_count is $stripe_count, expect 2"
19057         fi
19058         stripe_count=$($LFS getdirstripe -T $DIR/$tdir/striped_dir)
19059         if [ "$stripe_count" != "2" ]; then
19060                 error "2:stripe_count is $stripe_count, expect 2"
19061         fi
19062
19063         stripe_index=$($LFS getdirstripe -i $DIR/$tdir/striped_dir)
19064         if [ "$stripe_index" != "$mdt_index" ]; then
19065                 error "stripe_index is $stripe_index, expect $mdt_index"
19066         fi
19067
19068         [ $(stat -c%h $DIR/$tdir/striped_dir) == '2' ] ||
19069                 error "nlink error after create striped dir"
19070
19071         mkdir $DIR/$tdir/striped_dir/a
19072         mkdir $DIR/$tdir/striped_dir/b
19073
19074         stat $DIR/$tdir/striped_dir/a ||
19075                 error "create dir under striped dir failed"
19076         stat $DIR/$tdir/striped_dir/b ||
19077                 error "create dir under striped dir failed"
19078
19079         [ $(stat -c%h $DIR/$tdir/striped_dir) == '4' ] ||
19080                 error "nlink error after mkdir"
19081
19082         rmdir $DIR/$tdir/striped_dir/a
19083         [ $(stat -c%h $DIR/$tdir/striped_dir) == '3' ] ||
19084                 error "nlink error after rmdir"
19085
19086         rmdir $DIR/$tdir/striped_dir/b
19087         [ $(stat -c%h $DIR/$tdir/striped_dir) == '2' ] ||
19088                 error "nlink error after rmdir"
19089
19090         chattr +i $DIR/$tdir/striped_dir
19091         createmany -o $DIR/$tdir/striped_dir/f 10 &&
19092                 error "immutable flags not working under striped dir!"
19093         chattr -i $DIR/$tdir/striped_dir
19094
19095         rmdir $DIR/$tdir/striped_dir ||
19096                 error "rmdir striped dir error"
19097
19098         cleanup_test_300
19099
19100         true
19101 }
19102
19103 test_300a() {
19104         [ $MDS1_VERSION -lt $(version_code 2.7.0) ] &&
19105                 skip "skipped for lustre < 2.7.0"
19106         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19107         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19108
19109         test_striped_dir 0 || error "failed on striped dir on MDT0"
19110         test_striped_dir 1 || error "failed on striped dir on MDT0"
19111 }
19112 run_test 300a "basic striped dir sanity test"
19113
19114 test_300b() {
19115         [ $MDS1_VERSION -lt $(version_code 2.7.0) ] &&
19116                 skip "skipped for lustre < 2.7.0"
19117         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19118         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19119
19120         local i
19121         local mtime1
19122         local mtime2
19123         local mtime3
19124
19125         test_mkdir $DIR/$tdir || error "mkdir fail"
19126         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir ||
19127                 error "set striped dir error"
19128         for i in {0..9}; do
19129                 mtime1=$(stat -c %Y $DIR/$tdir/striped_dir)
19130                 sleep 1
19131                 touch $DIR/$tdir/striped_dir/file_$i || error "touch error $i"
19132                 mtime2=$(stat -c %Y $DIR/$tdir/striped_dir)
19133                 [ $mtime1 -eq $mtime2 ] && error "mtime unchanged after create"
19134                 sleep 1
19135                 rm -f $DIR/$tdir/striped_dir/file_$i || error "unlink error $i"
19136                 mtime3=$(stat -c %Y $DIR/$tdir/striped_dir)
19137                 [ $mtime2 -eq $mtime3 ] && error "mtime unchanged after unlink"
19138         done
19139         true
19140 }
19141 run_test 300b "check ctime/mtime for striped dir"
19142
19143 test_300c() {
19144         [ $MDS1_VERSION -lt $(version_code 2.7.0) ] &&
19145                 skip "skipped for lustre < 2.7.0"
19146         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19147         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19148
19149         local file_count
19150
19151         mkdir -p $DIR/$tdir
19152         $LFS setdirstripe -i 0 -c 2 $DIR/$tdir/striped_dir ||
19153                 error "set striped dir error"
19154
19155         chown $RUNAS_ID:$RUNAS_GID $DIR/$tdir/striped_dir ||
19156                 error "chown striped dir failed"
19157
19158         $RUNAS createmany -o $DIR/$tdir/striped_dir/f 5000 ||
19159                 error "create 5k files failed"
19160
19161         file_count=$(ls $DIR/$tdir/striped_dir | wc -l)
19162
19163         [ "$file_count" = 5000 ] || error "file count $file_count != 5000"
19164
19165         rm -rf $DIR/$tdir
19166 }
19167 run_test 300c "chown && check ls under striped directory"
19168
19169 test_300d() {
19170         [ $MDS1_VERSION -lt $(version_code 2.7.0) ] &&
19171                 skip "skipped for lustre < 2.7.0"
19172         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19173         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19174
19175         local stripe_count
19176         local file
19177
19178         mkdir -p $DIR/$tdir
19179         $LFS setstripe -c 2 $DIR/$tdir
19180
19181         #local striped directory
19182         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir ||
19183                 error "set striped dir error"
19184         createmany -o $DIR/$tdir/striped_dir/f 10 ||
19185                 error "create 10 files failed"
19186
19187         #remote striped directory
19188         $LFS setdirstripe -i 1 -c 2 $DIR/$tdir/remote_striped_dir ||
19189                 error "set striped dir error"
19190         createmany -o $DIR/$tdir/remote_striped_dir/f 10 ||
19191                 error "create 10 files failed"
19192
19193         for file in $(find $DIR/$tdir); do
19194                 stripe_count=$($LFS getstripe -c $file)
19195                 [ $stripe_count -eq 2 ] ||
19196                         error "wrong stripe $stripe_count for $file"
19197         done
19198
19199         rm -rf $DIR/$tdir
19200 }
19201 run_test 300d "check default stripe under striped directory"
19202
19203 test_300e() {
19204         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19205                 skip "Need MDS version at least 2.7.55"
19206         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19207         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19208
19209         local stripe_count
19210         local file
19211
19212         mkdir -p $DIR/$tdir
19213
19214         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir ||
19215                 error "set striped dir error"
19216
19217         touch $DIR/$tdir/striped_dir/a
19218         touch $DIR/$tdir/striped_dir/b
19219         touch $DIR/$tdir/striped_dir/c
19220
19221         mkdir $DIR/$tdir/striped_dir/dir_a
19222         mkdir $DIR/$tdir/striped_dir/dir_b
19223         mkdir $DIR/$tdir/striped_dir/dir_c
19224
19225         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir/stp_a ||
19226                 error "set striped adir under striped dir error"
19227
19228         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir/stp_b ||
19229                 error "set striped bdir under striped dir error"
19230
19231         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir/stp_c ||
19232                 error "set striped cdir under striped dir error"
19233
19234         mrename $DIR/$tdir/striped_dir/dir_a $DIR/$tdir/striped_dir/dir_b ||
19235                 error "rename dir under striped dir fails"
19236
19237         mrename $DIR/$tdir/striped_dir/stp_a $DIR/$tdir/striped_dir/stp_b ||
19238                 error "rename dir under different stripes fails"
19239
19240         mrename $DIR/$tdir/striped_dir/a $DIR/$tdir/striped_dir/c ||
19241                 error "rename file under striped dir should succeed"
19242
19243         mrename $DIR/$tdir/striped_dir/dir_b $DIR/$tdir/striped_dir/dir_c ||
19244                 error "rename dir under striped dir should succeed"
19245
19246         rm -rf $DIR/$tdir
19247 }
19248 run_test 300e "check rename under striped directory"
19249
19250 test_300f() {
19251         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19252         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19253         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19254                 skip "Need MDS version at least 2.7.55"
19255
19256         local stripe_count
19257         local file
19258
19259         rm -rf $DIR/$tdir
19260         mkdir -p $DIR/$tdir
19261
19262         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir ||
19263                 error "set striped dir error"
19264
19265         $LFS setdirstripe -i 0 -c 2 -H all_char $DIR/$tdir/striped_dir1 ||
19266                 error "set striped dir error"
19267
19268         touch $DIR/$tdir/striped_dir/a
19269         mkdir $DIR/$tdir/striped_dir/dir_a
19270         $LFS setdirstripe -i 0 -c 2 $DIR/$tdir/striped_dir/stp_a ||
19271                 error "create striped dir under striped dir fails"
19272
19273         touch $DIR/$tdir/striped_dir1/b
19274         mkdir $DIR/$tdir/striped_dir1/dir_b
19275         $LFS setdirstripe -i 0 -c 2 $DIR/$tdir/striped_dir/stp_b ||
19276                 error "create striped dir under striped dir fails"
19277
19278         mrename $DIR/$tdir/striped_dir/dir_a $DIR/$tdir/striped_dir1/dir_b ||
19279                 error "rename dir under different striped dir should fail"
19280
19281         mrename $DIR/$tdir/striped_dir/stp_a $DIR/$tdir/striped_dir1/stp_b ||
19282                 error "rename striped dir under diff striped dir should fail"
19283
19284         mrename $DIR/$tdir/striped_dir/a $DIR/$tdir/striped_dir1/a ||
19285                 error "rename file under diff striped dirs fails"
19286
19287         rm -rf $DIR/$tdir
19288 }
19289 run_test 300f "check rename cross striped directory"
19290
19291 test_300_check_default_striped_dir()
19292 {
19293         local dirname=$1
19294         local default_count=$2
19295         local default_index=$3
19296         local stripe_count
19297         local stripe_index
19298         local dir_stripe_index
19299         local dir
19300
19301         echo "checking $dirname $default_count $default_index"
19302         $LFS setdirstripe -D -c $default_count -i $default_index \
19303                                 -t all_char $DIR/$tdir/$dirname ||
19304                 error "set default stripe on striped dir error"
19305         stripe_count=$($LFS getdirstripe -D -c $DIR/$tdir/$dirname)
19306         [ $stripe_count -eq $default_count ] ||
19307                 error "expect $default_count get $stripe_count for $dirname"
19308
19309         stripe_index=$($LFS getdirstripe -D -i $DIR/$tdir/$dirname)
19310         [ $stripe_index -eq $default_index ] ||
19311                 error "expect $default_index get $stripe_index for $dirname"
19312
19313         mkdir $DIR/$tdir/$dirname/{test1,test2,test3,test4} ||
19314                                                 error "create dirs failed"
19315
19316         createmany -o $DIR/$tdir/$dirname/f- 10 || error "create files failed"
19317         unlinkmany $DIR/$tdir/$dirname/f- 10    || error "unlink files failed"
19318         for dir in $(find $DIR/$tdir/$dirname/*); do
19319                 stripe_count=$($LFS getdirstripe -c $dir)
19320                 [ $stripe_count -eq $default_count ] ||
19321                 [ $stripe_count -eq 0 ] || [ $default_count -eq 1 ] ||
19322                 error "stripe count $default_count != $stripe_count for $dir"
19323
19324                 stripe_index=$($LFS getdirstripe -i $dir)
19325                 [ $default_index -eq -1 ] ||
19326                         [ $stripe_index -eq $default_index ] ||
19327                         error "$stripe_index != $default_index for $dir"
19328
19329                 #check default stripe
19330                 stripe_count=$($LFS getdirstripe -D -c $dir)
19331                 [ $stripe_count -eq $default_count ] ||
19332                 error "default count $default_count != $stripe_count for $dir"
19333
19334                 stripe_index=$($LFS getdirstripe -D -i $dir)
19335                 [ $stripe_index -eq $default_index ] ||
19336                 error "default index $default_index != $stripe_index for $dir"
19337         done
19338         rmdir $DIR/$tdir/$dirname/* || error "rmdir failed"
19339 }
19340
19341 test_300g() {
19342         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19343         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19344                 skip "Need MDS version at least 2.7.55"
19345
19346         local dir
19347         local stripe_count
19348         local stripe_index
19349
19350         mkdir $DIR/$tdir
19351         mkdir $DIR/$tdir/normal_dir
19352
19353         #Checking when client cache stripe index
19354         $LFS setdirstripe -c$MDSCOUNT $DIR/$tdir/striped_dir
19355         $LFS setdirstripe -D -i1 $DIR/$tdir/striped_dir ||
19356                 error "create striped_dir failed"
19357
19358         $LFS setdirstripe -i0 $DIR/$tdir/striped_dir/dir0 ||
19359                 error "create dir0 fails"
19360         stripe_index=$($LFS getdirstripe -i $DIR/$tdir/striped_dir/dir0)
19361         [ $stripe_index -eq 0 ] ||
19362                 error "dir0 expect index 0 got $stripe_index"
19363
19364         mkdir $DIR/$tdir/striped_dir/dir1 ||
19365                 error "create dir1 fails"
19366         stripe_index=$($LFS getdirstripe -i $DIR/$tdir/striped_dir/dir1)
19367         [ $stripe_index -eq 1 ] ||
19368                 error "dir1 expect index 1 got $stripe_index"
19369
19370         #check default stripe count/stripe index
19371         test_300_check_default_striped_dir normal_dir $MDSCOUNT 1
19372         test_300_check_default_striped_dir normal_dir 1 0
19373         test_300_check_default_striped_dir normal_dir 2 1
19374         test_300_check_default_striped_dir normal_dir 2 -1
19375
19376         #delete default stripe information
19377         echo "delete default stripeEA"
19378         $LFS setdirstripe -d $DIR/$tdir/normal_dir ||
19379                 error "set default stripe on striped dir error"
19380
19381         mkdir -p $DIR/$tdir/normal_dir/{test1,test2,test3,test4}
19382         for dir in $(find $DIR/$tdir/normal_dir/*); do
19383                 stripe_count=$($LFS getdirstripe -c $dir)
19384                 [ $stripe_count -eq 0 ] ||
19385                         error "expect 1 get $stripe_count for $dir"
19386                 stripe_index=$($LFS getdirstripe -i $dir)
19387                 [ $stripe_index -eq 0 ] ||
19388                         error "expect 0 get $stripe_index for $dir"
19389         done
19390 }
19391 run_test 300g "check default striped directory for normal directory"
19392
19393 test_300h() {
19394         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19395         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19396                 skip "Need MDS version at least 2.7.55"
19397
19398         local dir
19399         local stripe_count
19400
19401         mkdir $DIR/$tdir
19402         $LFS setdirstripe -i0 -c$MDSCOUNT -H all_char $DIR/$tdir/striped_dir ||
19403                 error "set striped dir error"
19404
19405         test_300_check_default_striped_dir striped_dir $MDSCOUNT 1
19406         test_300_check_default_striped_dir striped_dir 1 0
19407         test_300_check_default_striped_dir striped_dir 2 1
19408         test_300_check_default_striped_dir striped_dir 2 -1
19409
19410         #delete default stripe information
19411         $LFS setdirstripe -d $DIR/$tdir/striped_dir ||
19412                 error "set default stripe on striped dir error"
19413
19414         mkdir -p $DIR/$tdir/striped_dir/{test1,test2,test3,test4}
19415         for dir in $(find $DIR/$tdir/striped_dir/*); do
19416                 stripe_count=$($LFS getdirstripe -c $dir)
19417                 [ $stripe_count -eq 0 ] ||
19418                         error "expect 1 get $stripe_count for $dir"
19419         done
19420 }
19421 run_test 300h "check default striped directory for striped directory"
19422
19423 test_300i() {
19424         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19425         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19426         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19427                 skip "Need MDS version at least 2.7.55"
19428
19429         local stripe_count
19430         local file
19431
19432         mkdir $DIR/$tdir
19433
19434         $LFS setdirstripe -i 0 -c$MDSCOUNT -H all_char $DIR/$tdir/striped_dir ||
19435                 error "set striped dir error"
19436
19437         createmany -o $DIR/$tdir/striped_dir/f- 10 ||
19438                 error "create files under striped dir failed"
19439
19440         $LFS setdirstripe -i0 -c$MDSCOUNT -H all_char $DIR/$tdir/hashdir ||
19441                 error "set striped hashdir error"
19442
19443         $LFS setdirstripe -i0 -c$MDSCOUNT -H all_char $DIR/$tdir/hashdir/d0 ||
19444                 error "create dir0 under hash dir failed"
19445         $LFS setdirstripe -i0 -c$MDSCOUNT -H fnv_1a_64 $DIR/$tdir/hashdir/d1 ||
19446                 error "create dir1 under hash dir failed"
19447
19448         # unfortunately, we need to umount to clear dir layout cache for now
19449         # once we fully implement dir layout, we can drop this
19450         umount_client $MOUNT || error "umount failed"
19451         mount_client $MOUNT || error "mount failed"
19452
19453         $LFS find -H fnv_1a_64 $DIR/$tdir/hashdir
19454         local dircnt=$($LFS find -H fnv_1a_64 $DIR/$tdir/hashdir | wc -l)
19455         [ $dircnt -eq 1 ] || error "lfs find striped dir got:$dircnt,except:1"
19456
19457         #set the stripe to be unknown hash type
19458         #define OBD_FAIL_UNKNOWN_LMV_STRIPE     0x1901
19459         $LCTL set_param fail_loc=0x1901
19460         for ((i = 0; i < 10; i++)); do
19461                 $CHECKSTAT -t file $DIR/$tdir/striped_dir/f-$i ||
19462                         error "stat f-$i failed"
19463                 rm $DIR/$tdir/striped_dir/f-$i || error "unlink f-$i failed"
19464         done
19465
19466         touch $DIR/$tdir/striped_dir/f0 &&
19467                 error "create under striped dir with unknown hash should fail"
19468
19469         $LCTL set_param fail_loc=0
19470
19471         umount_client $MOUNT || error "umount failed"
19472         mount_client $MOUNT || error "mount failed"
19473
19474         return 0
19475 }
19476 run_test 300i "client handle unknown hash type striped directory"
19477
19478 test_300j() {
19479         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19480         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19481         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19482                 skip "Need MDS version at least 2.7.55"
19483
19484         local stripe_count
19485         local file
19486
19487         mkdir $DIR/$tdir
19488
19489         #define OBD_FAIL_SPLIT_UPDATE_REC       0x1702
19490         $LCTL set_param fail_loc=0x1702
19491         $LFS setdirstripe -i 0 -c$MDSCOUNT -H all_char $DIR/$tdir/striped_dir ||
19492                 error "set striped dir error"
19493
19494         createmany -o $DIR/$tdir/striped_dir/f- 10 ||
19495                 error "create files under striped dir failed"
19496
19497         $LCTL set_param fail_loc=0
19498
19499         rm -rf $DIR/$tdir || error "unlink striped dir fails"
19500
19501         return 0
19502 }
19503 run_test 300j "test large update record"
19504
19505 test_300k() {
19506         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19507         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19508         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19509                 skip "Need MDS version at least 2.7.55"
19510
19511         # this test needs a huge transaction
19512         local kb
19513         kb=$(do_facet $SINGLEMDS lctl get_param -n osd*.lustre-MDT0000.kbytestotal)
19514         [ $kb -lt $((1024*1024)) ] && skip "too small mds: $kb"
19515
19516         local stripe_count
19517         local file
19518
19519         mkdir $DIR/$tdir
19520
19521         #define OBD_FAIL_LARGE_STRIPE   0x1703
19522         $LCTL set_param fail_loc=0x1703
19523         $LFS setdirstripe -i 0 -c192 $DIR/$tdir/striped_dir ||
19524                 error "set striped dir error"
19525         $LCTL set_param fail_loc=0
19526
19527         $LFS getdirstripe $DIR/$tdir/striped_dir ||
19528                 error "getstripeddir fails"
19529         rm -rf $DIR/$tdir/striped_dir ||
19530                 error "unlink striped dir fails"
19531
19532         return 0
19533 }
19534 run_test 300k "test large striped directory"
19535
19536 test_300l() {
19537         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19538         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19539         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19540                 skip "Need MDS version at least 2.7.55"
19541
19542         local stripe_index
19543
19544         test_mkdir -p $DIR/$tdir/striped_dir
19545         chown $RUNAS_ID $DIR/$tdir/striped_dir ||
19546                         error "chown $RUNAS_ID failed"
19547         $LFS setdirstripe -i 1 -D $DIR/$tdir/striped_dir ||
19548                 error "set default striped dir failed"
19549
19550         #define OBD_FAIL_MDS_STALE_DIR_LAYOUT    0x158
19551         $LCTL set_param fail_loc=0x80000158
19552         $RUNAS mkdir $DIR/$tdir/striped_dir/test_dir || error "create dir fails"
19553
19554         stripe_index=$($LFS getdirstripe -i $DIR/$tdir/striped_dir/test_dir)
19555         [ $stripe_index -eq 1 ] ||
19556                 error "expect 1 get $stripe_index for $dir"
19557 }
19558 run_test 300l "non-root user to create dir under striped dir with stale layout"
19559
19560 test_300m() {
19561         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19562         [ $MDSCOUNT -ge 2 ] && skip_env "Only for single MDT"
19563         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19564                 skip "Need MDS version at least 2.7.55"
19565
19566         mkdir -p $DIR/$tdir/striped_dir
19567         $LFS setdirstripe -D -c 1 $DIR/$tdir/striped_dir ||
19568                 error "set default stripes dir error"
19569
19570         mkdir $DIR/$tdir/striped_dir/a || error "mkdir a fails"
19571
19572         stripe_count=$($LFS getdirstripe -c $DIR/$tdir/striped_dir/a)
19573         [ $stripe_count -eq 0 ] ||
19574                         error "expect 0 get $stripe_count for a"
19575
19576         $LFS setdirstripe -D -c 2 $DIR/$tdir/striped_dir ||
19577                 error "set default stripes dir error"
19578
19579         mkdir $DIR/$tdir/striped_dir/b || error "mkdir b fails"
19580
19581         stripe_count=$($LFS getdirstripe -c $DIR/$tdir/striped_dir/b)
19582         [ $stripe_count -eq 0 ] ||
19583                         error "expect 0 get $stripe_count for b"
19584
19585         $LFS setdirstripe -D -c1 -i2 $DIR/$tdir/striped_dir ||
19586                 error "set default stripes dir error"
19587
19588         mkdir $DIR/$tdir/striped_dir/c &&
19589                 error "default stripe_index is invalid, mkdir c should fails"
19590
19591         rm -rf $DIR/$tdir || error "rmdir fails"
19592 }
19593 run_test 300m "setstriped directory on single MDT FS"
19594
19595 cleanup_300n() {
19596         local list=$(comma_list $(mdts_nodes))
19597
19598         trap 0
19599         do_nodes $list $LCTL set_param -n mdt.*.enable_remote_dir_gid=0
19600 }
19601
19602 test_300n() {
19603         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19604         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19605         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19606                 skip "Need MDS version at least 2.7.55"
19607         remote_mds_nodsh && skip "remote MDS with nodsh"
19608
19609         local stripe_index
19610         local list=$(comma_list $(mdts_nodes))
19611
19612         trap cleanup_300n RETURN EXIT
19613         mkdir -p $DIR/$tdir
19614         chmod 777 $DIR/$tdir
19615         $RUNAS $LFS setdirstripe -i0 -c$MDSCOUNT \
19616                                 $DIR/$tdir/striped_dir > /dev/null 2>&1 &&
19617                 error "create striped dir succeeds with gid=0"
19618
19619         do_nodes $list $LCTL set_param -n mdt.*.enable_remote_dir_gid=-1
19620         $RUNAS $LFS setdirstripe -i0 -c$MDSCOUNT $DIR/$tdir/striped_dir ||
19621                 error "create striped dir fails with gid=-1"
19622
19623         do_nodes $list $LCTL set_param -n mdt.*.enable_remote_dir_gid=0
19624         $RUNAS $LFS setdirstripe -i 1 -c$MDSCOUNT -D \
19625                                 $DIR/$tdir/striped_dir > /dev/null 2>&1 &&
19626                 error "set default striped dir succeeds with gid=0"
19627
19628
19629         do_nodes $list $LCTL set_param -n mdt.*.enable_remote_dir_gid=-1
19630         $RUNAS $LFS setdirstripe -i 1 -c$MDSCOUNT -D $DIR/$tdir/striped_dir ||
19631                 error "set default striped dir fails with gid=-1"
19632
19633
19634         do_nodes $list $LCTL set_param -n mdt.*.enable_remote_dir_gid=0
19635         $RUNAS mkdir $DIR/$tdir/striped_dir/test_dir ||
19636                                         error "create test_dir fails"
19637         $RUNAS mkdir $DIR/$tdir/striped_dir/test_dir1 ||
19638                                         error "create test_dir1 fails"
19639         $RUNAS mkdir $DIR/$tdir/striped_dir/test_dir2 ||
19640                                         error "create test_dir2 fails"
19641         cleanup_300n
19642 }
19643 run_test 300n "non-root user to create dir under striped dir with default EA"
19644
19645 test_300o() {
19646         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19647         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19648         [ $MDS1_VERSION -lt $(version_code 2.7.55) ] &&
19649                 skip "Need MDS version at least 2.7.55"
19650
19651         local numfree1
19652         local numfree2
19653
19654         mkdir -p $DIR/$tdir
19655
19656         numfree1=$(lctl get_param -n mdc.*MDT0000*.filesfree)
19657         numfree2=$(lctl get_param -n mdc.*MDT0001*.filesfree)
19658         if [ $numfree1 -lt 66000 ] || [ $numfree2 -lt 66000 ]; then
19659                 skip "not enough free inodes $numfree1 $numfree2"
19660         fi
19661
19662         numfree1=$(lctl get_param -n mdc.*MDT0000-mdc-*.kbytesfree)
19663         numfree2=$(lctl get_param -n mdc.*MDT0001-mdc-*.kbytesfree)
19664         if [ $numfree1 -lt 300000 ] || [ $numfree2 -lt 300000 ]; then
19665                 skip "not enough free space $numfree1 $numfree2"
19666         fi
19667
19668         $LFS setdirstripe -c2 $DIR/$tdir/striped_dir ||
19669                 error "setdirstripe fails"
19670
19671         createmany -d $DIR/$tdir/striped_dir/d 131000 ||
19672                 error "create dirs fails"
19673
19674         $LCTL set_param ldlm.namespaces.*mdc-*.lru_size=0
19675         ls $DIR/$tdir/striped_dir > /dev/null ||
19676                 error "ls striped dir fails"
19677         unlinkmany -d $DIR/$tdir/striped_dir/d 131000 ||
19678                 error "unlink big striped dir fails"
19679 }
19680 run_test 300o "unlink big sub stripe(> 65000 subdirs)"
19681
19682 test_300p() {
19683         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19684         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19685         remote_mds_nodsh && skip "remote MDS with nodsh"
19686
19687         mkdir -p $DIR/$tdir
19688
19689         #define OBD_FAIL_OUT_ENOSPC     0x1704
19690         do_facet mds2 lctl set_param fail_loc=0x80001704
19691         $LFS setdirstripe -i 0 -c2 $DIR/$tdir/bad_striped_dir > /dev/null 2>&1 \
19692                  && error "create striped directory should fail"
19693
19694         [ -e $DIR/$tdir/bad_striped_dir ] && error "striped dir exists"
19695
19696         $LFS setdirstripe -c2 $DIR/$tdir/bad_striped_dir
19697         true
19698 }
19699 run_test 300p "create striped directory without space"
19700
19701 test_300q() {
19702         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19703         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
19704
19705         local fd=$(free_fd)
19706         local cmd="exec $fd<$tdir"
19707         cd $DIR
19708         $LFS mkdir -c $MDSCOUNT $tdir || error "create $tdir fails"
19709         eval $cmd
19710         cmd="exec $fd<&-"
19711         trap "eval $cmd" EXIT
19712         cd $tdir || error "cd $tdir fails"
19713         rmdir  ../$tdir || error "rmdir $tdir fails"
19714         mkdir local_dir && error "create dir succeeds"
19715         $LFS setdirstripe -i1 remote_dir && error "create remote dir succeeds"
19716         eval $cmd
19717         return 0
19718 }
19719 run_test 300q "create remote directory under orphan directory"
19720
19721 test_300r() {
19722         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.7.55) ] &&
19723                 skip "Need MDS version at least 2.7.55" && return
19724         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
19725
19726         mkdir $DIR/$tdir
19727
19728         $LFS setdirstripe -i 0 -c -1 $DIR/$tdir/striped_dir ||
19729                 error "set striped dir error"
19730
19731         $LFS getdirstripe $DIR/$tdir/striped_dir ||
19732                 error "getstripeddir fails"
19733
19734         local stripe_count
19735         stripe_count=$($LFS getdirstripe $DIR/$tdir/striped_dir |
19736                       awk '/lmv_stripe_count:/ { print $2 }')
19737
19738         [ $MDSCOUNT -ne $stripe_count ] &&
19739                 error "wrong stripe count $stripe_count expected $MDSCOUNT"
19740
19741         rm -rf $DIR/$tdir/striped_dir ||
19742                 error "unlink striped dir fails"
19743 }
19744 run_test 300r "test -1 striped directory"
19745
19746 prepare_remote_file() {
19747         mkdir $DIR/$tdir/src_dir ||
19748                 error "create remote source failed"
19749
19750         cp /etc/hosts $DIR/$tdir/src_dir/a ||
19751                  error "cp to remote source failed"
19752         touch $DIR/$tdir/src_dir/a
19753
19754         $LFS mkdir -i 1 $DIR/$tdir/tgt_dir ||
19755                 error "create remote target dir failed"
19756
19757         touch $DIR/$tdir/tgt_dir/b
19758
19759         mrename $DIR/$tdir/src_dir/a $DIR/$tdir/tgt_dir/b ||
19760                 error "rename dir cross MDT failed!"
19761
19762         $CHECKSTAT -t file $DIR/$tdir/src_dir/a &&
19763                 error "src_child still exists after rename"
19764
19765         $CHECKSTAT -t file $DIR/$tdir/tgt_dir/b ||
19766                 error "missing file(a) after rename"
19767
19768         diff /etc/hosts $DIR/$tdir/tgt_dir/b ||
19769                 error "diff after rename"
19770 }
19771
19772 test_310a() {
19773         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 4 MDTs"
19774         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19775
19776         local remote_file=$DIR/$tdir/tgt_dir/b
19777
19778         mkdir -p $DIR/$tdir
19779
19780         prepare_remote_file || error "prepare remote file failed"
19781
19782         #open-unlink file
19783         $OPENUNLINK $remote_file $remote_file ||
19784                 error "openunlink $remote_file failed"
19785         $CHECKSTAT -a $remote_file || error "$remote_file exists"
19786 }
19787 run_test 310a "open unlink remote file"
19788
19789 test_310b() {
19790         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 4 MDTs"
19791         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19792
19793         local remote_file=$DIR/$tdir/tgt_dir/b
19794
19795         mkdir -p $DIR/$tdir
19796
19797         prepare_remote_file || error "prepare remote file failed"
19798
19799         ln $remote_file $DIR/$tfile || error "link failed for remote file"
19800         $MULTIOP $DIR/$tfile Ouc || error "mulitop failed"
19801         $CHECKSTAT -t file $remote_file || error "check file failed"
19802 }
19803 run_test 310b "unlink remote file with multiple links while open"
19804
19805 test_310c() {
19806         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19807         [[ $MDSCOUNT -lt 4 ]] && skip_env "needs >= 4 MDTs"
19808
19809         local remote_file=$DIR/$tdir/tgt_dir/b
19810
19811         mkdir -p $DIR/$tdir
19812
19813         prepare_remote_file || error "prepare remote file failed"
19814
19815         ln $remote_file $DIR/$tfile || error "link failed for remote file"
19816         multiop_bg_pause $remote_file O_uc ||
19817                         error "mulitop failed for remote file"
19818         MULTIPID=$!
19819         $MULTIOP $DIR/$tfile Ouc
19820         kill -USR1 $MULTIPID
19821         wait $MULTIPID
19822 }
19823 run_test 310c "open-unlink remote file with multiple links"
19824
19825 #LU-4825
19826 test_311() {
19827         [ $PARALLEL == "yes" ] && skip "skip parallel run"
19828         [ $OSTCOUNT -lt 2 ] && skip "needs >= 2 OSTs"
19829         [ $MDS1_VERSION -lt $(version_code 2.8.54) ] &&
19830                 skip "lustre < 2.8.54 does not contain LU-4825 fix"
19831         remote_mds_nodsh && skip "remote MDS with nodsh"
19832
19833         local old_iused=$($LFS df -i | grep OST0000 | awk '{ print $3 }')
19834         local mdts=$(comma_list $(mdts_nodes))
19835
19836         mkdir -p $DIR/$tdir
19837         $LFS setstripe -i 0 -c 1 $DIR/$tdir
19838         createmany -o $DIR/$tdir/$tfile. 1000
19839
19840         # statfs data is not real time, let's just calculate it
19841         old_iused=$((old_iused + 1000))
19842
19843         local count=$(do_facet $SINGLEMDS "$LCTL get_param -n \
19844                         osp.*OST0000*MDT0000.create_count")
19845         local max_count=$(do_facet $SINGLEMDS "$LCTL get_param -n \
19846                                 osp.*OST0000*MDT0000.max_create_count")
19847         do_nodes $mdts "$LCTL set_param -n osp.*OST0000*.max_create_count=0"
19848
19849         $LFS setstripe -i 0 $DIR/$tdir/$tfile || error "setstripe failed"
19850         local index=$($LFS getstripe -i $DIR/$tdir/$tfile)
19851         [ $index -ne 0 ] || error "$tfile stripe index is 0"
19852
19853         unlinkmany $DIR/$tdir/$tfile. 1000
19854
19855         do_nodes $mdts "$LCTL set_param -n \
19856                         osp.*OST0000*.max_create_count=$max_count"
19857         [ $MDS1_VERSION -lt $(version_code 2.12.51) ] &&
19858                 do_nodes $mdts "$LCTL set_param -n \
19859                                 osp.*OST0000*.create_count=$count"
19860         do_nodes $mdts "$LCTL get_param osp.*OST0000*.create_count" |
19861                         grep "=0" && error "create_count is zero"
19862
19863         local new_iused
19864         for i in $(seq 120); do
19865                 new_iused=$($LFS df -i | grep OST0000 | awk '{ print $3 }')
19866                 # system may be too busy to destroy all objs in time, use
19867                 # a somewhat small value to not fail autotest
19868                 [ $((old_iused - new_iused)) -gt 400 ] && break
19869                 sleep 1
19870         done
19871
19872         echo "waited $i sec, old Iused $old_iused, new Iused $new_iused"
19873         [ $((old_iused - new_iused)) -gt 400 ] ||
19874                 error "objs not destroyed after unlink"
19875 }
19876 run_test 311 "disable OSP precreate, and unlink should destroy objs"
19877
19878 zfs_oid_to_objid()
19879 {
19880         local ost=$1
19881         local objid=$2
19882
19883         local vdevdir=$(dirname $(facet_vdevice $ost))
19884         local cmd="$ZDB -e -p $vdevdir -ddddd $(facet_device $ost)"
19885         local zfs_zapid=$(do_facet $ost $cmd |
19886                           grep -w "/O/0/d$((objid%32))" -C 5 |
19887                           awk '/Object/{getline; print $1}')
19888         local zfs_objid=$(do_facet $ost $cmd $zfs_zapid |
19889                           awk "/$objid = /"'{printf $3}')
19890
19891         echo $zfs_objid
19892 }
19893
19894 zfs_object_blksz() {
19895         local ost=$1
19896         local objid=$2
19897
19898         local vdevdir=$(dirname $(facet_vdevice $ost))
19899         local cmd="$ZDB -e -p $vdevdir -dddd $(facet_device $ost)"
19900         local blksz=$(do_facet $ost $cmd $objid |
19901                       awk '/dblk/{getline; printf $4}')
19902
19903         case "${blksz: -1}" in
19904                 k|K) blksz=$((${blksz:0:$((${#blksz} - 1))}*1024)) ;;
19905                 m|M) blksz=$((${blksz:0:$((${#blksz} - 1))}*1024*1024)) ;;
19906                 *) ;;
19907         esac
19908
19909         echo $blksz
19910 }
19911
19912 test_312() { # LU-4856
19913         remote_ost_nodsh && skip "remote OST with nodsh"
19914         [ "$ost1_FSTYPE" = "zfs" ] ||
19915                 skip_env "the test only applies to zfs"
19916
19917         local max_blksz=$(do_facet ost1 \
19918                           $ZFS get -p recordsize $(facet_device ost1) |
19919                           awk '!/VALUE/{print $3}')
19920
19921         # to make life a little bit easier
19922         $LFS mkdir -c 1 -i 0 $DIR/$tdir
19923         $LFS setstripe -c 1 -i 0 $DIR/$tdir
19924
19925         local tf=$DIR/$tdir/$tfile
19926         touch $tf
19927         local oid=$($LFS getstripe $tf | awk '/obdidx/{getline; print $2}')
19928
19929         # Get ZFS object id
19930         local zfs_objid=$(zfs_oid_to_objid ost1 $oid)
19931         # block size change by sequential overwrite
19932         local bs
19933
19934         for ((bs=$PAGE_SIZE; bs <= max_blksz; bs *= 4)) ; do
19935                 dd if=/dev/zero of=$tf bs=$bs count=1 oflag=sync conv=notrunc
19936
19937                 local blksz=$(zfs_object_blksz ost1 $zfs_objid)
19938                 [ $blksz -eq $bs ] || error "blksz error: $blksz, expected: $bs"
19939         done
19940         rm -f $tf
19941
19942         # block size change by sequential append write
19943         dd if=/dev/zero of=$tf bs=$PAGE_SIZE count=1 oflag=sync conv=notrunc
19944         oid=$($LFS getstripe $tf | awk '/obdidx/{getline; print $2}')
19945         zfs_objid=$(zfs_oid_to_objid ost1 $oid)
19946         local count
19947
19948         for ((count = 1; count < $((max_blksz / PAGE_SIZE)); count *= 2)); do
19949                 dd if=/dev/zero of=$tf bs=$PAGE_SIZE count=$count seek=$count \
19950                         oflag=sync conv=notrunc
19951
19952                 blksz=$(zfs_object_blksz ost1 $zfs_objid)
19953                 [ $blksz -eq $((2 * count * PAGE_SIZE)) ] ||
19954                         error "blksz error, actual $blksz, " \
19955                                 "expected: 2 * $count * $PAGE_SIZE"
19956         done
19957         rm -f $tf
19958
19959         # random write
19960         touch $tf
19961         oid=$($LFS getstripe $tf | awk '/obdidx/{getline; print $2}')
19962         zfs_objid=$(zfs_oid_to_objid ost1 $oid)
19963
19964         dd if=/dev/zero of=$tf bs=1K count=1 oflag=sync conv=notrunc
19965         blksz=$(zfs_object_blksz ost1 $zfs_objid)
19966         [ $blksz -eq $PAGE_SIZE ] ||
19967                 error "blksz error: $blksz, expected: $PAGE_SIZE"
19968
19969         dd if=/dev/zero of=$tf bs=64K count=1 oflag=sync conv=notrunc seek=128
19970         blksz=$(zfs_object_blksz ost1 $zfs_objid)
19971         [ $blksz -eq 65536 ] || error "blksz error: $blksz, expected: 64k"
19972
19973         dd if=/dev/zero of=$tf bs=1M count=1 oflag=sync conv=notrunc
19974         blksz=$(zfs_object_blksz ost1 $zfs_objid)
19975         [ $blksz -eq 65536 ] || error "rewrite error: $blksz, expected: 64k"
19976 }
19977 run_test 312 "make sure ZFS adjusts its block size by write pattern"
19978
19979 test_313() {
19980         remote_ost_nodsh && skip "remote OST with nodsh"
19981
19982         local file=$DIR/$tfile
19983
19984         rm -f $file
19985         $LFS setstripe -c 1 -i 0 $file || error "setstripe failed"
19986
19987         # define OBD_FAIL_TGT_RCVD_EIO           0x720
19988         do_facet ost1 "$LCTL set_param fail_loc=0x720"
19989         dd if=/dev/zero of=$file bs=$PAGE_SIZE oflag=direct count=1 &&
19990                 error "write should failed"
19991         do_facet ost1 "$LCTL set_param fail_loc=0"
19992         rm -f $file
19993 }
19994 run_test 313 "io should fail after last_rcvd update fail"
19995
19996 test_314() {
19997         [ $OSTCOUNT -lt 2 ] && skip "needs >= 2 OSTs"
19998
19999         $LFS setstripe -c 2 -i 0 $DIR/$tfile || error "setstripe failed"
20000         do_facet ost1 "$LCTL set_param fail_loc=0x720"
20001         rm -f $DIR/$tfile
20002         wait_delete_completed
20003         do_facet ost1 "$LCTL set_param fail_loc=0"
20004 }
20005 run_test 314 "OSP shouldn't fail after last_rcvd update failure"
20006
20007 test_315() { # LU-618
20008         [ -f /proc/$$/io ] || skip_env "no IO accounting in kernel"
20009
20010         local file=$DIR/$tfile
20011         rm -f $file
20012
20013         $MULTIOP $file oO_CREAT:O_DIRECT:O_RDWR:w4063232c ||
20014                 error "multiop file write failed"
20015         $MULTIOP $file oO_RDONLY:r4063232_c &
20016         PID=$!
20017
20018         sleep 2
20019
20020         local rbytes=$(awk '/read_bytes/ { print $2 }' /proc/$PID/io)
20021         kill -USR1 $PID
20022
20023         [ $rbytes -gt 4000000 ] || error "read is not accounted ($rbytes)"
20024         rm -f $file
20025 }
20026 run_test 315 "read should be accounted"
20027
20028 test_316() {
20029         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
20030         large_xattr_enabled || skip_env "ea_inode feature disabled"
20031
20032         rm -rf $DIR/$tdir/d
20033         mkdir -p $DIR/$tdir/d
20034         chown nobody $DIR/$tdir/d
20035         touch $DIR/$tdir/d/file
20036
20037         $LFS mv -M1 $DIR/$tdir/d || error "lfs mv failed"
20038 }
20039 run_test 316 "lfs mv"
20040
20041 test_317() {
20042         [ $MDS1_VERSION -lt $(version_code 2.11.53) ] &&
20043                 skip "Need MDS version at least 2.11.53"
20044         if [ "$ost1_FSTYPE" == "zfs" ]; then
20045                 skip "LU-10370: no implementation for ZFS"
20046         fi
20047
20048         local trunc_sz
20049         local grant_blk_size
20050
20051         grant_blk_size=$($LCTL get_param osc.$FSNAME*.import |
20052                         awk '/grant_block_size:/ { print $2; exit; }')
20053         #
20054         # Create File of size 5M. Truncate it to below size's and verify
20055         # blocks count.
20056         #
20057         dd if=/dev/zero of=$DIR/$tfile bs=5M count=1 conv=fsync ||
20058                 error "Create file $DIR/$tfile failed"
20059         stack_trap "rm -f $DIR/$tfile" EXIT
20060
20061         for trunc_sz in 2097152 4097 4000 509 0; do
20062                 $TRUNCATE $DIR/$tfile $trunc_sz ||
20063                         error "truncate $tfile to $trunc_sz failed"
20064                 local sz=$(stat --format=%s $DIR/$tfile)
20065                 local blk=$(stat --format=%b $DIR/$tfile)
20066                 local trunc_blk=$((((trunc_sz + (grant_blk_size - 1) ) /
20067                                      grant_blk_size) * 8))
20068
20069                 if [[ $blk -ne $trunc_blk ]]; then
20070                         $(which stat) $DIR/$tfile
20071                         error "Expected Block $trunc_blk got $blk for $tfile"
20072                 fi
20073
20074                 $CHECKSTAT -s $trunc_sz $DIR/$tfile ||
20075                         error "Expected Size $trunc_sz got $sz for $tfile"
20076         done
20077
20078         #
20079         # sparse file test
20080         # Create file with a hole and write actual two blocks. Block count
20081         # must be 16.
20082         #
20083         dd if=/dev/zero of=$DIR/$tfile bs=$grant_blk_size count=2 seek=5 \
20084                 conv=fsync || error "Create file : $DIR/$tfile"
20085
20086         # Calculate the final truncate size.
20087         trunc_sz=$(($(stat --format=%s $DIR/$tfile) - (grant_blk_size + 1)))
20088
20089         #
20090         # truncate to size $trunc_sz bytes. Strip the last block
20091         # The block count must drop to 8
20092         #
20093         $TRUNCATE $DIR/$tfile $trunc_sz ||
20094                 error "truncate $tfile to $trunc_sz failed"
20095
20096         local trunc_bsz=$((grant_blk_size / $(stat --format=%B $DIR/$tfile)))
20097         sz=$(stat --format=%s $DIR/$tfile)
20098         blk=$(stat --format=%b $DIR/$tfile)
20099
20100         if [[ $blk -ne $trunc_bsz ]]; then
20101                 $(which stat) $DIR/$tfile
20102                 error "Expected Block $trunc_bsz got $blk for $tfile"
20103         fi
20104
20105         $CHECKSTAT -s $trunc_sz $DIR/$tfile ||
20106                 error "Expected Size $trunc_sz got $sz for $tfile"
20107 }
20108 run_test 317 "Verify blocks get correctly update after truncate"
20109
20110 test_318() {
20111         local old_max_active=$($LCTL get_param -n \
20112                             llite.*.max_read_ahead_async_active 2>/dev/null)
20113
20114         $LCTL set_param llite.*.max_read_ahead_async_active=256
20115         local max_active=$($LCTL get_param -n \
20116                            llite.*.max_read_ahead_async_active 2>/dev/null)
20117         [ $max_active -ne 256 ] && error "expected 256 but got $max_active"
20118
20119         # currently reset to 0 is unsupported, leave it 512 for now.
20120         $LCTL set_param llite.*.max_read_ahead_async_active=0 &&
20121                 error "set max_read_ahead_async_active should fail"
20122
20123         $LCTL set_param llite.*.max_read_ahead_async_active=512
20124         max_active=$($LCTL get_param -n \
20125                      llite.*.max_read_ahead_async_active 2>/dev/null)
20126         [ $max_active -eq 512 ] || error "expected 512 but got $max_active"
20127
20128         # restore @max_active
20129         [ $old_max_active -ne 0 ] && $LCTL set_param \
20130                 llite.*.max_read_ahead_async_active=$old_max_active
20131
20132         local old_threshold=$($LCTL get_param -n \
20133                 llite.*.read_ahead_async_file_threshold_mb 2>/dev/null)
20134         local max_per_file_mb=$($LCTL get_param -n \
20135                 llite.*.max_read_ahead_per_file_mb 2>/dev/null)
20136
20137         local invalid=$(($max_per_file_mb + 1))
20138         $LCTL set_param \
20139                 llite.*.read_ahead_async_file_threshold_mb=$invalid\
20140                         && error "set $invalid should fail"
20141
20142         local valid=$(($invalid - 1))
20143         $LCTL set_param \
20144                 llite.*.read_ahead_async_file_threshold_mb=$valid ||
20145                         error "set $valid should succeed"
20146         local threshold=$($LCTL get_param -n \
20147                 llite.*.read_ahead_async_file_threshold_mb 2>/dev/null)
20148         [ $threshold -eq $valid ] || error \
20149                 "expect threshold $valid got $threshold"
20150         $LCTL set_param \
20151                 llite.*.read_ahead_async_file_threshold_mb=$old_threshold
20152 }
20153 run_test 318 "Verify async readahead tunables"
20154
20155 test_319() {
20156         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
20157
20158         local before=$(date +%s)
20159         local evict
20160         local mdir=$DIR/$tdir
20161         local file=$mdir/xxx
20162
20163         $LFS mkdir -i0 $mdir || error "mkdir $mdir fails"
20164         touch $file
20165
20166 #define OBD_FAIL_LDLM_LOCAL_CANCEL_PAUSE 0x32c
20167         $LCTL set_param fail_val=5 fail_loc=0x8000032c
20168         $LFS mv -m1 $file &
20169
20170         sleep 1
20171         dd if=$file of=/dev/null
20172         wait
20173         evict=$($LCTL get_param mdc.$FSNAME-MDT*.state |
20174           awk -F"[ [,]" '/EVICTED ]$/ { if (mx<$5) {mx=$5;} } END { print mx }')
20175
20176         [ -z "$evict" ] || [[ $evict -le $before ]] || error "eviction happened"
20177 }
20178 run_test 319 "lost lease lock on migrate error"
20179
20180 test_fake_rw() {
20181         local read_write=$1
20182         if [ "$read_write" = "write" ]; then
20183                 local dd_cmd="dd if=/dev/zero of=$DIR/$tfile"
20184         elif [ "$read_write" = "read" ]; then
20185                 local dd_cmd="dd of=/dev/null if=$DIR/$tfile"
20186         else
20187                 error "argument error"
20188         fi
20189
20190         # turn off debug for performance testing
20191         local saved_debug=$($LCTL get_param -n debug)
20192         $LCTL set_param debug=0
20193
20194         $LFS setstripe -c 1 -i 0 $DIR/$tfile
20195
20196         # get ost1 size - lustre-OST0000
20197         local ost1_avail_size=$($LFS df | awk /${ost1_svc}/'{ print $4 }')
20198         local blocks=$((ost1_avail_size/2/1024)) # half avail space by megabytes
20199         [ $blocks -gt 1000 ] && blocks=1000 # 1G in maximum
20200
20201         if [ "$read_write" = "read" ]; then
20202                 truncate -s $(expr 1048576 \* $blocks) $DIR/$tfile
20203         fi
20204
20205         local start_time=$(date +%s.%N)
20206         $dd_cmd bs=1M count=$blocks oflag=sync ||
20207                 error "real dd $read_write error"
20208         local duration=$(bc <<< "$(date +%s.%N) - $start_time")
20209
20210         if [ "$read_write" = "write" ]; then
20211                 rm -f $DIR/$tfile
20212         fi
20213
20214         # define OBD_FAIL_OST_FAKE_RW           0x238
20215         do_facet ost1 $LCTL set_param fail_loc=0x238
20216
20217         local start_time=$(date +%s.%N)
20218         $dd_cmd bs=1M count=$blocks oflag=sync ||
20219                 error "fake dd $read_write error"
20220         local duration_fake=$(bc <<< "$(date +%s.%N) - $start_time")
20221
20222         if [ "$read_write" = "write" ]; then
20223                 # verify file size
20224                 cancel_lru_locks osc
20225                 $CHECKSTAT -t file -s $((blocks * 1024 * 1024)) $DIR/$tfile ||
20226                         error "$tfile size not $blocks MB"
20227         fi
20228         do_facet ost1 $LCTL set_param fail_loc=0
20229
20230         echo "fake $read_write $duration_fake vs. normal $read_write" \
20231                 "$duration in seconds"
20232         [ $(bc <<< "$duration_fake < $duration") -eq 1 ] ||
20233                 error_not_in_vm "fake write is slower"
20234
20235         $LCTL set_param -n debug="$saved_debug"
20236         rm -f $DIR/$tfile
20237 }
20238 test_399a() { # LU-7655 for OST fake write
20239         remote_ost_nodsh && skip "remote OST with nodsh"
20240
20241         test_fake_rw write
20242 }
20243 run_test 399a "fake write should not be slower than normal write"
20244
20245 test_399b() { # LU-8726 for OST fake read
20246         remote_ost_nodsh && skip "remote OST with nodsh"
20247         if [ "$ost1_FSTYPE" != "ldiskfs" ]; then
20248                 skip_env "ldiskfs only test"
20249         fi
20250
20251         test_fake_rw read
20252 }
20253 run_test 399b "fake read should not be slower than normal read"
20254
20255 test_400a() { # LU-1606, was conf-sanity test_74
20256         if ! which $CC > /dev/null 2>&1; then
20257                 skip_env "$CC is not installed"
20258         fi
20259
20260         local extra_flags=''
20261         local out=$TMP/$tfile
20262         local prefix=/usr/include/lustre
20263         local prog
20264
20265         if ! [[ -d $prefix ]]; then
20266                 # Assume we're running in tree and fixup the include path.
20267                 extra_flags+=" -I$LUSTRE/../lnet/include/uapi -I$LUSTRE/include/uapi -I$LUSTRE/include"
20268                 extra_flags+=" -L$LUSTRE/utils/.lib"
20269         fi
20270
20271         for prog in $LUSTRE_TESTS_API_DIR/*.c; do
20272                 $CC -Wall -Werror $extra_flags -o $out $prog -llustreapi ||
20273                         error "client api broken"
20274         done
20275         rm -f $out
20276 }
20277 run_test 400a "Lustre client api program can compile and link"
20278
20279 test_400b() { # LU-1606, LU-5011
20280         local header
20281         local out=$TMP/$tfile
20282         local prefix=/usr/include/linux/lustre
20283
20284         # We use a hard coded prefix so that this test will not fail
20285         # when run in tree. There are headers in lustre/include/lustre/
20286         # that are not packaged (like lustre_idl.h) and have more
20287         # complicated include dependencies (like config.h and lnet/types.h).
20288         # Since this test about correct packaging we just skip them when
20289         # they don't exist (see below) rather than try to fixup cppflags.
20290
20291         if ! which $CC > /dev/null 2>&1; then
20292                 skip_env "$CC is not installed"
20293         fi
20294
20295         for header in $prefix/*.h; do
20296                 if ! [[ -f "$header" ]]; then
20297                         continue
20298                 fi
20299
20300                 if [[ "$(basename $header)" == lustre_ioctl.h ]]; then
20301                         continue # lustre_ioctl.h is internal header
20302                 fi
20303
20304                 $CC -Wall -Werror -include $header -c -x c /dev/null -o $out ||
20305                         error "cannot compile '$header'"
20306         done
20307         rm -f $out
20308 }
20309 run_test 400b "packaged headers can be compiled"
20310
20311 test_401a() { #LU-7437
20312         local printf_arg=$(find -printf 2>&1 | grep "unrecognized:")
20313         [ -n "$printf_arg" ] && skip_env "find does not support -printf"
20314
20315         #count the number of parameters by "list_param -R"
20316         local params=$($LCTL list_param -R '*' 2>/dev/null | wc -l)
20317         #count the number of parameters by listing proc files
20318         local proc_dirs=$(eval \ls -d $proc_regexp 2>/dev/null)
20319         echo "proc_dirs='$proc_dirs'"
20320         [ -n "$proc_dirs" ] || error "no proc_dirs on $HOSTNAME"
20321         local procs=$(find -L $proc_dirs -mindepth 1 -printf '%P\n' 2>/dev/null|
20322                       sort -u | wc -l)
20323
20324         [ $params -eq $procs ] ||
20325                 error "found $params parameters vs. $procs proc files"
20326
20327         # test the list_param -D option only returns directories
20328         params=$($LCTL list_param -R -D '*' 2>/dev/null | wc -l)
20329         #count the number of parameters by listing proc directories
20330         procs=$(find -L $proc_dirs -mindepth 1 -type d -printf '%P\n' 2>/dev/null |
20331                 sort -u | wc -l)
20332
20333         [ $params -eq $procs ] ||
20334                 error "found $params parameters vs. $procs proc files"
20335 }
20336 run_test 401a "Verify if 'lctl list_param -R' can list parameters recursively"
20337
20338 test_401b() {
20339         local save=$($LCTL get_param -n jobid_var)
20340         local tmp=testing
20341
20342         $LCTL set_param foo=bar jobid_var=$tmp bar=baz &&
20343                 error "no error returned when setting bad parameters"
20344
20345         local jobid_new=$($LCTL get_param -n foe jobid_var baz)
20346         [[ "$jobid_new" == "$tmp" ]] || error "jobid tmp $jobid_new != $tmp"
20347
20348         $LCTL set_param -n fog=bam jobid_var=$save bat=fog
20349         local jobid_old=$($LCTL get_param -n foe jobid_var bag)
20350         [[ "$jobid_old" == "$save" ]] || error "jobid new $jobid_old != $save"
20351 }
20352 run_test 401b "Verify 'lctl {get,set}_param' continue after error"
20353
20354 test_401c() {
20355         local jobid_var_old=$($LCTL get_param -n jobid_var)
20356         local jobid_var_new
20357
20358         $LCTL set_param jobid_var= &&
20359                 error "no error returned for 'set_param a='"
20360
20361         jobid_var_new=$($LCTL get_param -n jobid_var)
20362         [[ "$jobid_var_old" == "$jobid_var_new" ]] ||
20363                 error "jobid_var was changed by setting without value"
20364
20365         $LCTL set_param jobid_var &&
20366                 error "no error returned for 'set_param a'"
20367
20368         jobid_var_new=$($LCTL get_param -n jobid_var)
20369         [[ "$jobid_var_old" == "$jobid_var_new" ]] ||
20370                 error "jobid_var was changed by setting without value"
20371 }
20372 run_test 401c "Verify 'lctl set_param' without value fails in either format."
20373
20374 test_401d() {
20375         local jobid_var_old=$($LCTL get_param -n jobid_var)
20376         local jobid_var_new
20377         local new_value="foo=bar"
20378
20379         $LCTL set_param jobid_var=$new_value ||
20380                 error "'set_param a=b' did not accept a value containing '='"
20381
20382         jobid_var_new=$($LCTL get_param -n jobid_var)
20383         [[ "$jobid_var_new" == "$new_value" ]] ||
20384                 error "'set_param a=b' failed on a value containing '='"
20385
20386         # Reset the jobid_var to test the other format
20387         $LCTL set_param jobid_var=$jobid_var_old
20388         jobid_var_new=$($LCTL get_param -n jobid_var)
20389         [[ "$jobid_var_new" == "$jobid_var_old" ]] ||
20390                 error "failed to reset jobid_var"
20391
20392         $LCTL set_param jobid_var $new_value ||
20393                 error "'set_param a b' did not accept a value containing '='"
20394
20395         jobid_var_new=$($LCTL get_param -n jobid_var)
20396         [[ "$jobid_var_new" == "$new_value" ]] ||
20397                 error "'set_param a b' failed on a value containing '='"
20398
20399         $LCTL set_param jobid_var $jobid_var_old
20400         jobid_var_new=$($LCTL get_param -n jobid_var)
20401         [[ "$jobid_var_new" == "$jobid_var_old" ]] ||
20402                 error "failed to reset jobid_var"
20403 }
20404 run_test 401d "Verify 'lctl set_param' accepts values containing '='"
20405
20406 test_402() {
20407         [[ $MDS1_VERSION -ge $(version_code 2.7.66) ]] ||
20408         [[ $MDS1_VERSION -ge $(version_code 2.7.18.4) &&
20409                 $MDS1_VERSION -lt $(version_code 2.7.50) ]] ||
20410         [[ $MDS1_VERSION -ge $(version_code 2.7.2) &&
20411                 $MDS1_VERSION -lt $(version_code 2.7.11) ]] ||
20412                 skip "Need MDS version 2.7.2+ or 2.7.18.4+ or 2.7.66+"
20413         remote_mds_nodsh && skip "remote MDS with nodsh"
20414
20415         $LFS setdirstripe -i 0 $DIR/$tdir || error "setdirstripe -i 0 failed"
20416 #define OBD_FAIL_MDS_FLD_LOOKUP 0x15c
20417         do_facet mds1 "lctl set_param fail_loc=0x8000015c"
20418         touch $DIR/$tdir/$tfile && error "touch should fail with ENOENT" ||
20419                 echo "Touch failed - OK"
20420 }
20421 run_test 402 "Return ENOENT to lod_generate_and_set_lovea"
20422
20423 test_403() {
20424         local file1=$DIR/$tfile.1
20425         local file2=$DIR/$tfile.2
20426         local tfile=$TMP/$tfile
20427
20428         rm -f $file1 $file2 $tfile
20429
20430         touch $file1
20431         ln $file1 $file2
20432
20433         # 30 sec OBD_TIMEOUT in ll_getattr()
20434         # right before populating st_nlink
20435         $LCTL set_param fail_loc=0x80001409
20436         stat -c %h $file1 > $tfile &
20437
20438         # create an alias, drop all locks and reclaim the dentry
20439         < $file2
20440         cancel_lru_locks mdc
20441         cancel_lru_locks osc
20442         sysctl -w vm.drop_caches=2
20443
20444         wait
20445
20446         [ $(cat $tfile) -gt 0 ] || error "wrong nlink count: $(cat $tfile)"
20447
20448         rm -f $tfile $file1 $file2
20449 }
20450 run_test 403 "i_nlink should not drop to zero due to aliasing"
20451
20452 test_404() { # LU-6601
20453         [[ $MDS1_VERSION -ge $(version_code 2.8.53) ]] ||
20454                 skip "Need server version newer than 2.8.52"
20455         remote_mds_nodsh && skip "remote MDS with nodsh"
20456
20457         local mosps=$(do_facet $SINGLEMDS $LCTL dl |
20458                 awk '/osp .*-osc-MDT/ { print $4}')
20459
20460         local osp
20461         for osp in $mosps; do
20462                 echo "Deactivate: " $osp
20463                 do_facet $SINGLEMDS $LCTL --device %$osp deactivate
20464                 local stat=$(do_facet $SINGLEMDS $LCTL dl |
20465                         awk -vp=$osp '$4 == p { print $2 }')
20466                 [ $stat = IN ] || {
20467                         do_facet $SINGLEMDS $LCTL dl | grep -w $osp
20468                         error "deactivate error"
20469                 }
20470                 echo "Activate: " $osp
20471                 do_facet $SINGLEMDS $LCTL --device %$osp activate
20472                 local stat=$(do_facet $SINGLEMDS $LCTL dl |
20473                         awk -vp=$osp '$4 == p { print $2 }')
20474                 [ $stat = UP ] || {
20475                         do_facet $SINGLEMDS $LCTL dl | grep -w $osp
20476                         error "activate error"
20477                 }
20478         done
20479 }
20480 run_test 404 "validate manual {de}activated works properly for OSPs"
20481
20482 test_405() {
20483         [ -n "$FILESET" ] && skip "Not functional for FILESET set"
20484         [ $MDS1_VERSION -lt $(version_code 2.6.92) ] ||
20485                 [ $CLIENT_VERSION -lt $(version_code 2.6.99) ] &&
20486                         skip "Layout swap lock is not supported"
20487
20488         check_swap_layouts_support
20489
20490         test_mkdir $DIR/$tdir
20491         swap_lock_test -d $DIR/$tdir ||
20492                 error "One layout swap locked test failed"
20493 }
20494 run_test 405 "Various layout swap lock tests"
20495
20496 test_406() {
20497         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
20498         [ $OSTCOUNT -lt 2 ] && skip_env "needs >= 2 OSTs"
20499         [ -n "$FILESET" ] && skip "SKIP due to FILESET set"
20500         [ $PARALLEL == "yes" ] && skip "skip parallel run"
20501         [ $MDS1_VERSION -lt $(version_code 2.8.50) ] &&
20502                 skip "Need MDS version at least 2.8.50"
20503
20504         local def_stripe_size=$($LFS getstripe -S $MOUNT)
20505         local test_pool=$TESTNAME
20506
20507         if ! combined_mgs_mds ; then
20508                 mount_mgs_client
20509         fi
20510         pool_add $test_pool || error "pool_add failed"
20511         pool_add_targets $test_pool 0 $(($OSTCOUNT - 1)) 1 ||
20512                 error "pool_add_targets failed"
20513
20514         save_layout_restore_at_exit $MOUNT
20515
20516         # parent set default stripe count only, child will stripe from both
20517         # parent and fs default
20518         $LFS setstripe -c 1 -i 1 -S $((def_stripe_size * 2)) -p $test_pool $MOUNT ||
20519                 error "setstripe $MOUNT failed"
20520         $LFS mkdir -c $MDSCOUNT $DIR/$tdir || error "mkdir $tdir failed"
20521         $LFS setstripe -c $OSTCOUNT $DIR/$tdir || error "setstripe $tdir failed"
20522         for i in $(seq 10); do
20523                 local f=$DIR/$tdir/$tfile.$i
20524                 touch $f || error "touch failed"
20525                 local count=$($LFS getstripe -c $f)
20526                 [ $count -eq $OSTCOUNT ] ||
20527                         error "$f stripe count $count != $OSTCOUNT"
20528                 local offset=$($LFS getstripe -i $f)
20529                 [ $offset -eq 1 ] || error "$f stripe offset $offset != 1"
20530                 local size=$($LFS getstripe -S $f)
20531                 [ $size -eq $((def_stripe_size * 2)) ] ||
20532                         error "$f stripe size $size != $((def_stripe_size * 2))"
20533                 local pool=$($LFS getstripe -p $f)
20534                 [ $pool == $test_pool ] || error "$f pool $pool != $test_pool"
20535         done
20536
20537         # change fs default striping, delete parent default striping, now child
20538         # will stripe from new fs default striping only
20539         $LFS setstripe -c 1 -S $def_stripe_size -i 0 $MOUNT ||
20540                 error "change $MOUNT default stripe failed"
20541         $LFS setstripe -c 0 $DIR/$tdir ||
20542                 error "delete $tdir default stripe failed"
20543         for i in $(seq 11 20); do
20544                 local f=$DIR/$tdir/$tfile.$i
20545                 touch $f || error "touch $f failed"
20546                 local count=$($LFS getstripe -c $f)
20547                 [ $count -eq 1 ] || error "$f stripe count $count != 1"
20548                 local offset=$($LFS getstripe -i $f)
20549                 [ $offset -eq 0 ] || error "$f stripe offset $offset != 0"
20550                 local size=$($LFS getstripe -S $f)
20551                 [ $size -eq $def_stripe_size ] ||
20552                         error "$f stripe size $size != $def_stripe_size"
20553                 local pool=$($LFS getstripe -p $f)
20554                 [ $pool == $test_pool ] || error "$f pool $pool isn't set"
20555         done
20556
20557         unlinkmany $DIR/$tdir/$tfile. 1 20
20558
20559         local f=$DIR/$tdir/$tfile
20560         pool_remove_all_targets $test_pool $f
20561         pool_remove $test_pool $f
20562
20563         if ! combined_mgs_mds ; then
20564                 umount_mgs_client
20565         fi
20566 }
20567 run_test 406 "DNE support fs default striping"
20568
20569 test_407() {
20570         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
20571         [[ $MDS1_VERSION -lt $(version_code 2.8.55) ]] &&
20572                 skip "Need MDS version at least 2.8.55"
20573         remote_mds_nodsh && skip "remote MDS with nodsh"
20574
20575         $LFS mkdir -i 0 -c 1 $DIR/$tdir.0 ||
20576                 error "$LFS mkdir -i 0 -c 1 $tdir.0 failed"
20577         $LFS mkdir -i 1 -c 1 $DIR/$tdir.1 ||
20578                 error "$LFS mkdir -i 1 -c 1 $tdir.1 failed"
20579         touch $DIR/$tdir.0/$tfile.0 || error "touch $tdir.0/$tfile.0 failed"
20580
20581         #define OBD_FAIL_DT_TXN_STOP    0x2019
20582         for idx in $(seq $MDSCOUNT); do
20583                 do_facet mds$idx "lctl set_param fail_loc=0x2019"
20584         done
20585         $LFS mkdir -c 2 $DIR/$tdir && error "$LFS mkdir -c 2 $tdir should fail"
20586         mv $DIR/$tdir.0/$tfile.0 $DIR/$tdir.1/$tfile.1 &&
20587                 error "mv $tdir.0/$tfile.0 $tdir.1/$tfile.1 should fail"
20588         true
20589 }
20590 run_test 407 "transaction fail should cause operation fail"
20591
20592 test_408() {
20593         dd if=/dev/zero of=$DIR/$tfile bs=$PAGE_SIZE count=1 oflag=direct
20594
20595         #define OBD_FAIL_OSC_BRW_PREP_REQ2        0x40a
20596         lctl set_param fail_loc=0x8000040a
20597         # let ll_prepare_partial_page() fail
20598         dd if=/dev/zero of=$DIR/$tfile bs=2048 count=1 conv=notrunc || true
20599
20600         rm -f $DIR/$tfile
20601
20602         # create at least 100 unused inodes so that
20603         # shrink_icache_memory(0) should not return 0
20604         touch $DIR/$tfile-{0..100}
20605         rm -f $DIR/$tfile-{0..100}
20606         sync
20607
20608         echo 2 > /proc/sys/vm/drop_caches
20609 }
20610 run_test 408 "drop_caches should not hang due to page leaks"
20611
20612 test_409()
20613 {
20614         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
20615
20616         mkdir -p $DIR/$tdir || error "(0) Fail to mkdir"
20617         $LFS mkdir -i 1 -c 2 $DIR/$tdir/foo || error "(1) Fail to mkdir"
20618         touch $DIR/$tdir/guard || error "(2) Fail to create"
20619
20620         local PREFIX=$(str_repeat 'A' 128)
20621         echo "Create 1K hard links start at $(date)"
20622         createmany -l $DIR/$tdir/guard $DIR/$tdir/foo/${PREFIX}_ 1000 ||
20623                 error "(3) Fail to hard link"
20624
20625         echo "Links count should be right although linkEA overflow"
20626         stat $DIR/$tdir/guard || error "(4) Fail to stat"
20627         local linkcount=$(stat --format=%h $DIR/$tdir/guard)
20628         [ $linkcount -eq 1001 ] ||
20629                 error "(5) Unexpected hard links count: $linkcount"
20630
20631         echo "List all links start at $(date)"
20632         ls -l $DIR/$tdir/foo > /dev/null ||
20633                 error "(6) Fail to list $DIR/$tdir/foo"
20634
20635         echo "Unlink hard links start at $(date)"
20636         unlinkmany $DIR/$tdir/foo/${PREFIX}_ 1000 ||
20637                 error "(7) Fail to unlink"
20638         echo "Unlink hard links finished at $(date)"
20639 }
20640 run_test 409 "Large amount of cross-MDTs hard links on the same file"
20641
20642 test_410()
20643 {
20644         [[ $CLIENT_VERSION -lt $(version_code 2.9.59) ]] &&
20645                 skip "Need client version at least 2.9.59"
20646
20647         # Create a file, and stat it from the kernel
20648         local testfile=$DIR/$tfile
20649         touch $testfile
20650
20651         local run_id=$RANDOM
20652         local my_ino=$(stat --format "%i" $testfile)
20653
20654         # Try to insert the module. This will always fail as the
20655         # module is designed to not be inserted.
20656         insmod $LUSTRE/tests/kernel/kinode.ko run_id=$run_id fname=$testfile \
20657             &> /dev/null
20658
20659         # Anything but success is a test failure
20660         dmesg | grep -q \
20661             "lustre_kinode_$run_id: inode numbers are identical: $my_ino" ||
20662             error "no inode match"
20663 }
20664 run_test 410 "Test inode number returned from kernel thread"
20665
20666 cleanup_test411_cgroup() {
20667         trap 0
20668         rmdir "$1"
20669 }
20670
20671 test_411() {
20672         local cg_basedir=/sys/fs/cgroup/memory
20673         # LU-9966
20674         test -f "$cg_basedir/memory.kmem.limit_in_bytes" ||
20675                 skip "no setup for cgroup"
20676
20677         dd if=/dev/zero of=$DIR/$tfile bs=1M count=100 conv=fsync ||
20678                 error "test file creation failed"
20679         cancel_lru_locks osc
20680
20681         # Create a very small memory cgroup to force a slab allocation error
20682         local cgdir=$cg_basedir/osc_slab_alloc
20683         mkdir $cgdir || error "cgroup mkdir '$cgdir' failed"
20684         trap "cleanup_test411_cgroup $cgdir" EXIT
20685         echo 2M > $cgdir/memory.kmem.limit_in_bytes
20686         echo 1M > $cgdir/memory.limit_in_bytes
20687
20688         # Should not LBUG, just be killed by oom-killer
20689         # dd will return 0 even allocation failure in some environment.
20690         # So don't check return value
20691         sh -c "echo \$$ > $cgdir/tasks && dd if=$DIR/$tfile of=/dev/null"
20692         cleanup_test411_cgroup $cgdir
20693
20694         return 0
20695 }
20696 run_test 411 "Slab allocation error with cgroup does not LBUG"
20697
20698 test_412() {
20699         [ $MDSCOUNT -lt 2 ] && skip_env "needs >= 2 MDTs"
20700         if [ $(lustre_version_code mds1) -lt $(version_code 2.10.55) ]; then
20701                 skip "Need server version at least 2.10.55"
20702         fi
20703
20704         $LFS mkdir -i $((MDSCOUNT - 1)),$((MDSCOUNT - 2)) $DIR/$tdir ||
20705                 error "mkdir failed"
20706         $LFS getdirstripe $DIR/$tdir
20707         local stripe_index=$($LFS getdirstripe -i $DIR/$tdir)
20708         [ $stripe_index -eq $((MDSCOUNT - 1)) ] ||
20709                 error "expect $((MDSCOUT - 1)) get $stripe_index"
20710         local stripe_count=$($LFS getdirstripe -T $DIR/$tdir)
20711         [ $stripe_count -eq 2 ] ||
20712                 error "expect 2 get $stripe_count"
20713 }
20714 run_test 412 "mkdir on specific MDTs"
20715
20716 test_413a() {
20717         [ $MDSCOUNT -lt 2 ] &&
20718                 skip "We need at least 2 MDTs for this test"
20719
20720         if [ $(lustre_version_code mds1) -lt $(version_code 2.10.55) ]; then
20721                 skip "Need server version at least 2.10.55"
20722         fi
20723
20724         mkdir $DIR/$tdir || error "mkdir failed"
20725
20726         # find MDT that is the most full
20727         local max=$($LFS df | grep MDT |
20728                 awk 'BEGIN { a=0 }
20729                         { sub("%", "", $5)
20730                           if (0+$5 >= a)
20731                           {
20732                                 a = $5
20733                                 b = $6
20734                           }
20735                         }
20736                      END { split(b, c, ":")
20737                            sub("]", "", c[2])
20738                            print c[2]
20739                          }')
20740
20741         for i in $(seq $((MDSCOUNT - 1))); do
20742                 $LFS mkdir -c $i $DIR/$tdir/d$i ||
20743                         error "mkdir d$i failed"
20744                 $LFS getdirstripe $DIR/$tdir/d$i
20745                 local stripe_index=$($LFS getdirstripe -i $DIR/$tdir/d$i)
20746                 [ $stripe_index -ne $max ] ||
20747                         error "don't expect $max"
20748         done
20749 }
20750 run_test 413a "mkdir on less full MDTs"
20751
20752 test_413b() {
20753         [ $MDSCOUNT -lt 2 ] &&
20754                 skip "We need at least 2 MDTs for this test"
20755
20756         [ $MDS1_VERSION -lt $(version_code 2.12.52) ] &&
20757                 skip "Need server version at least 2.12.52"
20758
20759         mkdir $DIR/$tdir || error "mkdir failed"
20760         $LFS setdirstripe -D -i -1 -H space $DIR/$tdir ||
20761                 error "setdirstripe failed"
20762
20763         local qos_prio_free
20764         local qos_threshold_rr
20765         local count
20766
20767         qos_prio_free=$($LCTL get_param -n lmv.*.qos_prio_free | head -n1)
20768         qos_prio_free=${qos_prio_free%%%}
20769         qos_threshold_rr=$($LCTL get_param -n lmv.*.qos_threshold_rr | head -n1)
20770         qos_threshold_rr=${qos_threshold_rr%%%}
20771         qos_maxage=$($LCTL get_param -n lmv.*.qos_maxage)
20772
20773         stack_trap "$LCTL set_param lmv.*.qos_prio_free=$qos_prio_free" EXIT
20774         stack_trap "$LCTL set_param lmv.*.qos_threshold_rr=$qos_threshold_rr" \
20775                 EXIT
20776         stack_trap "$LCTL set_param lmv.*.qos_maxage=$qos_maxage" EXIT
20777
20778         echo "mkdir with roundrobin"
20779
20780         $LCTL set_param lmv.*.qos_threshold_rr=100
20781         for i in $(seq $((100 * MDSCOUNT))); do
20782                 mkdir $DIR/$tdir/subdir$i || error "mkdir subdir$i failed"
20783         done
20784         for i in $(seq $MDSCOUNT); do
20785                 count=$($LFS getdirstripe -i $DIR/$tdir/* | grep ^$((i - 1))$ |
20786                         wc -w)
20787                 echo "$count directories created on MDT$((i - 1))"
20788                 [ $count -eq 100 ] || error "subdirs are not evenly distributed"
20789         done
20790
20791         rm -rf $DIR/$tdir/*
20792
20793         $LCTL set_param lmv.*.qos_threshold_rr=$qos_threshold_rr
20794         # Shorten statfs result age, so that it can be updated in time
20795         $LCTL set_param lmv.*.qos_maxage=1
20796         sleep_maxage
20797
20798         local ffree
20799         local max
20800         local min
20801         local max_index
20802         local min_index
20803
20804         ffree=($(lctl get_param -n mdc.*[mM][dD][cC]-[^M]*.filesfree | uniq))
20805         echo "MDT filesfree available: ${ffree[@]}"
20806         max=${ffree[0]}
20807         min=${ffree[0]}
20808         max_index=0
20809         min_index=0
20810         for ((i = 0; i < ${#ffree[@]}; i++)); do
20811                 if [[ ${ffree[i]} -gt $max ]]; then
20812                         max=${ffree[i]}
20813                         max_index=$i
20814                 fi
20815                 if [[ ${ffree[i]} -lt $min ]]; then
20816                         min=${ffree[i]}
20817                         min_index=$i
20818                 fi
20819         done
20820         echo "Min free files: MDT$min_index: $min"
20821         echo "Max free files: MDT$max_index: $max"
20822
20823         [ $min -eq 0 ] && skip "no free files in MDT$min_index"
20824         [ $min -gt 10000000 ] && skip "too much free files in MDT$min_index"
20825
20826         # Check if we need to generate uneven MDTs
20827         test_mkdir -i $min_index -c 1 -p $DIR/$tdir-MDT$min_index
20828         local threshold=10
20829         local diff=$((max - min))
20830         local diff2=$((diff * 100 / min))
20831
20832         echo -n "Check for uneven MDTs: "
20833         echo -n "diff=$diff files ($diff2%) must be > $threshold% ..."
20834
20835         if [ $diff2 -gt $threshold ]; then
20836                 echo "ok"
20837                 echo "Don't need to fill MDT$min_index"
20838         else
20839                 # generate uneven MDTs, create till 25% diff
20840                 echo "no"
20841                 diff2=$((threshold - diff2))
20842                 diff=$((min * diff2 / 100))
20843                 # 50 sec per 10000 files in vm
20844                 [ $diff -gt 40000 ] && [ "$SLOW" = "no" ] &&
20845                         skip "$diff files to create"
20846                 echo "Fill $diff2% diff in MDT$min_index with $diff files"
20847                 local i
20848                 local value="$(generate_string 1024)"
20849                 for i in $(seq $diff); do
20850                         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE \
20851                                 $DIR/$tdir-MDT$min_index/f$i > /dev/null ||
20852                                 error "create f$i failed"
20853                         setfattr -n user.413b -v $value \
20854                                 $DIR/$tdir-MDT$min_index/f$i ||
20855                                 error "setfattr f$i failed"
20856                 done
20857         fi
20858
20859         min=$((100 *MDSCOUNT))
20860         max=0
20861
20862         echo "mkdir with balanced space usage"
20863         $LCTL set_param lmv.*.qos_prio_free=100
20864         for i in $(seq $((100 * MDSCOUNT))); do
20865                 mkdir $DIR/$tdir/subdir$i || error "mkdir subdir$i failed"
20866         done
20867         for i in $(seq $MDSCOUNT); do
20868                 count=$($LFS getdirstripe -i $DIR/$tdir/* | grep ^$((i - 1))$ |
20869                         wc -w)
20870                 echo "$count directories created on MDT$((i - 1))"
20871                 [ $min -gt $count ] && min=$count
20872                 [ $max -lt $count ] && max=$count
20873         done
20874         [ $((max - min)) -gt $MDSCOUNT ] ||
20875                 error "subdirs shouldn't be evenly distributed"
20876
20877         which getfattr > /dev/null 2>&1 || skip_env "no getfattr command"
20878
20879         $LFS setdirstripe -D -d $DIR/$tdir || error "setdirstripe -d failed"
20880         getfattr -n trusted.dmv $DIR/$tdir && error "default dir layout exists"
20881         true
20882 }
20883 run_test 413b "mkdir with balanced space usage"
20884
20885 test_414() {
20886 #define OBD_FAIL_PTLRPC_BULK_ATTACH      0x521
20887         $LCTL set_param fail_loc=0x80000521
20888         dd if=/dev/zero of=$DIR/$tfile bs=2M count=1 oflag=sync
20889         rm -f $DIR/$tfile
20890 }
20891 run_test 414 "simulate ENOMEM in ptlrpc_register_bulk()"
20892
20893 test_415() {
20894         [ $PARALLEL == "yes" ] && skip "skip parallel run"
20895         [ $(lustre_version_code mds1) -lt $(version_code 2.11.52) ] &&
20896                 skip "Need server version at least 2.11.52"
20897
20898         # LU-11102
20899         local total
20900         local setattr_pid
20901         local start_time
20902         local end_time
20903         local duration
20904
20905         total=500
20906         # this test may be slow on ZFS
20907         [ "$mds1_FSTYPE" == "zfs" ] && total=100
20908
20909         # though this test is designed for striped directory, let's test normal
20910         # directory too since lock is always saved as CoS lock.
20911         test_mkdir $DIR/$tdir || error "mkdir $tdir"
20912         createmany -o $DIR/$tdir/$tfile. $total || error "createmany"
20913
20914         (
20915                 while true; do
20916                         touch $DIR/$tdir
20917                 done
20918         ) &
20919         setattr_pid=$!
20920
20921         start_time=$(date +%s)
20922         for i in $(seq $total); do
20923                 mrename $DIR/$tdir/$tfile.$i $DIR/$tdir/$tfile-new.$i \
20924                         > /dev/null
20925         done
20926         end_time=$(date +%s)
20927         duration=$((end_time - start_time))
20928
20929         kill -9 $setattr_pid
20930
20931         echo "rename $total files took $duration sec"
20932         [ $duration -lt 100 ] || error "rename took $duration sec"
20933 }
20934 run_test 415 "lock revoke is not missing"
20935
20936 test_416() {
20937         [ $(lustre_version_code mds1) -lt $(version_code 2.11.55) ] &&
20938                 skip "Need server version at least 2.11.55"
20939
20940         # define OBD_FAIL_OSD_TXN_START    0x19a
20941         do_facet mds1 lctl set_param fail_loc=0x19a
20942
20943         lfs mkdir -c $MDSCOUNT $DIR/$tdir
20944
20945         true
20946 }
20947 run_test 416 "transaction start failure won't cause system hung"
20948
20949 cleanup_417() {
20950         trap 0
20951         do_nodes $(comma_list $(mdts_nodes)) \
20952                 "$LCTL set_param -n mdt.*MDT*.enable_dir_migration=1"
20953         do_nodes $(comma_list $(mdts_nodes)) \
20954                 "$LCTL set_param -n mdt.*MDT*.enable_remote_dir=1"
20955         do_nodes $(comma_list $(mdts_nodes)) \
20956                 "$LCTL set_param -n mdt.*MDT*.enable_striped_dir=1"
20957 }
20958
20959 test_417() {
20960         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
20961         [[ $MDS1_VERSION -lt $(version_code 2.11.56) ]] &&
20962                 skip "Need MDS version at least 2.11.56"
20963
20964         trap cleanup_417 RETURN EXIT
20965
20966         $LFS mkdir -i 1 $DIR/$tdir.1 || error "create remote dir $tdir.1 failed"
20967         do_nodes $(comma_list $(mdts_nodes)) \
20968                 "$LCTL set_param -n mdt.*MDT*.enable_dir_migration=0"
20969         $LFS migrate -m 0 $DIR/$tdir.1 &&
20970                 error "migrate dir $tdir.1 should fail"
20971
20972         do_nodes $(comma_list $(mdts_nodes)) \
20973                 "$LCTL set_param -n mdt.*MDT*.enable_remote_dir=0"
20974         $LFS mkdir -i 1 $DIR/$tdir.2 &&
20975                 error "create remote dir $tdir.2 should fail"
20976
20977         do_nodes $(comma_list $(mdts_nodes)) \
20978                 "$LCTL set_param -n mdt.*MDT*.enable_striped_dir=0"
20979         $LFS mkdir -c 2 $DIR/$tdir.3 &&
20980                 error "create striped dir $tdir.3 should fail"
20981         true
20982 }
20983 run_test 417 "disable remote dir, striped dir and dir migration"
20984
20985 # Checks that the outputs of df [-i] and lfs df [-i] match
20986 #
20987 # usage: check_lfs_df <blocks | inodes> <mountpoint>
20988 check_lfs_df() {
20989         local dir=$2
20990         local inodes
20991         local df_out
20992         local lfs_df_out
20993         local count
20994         local passed=false
20995
20996         # blocks or inodes
20997         [ "$1" == "blocks" ] && inodes= || inodes="-i"
20998
20999         for count in {1..100}; do
21000                 cancel_lru_locks
21001                 sync; sleep 0.2
21002
21003                 # read the lines of interest
21004                 df_out=($(df -P $inodes $dir | tail -n +2)) ||
21005                         error "df $inodes $dir | tail -n +2 failed"
21006                 lfs_df_out=($($LFS df $inodes $dir | grep summary:)) ||
21007                         error "lfs df $inodes $dir | grep summary: failed"
21008
21009                 # skip first substrings of each output as they are different
21010                 # "<NID>:/<fsname>" for df, "filesystem_summary:" for lfs df
21011                 # compare the two outputs
21012                 passed=true
21013                 for i in {1..5}; do
21014                         [ "${df_out[i]}" != "${lfs_df_out[i]}" ] && passed=false
21015                 done
21016                 $passed && break
21017         done
21018
21019         if ! $passed; then
21020                 df -P $inodes $dir
21021                 echo
21022                 lfs df $inodes $dir
21023                 error "df and lfs df $1 output mismatch: "      \
21024                       "df ${inodes}: ${df_out[*]}, "            \
21025                       "lfs df ${inodes}: ${lfs_df_out[*]}"
21026         fi
21027 }
21028
21029 test_418() {
21030         [ $PARALLEL == "yes" ] && skip "skip parallel run"
21031
21032         local dir=$DIR/$tdir
21033         local numfiles=$((RANDOM % 4096 + 2))
21034         local numblocks=$((RANDOM % 256 + 1))
21035
21036         wait_delete_completed
21037         test_mkdir $dir
21038
21039         # check block output
21040         check_lfs_df blocks $dir
21041         # check inode output
21042         check_lfs_df inodes $dir
21043
21044         # create a single file and retest
21045         echo "Creating a single file and testing"
21046         createmany -o $dir/$tfile- 1 &>/dev/null ||
21047                 error "creating 1 file in $dir failed"
21048         check_lfs_df blocks $dir
21049         check_lfs_df inodes $dir
21050
21051         # create a random number of files
21052         echo "Creating $((numfiles - 1)) files and testing"
21053         createmany -o $dir/$tfile- 1 $((numfiles - 1)) &>/dev/null ||
21054                 error "creating $((numfiles - 1)) files in $dir failed"
21055
21056         # write a random number of blocks to the first test file
21057         echo "Writing $numblocks 4K blocks and testing"
21058         dd if=/dev/urandom of=$dir/${tfile}-0 bs=4K conv=fsync \
21059                 count=$numblocks &>/dev/null ||
21060                 error "dd to $dir/${tfile}-0 failed"
21061
21062         # retest
21063         check_lfs_df blocks $dir
21064         check_lfs_df inodes $dir
21065
21066         unlinkmany $dir/$tfile- $numfiles &>/dev/null ||
21067                 error "unlinking $numfiles files in $dir failed"
21068 }
21069 run_test 418 "df and lfs df outputs match"
21070
21071 test_419()
21072 {
21073         local dir=$DIR/$tdir
21074
21075         mkdir -p $dir
21076         touch $dir/file
21077
21078         cancel_lru_locks mdc
21079
21080         #OBD_FAIL_LLITE_OPEN_BY_NAME    0x1410
21081         $LCTL set_param fail_loc=0x1410
21082         cat $dir/file
21083         $LCTL set_param fail_loc=0
21084         rm -rf $dir
21085 }
21086 run_test 419 "Verify open file by name doesn't crash kernel"
21087
21088 test_420()
21089 {
21090         [[ $MDS1_VERSION -ge $(version_code 2.12.53) ]] ||
21091                 skip "Need MDS version at least 2.12.53"
21092
21093         local SAVE_UMASK=$(umask)
21094         local dir=$DIR/$tdir
21095         local uname=$(getent passwd $RUNAS_ID | cut -d: -f1)
21096
21097         mkdir -p $dir
21098         umask 0000
21099         mkdir -m03777 $dir/testdir
21100         ls -dn $dir/testdir
21101         # Need to remove trailing '.' when SELinux is enabled
21102         local dirperms=$(ls -dn $dir/testdir |
21103                          awk '{ sub(/\.$/, "", $1); print $1}')
21104         [ $dirperms == "drwxrwsrwt" ] ||
21105                 error "incorrect perms on $dir/testdir"
21106
21107         su - $uname -c "PATH=$LUSTRE/tests:\$PATH; \
21108                 openfile -f O_RDONLY:O_CREAT -m 02755 $dir/testdir/testfile"
21109         ls -n $dir/testdir/testfile
21110         local fileperms=$(ls -n $dir/testdir/testfile |
21111                           awk '{ sub(/\.$/, "", $1); print $1}')
21112         [ $fileperms == "-rwxr-xr-x" ] ||
21113                 error "incorrect perms on $dir/testdir/testfile"
21114
21115         umask $SAVE_UMASK
21116 }
21117 run_test 420 "clear SGID bit on non-directories for non-members"
21118
21119 test_421a() {
21120         local cnt
21121         local fid1
21122         local fid2
21123
21124         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
21125                 skip "Need MDS version at least 2.12.54"
21126
21127         test_mkdir $DIR/$tdir
21128         createmany -o $DIR/$tdir/f 3
21129         cnt=$(ls -1 $DIR/$tdir | wc -l)
21130         [ $cnt != 3 ] && error "unexpected #files: $cnt"
21131
21132         fid1=$(lfs path2fid $DIR/$tdir/f1)
21133         fid2=$(lfs path2fid $DIR/$tdir/f2)
21134         $LFS rmfid $DIR $fid1 $fid2 || error "rmfid failed"
21135
21136         stat $DIR/$tdir/f1 && error "f1 still visible on the client"
21137         stat $DIR/$tdir/f2 && error "f2 still visible on the client"
21138
21139         cnt=$(ls -1 $DIR/$tdir | wc -l)
21140         [ $cnt == 1 ] || error "unexpected #files after: $cnt"
21141
21142         rm -f $DIR/$tdir/f3 || error "can't remove f3"
21143         createmany -o $DIR/$tdir/f 3
21144         cnt=$(ls -1 $DIR/$tdir | wc -l)
21145         [ $cnt != 3 ] && error "unexpected #files: $cnt"
21146
21147         fid1=$(lfs path2fid $DIR/$tdir/f1)
21148         fid2=$(lfs path2fid $DIR/$tdir/f2)
21149         echo "remove using fsname $FSNAME"
21150         $LFS rmfid $FSNAME $fid1 $fid2 || error "rmfid with fsname failed"
21151
21152         cnt=$(ls -1 $DIR/$tdir | wc -l)
21153         [ $cnt == 1 ] || error "unexpected #files after: $cnt"
21154 }
21155 run_test 421a "simple rm by fid"
21156
21157 test_421b() {
21158         local cnt
21159         local FID1
21160         local FID2
21161
21162         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
21163                 skip "Need MDS version at least 2.12.54"
21164
21165         test_mkdir $DIR/$tdir
21166         createmany -o $DIR/$tdir/f 3
21167         multiop_bg_pause $DIR/$tdir/f1 o_c || error "multiop failed to start"
21168         MULTIPID=$!
21169
21170         FID1=$(lfs path2fid $DIR/$tdir/f1)
21171         FID2=$(lfs path2fid $DIR/$tdir/f2)
21172         $LFS rmfid $DIR $FID1 $FID2 && error "rmfid didn't fail"
21173
21174         kill -USR1 $MULTIPID
21175         wait
21176
21177         cnt=$(ls $DIR/$tdir | wc -l)
21178         [ $cnt == 2 ] || error "unexpected #files after: $cnt"
21179 }
21180 run_test 421b "rm by fid on open file"
21181
21182 test_421c() {
21183         local cnt
21184         local FIDS
21185
21186         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
21187                 skip "Need MDS version at least 2.12.54"
21188
21189         test_mkdir $DIR/$tdir
21190         createmany -o $DIR/$tdir/f 3
21191         touch $DIR/$tdir/$tfile
21192         createmany -l$DIR/$tdir/$tfile $DIR/$tdir/h 180
21193         cnt=$(ls -1 $DIR/$tdir | wc -l)
21194         [ $cnt != 184 ] && error "unexpected #files: $cnt"
21195
21196         FID1=$(lfs path2fid $DIR/$tdir/$tfile)
21197         $LFS rmfid $DIR $FID1 || error "rmfid failed"
21198
21199         cnt=$(ls $DIR/$tdir | wc -l)
21200         [ $cnt == 3 ] || error "unexpected #files after: $cnt"
21201 }
21202 run_test 421c "rm by fid against hardlinked files"
21203
21204 test_421d() {
21205         local cnt
21206         local FIDS
21207
21208         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
21209                 skip "Need MDS version at least 2.12.54"
21210
21211         test_mkdir $DIR/$tdir
21212         createmany -o $DIR/$tdir/f 4097
21213         cnt=$(ls -1 $DIR/$tdir | wc -l)
21214         [ $cnt != 4097 ] && error "unexpected #files: $cnt"
21215
21216         FIDS=$(lfs path2fid $DIR/$tdir/f* | sed "s/[/][^:]*://g")
21217         $LFS rmfid $DIR $FIDS || error "rmfid failed"
21218
21219         cnt=$(ls $DIR/$tdir | wc -l)
21220         rm -rf $DIR/$tdir
21221         [ $cnt == 0 ] || error "unexpected #files after: $cnt"
21222 }
21223 run_test 421d "rmfid en masse"
21224
21225 test_421e() {
21226         local cnt
21227         local FID
21228
21229         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
21230         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
21231                 skip "Need MDS version at least 2.12.54"
21232
21233         mkdir -p $DIR/$tdir
21234         $LFS setdirstripe -c$MDSCOUNT $DIR/$tdir/striped_dir
21235         createmany -o $DIR/$tdir/striped_dir/f 512
21236         cnt=$(ls -1 $DIR/$tdir/striped_dir | wc -l)
21237         [ $cnt != 512 ] && error "unexpected #files: $cnt"
21238
21239         FIDS=$(lfs path2fid $DIR/$tdir/striped_dir/f* |
21240                 sed "s/[/][^:]*://g")
21241         $LFS rmfid $DIR $FIDS || error "rmfid failed"
21242
21243         cnt=$(ls $DIR/$tdir/striped_dir | wc -l)
21244         rm -rf $DIR/$tdir
21245         [ $cnt == 0 ] || error "unexpected #files after: $cnt"
21246 }
21247 run_test 421e "rmfid in DNE"
21248
21249 test_421f() {
21250         local cnt
21251         local FID
21252
21253         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
21254                 skip "Need MDS version at least 2.12.54"
21255
21256         test_mkdir $DIR/$tdir
21257         touch $DIR/$tdir/f
21258         cnt=$(ls -1 $DIR/$tdir | wc -l)
21259         [ $cnt != 1 ] && error "unexpected #files: $cnt"
21260
21261         FID=$(lfs path2fid $DIR/$tdir/f)
21262         $RUNAS $LFS rmfid $DIR $FID && error "rmfid didn't fail (1)"
21263         # rmfid should fail
21264         cnt=$(ls -1 $DIR/$tdir | wc -l)
21265         [ $cnt != 1 ] && error "unexpected #files after (2): $cnt"
21266
21267         chmod a+rw $DIR/$tdir
21268         ls -la $DIR/$tdir
21269         $RUNAS $LFS rmfid $DIR $FID && error "rmfid didn't fail (2)"
21270         # rmfid should fail
21271         cnt=$(ls -1 $DIR/$tdir | wc -l)
21272         [ $cnt != 1 ] && error "unexpected #files after (3): $cnt"
21273
21274         rm -f $DIR/$tdir/f
21275         $RUNAS touch $DIR/$tdir/f
21276         FID=$(lfs path2fid $DIR/$tdir/f)
21277         echo "rmfid as root"
21278         $LFS rmfid $DIR $FID || error "rmfid as root failed"
21279         cnt=$(ls -1 $DIR/$tdir | wc -l)
21280         [ $cnt == 0 ] || error "unexpected #files after (4): $cnt"
21281
21282         rm -f $DIR/$tdir/f
21283         $RUNAS touch $DIR/$tdir/f
21284         cnt=$(ls -1 $DIR/$tdir | wc -l)
21285         [ $cnt != 1 ] && error "unexpected #files (4): $cnt"
21286         FID=$(lfs path2fid $DIR/$tdir/f)
21287         # rmfid w/o user_fid2path mount option should fail
21288         $RUNAS $LFS rmfid $DIR $FID && error "rmfid didn't fail(3)"
21289         cnt=$(ls -1 $DIR/$tdir | wc -l)
21290         [ $cnt == 1 ] || error "unexpected #files after (5): $cnt"
21291
21292         umount_client $MOUNT || error "failed to umount client"
21293         mount_client $MOUNT "$MOUNT_OPTS,user_fid2path" ||
21294                 error "failed to mount client'"
21295
21296         $RUNAS $LFS rmfid $DIR $FID || error "rmfid failed"
21297         # rmfid should succeed
21298         cnt=$(ls -1 $DIR/$tdir | wc -l)
21299         [ $cnt == 0 ] || error "unexpected #files after (6): $cnt"
21300
21301         # rmfid shouldn't allow to remove files due to dir's permission
21302         chmod a+rwx $DIR/$tdir
21303         touch $DIR/$tdir/f
21304         ls -la $DIR/$tdir
21305         FID=$(lfs path2fid $DIR/$tdir/f)
21306         $RUNAS $LFS rmfid $DIR $FID && error "rmfid didn't fail"
21307
21308         umount_client $MOUNT || error "failed to umount client"
21309         mount_client $MOUNT "$MOUNT_OPTS" ||
21310                 error "failed to mount client'"
21311
21312 }
21313 run_test 421f "rmfid checks permissions"
21314
21315 test_421g() {
21316         local cnt
21317         local FIDS
21318
21319         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
21320         [ $MDS1_VERSION -lt $(version_code 2.12.54) ] &&
21321                 skip "Need MDS version at least 2.12.54"
21322
21323         mkdir -p $DIR/$tdir
21324         $LFS setdirstripe -c$MDSCOUNT $DIR/$tdir/striped_dir
21325         createmany -o $DIR/$tdir/striped_dir/f 512
21326         cnt=$(ls -1 $DIR/$tdir/striped_dir | wc -l)
21327         [ $cnt != 512 ] && error "unexpected #files: $cnt"
21328
21329         FIDS=$(lfs path2fid $DIR/$tdir/striped_dir/f* |
21330                 sed "s/[/][^:]*://g")
21331
21332         rm -f $DIR/$tdir/striped_dir/f1*
21333         cnt=$(ls -1 $DIR/$tdir/striped_dir | wc -l)
21334         removed=$((512 - cnt))
21335
21336         # few files have been just removed, so we expect
21337         # rmfid to fail on their fids
21338         errors=$($LFS rmfid $DIR $FIDS 2>&1 | wc -l)
21339         [ $removed != $errors ] && error "$errors != $removed"
21340
21341         cnt=$(ls $DIR/$tdir/striped_dir | wc -l)
21342         rm -rf $DIR/$tdir
21343         [ $cnt == 0 ] || error "unexpected #files after: $cnt"
21344 }
21345 run_test 421g "rmfid to return errors properly"
21346
21347 prep_801() {
21348         [[ $(lustre_version_code mds1) -lt $(version_code 2.9.55) ]] ||
21349         [[ $OST1_VERSION -lt $(version_code 2.9.55) ]] &&
21350                 skip "Need server version at least 2.9.55"
21351
21352         start_full_debug_logging
21353 }
21354
21355 post_801() {
21356         stop_full_debug_logging
21357 }
21358
21359 barrier_stat() {
21360         if [ $MGS_VERSION -le $(version_code 2.10.0) ]; then
21361                 local st=$(do_facet mgs $LCTL barrier_stat $FSNAME |
21362                            awk '/The barrier for/ { print $7 }')
21363                 echo $st
21364         else
21365                 local st=$(do_facet mgs $LCTL barrier_stat -s $FSNAME)
21366                 echo \'$st\'
21367         fi
21368 }
21369
21370 barrier_expired() {
21371         local expired
21372
21373         if [ $MGS_VERSION -le $(version_code 2.10.0) ]; then
21374                 expired=$(do_facet mgs $LCTL barrier_stat $FSNAME |
21375                           awk '/will be expired/ { print $7 }')
21376         else
21377                 expired=$(do_facet mgs $LCTL barrier_stat -t $FSNAME)
21378         fi
21379
21380         echo $expired
21381 }
21382
21383 test_801a() {
21384         prep_801
21385
21386         echo "Start barrier_freeze at: $(date)"
21387         #define OBD_FAIL_BARRIER_DELAY          0x2202
21388         do_facet mgs $LCTL set_param fail_val=5 fail_loc=0x2202
21389         # Do not reduce barrier time - See LU-11873
21390         do_facet mgs $LCTL barrier_freeze $FSNAME 20 &
21391
21392         sleep 2
21393         local b_status=$(barrier_stat)
21394         echo "Got barrier status at: $(date)"
21395         [ "$b_status" = "'freezing_p1'" ] ||
21396                 error "(1) unexpected barrier status $b_status"
21397
21398         do_facet mgs $LCTL set_param fail_val=0 fail_loc=0
21399         wait
21400         b_status=$(barrier_stat)
21401         [ "$b_status" = "'frozen'" ] ||
21402                 error "(2) unexpected barrier status $b_status"
21403
21404         local expired=$(barrier_expired)
21405         echo "sleep $((expired + 3)) seconds, then the barrier will be expired"
21406         sleep $((expired + 3))
21407
21408         b_status=$(barrier_stat)
21409         [ "$b_status" = "'expired'" ] ||
21410                 error "(3) unexpected barrier status $b_status"
21411
21412         # Do not reduce barrier time - See LU-11873
21413         do_facet mgs $LCTL barrier_freeze $FSNAME 20 ||
21414                 error "(4) fail to freeze barrier"
21415
21416         b_status=$(barrier_stat)
21417         [ "$b_status" = "'frozen'" ] ||
21418                 error "(5) unexpected barrier status $b_status"
21419
21420         echo "Start barrier_thaw at: $(date)"
21421         #define OBD_FAIL_BARRIER_DELAY          0x2202
21422         do_facet mgs $LCTL set_param fail_val=5 fail_loc=0x2202
21423         do_facet mgs $LCTL barrier_thaw $FSNAME &
21424
21425         sleep 2
21426         b_status=$(barrier_stat)
21427         echo "Got barrier status at: $(date)"
21428         [ "$b_status" = "'thawing'" ] ||
21429                 error "(6) unexpected barrier status $b_status"
21430
21431         do_facet mgs $LCTL set_param fail_val=0 fail_loc=0
21432         wait
21433         b_status=$(barrier_stat)
21434         [ "$b_status" = "'thawed'" ] ||
21435                 error "(7) unexpected barrier status $b_status"
21436
21437         #define OBD_FAIL_BARRIER_FAILURE        0x2203
21438         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x2203
21439         do_facet mgs $LCTL barrier_freeze $FSNAME
21440
21441         b_status=$(barrier_stat)
21442         [ "$b_status" = "'failed'" ] ||
21443                 error "(8) unexpected barrier status $b_status"
21444
21445         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
21446         do_facet mgs $LCTL barrier_thaw $FSNAME
21447
21448         post_801
21449 }
21450 run_test 801a "write barrier user interfaces and stat machine"
21451
21452 test_801b() {
21453         prep_801
21454
21455         mkdir $DIR/$tdir || error "(1) fail to mkdir"
21456         createmany -d $DIR/$tdir/d 6 || "(2) fail to mkdir"
21457         touch $DIR/$tdir/d2/f10 || error "(3) fail to touch"
21458         touch $DIR/$tdir/d3/f11 || error "(4) fail to touch"
21459         touch $DIR/$tdir/d4/f12 || error "(5) fail to touch"
21460
21461         cancel_lru_locks mdc
21462
21463         # 180 seconds should be long enough
21464         do_facet mgs $LCTL barrier_freeze $FSNAME 180
21465
21466         local b_status=$(barrier_stat)
21467         [ "$b_status" = "'frozen'" ] ||
21468                 error "(6) unexpected barrier status $b_status"
21469
21470         mkdir $DIR/$tdir/d0/d10 &
21471         mkdir_pid=$!
21472
21473         touch $DIR/$tdir/d1/f13 &
21474         touch_pid=$!
21475
21476         ln $DIR/$tdir/d2/f10 $DIR/$tdir/d2/f14 &
21477         ln_pid=$!
21478
21479         mv $DIR/$tdir/d3/f11 $DIR/$tdir/d3/f15 &
21480         mv_pid=$!
21481
21482         rm -f $DIR/$tdir/d4/f12 &
21483         rm_pid=$!
21484
21485         stat $DIR/$tdir/d5 || error "(7) stat should succeed"
21486
21487         # To guarantee taht the 'stat' is not blocked
21488         b_status=$(barrier_stat)
21489         [ "$b_status" = "'frozen'" ] ||
21490                 error "(8) unexpected barrier status $b_status"
21491
21492         # let above commands to run at background
21493         sleep 5
21494
21495         ps -p $mkdir_pid || error "(9) mkdir should be blocked"
21496         ps -p $touch_pid || error "(10) touch should be blocked"
21497         ps -p $ln_pid || error "(11) link should be blocked"
21498         ps -p $mv_pid || error "(12) rename should be blocked"
21499         ps -p $rm_pid || error "(13) unlink should be blocked"
21500
21501         b_status=$(barrier_stat)
21502         [ "$b_status" = "'frozen'" ] ||
21503                 error "(14) unexpected barrier status $b_status"
21504
21505         do_facet mgs $LCTL barrier_thaw $FSNAME
21506         b_status=$(barrier_stat)
21507         [ "$b_status" = "'thawed'" ] ||
21508                 error "(15) unexpected barrier status $b_status"
21509
21510         wait $mkdir_pid || error "(16) mkdir should succeed"
21511         wait $touch_pid || error "(17) touch should succeed"
21512         wait $ln_pid || error "(18) link should succeed"
21513         wait $mv_pid || error "(19) rename should succeed"
21514         wait $rm_pid || error "(20) unlink should succeed"
21515
21516         post_801
21517 }
21518 run_test 801b "modification will be blocked by write barrier"
21519
21520 test_801c() {
21521         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
21522
21523         prep_801
21524
21525         stop mds2 || error "(1) Fail to stop mds2"
21526
21527         do_facet mgs $LCTL barrier_freeze $FSNAME 30
21528
21529         local b_status=$(barrier_stat)
21530         [ "$b_status" = "'expired'" ] || [ "$b_status" = "'failed'" ] || {
21531                 do_facet mgs $LCTL barrier_thaw $FSNAME
21532                 error "(2) unexpected barrier status $b_status"
21533         }
21534
21535         do_facet mgs $LCTL barrier_rescan $FSNAME ||
21536                 error "(3) Fail to rescan barrier bitmap"
21537
21538         # Do not reduce barrier time - See LU-11873
21539         do_facet mgs $LCTL barrier_freeze $FSNAME 20
21540
21541         b_status=$(barrier_stat)
21542         [ "$b_status" = "'frozen'" ] ||
21543                 error "(4) unexpected barrier status $b_status"
21544
21545         do_facet mgs $LCTL barrier_thaw $FSNAME
21546         b_status=$(barrier_stat)
21547         [ "$b_status" = "'thawed'" ] ||
21548                 error "(5) unexpected barrier status $b_status"
21549
21550         local devname=$(mdsdevname 2)
21551
21552         start mds2 $devname $MDS_MOUNT_OPTS || error "(6) Fail to start mds2"
21553
21554         do_facet mgs $LCTL barrier_rescan $FSNAME ||
21555                 error "(7) Fail to rescan barrier bitmap"
21556
21557         post_801
21558 }
21559 run_test 801c "rescan barrier bitmap"
21560
21561 saved_MGS_MOUNT_OPTS=$MGS_MOUNT_OPTS
21562 saved_MDS_MOUNT_OPTS=$MDS_MOUNT_OPTS
21563 saved_OST_MOUNT_OPTS=$OST_MOUNT_OPTS
21564 saved_MOUNT_OPTS=$MOUNT_OPTS
21565
21566 cleanup_802a() {
21567         trap 0
21568
21569         stopall
21570         MGS_MOUNT_OPTS=$saved_MGS_MOUNT_OPTS
21571         MDS_MOUNT_OPTS=$saved_MDS_MOUNT_OPTS
21572         OST_MOUNT_OPTS=$saved_OST_MOUNT_OPTS
21573         MOUNT_OPTS=$saved_MOUNT_OPTS
21574         setupall
21575 }
21576
21577 test_802a() {
21578         [[ $mds1_FSTYPE = zfs ]] || skip "ZFS specific test"
21579         [[ $(lustre_version_code mds1) -lt $(version_code 2.9.55) ]] ||
21580         [[ $OST1_VERSION -lt $(version_code 2.9.55) ]] &&
21581                 skip "Need server version at least 2.9.55"
21582
21583         [[ $ENABLE_QUOTA ]] && skip "Quota enabled for read-only test"
21584
21585         mkdir $DIR/$tdir || error "(1) fail to mkdir"
21586
21587         cp $LUSTRE/tests/test-framework.sh $DIR/$tdir/ ||
21588                 error "(2) Fail to copy"
21589
21590         trap cleanup_802a EXIT
21591
21592         # sync by force before remount as readonly
21593         sync; sync_all_data; sleep 3; sync_all_data
21594
21595         stopall
21596
21597         MGS_MOUNT_OPTS=$(csa_add "$MGS_MOUNT_OPTS" -o rdonly_dev)
21598         MDS_MOUNT_OPTS=$(csa_add "$MDS_MOUNT_OPTS" -o rdonly_dev)
21599         OST_MOUNT_OPTS=$(csa_add "$OST_MOUNT_OPTS" -o rdonly_dev)
21600
21601         echo "Mount the server as read only"
21602         setupall server_only || error "(3) Fail to start servers"
21603
21604         echo "Mount client without ro should fail"
21605         mount_client $MOUNT &&
21606                 error "(4) Mount client without 'ro' should fail"
21607
21608         echo "Mount client with ro should succeed"
21609         MOUNT_OPTS=$(csa_add "$MOUNT_OPTS" -o ro)
21610         mount_client $MOUNT ||
21611                 error "(5) Mount client with 'ro' should succeed"
21612
21613         echo "Modify should be refused"
21614         touch $DIR/$tdir/guard && error "(6) Touch should fail under ro mode"
21615
21616         echo "Read should be allowed"
21617         diff $LUSTRE/tests/test-framework.sh $DIR/$tdir/test-framework.sh ||
21618                 error "(7) Read should succeed under ro mode"
21619
21620         cleanup_802a
21621 }
21622 run_test 802a "simulate readonly device"
21623
21624 test_802b() {
21625         [ $PARALLEL == "yes" ] && skip "skip parallel run"
21626         remote_mds_nodsh && skip "remote MDS with nodsh"
21627
21628         do_facet $SINGLEMDS $LCTL get_param mdt.*.readonly ||
21629                 skip "readonly option not available"
21630
21631         $LFS mkdir -i 0 -c 1 $DIR/$tdir || error "(1) fail to mkdir"
21632
21633         cp $LUSTRE/tests/test-framework.sh $DIR/$tdir/ ||
21634                 error "(2) Fail to copy"
21635
21636         # write back all cached data before setting MDT to readonly
21637         cancel_lru_locks
21638         sync_all_data
21639
21640         do_facet $SINGLEMDS $LCTL set_param mdt.*.readonly=1
21641         stack_trap "do_facet $SINGLEMDS $LCTL set_param mdt.*.readonly=0" EXIT
21642
21643         echo "Modify should be refused"
21644         touch $DIR/$tdir/guard && error "(6) Touch should fail under ro mode"
21645
21646         echo "Read should be allowed"
21647         diff $LUSTRE/tests/test-framework.sh $DIR/$tdir/test-framework.sh ||
21648                 error "(7) Read should succeed under ro mode"
21649
21650         # disable readonly
21651         do_facet $SINGLEMDS $LCTL set_param mdt.*.readonly=0
21652 }
21653 run_test 802b "be able to set MDTs to readonly"
21654
21655 test_803() {
21656         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
21657         [ $MDS1_VERSION -lt $(version_code 2.10.54) ] &&
21658                 skip "MDS needs to be newer than 2.10.54"
21659
21660         mkdir -p $DIR/$tdir
21661         # Create some objects on all MDTs to trigger related logs objects
21662         for idx in $(seq $MDSCOUNT); do
21663                 $LFS mkdir -c $MDSCOUNT -i $((idx % $MDSCOUNT)) \
21664                         $DIR/$tdir/dir${idx} ||
21665                         error "Fail to create $DIR/$tdir/dir${idx}"
21666         done
21667
21668         sync; sleep 3
21669         wait_delete_completed # ensure old test cleanups are finished
21670         echo "before create:"
21671         $LFS df -i $MOUNT
21672         local before_used=$($LFS df -i | grep MDT0000_UUID | awk '{print $3}')
21673
21674         for i in {1..10}; do
21675                 $LFS mkdir -c 1 -i 1 $DIR/$tdir/foo$i ||
21676                         error "Fail to create $DIR/$tdir/foo$i"
21677         done
21678
21679         sync; sleep 3
21680         echo "after create:"
21681         $LFS df -i $MOUNT
21682         local after_used=$($LFS df -i | grep MDT0000_UUID | awk '{print $3}')
21683
21684         # allow for an llog to be cleaned up during the test
21685         [ $after_used -ge $((before_used + 10 - 1)) ] ||
21686                 error "before ($before_used) + 10 > after ($after_used)"
21687
21688         for i in {1..10}; do
21689                 rm -rf $DIR/$tdir/foo$i ||
21690                         error "Fail to remove $DIR/$tdir/foo$i"
21691         done
21692
21693         sleep 3 # avoid MDT return cached statfs
21694         wait_delete_completed
21695         echo "after unlink:"
21696         $LFS df -i $MOUNT
21697         after_used=$($LFS df -i | grep MDT0000_UUID | awk '{print $3}')
21698
21699         # allow for an llog to be created during the test
21700         [ $after_used -le $((before_used + 1)) ] ||
21701                 error "after ($after_used) > before ($before_used) + 1"
21702 }
21703 run_test 803 "verify agent object for remote object"
21704
21705 test_804() {
21706         [[ $MDSCOUNT -lt 2 ]] && skip_env "needs >= 2 MDTs"
21707         [ $MDS1_VERSION -lt $(version_code 2.10.54) ] &&
21708                 skip "MDS needs to be newer than 2.10.54"
21709         [ "$mds1_FSTYPE" != "ldiskfs" ] && skip_env "ldiskfs only test"
21710
21711         mkdir -p $DIR/$tdir
21712         $LFS mkdir -c 1 -i 1 $DIR/$tdir/dir0 ||
21713                 error "Fail to create $DIR/$tdir/dir0"
21714
21715         local fid=$($LFS path2fid $DIR/$tdir/dir0)
21716         local dev=$(mdsdevname 2)
21717
21718         do_facet mds2 "$DEBUGFS -c -R 'ls /REMOTE_PARENT_DIR' $dev" |
21719                 grep ${fid} || error "NOT found agent entry for dir0"
21720
21721         $LFS mkdir -c $MDSCOUNT -i 0 $DIR/$tdir/dir1 ||
21722                 error "Fail to create $DIR/$tdir/dir1"
21723
21724         touch $DIR/$tdir/dir1/foo0 ||
21725                 error "Fail to create $DIR/$tdir/dir1/foo0"
21726         fid=$($LFS path2fid $DIR/$tdir/dir1/foo0)
21727         local rc=0
21728
21729         for idx in $(seq $MDSCOUNT); do
21730                 dev=$(mdsdevname $idx)
21731                 do_facet mds${idx} \
21732                         "$DEBUGFS -c -R 'ls /REMOTE_PARENT_DIR' $dev" |
21733                         grep ${fid} && rc=$idx
21734         done
21735
21736         mv $DIR/$tdir/dir1/foo0 $DIR/$tdir/dir1/foo1 ||
21737                 error "Fail to rename foo0 to foo1"
21738         if [ $rc -eq 0 ]; then
21739                 for idx in $(seq $MDSCOUNT); do
21740                         dev=$(mdsdevname $idx)
21741                         do_facet mds${idx} \
21742                         "$DEBUGFS -c -R 'ls /REMOTE_PARENT_DIR' $dev" |
21743                         grep ${fid} && rc=$idx
21744                 done
21745         fi
21746
21747         mv $DIR/$tdir/dir1/foo1 $DIR/$tdir/dir1/foo2 ||
21748                 error "Fail to rename foo1 to foo2"
21749         if [ $rc -eq 0 ]; then
21750                 for idx in $(seq $MDSCOUNT); do
21751                         dev=$(mdsdevname $idx)
21752                         do_facet mds${idx} \
21753                         "$DEBUGFS -c -R 'ls /REMOTE_PARENT_DIR' $dev" |
21754                         grep ${fid} && rc=$idx
21755                 done
21756         fi
21757
21758         [ $rc -ne 0 ] || error "NOT found agent entry for foo"
21759
21760         ln $DIR/$tdir/dir1/foo2 $DIR/$tdir/dir0/guard ||
21761                 error "Fail to link to $DIR/$tdir/dir1/foo2"
21762         mv $DIR/$tdir/dir1/foo2 $DIR/$tdir/dir1/foo0 ||
21763                 error "Fail to rename foo2 to foo0"
21764         unlink $DIR/$tdir/dir1/foo0 ||
21765                 error "Fail to unlink $DIR/$tdir/dir1/foo0"
21766         rm -rf $DIR/$tdir/dir0 ||
21767                 error "Fail to rm $DIR/$tdir/dir0"
21768
21769         for idx in $(seq $MDSCOUNT); do
21770                 dev=$(mdsdevname $idx)
21771                 rc=0
21772
21773                 stop mds${idx}
21774                 run_e2fsck $(facet_active_host mds$idx) $dev -n ||
21775                         rc=$?
21776                 start mds${idx} $dev $MDS_MOUNT_OPTS ||
21777                         error "mount mds$idx failed"
21778                 df $MOUNT > /dev/null 2>&1
21779
21780                 # e2fsck should not return error
21781                 [ $rc -eq 0 ] ||
21782                         error "e2fsck detected error on MDT${idx}: rc=$rc"
21783         done
21784 }
21785 run_test 804 "verify agent entry for remote entry"
21786
21787 cleanup_805() {
21788         do_facet $SINGLEMDS zfs set quota=$old $fsset
21789         unlinkmany $DIR/$tdir/f- 1000000
21790         trap 0
21791 }
21792
21793 test_805() {
21794         local zfs_version=$(do_node $SINGLEMDS cat /sys/module/zfs/version)
21795         [ "$mds1_FSTYPE" != "zfs" ] && skip "ZFS specific test"
21796         [ $(version_code $zfs_version) -lt $(version_code 0.7.2) ] &&
21797                 skip "netfree not implemented before 0.7"
21798         [[ $MDS1_VERSION -ge $(version_code 2.10.57) ]] ||
21799                 skip "Need MDS version at least 2.10.57"
21800
21801         local fsset
21802         local freekb
21803         local usedkb
21804         local old
21805         local quota
21806         local pref="osd-zfs.lustre-MDT0000."
21807
21808         # limit available space on MDS dataset to meet nospace issue
21809         # quickly. then ZFS 0.7.2 can use reserved space if asked
21810         # properly (using netfree flag in osd_declare_destroy()
21811         fsset=$(do_facet $SINGLEMDS lctl get_param -n $pref.mntdev)
21812         old=$(do_facet $SINGLEMDS zfs get -H quota $fsset | \
21813                 gawk '{print $3}')
21814         freekb=$(do_facet $SINGLEMDS lctl get_param -n $pref.kbytesfree)
21815         usedkb=$(do_facet $SINGLEMDS lctl get_param -n $pref.kbytestotal)
21816         let "usedkb=usedkb-freekb"
21817         let "freekb=freekb/2"
21818         if let "freekb > 5000"; then
21819                 let "freekb=5000"
21820         fi
21821         do_facet $SINGLEMDS zfs set quota=$(((usedkb+freekb)*1024)) $fsset
21822         trap cleanup_805 EXIT
21823         mkdir $DIR/$tdir
21824         $LFS setstripe -E 1M -L mdt $DIR/$tdir || error "DoM not working"
21825         createmany -m $DIR/$tdir/f- 1000000 && error "ENOSPC wasn't met"
21826         rm -rf $DIR/$tdir || error "not able to remove"
21827         do_facet $SINGLEMDS zfs set quota=$old $fsset
21828         trap 0
21829 }
21830 run_test 805 "ZFS can remove from full fs"
21831
21832 # Size-on-MDS test
21833 check_lsom_data()
21834 {
21835         local file=$1
21836         local size=$($LFS getsom -s $file)
21837         local expect=$(stat -c %s $file)
21838
21839         [[ $size == $expect ]] ||
21840                 error "$file expected size: $expect, got: $size"
21841
21842         local blocks=$($LFS getsom -b $file)
21843         expect=$(stat -c %b $file)
21844         [[ $blocks == $expect ]] ||
21845                 error "$file expected blocks: $expect, got: $blocks"
21846 }
21847
21848 check_lsom_size()
21849 {
21850         local size=$($LFS getsom -s $1)
21851         local expect=$2
21852
21853         [[ $size == $expect ]] ||
21854                 error "$file expected size: $expect, got: $size"
21855 }
21856
21857 test_806() {
21858         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
21859                 skip "Need MDS version at least 2.11.52"
21860
21861         local bs=1048576
21862
21863         touch $DIR/$tfile || error "touch $tfile failed"
21864
21865         local save="$TMP/$TESTSUITE-$TESTNAME.parameters"
21866         save_lustre_params client "llite.*.xattr_cache" > $save
21867         lctl set_param llite.*.xattr_cache=0
21868         stack_trap "restore_lustre_params < $save; rm -f $save" EXIT
21869
21870         # single-threaded write
21871         echo "Test SOM for single-threaded write"
21872         dd if=/dev/zero of=$DIR/$tfile bs=$bs count=1 ||
21873                 error "write $tfile failed"
21874         check_lsom_size $DIR/$tfile $bs
21875
21876         local num=32
21877         local size=$(($num * $bs))
21878         local offset=0
21879         local i
21880
21881         echo "Test SOM for single client multi-threaded($num) write"
21882         $TRUNCATE $DIR/$tfile 0
21883         for ((i = 0; i < $num; i++)); do
21884                 $MULTIOP $DIR/$tfile Oz${offset}w${bs}c &
21885                 local pids[$i]=$!
21886                 offset=$((offset + $bs))
21887         done
21888         for (( i=0; i < $num; i++ )); do
21889                 wait ${pids[$i]}
21890         done
21891         check_lsom_size $DIR/$tfile $size
21892
21893         $TRUNCATE $DIR/$tfile 0
21894         for ((i = 0; i < $num; i++)); do
21895                 offset=$((offset - $bs))
21896                 $MULTIOP $DIR/$tfile Oz${offset}w${bs}c &
21897                 local pids[$i]=$!
21898         done
21899         for (( i=0; i < $num; i++ )); do
21900                 wait ${pids[$i]}
21901         done
21902         check_lsom_size $DIR/$tfile $size
21903
21904         # multi-client writes
21905         num=$(get_node_count ${CLIENTS//,/ })
21906         size=$(($num * $bs))
21907         offset=0
21908         i=0
21909
21910         echo "Test SOM for multi-client ($num) writes"
21911         $TRUNCATE $DIR/$tfile 0
21912         for client in ${CLIENTS//,/ }; do
21913                 do_node $client $MULTIOP $DIR/$tfile Oz${offset}w${bs}c &
21914                 local pids[$i]=$!
21915                 i=$((i + 1))
21916                 offset=$((offset + $bs))
21917         done
21918         for (( i=0; i < $num; i++ )); do
21919                 wait ${pids[$i]}
21920         done
21921         check_lsom_size $DIR/$tfile $offset
21922
21923         i=0
21924         $TRUNCATE $DIR/$tfile 0
21925         for client in ${CLIENTS//,/ }; do
21926                 offset=$((offset - $bs))
21927                 do_node $client $MULTIOP $DIR/$tfile Oz${offset}w${bs}c &
21928                 local pids[$i]=$!
21929                 i=$((i + 1))
21930         done
21931         for (( i=0; i < $num; i++ )); do
21932                 wait ${pids[$i]}
21933         done
21934         check_lsom_size $DIR/$tfile $size
21935
21936         # verify truncate
21937         echo "Test SOM for truncate"
21938         $TRUNCATE $DIR/$tfile 1048576
21939         check_lsom_size $DIR/$tfile 1048576
21940         $TRUNCATE $DIR/$tfile 1234
21941         check_lsom_size $DIR/$tfile 1234
21942
21943         # verify SOM blocks count
21944         echo "Verify SOM block count"
21945         $TRUNCATE $DIR/$tfile 0
21946         $MULTIOP $DIR/$tfile oO_TRUNC:O_RDWR:w1048576YSc ||
21947                 error "failed to write file $tfile"
21948         check_lsom_data $DIR/$tfile
21949 }
21950 run_test 806 "Verify Lazy Size on MDS"
21951
21952 test_807() {
21953         [ -n "$FILESET" ] && skip "Not functional for FILESET set"
21954         [ $MDS1_VERSION -lt $(version_code 2.11.52) ] &&
21955                 skip "Need MDS version at least 2.11.52"
21956
21957         # Registration step
21958         changelog_register || error "changelog_register failed"
21959         local cl_user="${CL_USERS[$SINGLEMDS]%% *}"
21960         changelog_users $SINGLEMDS | grep -q $cl_user ||
21961                 error "User $cl_user not found in changelog_users"
21962
21963         local save="$TMP/$TESTSUITE-$TESTNAME.parameters"
21964         save_lustre_params client "llite.*.xattr_cache" > $save
21965         lctl set_param llite.*.xattr_cache=0
21966         stack_trap "restore_lustre_params < $save; rm -f $save" EXIT
21967
21968         rm -rf $DIR/$tdir || error "rm $tdir failed"
21969         mkdir -p $DIR/$tdir || error "mkdir $tdir failed"
21970         touch $DIR/$tdir/trunc || error "touch $tdir/trunc failed"
21971         $TRUNCATE $DIR/$tdir/trunc 1024 || error "truncate $tdir/trunc failed"
21972         $TRUNCATE $DIR/$tdir/trunc 1048576 ||
21973                 error "truncate $tdir/trunc failed"
21974
21975         local bs=1048576
21976         dd if=/dev/zero of=$DIR/$tdir/single_dd bs=$bs count=1 ||
21977                 error "write $tfile failed"
21978
21979         # multi-client wirtes
21980         local num=$(get_node_count ${CLIENTS//,/ })
21981         local offset=0
21982         local i=0
21983
21984         echo "Test SOM for multi-client ($num) writes"
21985         touch $DIR/$tfile || error "touch $tfile failed"
21986         $TRUNCATE $DIR/$tfile 0
21987         for client in ${CLIENTS//,/ }; do
21988                 do_node $client $MULTIOP $DIR/$tfile Oz${offset}w${bs}c &
21989                 local pids[$i]=$!
21990                 i=$((i + 1))
21991                 offset=$((offset + $bs))
21992         done
21993         for (( i=0; i < $num; i++ )); do
21994                 wait ${pids[$i]}
21995         done
21996
21997         sleep 5
21998         $LSOM_SYNC -u $cl_user -m $FSNAME-MDT0000 $MOUNT
21999         check_lsom_data $DIR/$tdir/trunc
22000         check_lsom_data $DIR/$tdir/single_dd
22001         check_lsom_data $DIR/$tfile
22002
22003         rm -rf $DIR/$tdir
22004         # Deregistration step
22005         changelog_deregister || error "changelog_deregister failed"
22006 }
22007 run_test 807 "verify LSOM syncing tool"
22008
22009 check_som_nologged()
22010 {
22011         local lines=$($LFS changelog $FSNAME-MDT0000 |
22012                 grep 'x=trusted.som' | wc -l)
22013         [ $lines -ne 0 ] && error "trusted.som xattr is logged in Changelogs"
22014 }
22015
22016 test_808() {
22017         [ $MDS1_VERSION -lt $(version_code 2.11.55) ] &&
22018                 skip "Need MDS version at least 2.11.55"
22019
22020         # Registration step
22021         changelog_register || error "changelog_register failed"
22022
22023         touch $DIR/$tfile || error "touch $tfile failed"
22024         check_som_nologged
22025
22026         dd if=/dev/zero of=$DIR/$tfile bs=1048576 count=1 ||
22027                 error "write $tfile failed"
22028         check_som_nologged
22029
22030         $TRUNCATE $DIR/$tfile 1234
22031         check_som_nologged
22032
22033         $TRUNCATE $DIR/$tfile 1048576
22034         check_som_nologged
22035
22036         # Deregistration step
22037         changelog_deregister || error "changelog_deregister failed"
22038 }
22039 run_test 808 "Check trusted.som xattr not logged in Changelogs"
22040
22041 check_som_nodata()
22042 {
22043         $LFS getsom $1
22044         [[ $? -eq 61 ]] || error "DoM-only file $1 has SOM xattr"
22045 }
22046
22047 test_809() {
22048         [ $MDS1_VERSION -lt $(version_code 2.11.56) ] &&
22049                 skip "Need MDS version at least 2.11.56"
22050
22051         $LFS setstripe -E 1M -L mdt $DIR/$tfile ||
22052                 error "failed to create DoM-only file $DIR/$tfile"
22053         touch $DIR/$tfile || error "touch $tfile failed"
22054         check_som_nodata $DIR/$tfile
22055
22056         dd if=/dev/zero of=$DIR/$tfile bs=2048 count=1 ||
22057                 error "write $tfile failed"
22058         check_som_nodata $DIR/$tfile
22059
22060         $TRUNCATE $DIR/$tfile 1234
22061         check_som_nodata $DIR/$tfile
22062
22063         $TRUNCATE $DIR/$tfile 4097
22064         check_som_nodata $DIR/$file
22065 }
22066 run_test 809 "Verify no SOM xattr store for DoM-only files"
22067
22068 test_810() {
22069         [ $PARALLEL == "yes" ] && skip "skip parallel run"
22070         $GSS && skip_env "could not run with gss"
22071
22072         set_checksums 1
22073         stack_trap "set_checksums $ORIG_CSUM" EXIT
22074         stack_trap "set_checksum_type $ORIG_CSUM_TYPE" EXIT
22075
22076         local csum
22077         local before
22078         local after
22079         for csum in $CKSUM_TYPES; do
22080                 #define OBD_FAIL_OSC_NO_GRANT   0x411
22081                 $LCTL set_param osc.*.checksum_type=$csum fail_loc=0x411
22082                 for i in "10240 0" "10000 0" "4000 1" "500 1"; do
22083                         eval set -- $i
22084                         dd if=/dev/urandom of=$DIR/$tfile bs=$1 count=2 seek=$2
22085                         before=$(md5sum $DIR/$tfile)
22086                         $LCTL set_param ldlm.namespaces.*osc*.lru_size=clear
22087                         after=$(md5sum $DIR/$tfile)
22088                         [ "$before" == "$after" ] ||
22089                                 error "$csum: $before != $after bs=$1 seek=$2"
22090                 done
22091         done
22092 }
22093 run_test 810 "partial page writes on ZFS (LU-11663)"
22094
22095 test_811() {
22096         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.11.56) ] &&
22097                 skip "Need MDS version at least 2.11.56"
22098
22099         #define OBD_FAIL_MDS_ORPHAN_DELETE      0x165
22100         do_facet mds1 $LCTL set_param fail_loc=0x165
22101         $MULTIOP $DIR/$tfile Ouc || error "multiop failed"
22102
22103         stop mds1
22104         start mds1 $(mdsdevname 1) $MDS_MOUNT_OPTS
22105
22106         sleep 5
22107         [[ $(do_facet mds1 pgrep orph_.*-MDD | wc -l) -eq 0 ]] ||
22108                 error "MDD orphan cleanup thread not quit"
22109 }
22110 run_test 811 "orphan name stub can be cleaned up in startup"
22111
22112 test_812() {
22113         [ $OST1_VERSION -lt $(version_code 2.12.51) ] &&
22114                 skip "OST < 2.12.51 doesn't support this fail_loc"
22115         [ "$SHARED_KEY" = true ] &&
22116                 skip "OSC connections never go IDLE with Shared-Keys enabled"
22117
22118         $LFS setstripe -c 1 -i 0 $DIR/$tfile
22119         # ensure ost1 is connected
22120         stat $DIR/$tfile >/dev/null || error "can't stat"
22121         wait_osc_import_state client ost1 FULL
22122         # no locks, no reqs to let the connection idle
22123         cancel_lru_locks osc
22124
22125         # delay OST_DISCONNECT on OST1 to put OSC into intermediate state
22126 #define OBD_FAIL_OST_DISCONNECT_DELAY    0x245
22127         do_facet ost1 "$LCTL set_param fail_loc=0x245 fail_val=8"
22128         wait_osc_import_state client ost1 CONNECTING
22129         do_facet ost1 "$LCTL set_param fail_loc=0 fail_val=0"
22130
22131         stat $DIR/$tfile >/dev/null || error "can't stat file"
22132 }
22133 run_test 812 "do not drop reqs generated when imp is going to idle (LU-11951)"
22134
22135 test_813() {
22136         local file_heat_sav=$($LCTL get_param -n llite.*.file_heat 2>/dev/null)
22137         [ -z "$file_heat_sav" ] && skip "no file heat support"
22138
22139         local readsample
22140         local writesample
22141         local readbyte
22142         local writebyte
22143         local readsample1
22144         local writesample1
22145         local readbyte1
22146         local writebyte1
22147
22148         local period_second=$($LCTL get_param -n llite.*.heat_period_second)
22149         local decay_pct=$($LCTL get_param -n llite.*.heat_decay_percentage)
22150
22151         $LCTL set_param -n llite.*.file_heat=1
22152         echo "Turn on file heat"
22153         echo "Period second: $period_second, Decay percentage: $decay_pct"
22154
22155         echo "QQQQ" > $DIR/$tfile
22156         echo "QQQQ" > $DIR/$tfile
22157         echo "QQQQ" > $DIR/$tfile
22158         cat $DIR/$tfile > /dev/null
22159         cat $DIR/$tfile > /dev/null
22160         cat $DIR/$tfile > /dev/null
22161         cat $DIR/$tfile > /dev/null
22162
22163         local out=$($LFS heat_get $DIR/$tfile)
22164
22165         $LFS heat_get $DIR/$tfile
22166         readsample=$(echo "$out" | grep 'readsample' | awk '{ print $2 }')
22167         writesample=$(echo "$out" | grep 'writesample' | awk '{ print $2 }')
22168         readbyte=$(echo "$out" | grep 'readbyte' | awk '{ print $2 }')
22169         writebyte=$(echo "$out" | grep 'writebyte' | awk '{ print $2 }')
22170
22171         [ $readsample -le 4 ] || error "read sample ($readsample) is wrong"
22172         [ $writesample -le 3 ] || error "write sample ($writesample) is wrong"
22173         [ $readbyte -le 20 ] || error "read bytes ($readbyte) is wrong"
22174         [ $writebyte -le 15 ] || error "write bytes ($writebyte) is wrong"
22175
22176         sleep $((period_second + 3))
22177         echo "Sleep $((period_second + 3)) seconds..."
22178         # The recursion formula to calculate the heat of the file f is as
22179         # follow:
22180         # Hi+1(f) = (1-P)*Hi(f)+ P*Ci
22181         # Where Hi is the heat value in the period between time points i*I and
22182         # (i+1)*I; Ci is the access count in the period; the symbol P refers
22183         # to the weight of Ci.
22184         out=$($LFS heat_get $DIR/$tfile)
22185         $LFS heat_get $DIR/$tfile
22186         readsample=$(echo "$out" | grep 'readsample' | awk '{ print $2 }')
22187         writesample=$(echo "$out" | grep 'writesample' | awk '{ print $2 }')
22188         readbyte=$(echo "$out" | grep 'readbyte' | awk '{ print $2 }')
22189         writebyte=$(echo "$out" | grep 'writebyte' | awk '{ print $2 }')
22190
22191         [ $(bc <<< "$readsample <= 4 * $decay_pct / 100") -eq 1 ] ||
22192                 error "read sample ($readsample) is wrong"
22193         [ $(bc <<< "$writesample <= 3 * $decay_pct / 100") -eq 1 ] ||
22194                 error "write sample ($writesample) is wrong"
22195         [ $(bc <<< "$readbyte <= 20 * $decay_pct / 100") -eq 1 ] ||
22196                 error "read bytes ($readbyte) is wrong"
22197         [ $(bc <<< "$writebyte <= 15 * $decay_pct / 100") -eq 1 ] ||
22198                 error "write bytes ($writebyte) is wrong"
22199
22200         echo "QQQQ" > $DIR/$tfile
22201         echo "QQQQ" > $DIR/$tfile
22202         echo "QQQQ" > $DIR/$tfile
22203         cat $DIR/$tfile > /dev/null
22204         cat $DIR/$tfile > /dev/null
22205         cat $DIR/$tfile > /dev/null
22206         cat $DIR/$tfile > /dev/null
22207
22208         sleep $((period_second + 3))
22209         echo "Sleep $((period_second + 3)) seconds..."
22210
22211         out=$($LFS heat_get $DIR/$tfile)
22212         $LFS heat_get $DIR/$tfile
22213         readsample1=$(echo "$out" | grep 'readsample' | awk '{ print $2 }')
22214         writesample1=$(echo "$out" | grep 'writesample' | awk '{ print $2 }')
22215         readbyte1=$(echo "$out" | grep 'readbyte' | awk '{ print $2 }')
22216         writebyte1=$(echo "$out" | grep 'writebyte' | awk '{ print $2 }')
22217
22218         [ $(bc <<< "$readsample1 <= ($readsample * (100 - $decay_pct) + \
22219                 4 * $decay_pct) / 100") -eq 1 ] ||
22220                 error "read sample ($readsample1) is wrong"
22221         [ $(bc <<< "$writesample1 <= ($writesample * (100 - $decay_pct) + \
22222                 3 * $decay_pct) / 100") -eq 1 ] ||
22223                 error "write sample ($writesample1) is wrong"
22224         [ $(bc <<< "$readbyte1 <= ($readbyte * (100 - $decay_pct) + \
22225                 20 * $decay_pct) / 100") -eq 1 ] ||
22226                 error "read bytes ($readbyte1) is wrong"
22227         [ $(bc <<< "$writebyte1 <= ($writebyte * (100 - $decay_pct) + \
22228                 15 * $decay_pct) / 100") -eq 1 ] ||
22229                 error "write bytes ($writebyte1) is wrong"
22230
22231         echo "Turn off file heat for the file $DIR/$tfile"
22232         $LFS heat_set -o $DIR/$tfile
22233
22234         echo "QQQQ" > $DIR/$tfile
22235         echo "QQQQ" > $DIR/$tfile
22236         echo "QQQQ" > $DIR/$tfile
22237         cat $DIR/$tfile > /dev/null
22238         cat $DIR/$tfile > /dev/null
22239         cat $DIR/$tfile > /dev/null
22240         cat $DIR/$tfile > /dev/null
22241
22242         out=$($LFS heat_get $DIR/$tfile)
22243         $LFS heat_get $DIR/$tfile
22244         readsample=$(echo "$out" | grep 'readsample' | awk '{ print $2 }')
22245         writesample=$(echo "$out" | grep 'writesample' | awk '{ print $2 }')
22246         readbyte=$(echo "$out" | grep 'readbyte' | awk '{ print $2 }')
22247         writebyte=$(echo "$out" | grep 'writebyte' | awk '{ print $2 }')
22248
22249         [ $readsample -eq 0 ] || error "read sample ($readsample) is wrong"
22250         [ $writesample -eq 0 ] || error "write sample ($writesample) is wrong"
22251         [ $readbyte -eq 0 ] || error "read bytes ($readbyte) is wrong"
22252         [ $writebyte -eq 0 ] || error "write bytes ($writebyte) is wrong"
22253
22254         echo "Trun on file heat for the file $DIR/$tfile"
22255         $LFS heat_set -O $DIR/$tfile
22256
22257         echo "QQQQ" > $DIR/$tfile
22258         echo "QQQQ" > $DIR/$tfile
22259         echo "QQQQ" > $DIR/$tfile
22260         cat $DIR/$tfile > /dev/null
22261         cat $DIR/$tfile > /dev/null
22262         cat $DIR/$tfile > /dev/null
22263         cat $DIR/$tfile > /dev/null
22264
22265         out=$($LFS heat_get $DIR/$tfile)
22266         $LFS heat_get $DIR/$tfile
22267         readsample=$(echo "$out" | grep 'readsample' | awk '{ print $2 }')
22268         writesample=$(echo "$out" | grep 'writesample' | awk '{ print $2 }')
22269         readbyte=$(echo "$out" | grep 'readbyte' | awk '{ print $2 }')
22270         writebyte=$(echo "$out" | grep 'writebyte' | awk '{ print $2 }')
22271
22272         [ $readsample -gt 0 ] || error "read sample ($readsample) is wrong"
22273         [ $writesample -gt 0 ] || error "write sample ($writesample) is wrong"
22274         [ $readbyte -gt 0 ] || error "read bytes ($readbyte) is wrong"
22275         [ $writebyte -gt 0 ] || error "write bytes ($writebyte) is wrong"
22276
22277         $LFS heat_set -c $DIR/$tfile
22278         $LCTL set_param -n llite.*.file_heat=0
22279         echo "Turn off file heat support for the Lustre filesystem"
22280
22281         echo "QQQQ" > $DIR/$tfile
22282         echo "QQQQ" > $DIR/$tfile
22283         echo "QQQQ" > $DIR/$tfile
22284         cat $DIR/$tfile > /dev/null
22285         cat $DIR/$tfile > /dev/null
22286         cat $DIR/$tfile > /dev/null
22287         cat $DIR/$tfile > /dev/null
22288
22289         out=$($LFS heat_get $DIR/$tfile)
22290         $LFS heat_get $DIR/$tfile
22291         readsample=$(echo "$out" | grep 'readsample' | awk '{ print $2 }')
22292         writesample=$(echo "$out" | grep 'writesample' | awk '{ print $2 }')
22293         readbyte=$(echo "$out" | grep 'readbyte' | awk '{ print $2 }')
22294         writebyte=$(echo "$out" | grep 'writebyte' | awk '{ print $2 }')
22295
22296         [ $readsample -eq 0 ] || error "read sample ($readsample) is wrong"
22297         [ $writesample -eq 0 ] || error "write sample ($writesample) is wrong"
22298         [ $readbyte -eq 0 ] || error "read bytes ($readbyte) is wrong"
22299         [ $writebyte -eq 0 ] || error "write bytes ($writebyte) is wrong"
22300
22301         $LCTL set_param -n llite.*.file_heat=$file_heat_sav
22302         rm -f $DIR/$tfile
22303 }
22304 run_test 813 "File heat verfication"
22305
22306 test_814()
22307 {
22308         dd of=$DIR/$tfile seek=128 bs=1k < /dev/null
22309         echo -n y >> $DIR/$tfile
22310         cp --sparse=always $DIR/$tfile $DIR/${tfile}.cp || error "copy failed"
22311         diff $DIR/$tfile $DIR/${tfile}.cp || error "files should be same"
22312 }
22313 run_test 814 "sparse cp works as expected (LU-12361)"
22314
22315 test_815()
22316 {
22317         writeme -b 100 $DIR/$tfile || error "write 100 bytes failed"
22318         writeme -b 0 $DIR/$tfile || error "write 0 byte failed"
22319 }
22320 run_test 815 "zero byte tiny write doesn't hang (LU-12382)"
22321
22322 test_816() {
22323         [ "$SHARED_KEY" = true ] &&
22324                 skip "OSC connections never go IDLE with Shared-Keys enabled"
22325
22326         $LFS setstripe -c 1 -i 0 $DIR/$tfile
22327         # ensure ost1 is connected
22328         stat $DIR/$tfile >/dev/null || error "can't stat"
22329         wait_osc_import_state client ost1 FULL
22330         # no locks, no reqs to let the connection idle
22331         cancel_lru_locks osc
22332         lru_resize_disable osc
22333         local before
22334         local now
22335         before=$($LCTL get_param -n \
22336                  ldlm.namespaces.$FSNAME-OST0000-osc-[^M]*.lru_size)
22337
22338         wait_osc_import_state client ost1 IDLE
22339         dd if=/dev/null of=$DIR/$tfile bs=1k count=1 conv=sync
22340         now=$($LCTL get_param -n \
22341               ldlm.namespaces.$FSNAME-OST0000-osc-[^M]*.lru_size)
22342         [ $before == $now ] || error "lru_size changed $before != $now"
22343 }
22344 run_test 816 "do not reset lru_resize on idle reconnect"
22345
22346 cleanup_817() {
22347         umount $tmpdir
22348         exportfs -u localhost:$DIR/nfsexp
22349         rm -rf $DIR/nfsexp
22350 }
22351
22352 test_817() {
22353         systemctl restart nfs-server.service || skip "failed to restart nfsd"
22354
22355         mkdir -p $DIR/nfsexp
22356         exportfs -orw,no_root_squash localhost:$DIR/nfsexp ||
22357                 error "failed to export nfs"
22358
22359         tmpdir=$(mktemp -d /tmp/nfs-XXXXXX)
22360         stack_trap cleanup_817 EXIT
22361
22362         mount -t nfs -orw localhost:$DIR/nfsexp $tmpdir ||
22363                 error "failed to mount nfs to $tmpdir"
22364
22365         cp /bin/true $tmpdir
22366         $DIR/nfsexp/true || error "failed to execute 'true' command"
22367 }
22368 run_test 817 "nfsd won't cache write lock for exec file"
22369
22370 test_818() {
22371         mkdir $DIR/$tdir
22372         $LFS setstripe -c1 -i0 $DIR/$tfile
22373         $LFS setstripe -c1 -i1 $DIR/$tfile
22374         stop $SINGLEMDS
22375         #define OBD_FAIL_OSP_CANT_PROCESS_LLOG          0x2105
22376         do_facet $SINGLEMDS lctl set_param fail_loc=0x80002105
22377         start $SINGLEMDS $(mdsdevname ${SINGLEMDS//mds/}) $MDS_MOUNT_OPTS ||
22378                 error "start $SINGLEMDS failed"
22379         rm -rf $DIR/$tdir
22380 }
22381 run_test 818 "unlink with failed llog"
22382
22383 test_819a() {
22384         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1
22385         cancel_lru_locks osc
22386         #define OBD_FAIL_OST_2BIG_NIOBUF                0x248
22387         do_facet $SINGLEMDS lctl set_param fail_loc=0x80000248
22388         dd if=$DIR/$tfile of=/dev/null bs=1M count=1
22389         rm -f $TDIR/$tfile
22390 }
22391 run_test 819a "too big niobuf in read"
22392
22393 test_819b() {
22394         #define OBD_FAIL_OST_2BIG_NIOBUF                0x248
22395         do_facet $SINGLEMDS lctl set_param fail_loc=0x80000248
22396         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1
22397         cancel_lru_locks osc
22398         sleep 1
22399         rm -f $TDIR/$tfile
22400 }
22401 run_test 819b "too big niobuf in write"
22402
22403 #
22404 # tests that do cleanup/setup should be run at the end
22405 #
22406
22407 test_900() {
22408         [ $PARALLEL == "yes" ] && skip "skip parallel run"
22409         local ls
22410
22411         #define OBD_FAIL_MGC_PAUSE_PROCESS_LOG   0x903
22412         $LCTL set_param fail_loc=0x903
22413
22414         cancel_lru_locks MGC
22415
22416         FAIL_ON_ERROR=true cleanup
22417         FAIL_ON_ERROR=true setup
22418 }
22419 run_test 900 "umount should not race with any mgc requeue thread"
22420
22421 complete $SECONDS
22422 [ -f $EXT2_DEV ] && rm $EXT2_DEV || true
22423 check_and_cleanup_lustre
22424 if [ "$I_MOUNTED" != "yes" ]; then
22425         lctl set_param debug="$OLDDEBUG" 2> /dev/null || true
22426 fi
22427 exit_status