lustre/tests/sanity.sh

   1 #!/bin/bash
   2 # -*- tab-width: 4; indent-tabs-mode: t; -*-
   3 #
   4 # Run select tests by setting ONLY, or as arguments to the script.
   5 # Skip specific tests by setting EXCEPT.
   6 #
   7 # e.g. ONLY="22 23" or ONLY="`seq 32 39`" or EXCEPT="31"
   8 set -e
   9
  10 ONLY=${ONLY:-"$*"}
  11 # bug number for skipped test: 13297 2108 9789 3637 9789 3561 12622 5188
  12 ALWAYS_EXCEPT="                42a  42b  42c  42d  45   51d   68b   $SANITY_EXCEPT"
  13 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  14
  15 # with LOD/OSP landing
  16 # bug number for skipped tests: LU-2036
  17 ALWAYS_EXCEPT="                 76     $ALWAYS_EXCEPT"
  18
  19
  20 SRCDIR=$(cd $(dirname $0); echo $PWD)
  21 export PATH=$PATH:/sbin
  22
  23 TMP=${TMP:-/tmp}
  24
  25 CHECKSTAT=${CHECKSTAT:-"checkstat -v"}
  26 CREATETEST=${CREATETEST:-createtest}
  27 LFS=${LFS:-lfs}
  28 LFIND=${LFIND:-"$LFS find"}
  29 LVERIFY=${LVERIFY:-ll_dirstripe_verify}
  30 LCTL=${LCTL:-lctl}
  31 MCREATE=${MCREATE:-mcreate}
  32 OPENFILE=${OPENFILE:-openfile}
  33 OPENUNLINK=${OPENUNLINK:-openunlink}
  34 export MULTIOP=${MULTIOP:-multiop}
  35 READS=${READS:-"reads"}
  36 MUNLINK=${MUNLINK:-munlink}
  37 SOCKETSERVER=${SOCKETSERVER:-socketserver}
  38 SOCKETCLIENT=${SOCKETCLIENT:-socketclient}
  39 MEMHOG=${MEMHOG:-memhog}
  40 DIRECTIO=${DIRECTIO:-directio}
  41 ACCEPTOR_PORT=${ACCEPTOR_PORT:-988}
  42 UMOUNT=${UMOUNT:-"umount -d"}
  43 STRIPES_PER_OBJ=-1
  44 CHECK_GRANT=${CHECK_GRANT:-"yes"}
  45 GRANT_CHECK_LIST=${GRANT_CHECK_LIST:-""}
  46 export PARALLEL=${PARALLEL:-"no"}
  47
  48 export NAME=${NAME:-local}
  49
  50 SAVE_PWD=$PWD
  51
  52 CLEANUP=${CLEANUP:-:}
  53 SETUP=${SETUP:-:}
  54 TRACE=${TRACE:-""}
  55 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
  56 . $LUSTRE/tests/test-framework.sh
  57 init_test_env $@
  58 . ${CONFIG:=$LUSTRE/tests/cfg/${NAME}.sh}
  59 init_logging
  60
  61 [ "$SLOW" = "no" ] && EXCEPT_SLOW="24o 27m 64b 68 71 77f 78 115 124b"
  62
  63 [ $(facet_fstype $SINGLEMDS) = "zfs" ] &&
  64 # bug number for skipped test:        LU-1593 LU-2610 LU-2833 LU-1957 LU-2805
  65         ALWAYS_EXCEPT="$ALWAYS_EXCEPT 34h     40      48a     180     184c"
  66
  67 FAIL_ON_ERROR=false
  68
  69 cleanup() {
  70         echo -n "cln.."
  71         pgrep ll_sa > /dev/null && { echo "There are ll_sa thread not exit!"; exit 20; }
  72         cleanupall ${FORCE} $* || { echo "FAILed to clean up"; exit 20; }
  73 }
  74 setup() {
  75         echo -n "mnt.."
  76         load_modules
  77         setupall || exit 10
  78         echo "done"
  79 }
  80
  81 check_kernel_version() {
  82         WANT_VER=$1
  83         GOT_VER=$(lctl get_param -n version | awk '/kernel:/ {print $2}')
  84         case $GOT_VER in
  85         patchless|patchless_client) return 0;;
  86         *) [ $GOT_VER -ge $WANT_VER ] && return 0 ;;
  87         esac
  88         log "test needs at least kernel version $WANT_VER, running $GOT_VER"
  89         return 1
  90 }
  91
  92 check_swap_layouts_support()
  93 {
  94         $LCTL get_param -n llite.*.sbi_flags | grep -q layout ||
  95                 { skip "Does not support layout lock."; return 0; }
  96         return 1
  97 }
  98
  99 if [ "$ONLY" == "cleanup" ]; then
 100        sh llmountcleanup.sh
 101        exit 0
 102 fi
 103
 104 check_and_setup_lustre
 105
 106 DIR=${DIR:-$MOUNT}
 107 assert_DIR
 108
 109 MDT0=$($LCTL get_param -n mdc.*.mds_server_uuid | \
 110     awk '{gsub(/_UUID/,""); print $1}' | head -1)
 111 LOVNAME=$($LCTL get_param -n llite.*.lov.common_name | tail -n 1)
 112 OSTCOUNT=$($LCTL get_param -n lov.$LOVNAME.numobd)
 113 STRIPECOUNT=$($LCTL get_param -n lov.$LOVNAME.stripecount)
 114 STRIPESIZE=$($LCTL get_param -n lov.$LOVNAME.stripesize)
 115 ORIGFREE=$($LCTL get_param -n lov.$LOVNAME.kbytesavail)
 116 MAXFREE=${MAXFREE:-$((200000 * $OSTCOUNT))}
 117
 118 [ -f $DIR/d52a/foo ] && chattr -a $DIR/d52a/foo
 119 [ -f $DIR/d52b/foo ] && chattr -i $DIR/d52b/foo
 120 rm -rf $DIR/[Rdfs][0-9]*
 121
 122 # $RUNAS_ID may get set incorrectly somewhere else
 123 [ $UID -eq 0 -a $RUNAS_ID -eq 0 ] && error "\$RUNAS_ID set to 0, but \$UID is also 0!"
 124
 125 check_runas_id $RUNAS_ID $RUNAS_GID $RUNAS
 126
 127 build_test_filter
 128
 129 if [ "${ONLY}" = "MOUNT" ] ; then
 130         echo "Lustre is up, please go on"
 131         exit
 132 fi
 133
 134 echo "preparing for tests involving mounts"
 135 EXT2_DEV=${EXT2_DEV:-$TMP/SANITY.LOOP}
 136 touch $EXT2_DEV
 137 mke2fs -j -F $EXT2_DEV 8000 > /dev/null
 138 echo # add a newline after mke2fs.
 139
 140 umask 077
 141
 142 OLDDEBUG=$(lctl get_param -n debug 2> /dev/null)
 143 lctl set_param debug=-1 2> /dev/null || true
 144 test_0a() {
 145         touch $DIR/$tfile
 146         $CHECKSTAT -t file $DIR/$tfile || error "$tfile is not a file"
 147         rm $DIR/$tfile
 148         $CHECKSTAT -a $DIR/$tfile || error "$tfile was not removed"
 149 }
 150 run_test 0a "touch; rm ====================="
 151
 152 test_0b() {
 153         chmod 0755 $DIR || error "chmod 0755 $DIR failed"
 154         $CHECKSTAT -p 0755 $DIR || error "$DIR permission is not 0755"
 155 }
 156 run_test 0b "chmod 0755 $DIR ============================="
 157
 158 test_0c() {
 159         $LCTL get_param mdc.*.import | grep "state: FULL" ||
 160                 error "import not FULL"
 161         $LCTL get_param mdc.*.import | grep "target: $FSNAME-MDT" ||
 162                 error "bad target"
 163 }
 164 run_test 0c "check import proc ============================="
 165
 166 test_1() {
 167         test_mkdir -p $DIR/$tdir || error "mkdir $tdir failed"
 168         test_mkdir -p $DIR/$tdir/d2 || error "mkdir $tdir/d2 failed"
 169         test_mkdir $DIR/$tdir/d2 && error "we expect EEXIST, but not returned"
 170         $CHECKSTAT -t dir $DIR/$tdir/d2 || error "$tdir/d2 is not a dir"
 171         rmdir $DIR/$tdir/d2
 172         rmdir $DIR/$tdir
 173         $CHECKSTAT -a $DIR/$tdir || error "$tdir was not removed"
 174 }
 175 run_test 1 "mkdir; remkdir; rmdir =============================="
 176
 177 test_2() {
 178         test_mkdir -p $DIR/$tdir || error "mkdir $tdir failed"
 179         touch $DIR/$tdir/$tfile || error "touch $tdir/$tfile failed"
 180         $CHECKSTAT -t file $DIR/$tdir/$tfile || error "$tdir/$tfile not a file"
 181         rm -r $DIR/$tdir
 182         $CHECKSTAT -a $DIR/$tdir/$tfile || error "$tdir/$file is not removed"
 183 }
 184 run_test 2 "mkdir; touch; rmdir; check file ===================="
 185
 186 test_3() {
 187         test_mkdir -p $DIR/$tdir || error "mkdir $tdir failed"
 188         $CHECKSTAT -t dir $DIR/$tdir || error "$tdir is not a directory"
 189         touch $DIR/$tdir/$tfile
 190         $CHECKSTAT -t file $DIR/$tdir/$tfile || error "$tdir/$tfile not a file"
 191         rm -r $DIR/$tdir
 192         $CHECKSTAT -a $DIR/$tdir || error "$tdir is not removed"
 193 }
 194 run_test 3 "mkdir; touch; rmdir; check dir ====================="
 195
 196 test_5() {
 197         test_mkdir -p $DIR/$tdir || error "mkdir $tdir failed"
 198         test_mkdir $DIR/$tdir/d2 || error "mkdir $tdir/d2 failed"
 199         chmod 0707 $DIR/$tdir/d2 || error "chmod 0707 $tdir/d2 failed"
 200         $CHECKSTAT -t dir -p 0707 $DIR/$tdir/d2 || error "$tdir/d2 not mode 707"
 201         $CHECKSTAT -t dir $DIR/$tdir/d2 || error "$tdir/d2 is not a directory"
 202 }
 203 run_test 5 "mkdir .../d5 .../d5/d2; chmod .../d5/d2 ============"
 204
 205 test_6a() {
 206         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
 207         chmod 0666 $DIR/$tfile || error "chmod 0666 $tfile failed"
 208         $CHECKSTAT -t file -p 0666 -u \#$UID $DIR/$tfile ||
 209                 error "$tfile does not have perm 0666 or UID $UID"
 210         $RUNAS chmod 0444 $DIR/$tfile && error "chmod $tfile worked on UID $UID"
 211         $CHECKSTAT -t file -p 0666 -u \#$UID $DIR/$tfile ||
 212                 error "$tfile should be 0666 and owned by UID $UID"
 213 }
 214 run_test 6a "touch f6a; chmod f6a; $RUNAS chmod f6a (should return error) =="
 215
 216 test_6c() {
 217         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID" && return
 218         touch $DIR/$tfile
 219         chown $RUNAS_ID $DIR/$tfile || error "chown $RUNAS_ID $file failed"
 220         $CHECKSTAT -t file -u \#$RUNAS_ID $DIR/$tfile ||
 221                 error "$tfile should be owned by UID $RUNAS_ID"
 222         $RUNAS chown $UID $DIR/$tfile && error "chown $UID $file succeeded"
 223         $CHECKSTAT -t file -u \#$RUNAS_ID $DIR/$tfile ||
 224                 error "$tfile should be owned by UID $RUNAS_ID"
 225 }
 226 run_test 6c "touch f6c; chown f6c; $RUNAS chown f6c (should return error) =="
 227
 228 test_6e() {
 229         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID" && return
 230         touch $DIR/$tfile
 231         chgrp $RUNAS_ID $DIR/$tfile || error "chgrp $RUNAS_ID $file failed"
 232         $CHECKSTAT -t file -u \#$UID -g \#$RUNAS_ID $DIR/$tfile ||
 233                 error "$tfile should be owned by GID $UID"
 234         $RUNAS chgrp $UID $DIR/$tfile && error "chgrp $UID $file succeeded"
 235         $CHECKSTAT -t file -u \#$UID -g \#$RUNAS_ID $DIR/$tfile ||
 236                 error "$tfile should be owned by UID $UID and GID $RUNAS_ID"
 237 }
 238 run_test 6e "touch f6e; chgrp f6e; $RUNAS chgrp f6e (should return error) =="
 239
 240 test_6g() {
 241         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID" && return
 242         test_mkdir $DIR/$tdir || error "mkdir $tfile failed"
 243         chmod 777 $DIR/$tdir || error "chmod 0777 $tdir failed"
 244         $RUNAS mkdir $DIR/$tdir/d || error "mkdir $tdir/d failed"
 245         chmod g+s $DIR/$tdir/d || error "chmod g+s $tdir/d failed"
 246         test_mkdir $DIR/$tdir/d/subdir || error "mkdir $tdir/d/subdir failed"
 247         $CHECKSTAT -g \#$RUNAS_GID $DIR/$tdir/d/subdir ||
 248                 error "$tdir/d/subdir should be GID $RUNAS_GID"
 249 }
 250 run_test 6g "Is new dir in sgid dir inheriting group?"
 251
 252 test_6h() { # bug 7331
 253         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID" && return
 254         touch $DIR/$tfile || error "touch failed"
 255         chown $RUNAS_ID:$RUNAS_GID $DIR/$tfile || error "initial chown failed"
 256         $RUNAS -G$RUNAS_GID chown $RUNAS_ID:0 $DIR/$tfile &&
 257                 error "chown $RUNAS_ID:0 $tfile worked as GID $RUNAS_GID"
 258         $CHECKSTAT -t file -u \#$RUNAS_ID -g \#$RUNAS_GID $DIR/$tfile ||
 259                 error "$tdir/$tfile should be UID $RUNAS_UID GID $RUNAS_GID"
 260 }
 261 run_test 6h "$RUNAS chown RUNAS_ID.0 .../f6h (should return error)"
 262
 263 test_7a() {
 264         test_mkdir $DIR/$tdir
 265         $MCREATE $DIR/$tdir/$tfile
 266         chmod 0666 $DIR/$tdir/$tfile
 267         $CHECKSTAT -t file -p 0666 $DIR/$tdir/$tfile ||
 268                 error "$tdir/$tfile should be mode 0666"
 269 }
 270 run_test 7a "mkdir .../d7; mcreate .../d7/f; chmod .../d7/f ===="
 271
 272 test_7b() {
 273         if [ ! -d $DIR/$tdir ]; then
 274                 mkdir $DIR/$tdir
 275         fi
 276         $MCREATE $DIR/$tdir/$tfile
 277         echo -n foo > $DIR/$tdir/$tfile
 278         [ "$(cat $DIR/$tdir/$tfile)" = "foo" ] || error "$tdir/$tfile not 'foo'"
 279         $CHECKSTAT -t file -s 3 $DIR/$tdir/$tfile || error "$tfile size not 3"
 280 }
 281 run_test 7b "mkdir .../d7; mcreate d7/f2; echo foo > d7/f2 ====="
 282
 283 test_8() {
 284         test_mkdir $DIR/$tdir
 285         touch $DIR/$tdir/$tfile
 286         chmod 0666 $DIR/$tdir/$tfile
 287         $CHECKSTAT -t file -p 0666 $DIR/$tdir/$tfile ||
 288                 error "$tfile mode not 0666"
 289 }
 290 run_test 8 "mkdir .../d8; touch .../d8/f; chmod .../d8/f ======="
 291
 292 test_9() {
 293         test_mkdir $DIR/$tdir
 294         test_mkdir $DIR/$tdir/d2
 295         test_mkdir $DIR/$tdir/d2/d3
 296         $CHECKSTAT -t dir $DIR/$tdir/d2/d3 || error "$tdir/d2/d3 not a dir"
 297 }
 298 run_test 9 "mkdir .../d9 .../d9/d2 .../d9/d2/d3 ================"
 299
 300 test_10() {
 301         test_mkdir $DIR/$tdir
 302         test_mkdir $DIR/$tdir/d2
 303         touch $DIR/$tdir/d2/$tfile
 304         $CHECKSTAT -t file $DIR/$tdir/d2/$tfile ||
 305                 error "$tdir/d2/$tfile not a file"
 306 }
 307 run_test 10 "mkdir .../d10 .../d10/d2; touch .../d10/d2/f ======"
 308
 309 test_11() {
 310         test_mkdir $DIR/$tdir
 311         test_mkdir $DIR/$tdir/d2
 312         chmod 0666 $DIR/$tdir/d2
 313         chmod 0705 $DIR/$tdir/d2
 314         $CHECKSTAT -t dir -p 0705 $DIR/$tdir/d2 ||
 315                 error "$tdir/d2 mode not 0705"
 316 }
 317 run_test 11 "mkdir .../d11 d11/d2; chmod .../d11/d2 ============"
 318
 319 test_12() {
 320         test_mkdir $DIR/$tdir
 321         touch $DIR/$tdir/$tfile
 322         chmod 0666 $DIR/$tdir/$tfile
 323         chmod 0654 $DIR/$tdir/$tfile
 324         $CHECKSTAT -t file -p 0654 $DIR/$tdir/$tfile ||
 325                 error "$tdir/d2 mode not 0654"
 326 }
 327 run_test 12 "touch .../d12/f; chmod .../d12/f .../d12/f ========"
 328
 329 test_13() {
 330         test_mkdir $DIR/$tdir
 331         dd if=/dev/zero of=$DIR/$tdir/$tfile count=10
 332         >  $DIR/$tdir/$tfile
 333         $CHECKSTAT -t file -s 0 $DIR/$tdir/$tfile ||
 334                 error "$tdir/$tfile size not 0 after truncate"
 335 }
 336 run_test 13 "creat .../d13/f; dd .../d13/f; > .../d13/f ========"
 337
 338 test_14() {
 339         test_mkdir $DIR/$tdir
 340         touch $DIR/$tdir/$tfile
 341         rm $DIR/$tdir/$tfile
 342         $CHECKSTAT -a $DIR/$tdir/$tfile || error "$tdir/$tfile not removed"
 343 }
 344 run_test 14 "touch .../d14/f; rm .../d14/f; rm .../d14/f ======="
 345
 346 test_15() {
 347         test_mkdir $DIR/$tdir
 348         touch $DIR/$tdir/$tfile
 349         mv $DIR/$tdir/$tfile $DIR/$tdir/${tfile}_2
 350         $CHECKSTAT -t file $DIR/$tdir/${tfile}_2 ||
 351                 error "$tdir/${tfile_2} not a file after rename"
 352 }
 353 run_test 15 "touch .../d15/f; mv .../d15/f .../d15/f2 =========="
 354
 355 test_16() {
 356         test_mkdir $DIR/$tdir
 357         touch $DIR/$tdir/$tfile
 358         rm -rf $DIR/$tdir/$tfile
 359         $CHECKSTAT -a $DIR/$tdir/$tfile || error "$tdir/$tfile not removed"
 360 }
 361 run_test 16 "touch .../d16/f; rm -rf .../d16/f ================="
 362
 363 test_17a() {
 364         test_mkdir -p $DIR/$tdir
 365         touch $DIR/$tdir/$tfile
 366         ln -s $DIR/$tdir/$tfile $DIR/$tdir/l-exist
 367         ls -l $DIR/$tdir
 368         $CHECKSTAT -l $DIR/$tdir/$tfile $DIR/$tdir/l-exist ||
 369                 error "$tdir/l-exist not a symlink"
 370         $CHECKSTAT -f -t f $DIR/$tdir/l-exist ||
 371                 error "$tdir/l-exist not referencing a file"
 372         rm -f $DIR/$tdir/l-exist
 373         $CHECKSTAT -a $DIR/$tdir/l-exist || error "$tdir/l-exist not removed"
 374 }
 375 run_test 17a "symlinks: create, remove (real) =================="
 376
 377 test_17b() {
 378         test_mkdir -p $DIR/$tdir
 379         ln -s no-such-file $DIR/$tdir/l-dangle
 380         ls -l $DIR/$tdir
 381         $CHECKSTAT -l no-such-file $DIR/$tdir/l-dangle ||
 382                 error "$tdir/l-dangle not referencing no-such-file"
 383         $CHECKSTAT -fa $DIR/$tdir/l-dangle ||
 384                 error "$tdir/l-dangle not referencing non-existent file"
 385         rm -f $DIR/$tdir/l-dangle
 386         $CHECKSTAT -a $DIR/$tdir/l-dangle || error "$tdir/l-dangle not removed"
 387 }
 388 run_test 17b "symlinks: create, remove (dangling) =============="
 389
 390 test_17c() { # bug 3440 - don't save failed open RPC for replay
 391         test_mkdir -p $DIR/$tdir
 392         ln -s foo $DIR/$tdir/$tfile
 393         cat $DIR/$tdir/$tfile && error "opened non-existent symlink" || true
 394 }
 395 run_test 17c "symlinks: open dangling (should return error) ===="
 396
 397 test_17d() {
 398         test_mkdir -p $DIR/$tdir
 399         ln -s foo $DIR/$tdir/$tfile
 400         touch $DIR/$tdir/$tfile || error "creating to new symlink"
 401 }
 402 run_test 17d "symlinks: create dangling ========================"
 403
 404 test_17e() {
 405         test_mkdir -p $DIR/$tdir
 406         local foo=$DIR/$tdir/$tfile
 407         ln -s $foo $foo || error "create symlink failed"
 408         ls -l $foo || error "ls -l failed"
 409         ls $foo && error "ls not failed" || true
 410 }
 411 run_test 17e "symlinks: create recursive symlink (should return error) ===="
 412
 413 test_17f() {
 414         test_mkdir -p $DIR/d17f
 415         ln -s 1234567890/2234567890/3234567890/4234567890 $DIR/d17f/111
 416         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890 $DIR/d17f/222
 417         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890 $DIR/d17f/333
 418         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890 $DIR/d17f/444
 419         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890/c234567890/d234567890/f234567890 $DIR/d17f/555
 420         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890/c234567890/d234567890/f234567890/aaaaaaaaaa/bbbbbbbbbb/cccccccccc/dddddddddd/eeeeeeeeee/ffffffffff/ $DIR/d17f/666
 421         ls -l  $DIR/d17f
 422 }
 423 run_test 17f "symlinks: long and very long symlink name ========================"
 424
 425 # str_repeat(S, N) generate a string that is string S repeated N times
 426 str_repeat() {
 427         local s=$1
 428         local n=$2
 429         local ret=''
 430         while [ $((n -= 1)) -ge 0 ]; do
 431                 ret=$ret$s
 432         done
 433         echo $ret
 434 }
 435
 436 # Long symlinks and LU-2241
 437 test_17g() {
 438         test_mkdir -p $DIR/$tdir
 439         local TESTS="59 60 61 4094 4095"
 440
 441         # Fix for inode size boundary in 2.1.4
 442         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.1.4) ] &&
 443                 TESTS="4094 4095"
 444
 445         # Patch not applied to 2.2 or 2.3 branches
 446         [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.0) ] &&
 447         [ $(lustre_version_code $SINGLEMDS) -le $(version_code 2.3.55) ] &&
 448                 TESTS="4094 4095"
 449
 450         # skip long symlink name for rhel6.5.
 451         # rhel6.5 has a limit (PATH_MAX - sizeof(struct filename))
 452         grep -q '6.5' /etc/redhat-release && TESTS="59 60 61 4062 4063"
 453
 454         for i in $TESTS; do
 455                 local SYMNAME=$(str_repeat 'x' $i)
 456                 ln -s $SYMNAME $DIR/$tdir/f$i || error "failed $i-char symlink"
 457                 readlink $DIR/$tdir/f$i || error "failed $i-char readlink"
 458         done
 459 }
 460 run_test 17g "symlinks: really long symlink name and inode boundaries"
 461
 462 test_17h() { #bug 17378
 463         remote_mds_nodsh && skip "remote MDS with nodsh" && return
 464         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
 465         local mdt_idx
 466         test_mkdir -p $DIR/$tdir
 467         if [ $MDSCOUNT -gt 1 ]; then
 468                 mdt_idx=$($LFS getdirstripe -i $DIR/$tdir)
 469         else
 470                 mdt_idx=0
 471         fi
 472         $SETSTRIPE -c -1 $DIR/$tdir
 473 #define OBD_FAIL_MDS_LOV_PREP_CREATE 0x141
 474         do_facet mds$((mdt_idx + 1)) lctl set_param fail_loc=0x80000141
 475         touch $DIR/$tdir/$tfile || true
 476 }
 477 run_test 17h "create objects: lov_free_memmd() doesn't lbug"
 478
 479 test_17i() { #bug 20018
 480         remote_mds_nodsh && skip "remote MDS with nodsh" && return
 481         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
 482         test_mkdir -p $DIR/$tdir
 483         local foo=$DIR/$tdir/$tfile
 484         local mdt_idx
 485         if [ $MDSCOUNT -gt 1 ]; then
 486                 mdt_idx=$($LFS getdirstripe -i $DIR/$tdir)
 487         else
 488                 mdt_idx=0
 489         fi
 490         ln -s $foo $foo || error "create symlink failed"
 491 #define OBD_FAIL_MDS_READLINK_EPROTO     0x143
 492         do_facet mds$((mdt_idx + 1)) lctl set_param fail_loc=0x80000143
 493         ls -l $foo && error "error not detected"
 494         return 0
 495 }
 496 run_test 17i "don't panic on short symlink"
 497
 498 test_17k() { #bug 22301
 499         rsync --help | grep -q xattr ||
 500                 skip_env "$(rsync --version| head -1) does not support xattrs"
 501         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
 502         test_mkdir -p $DIR/$tdir
 503         test_mkdir -p $DIR/$tdir.new
 504         touch $DIR/$tdir/$tfile
 505         ln -s $DIR/$tdir/$tfile $DIR/$tdir/$tfile.lnk
 506         rsync -av -X $DIR/$tdir/ $DIR/$tdir.new ||
 507                 error "rsync failed with xattrs enabled"
 508 }
 509 run_test 17k "symlinks: rsync with xattrs enabled ========================="
 510
 511 test_17l() { # LU-279
 512         mkdir -p $DIR/$tdir
 513         touch $DIR/$tdir/$tfile
 514         ln -s $DIR/$tdir/$tfile $DIR/$tdir/$tfile.lnk
 515         for path in "$DIR/$tdir" "$DIR/$tdir/$tfile" "$DIR/$tdir/$tfile.lnk"; do
 516                 # -h to not follow symlinks. -m '' to list all the xattrs.
 517                 # grep to remove first line: '# file: $path'.
 518                 for xattr in `getfattr -hm '' $path 2>/dev/null | grep -v '^#'`;
 519                 do
 520                         lgetxattr_size_check $path $xattr ||
 521                                 error "lgetxattr_size_check $path $xattr failed"
 522                 done
 523         done
 524 }
 525 run_test 17l "Ensure lgetxattr's returned xattr size is consistent ========"
 526
 527 # LU-1540
 528 test_17m() {
 529         local short_sym="0123456789"
 530         local WDIR=$DIR/${tdir}m
 531         local mds_index
 532         local devname
 533         local cmd
 534         local i
 535         local rc=0
 536
 537         [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.0) ] &&
 538         [ $(lustre_version_code $SINGLEMDS) -le $(version_code 2.2.93) ] &&
 539                 skip "MDS 2.2.0-2.2.93 do not NUL-terminate symlinks" && return
 540
 541         [ "$(facet_fstype $SINGLEMDS)" != "ldiskfs" ] &&
 542                 skip "only for ldiskfs MDT" && return 0
 543
 544         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
 545
 546         mkdir -p $WDIR
 547         long_sym=$short_sym
 548         # create a long symlink file
 549         for ((i = 0; i < 4; ++i)); do
 550                 long_sym=${long_sym}${long_sym}
 551         done
 552
 553         echo "create 512 short and long symlink files under $WDIR"
 554         for ((i = 0; i < 256; ++i)); do
 555                 ln -sf ${long_sym}"a5a5" $WDIR/long-$i
 556                 ln -sf ${short_sym}"a5a5" $WDIR/short-$i
 557         done
 558
 559         echo "erase them"
 560         rm -f $WDIR/*
 561         sync
 562         wait_delete_completed
 563
 564         echo "recreate the 512 symlink files with a shorter string"
 565         for ((i = 0; i < 512; ++i)); do
 566                 # rewrite the symlink file with a shorter string
 567                 ln -sf ${long_sym} $WDIR/long-$i
 568                 ln -sf ${short_sym} $WDIR/short-$i
 569         done
 570
 571         mds_index=$($LFS getstripe -M $WDIR)
 572         mds_index=$((mds_index+1))
 573         devname=$(mdsdevname $mds_index)
 574         cmd="$E2FSCK -fnvd $devname"
 575
 576         echo "stop and checking mds${mds_index}: $cmd"
 577         # e2fsck should not return error
 578         stop mds${mds_index}
 579         do_facet mds${mds_index} $cmd || rc=$?
 580
 581         start mds${mds_index} $devname $MDS_MOUNT_OPTS
 582         df $MOUNT > /dev/null 2>&1
 583         [ $rc -ne 0 ] && error "e2fsck should not report error upon "\
 584                 "short/long symlink MDT: rc=$rc"
 585         return $rc
 586 }
 587 run_test 17m "run e2fsck against MDT which contains short/long symlink"
 588
 589 check_fs_consistency_17n() {
 590         local mdt_index
 591         local devname
 592         local cmd
 593         local rc=0
 594
 595         # create/unlink in 17n only change 2 MDTs(MDT1/MDT2),
 596         # so it only check MDT1/MDT2 instead of all of MDTs.
 597         for mdt_index in $(seq 1 2); do
 598                 devname=$(mdsdevname $mdt_index)
 599                 cmd="$E2FSCK -fnvd $devname"
 600
 601                 echo "stop and checking mds${mdt_index}: $cmd"
 602                 # e2fsck should not return error
 603                 stop mds${mdt_index}
 604                 do_facet mds${mdt_index} $cmd || rc=$?
 605
 606                 start mds${mdt_index} $devname $MDS_MOUNT_OPTS
 607                 df $MOUNT > /dev/null 2>&1
 608                 [ $rc -ne 0 ] && break
 609         done
 610         return $rc
 611 }
 612
 613 test_17n() {
 614         local i
 615
 616         [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.0) ] &&
 617         [ $(lustre_version_code $SINGLEMDS) -le $(version_code 2.2.93) ] &&
 618                 skip "MDS 2.2.0-2.2.93 do not NUL-terminate symlinks" && return
 619
 620         [ "$(facet_fstype $SINGLEMDS)" != "ldiskfs" ] &&
 621                 skip "only for ldiskfs MDT" && return 0
 622
 623         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
 624
 625         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
 626
 627         mkdir -p $DIR/$tdir
 628         for ((i=0; i<10; i++)); do
 629                 $LFS mkdir -i 1 $DIR/$tdir/remote_dir_${i} ||
 630                         error "create remote dir error $i"
 631                 createmany -o $DIR/$tdir/remote_dir_${i}/f 10 ||
 632                         error "create files under remote dir failed $i"
 633         done
 634
 635         check_fs_consistency_17n || error "e2fsck report error"
 636
 637         for ((i=0;i<10;i++)); do
 638                 rm -rf $DIR/$tdir/remote_dir_${i} ||
 639                         error "destroy remote dir error $i"
 640         done
 641
 642         check_fs_consistency_17n || error "e2fsck report error"
 643 }
 644 run_test 17n "run e2fsck against master/slave MDT which contains remote dir"
 645
 646 test_17o() {
 647         [[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.3.64) ]] &&
 648                 skip "Need MDS version at least 2.3.64" && return
 649
 650         local WDIR=$DIR/${tdir}o
 651         local mdt_index
 652         local mdtdevname
 653         local rc=0
 654
 655         mkdir -p $WDIR
 656         mdt_index=$($LFS getstripe -M $WDIR)
 657         mdt_index=$((mdt_index+1))
 658         mdtdevname=$(mdsdevname $mdt_index)
 659
 660         touch $WDIR/$tfile
 661         stop mds${mdt_index}
 662         start mds${mdt_index} $mdtdevname $MDS_MOUNT_OPTS
 663
 664         #define OBD_FAIL_OSD_LMA_INCOMPAT 0x194
 665         do_facet mds${mdt_index} lctl set_param fail_loc=0x194
 666         ls -l $WDIR/$tfile && rc=1
 667         do_facet mds${mdt_index} lctl set_param fail_loc=0
 668         [[ $rc -ne 0 ]] && error "stat file should fail"
 669         true
 670 }
 671 run_test 17o "stat file with incompat LMA feature"
 672
 673 test_18() {
 674         touch $DIR/f || error "Failed to touch $DIR/f: $?"
 675         ls $DIR || error "Failed to ls $DIR: $?"
 676 }
 677 run_test 18 "touch .../f ; ls ... =============================="
 678
 679 test_19a() {
 680         touch $DIR/$tfile
 681         ls -l $DIR
 682         rm $DIR/$tfile
 683         $CHECKSTAT -a $DIR/$tfile || error "$tfile was not removed"
 684 }
 685 run_test 19a "touch .../f19 ; ls -l ... ; rm .../f19 ==========="
 686
 687 test_19b() {
 688         ls -l $DIR/$tfile && error "ls -l $tfile failed"|| true
 689 }
 690 run_test 19b "ls -l .../f19 (should return error) =============="
 691
 692 test_19c() {
 693         [ $RUNAS_ID -eq $UID ] &&
 694                 skip_env "RUNAS_ID = UID = $UID -- skipping" && return
 695         $RUNAS touch $DIR/$tfile && error "create non-root file failed" || true
 696 }
 697 run_test 19c "$RUNAS touch .../f19 (should return error) =="
 698
 699 test_19d() {
 700         cat $DIR/f19 && error || true
 701 }
 702 run_test 19d "cat .../f19 (should return error) =============="
 703
 704 test_20() {
 705         touch $DIR/$tfile
 706         rm $DIR/$tfile
 707         log "1 done"
 708         touch $DIR/$tfile
 709         rm $DIR/$tfile
 710         log "2 done"
 711         touch $DIR/$tfile
 712         rm $DIR/$tfile
 713         log "3 done"
 714         $CHECKSTAT -a $DIR/$tfile || error "$tfile was not removed"
 715 }
 716 run_test 20 "touch .../f ; ls -l ... ==========================="
 717
 718 test_21() {
 719         test_mkdir -p $DIR/$tdir
 720         [ -f $DIR/$tdir/dangle ] && rm -f $DIR/$tdir/dangle
 721         ln -s dangle $DIR/$tdir/link
 722         echo foo >> $DIR/$tdir/link
 723         cat $DIR/$tdir/dangle
 724         $CHECKSTAT -t link $DIR/$tdir/link || error "$tdir/link not a link"
 725         $CHECKSTAT -f -t file $DIR/$tdir/link ||
 726                 error "$tdir/link not linked to a file"
 727 }
 728 run_test 21 "write to dangling link ============================"
 729
 730 test_22() {
 731         WDIR=$DIR/$tdir
 732         test_mkdir -p $DIR/$tdir
 733         chown $RUNAS_ID:$RUNAS_GID $WDIR
 734         (cd $WDIR || error "cd $WDIR failed";
 735         $RUNAS tar cf - /etc/hosts /etc/sysconfig/network | \
 736         $RUNAS tar xf -)
 737         ls -lR $WDIR/etc || error "ls -lR $WDIR/etc failed"
 738         $CHECKSTAT -t dir $WDIR/etc || error "checkstat -t dir failed"
 739         $CHECKSTAT -u \#$RUNAS_ID -g \#$RUNAS_GID $WDIR/etc || error "checkstat -u failed"
 740 }
 741 run_test 22 "unpack tar archive as non-root user ==============="
 742
 743 # was test_23
 744 test_23a() {
 745         test_mkdir -p $DIR/$tdir
 746         local file=$DIR/$tdir/$tfile
 747
 748         openfile -f O_CREAT:O_EXCL $file || error "$file create failed"
 749         openfile -f O_CREAT:O_EXCL $file &&
 750                 error "$file recreate succeeded" || true
 751 }
 752 run_test 23a "O_CREAT|O_EXCL in subdir =========================="
 753
 754 test_23b() { # bug 18988
 755         test_mkdir -p $DIR/$tdir
 756         local file=$DIR/$tdir/$tfile
 757
 758         rm -f $file
 759         echo foo > $file || error "write filed"
 760         echo bar >> $file || error "append filed"
 761         $CHECKSTAT -s 8 $file || error "wrong size"
 762         rm $file
 763 }
 764 run_test 23b "O_APPEND check =========================="
 765
 766 # rename sanity
 767 test_24a() {
 768         echo '-- same directory rename'
 769         test_mkdir $DIR/$tdir
 770         touch $DIR/$tdir/$tfile.1
 771         mv $DIR/$tdir/$tfile.1 $DIR/$tdir/$tfile.2
 772         $CHECKSTAT -t file $DIR/$tdir/$tfile.2 || error "$tfile.2 not a file"
 773 }
 774 run_test 24a "rename file to non-existent target"
 775
 776 test_24b() {
 777         test_mkdir $DIR/$tdir
 778         touch $DIR/$tdir/$tfile.{1,2}
 779         mv $DIR/$tdir/$tfile.1 $DIR/$tdir/$tfile.2
 780         $CHECKSTAT -a $DIR/$tdir/$tfile.1 || error "$tfile.1 exists"
 781         $CHECKSTAT -t file $DIR/$tdir/$tfile.2 || error "$tfile.2 not a file"
 782 }
 783 run_test 24b "rename file to existing target"
 784
 785 test_24c() {
 786         test_mkdir $DIR/$tdir
 787         test_mkdir $DIR/$tdir/d$testnum.1
 788         mv $DIR/$tdir/d$testnum.1 $DIR/$tdir/d$testnum.2
 789         $CHECKSTAT -a $DIR/$tdir/d$testnum.1 || error "d$testnum.1 exists"
 790         $CHECKSTAT -t dir $DIR/$tdir/d$testnum.2 || error "d$testnum.2 not dir"
 791 }
 792 run_test 24c "rename directory to non-existent target"
 793
 794 test_24d() {
 795         test_mkdir $DIR/$tdir
 796         test_mkdir $DIR/$tdir/d$testnum.1
 797         test_mkdir $DIR/$tdir/d$testnum.2
 798         mrename $DIR/$tdir/d$testnum.1 $DIR/$tdir/d$testnum.2
 799         $CHECKSTAT -a $DIR/$tdir/d$testnum.1 || error "d$testnum.1 exists"
 800         $CHECKSTAT -t dir $DIR/$tdir/d$testnum.2 || error "d$testnum.2 not dir"
 801 }
 802 run_test 24d "rename directory to existing target"
 803
 804 test_24e() {
 805         echo '-- cross directory renames --'
 806         test_mkdir $DIR/R5a
 807         test_mkdir $DIR/R5b
 808         touch $DIR/R5a/f
 809         mv $DIR/R5a/f $DIR/R5b/g
 810         $CHECKSTAT -a $DIR/R5a/f || error
 811         $CHECKSTAT -t file $DIR/R5b/g || error
 812 }
 813 run_test 24e "touch .../R5a/f; rename .../R5a/f .../R5b/g ======"
 814
 815 test_24f() {
 816         test_mkdir $DIR/R6a
 817         test_mkdir $DIR/R6b
 818         touch $DIR/R6a/f $DIR/R6b/g
 819         mv $DIR/R6a/f $DIR/R6b/g
 820         $CHECKSTAT -a $DIR/R6a/f || error
 821         $CHECKSTAT -t file $DIR/R6b/g || error
 822 }
 823 run_test 24f "touch .../R6a/f R6b/g; mv .../R6a/f .../R6b/g ===="
 824
 825 test_24g() {
 826         test_mkdir $DIR/R7a
 827         test_mkdir $DIR/R7b
 828         test_mkdir $DIR/R7a/d
 829         mv $DIR/R7a/d $DIR/R7b/e
 830         $CHECKSTAT -a $DIR/R7a/d || error
 831         $CHECKSTAT -t dir $DIR/R7b/e || error
 832 }
 833 run_test 24g "mkdir .../R7{a,b}/d; mv .../R7a/d .../R7b/e ======"
 834
 835 test_24h() {
 836         test_mkdir $DIR/R8a
 837         test_mkdir $DIR/R8b
 838         test_mkdir $DIR/R8a/d
 839         test_mkdir $DIR/R8b/e
 840         mrename $DIR/R8a/d $DIR/R8b/e
 841         $CHECKSTAT -a $DIR/R8a/d || error
 842         $CHECKSTAT -t dir $DIR/R8b/e || error
 843 }
 844 run_test 24h "mkdir .../R8{a,b}/{d,e}; rename .../R8a/d .../R8b/e"
 845
 846 test_24i() {
 847         echo "-- rename error cases"
 848         test_mkdir $DIR/R9
 849         test_mkdir $DIR/R9/a
 850         touch $DIR/R9/f
 851         mrename $DIR/R9/f $DIR/R9/a
 852         $CHECKSTAT -t file $DIR/R9/f || error
 853         $CHECKSTAT -t dir  $DIR/R9/a || error
 854         $CHECKSTAT -a $DIR/R9/a/f || error
 855 }
 856 run_test 24i "rename file to dir error: touch f ; mkdir a ; rename f a"
 857
 858 test_24j() {
 859         test_mkdir $DIR/R10
 860         mrename $DIR/R10/f $DIR/R10/g
 861         $CHECKSTAT -t dir $DIR/R10 || error
 862         $CHECKSTAT -a $DIR/R10/f || error
 863         $CHECKSTAT -a $DIR/R10/g || error
 864 }
 865 run_test 24j "source does not exist ============================"
 866
 867 test_24k() {
 868         test_mkdir $DIR/R11a
 869         test_mkdir $DIR/R11a/d
 870         touch $DIR/R11a/f
 871         mv $DIR/R11a/f $DIR/R11a/d
 872         $CHECKSTAT -a $DIR/R11a/f || error
 873         $CHECKSTAT -t file $DIR/R11a/d/f || error
 874 }
 875 run_test 24k "touch .../R11a/f; mv .../R11a/f .../R11a/d ======="
 876
 877 # bug 2429 - rename foo foo foo creates invalid file
 878 test_24l() {
 879         f="$DIR/f24l"
 880         $MULTIOP $f OcNs || error
 881 }
 882 run_test 24l "Renaming a file to itself ========================"
 883
 884 test_24m() {
 885         f="$DIR/f24m"
 886         $MULTIOP $f OcLN ${f}2 ${f}2 || error "link ${f}2 ${f}2 failed"
 887         # on ext3 this does not remove either the source or target files
 888         # though the "expected" operation would be to remove the source
 889         $CHECKSTAT -t file ${f} || error "${f} missing"
 890         $CHECKSTAT -t file ${f}2 || error "${f}2 missing"
 891 }
 892 run_test 24m "Renaming a file to a hard link to itself ========="
 893
 894 test_24n() {
 895     f="$DIR/f24n"
 896     # this stats the old file after it was renamed, so it should fail
 897     touch ${f}
 898     $CHECKSTAT ${f}
 899     mv ${f} ${f}.rename
 900     $CHECKSTAT ${f}.rename
 901     $CHECKSTAT -a ${f}
 902 }
 903 run_test 24n "Statting the old file after renaming (Posix rename 2)"
 904
 905 test_24o() {
 906         check_kernel_version 37 || return 0
 907         test_mkdir -p $DIR/d24o
 908         rename_many -s random -v -n 10 $DIR/d24o
 909 }
 910 run_test 24o "rename of files during htree split ==============="
 911
 912 test_24p() {
 913         test_mkdir $DIR/R12a
 914         test_mkdir $DIR/R12b
 915         DIRINO=`ls -lid $DIR/R12a | awk '{ print $1 }'`
 916         mrename $DIR/R12a $DIR/R12b
 917         $CHECKSTAT -a $DIR/R12a || error
 918         $CHECKSTAT -t dir $DIR/R12b || error
 919         DIRINO2=`ls -lid $DIR/R12b | awk '{ print $1 }'`
 920         [ "$DIRINO" = "$DIRINO2" ] || error "R12a $DIRINO != R12b $DIRINO2"
 921 }
 922 run_test 24p "mkdir .../R12{a,b}; rename .../R12a .../R12b"
 923
 924 cleanup_multiop_pause() {
 925         trap 0
 926         kill -USR1 $MULTIPID
 927 }
 928
 929 test_24q() {
 930         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
 931         test_mkdir $DIR/R13a
 932         test_mkdir $DIR/R13b
 933         local DIRINO=$(ls -lid $DIR/R13a | awk '{ print $1 }')
 934         multiop_bg_pause $DIR/R13b D_c || error "multiop failed to start"
 935         MULTIPID=$!
 936
 937         trap cleanup_multiop_pause EXIT
 938         mrename $DIR/R13a $DIR/R13b
 939         $CHECKSTAT -a $DIR/R13a || error "R13a still exists"
 940         $CHECKSTAT -t dir $DIR/R13b || error "R13b does not exist"
 941         local DIRINO2=$(ls -lid $DIR/R13b | awk '{ print $1 }')
 942         [ "$DIRINO" = "$DIRINO2" ] || error "R13a $DIRINO != R13b $DIRINO2"
 943         cleanup_multiop_pause
 944         wait $MULTIPID || error "multiop close failed"
 945 }
 946 run_test 24q "mkdir .../R13{a,b}; open R13b rename R13a R13b ==="
 947
 948 test_24r() { #bug 3789
 949         test_mkdir $DIR/R14a
 950         test_mkdir $DIR/R14a/b
 951         mrename $DIR/R14a $DIR/R14a/b && error "rename to subdir worked!"
 952         $CHECKSTAT -t dir $DIR/R14a || error "$DIR/R14a missing"
 953         $CHECKSTAT -t dir $DIR/R14a/b || error "$DIR/R14a/b missing"
 954 }
 955 run_test 24r "mkdir .../R14a/b; rename .../R14a .../R14a/b ====="
 956
 957 test_24s() {
 958         test_mkdir $DIR/R15a
 959         test_mkdir $DIR/R15a/b
 960         test_mkdir $DIR/R15a/b/c
 961         mrename $DIR/R15a $DIR/R15a/b/c && error "rename to sub-subdir worked!"
 962         $CHECKSTAT -t dir $DIR/R15a || error "$DIR/R15a missing"
 963         $CHECKSTAT -t dir $DIR/R15a/b/c || error "$DIR/R15a/b/c missing"
 964 }
 965 run_test 24s "mkdir .../R15a/b/c; rename .../R15a .../R15a/b/c ="
 966 test_24t() {
 967         test_mkdir $DIR/R16a
 968         test_mkdir $DIR/R16a/b
 969         test_mkdir $DIR/R16a/b/c
 970         mrename $DIR/R16a/b/c $DIR/R16a && error "rename to sub-subdir worked!"
 971         $CHECKSTAT -t dir $DIR/R16a || error "$DIR/R16a missing"
 972         $CHECKSTAT -t dir $DIR/R16a/b/c || error "$DIR/R16a/b/c missing"
 973 }
 974 run_test 24t "mkdir .../R16a/b/c; rename .../R16a/b/c .../R16a ="
 975
 976 test_24u() { # bug12192
 977         rm -rf $DIR/$tfile
 978         $MULTIOP $DIR/$tfile C2w$((2048 * 1024))c || error
 979         $CHECKSTAT -s $((2048 * 1024)) $DIR/$tfile || error "wrong file size"
 980 }
 981 run_test 24u "create stripe file"
 982
 983 page_size() {
 984         getconf PAGE_SIZE
 985 }
 986
 987 simple_cleanup_common() {
 988         trap 0
 989         rm -rf $DIR/$tdir
 990         wait_delete_completed
 991 }
 992
 993 max_pages_per_rpc() {
 994         $LCTL get_param -n mdc.*.max_pages_per_rpc | head -1
 995 }
 996
 997 test_24v() {
 998         local NRFILES=100000
 999         local FREE_INODES=$(mdt_free_inodes 0)
1000         [ $FREE_INODES -lt $NRFILES ] && \
1001                 skip "not enough free inodes $FREE_INODES required $NRFILES" &&
1002                 return
1003
1004         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1005         trap simple_cleanup_common EXIT
1006
1007         # Performance issue on ZFS see LU-4072 (c.f. LU-2887)
1008         [ $(facet_fstype $SINGLEMDS) = "zfs" ] && NRFILES=10000
1009
1010         mkdir -p $DIR/$tdir
1011         createmany -m $DIR/$tdir/$tfile $NRFILES
1012
1013         cancel_lru_locks mdc
1014         lctl set_param mdc.*.stats clear
1015
1016         ls $DIR/$tdir >/dev/null || error "error in listing large dir"
1017
1018         # LU-5 large readdir
1019         # DIRENT_SIZE = 32 bytes for sizeof(struct lu_dirent) +
1020         #               8 bytes for name(filename is mostly 5 in this test) +
1021         #               8 bytes for luda_type
1022         # take into account of overhead in lu_dirpage header and end mark in
1023         # each page, plus one in RPC_NUM calculation.
1024         DIRENT_SIZE=48
1025         RPC_SIZE=$(($(max_pages_per_rpc) * $(page_size)))
1026         RPC_NUM=$(((NRFILES * DIRENT_SIZE + RPC_SIZE - 1) / RPC_SIZE + 1))
1027         mds_readpage=$(lctl get_param mdc.*MDT0000*.stats | \
1028                                 awk '/^mds_readpage/ {print $2}')
1029         [ $mds_readpage -gt $RPC_NUM ] && \
1030                 error "large readdir doesn't take effect"
1031
1032         simple_cleanup_common
1033 }
1034 run_test 24v "list directory with large files (handle hash collision, bug: 17560)"
1035
1036 test_24w() { # bug21506
1037         SZ1=234852
1038         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=4096 || return 1
1039         dd if=/dev/zero bs=$SZ1 count=1 >> $DIR/$tfile || return 2
1040         dd if=$DIR/$tfile of=$DIR/${tfile}_left bs=1M skip=4097 || return 3
1041         SZ2=`ls -l $DIR/${tfile}_left | awk '{print $5}'`
1042         [ "$SZ1" = "$SZ2" ] || \
1043                 error "Error reading at the end of the file $tfile"
1044 }
1045 run_test 24w "Reading a file larger than 4Gb"
1046
1047 test_24x() {
1048         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
1049         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1050         local MDTIDX=1
1051         local remote_dir=$DIR/$tdir/remote_dir
1052
1053         mkdir -p $DIR/$tdir
1054         $LFS mkdir -i $MDTIDX $remote_dir ||
1055                 error "create remote directory failed"
1056
1057         mkdir -p $DIR/$tdir/src_dir
1058         touch $DIR/$tdir/src_file
1059         mkdir -p $remote_dir/tgt_dir
1060         touch $remote_dir/tgt_file
1061
1062         mrename $remote_dir $DIR/ &&
1063                 error "rename dir cross MDT works!"
1064
1065         mrename $DIR/$tdir/src_dir $remote_dir/tgt_dir &&
1066                 error "rename dir cross MDT works!"
1067
1068         mrename $DIR/$tdir/src_file $remote_dir/tgt_file &&
1069                 error "rename file cross MDT works!"
1070
1071         ln $DIR/$tdir/src_file $remote_dir/tgt_file1 &&
1072                 error "ln file cross MDT should not work!"
1073
1074         rm -rf $DIR/$tdir || error "Can not delete directories"
1075 }
1076 run_test 24x "cross rename/link should be failed"
1077
1078 test_24y() {
1079         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
1080         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1081         local MDTIDX=1
1082         local remote_dir=$DIR/$tdir/remote_dir
1083
1084         mkdir -p $DIR/$tdir
1085         $LFS mkdir -i $MDTIDX $remote_dir ||
1086                    error "create remote directory failed"
1087
1088         mkdir -p $remote_dir/src_dir
1089         touch $remote_dir/src_file
1090         mkdir -p $remote_dir/tgt_dir
1091         touch $remote_dir/tgt_file
1092
1093         mrename $remote_dir/src_dir $remote_dir/tgt_dir ||
1094                 error "rename subdir in the same remote dir failed!"
1095
1096         mrename $remote_dir/src_file $remote_dir/tgt_file ||
1097                 error "rename files in the same remote dir failed!"
1098
1099         ln $remote_dir/tgt_file $remote_dir/tgt_file1 ||
1100                 error "link files in the same remote dir failed!"
1101
1102         rm -rf $DIR/$tdir || error "Can not delete directories"
1103 }
1104 run_test 24y "rename/link on the same dir should succeed"
1105
1106 test_24z() {
1107         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
1108         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1109         local MDTIDX=1
1110         local remote_src=$DIR/$tdir/remote_dir
1111         local remote_tgt=$DIR/$tdir/remote_tgt
1112
1113         mkdir -p $DIR/$tdir
1114         $LFS mkdir -i $MDTIDX $remote_src ||
1115                    error "create remote directory failed"
1116
1117         $LFS mkdir -i $MDTIDX $remote_tgt ||
1118                    error "create remote directory failed"
1119
1120         mrename $remote_src $remote_tgt &&
1121                 error "rename remote dirs should not work!"
1122
1123         # If target dir does not exists, it should succeed
1124         rm -rf $remote_tgt
1125         mrename $remote_src $remote_tgt ||
1126                 error "rename remote dirs(tgt dir does not exists) failed!"
1127
1128         rm -rf $DIR/$tdir || error "Can not delete directories"
1129 }
1130 run_test 24z "rename one remote dir to another remote dir should fail"
1131
1132 test_24A() { # LU-3182
1133         local NFILES=5000
1134
1135         rm -rf $DIR/$tdir
1136         mkdir -p $DIR/$tdir
1137         createmany -m $DIR/$tdir/$tfile $NFILES
1138         local t=`ls $DIR/$tdir | wc -l`
1139         local u=`ls $DIR/$tdir | sort -u | wc -l`
1140         if [ $t -ne $NFILES -o $u -ne $NFILES ] ; then
1141                 error "Expected $NFILES files, got $t ($u unique)"
1142         fi
1143
1144         rm -rf $DIR/$tdir || error "Can not delete directories"
1145 }
1146 run_test 24A "readdir() returns correct number of entries."
1147
1148 test_25a() {
1149         echo '== symlink sanity ============================================='
1150
1151         test_mkdir $DIR/d25
1152         ln -s d25 $DIR/s25
1153         touch $DIR/s25/foo || error
1154 }
1155 run_test 25a "create file in symlinked directory ==============="
1156
1157 test_25b() {
1158         [ ! -d $DIR/d25 ] && test_25a
1159         $CHECKSTAT -t file $DIR/s25/foo || error
1160 }
1161 run_test 25b "lookup file in symlinked directory ==============="
1162
1163 test_26a() {
1164         test_mkdir $DIR/d26
1165         test_mkdir $DIR/d26/d26-2
1166         ln -s d26/d26-2 $DIR/s26
1167         touch $DIR/s26/foo || error
1168 }
1169 run_test 26a "multiple component symlink ======================="
1170
1171 test_26b() {
1172         test_mkdir -p $DIR/d26b/d26-2
1173         ln -s d26b/d26-2/foo $DIR/s26-2
1174         touch $DIR/s26-2 || error
1175 }
1176 run_test 26b "multiple component symlink at end of lookup ======"
1177
1178 test_26c() {
1179         test_mkdir $DIR/d26.2
1180         touch $DIR/d26.2/foo
1181         ln -s d26.2 $DIR/s26.2-1
1182         ln -s s26.2-1 $DIR/s26.2-2
1183         ln -s s26.2-2 $DIR/s26.2-3
1184         chmod 0666 $DIR/s26.2-3/foo
1185 }
1186 run_test 26c "chain of symlinks ================================"
1187
1188 # recursive symlinks (bug 439)
1189 test_26d() {
1190         ln -s d26-3/foo $DIR/d26-3
1191 }
1192 run_test 26d "create multiple component recursive symlink ======"
1193
1194 test_26e() {
1195         [ ! -h $DIR/d26-3 ] && test_26d
1196         rm $DIR/d26-3
1197 }
1198 run_test 26e "unlink multiple component recursive symlink ======"
1199
1200 # recursive symlinks (bug 7022)
1201 test_26f() {
1202         test_mkdir -p $DIR/$tdir
1203         test_mkdir $DIR/$tdir/$tfile   || error "mkdir $DIR/$tdir/$tfile failed"
1204         cd $DIR/$tdir/$tfile           || error "cd $DIR/$tdir/$tfile failed"
1205         test_mkdir -p lndir/bar1      || error "mkdir lndir/bar1 failed"
1206         test_mkdir $DIR/$tdir/$tfile/$tfile   || error "mkdir $tfile failed"
1207         cd $tfile                || error "cd $tfile failed"
1208         ln -s .. dotdot          || error "ln dotdot failed"
1209         ln -s dotdot/lndir lndir || error "ln lndir failed"
1210         cd $DIR/$tdir                 || error "cd $DIR/$tdir failed"
1211         output=`ls $tfile/$tfile/lndir/bar1`
1212         [ "$output" = bar1 ] && error "unexpected output"
1213         rm -r $tfile             || error "rm $tfile failed"
1214         $CHECKSTAT -a $DIR/$tfile || error "$tfile not gone"
1215 }
1216 run_test 26f "rm -r of a directory which has recursive symlink ="
1217
1218 test_27a() {
1219         echo '== stripe sanity =============================================='
1220         test_mkdir -p $DIR/d27 || error "mkdir failed"
1221         $GETSTRIPE $DIR/d27
1222         $SETSTRIPE -c 1 $DIR/d27/f0 || error "setstripe failed"
1223         $CHECKSTAT -t file $DIR/d27/f0 || error "checkstat failed"
1224         pass
1225         log "== test_27a: write to one stripe file ========================="
1226         cp /etc/hosts $DIR/d27/f0 || error
1227 }
1228 run_test 27a "one stripe file =================================="
1229
1230 test_27b() {
1231         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
1232         test_mkdir -p $DIR/d27
1233         $SETSTRIPE -c 2 $DIR/d27/f01 || error "setstripe failed"
1234         $GETSTRIPE -c $DIR/d27/f01
1235         [ $($GETSTRIPE -c $DIR/d27/f01) -eq 2 ] ||
1236                 error "two-stripe file doesn't have two stripes"
1237
1238         dd if=/dev/zero of=$DIR/d27/f01 bs=4k count=4 || error "dd failed"
1239 }
1240 run_test 27b "create and write to two stripe file"
1241
1242 test_27d() {
1243         test_mkdir -p $DIR/d27
1244         $SETSTRIPE -c 0 -i -1 -S 0 $DIR/d27/fdef || error "setstripe failed"
1245         $CHECKSTAT -t file $DIR/d27/fdef || error "checkstat failed"
1246         dd if=/dev/zero of=$DIR/d27/fdef bs=4k count=4 || error
1247 }
1248 run_test 27d "create file with default settings ================"
1249
1250 test_27e() {
1251         test_mkdir -p $DIR/d27
1252         $SETSTRIPE -c 2 $DIR/d27/f12 || error "setstripe failed"
1253         $SETSTRIPE -c 2 $DIR/d27/f12 && error "setstripe succeeded twice"
1254         $CHECKSTAT -t file $DIR/d27/f12 || error "checkstat failed"
1255 }
1256 run_test 27e "setstripe existing file (should return error) ======"
1257
1258 test_27f() {
1259         test_mkdir -p $DIR/d27
1260         $SETSTRIPE -S 100 -i 0 -c 1 $DIR/d27/fbad && error "setstripe failed"
1261         dd if=/dev/zero of=$DIR/d27/fbad bs=4k count=4 || error "dd failed"
1262         $GETSTRIPE $DIR/d27/fbad || error "$GETSTRIPE failed"
1263 }
1264 run_test 27f "setstripe with bad stripe size (should return error)"
1265
1266 test_27g() {
1267         test_mkdir -p $DIR/d27
1268         $MCREATE $DIR/d27/fnone || error "mcreate failed"
1269         $GETSTRIPE $DIR/d27/fnone 2>&1 | grep "no stripe info" ||
1270                 error "$DIR/d27/fnone has object"
1271 }
1272 run_test 27g "$GETSTRIPE with no objects"
1273
1274 test_27i() {
1275         touch $DIR/d27/fsome || error "touch failed"
1276         [ $($GETSTRIPE -c $DIR/d27/fsome) -gt 0 ] || error "missing objects"
1277 }
1278 run_test 27i "$GETSTRIPE with some objects"
1279
1280 test_27j() {
1281         test_mkdir -p $DIR/d27
1282         $SETSTRIPE -i $OSTCOUNT $DIR/d27/f27j && error "setstripe failed"||true
1283 }
1284 run_test 27j "setstripe with bad stripe offset (should return error)"
1285
1286 test_27k() { # bug 2844
1287         test_mkdir -p $DIR/d27
1288         FILE=$DIR/d27/f27k
1289         LL_MAX_BLKSIZE=$((4 * 1024 * 1024))
1290         [ ! -d $DIR/d27 ] && test_mkdir -p $DIR d27
1291         $SETSTRIPE -S 67108864 $FILE || error "setstripe failed"
1292         BLKSIZE=`stat $FILE | awk '/IO Block:/ { print $7 }'`
1293         [ $BLKSIZE -le $LL_MAX_BLKSIZE ] || error "1:$BLKSIZE > $LL_MAX_BLKSIZE"
1294         dd if=/dev/zero of=$FILE bs=4k count=1
1295         BLKSIZE=`stat $FILE | awk '/IO Block:/ { print $7 }'`
1296         [ $BLKSIZE -le $LL_MAX_BLKSIZE ] || error "2:$BLKSIZE > $LL_MAX_BLKSIZE"
1297 }
1298 run_test 27k "limit i_blksize for broken user apps ============="
1299
1300 test_27l() {
1301         test_mkdir -p $DIR/d27
1302         mcreate $DIR/f27l || error "creating file"
1303         $RUNAS $SETSTRIPE -c 1 $DIR/f27l && \
1304                 error "setstripe should have failed" || true
1305 }
1306 run_test 27l "check setstripe permissions (should return error)"
1307
1308 test_27m() {
1309         [ "$OSTCOUNT" -lt "2" ] && skip_env "$OSTCOUNT < 2 OSTs -- skipping" &&
1310                 return
1311         if [ $ORIGFREE -gt $MAXFREE ]; then
1312                 skip "$ORIGFREE > $MAXFREE skipping out-of-space test on OST0"
1313                 return
1314         fi
1315         trap simple_cleanup_common EXIT
1316         test_mkdir -p $DIR/$tdir
1317         $SETSTRIPE -i 0 -c 1 $DIR/$tdir/f27m_1
1318         dd if=/dev/zero of=$DIR/$tdir/f27m_1 bs=1024 count=$MAXFREE &&
1319                 error "dd should fill OST0"
1320         i=2
1321         while $SETSTRIPE -i 0 -c 1 $DIR/$tdir/f27m_$i; do
1322                 i=`expr $i + 1`
1323                 [ $i -gt 256 ] && break
1324         done
1325         i=`expr $i + 1`
1326         touch $DIR/$tdir/f27m_$i
1327         [ `$GETSTRIPE $DIR/$tdir/f27m_$i | grep -A 10 obdidx | awk '{print $1}'| grep -w "0"` ] &&
1328                 error "OST0 was full but new created file still use it"
1329         i=`expr $i + 1`
1330         touch $DIR/$tdir/f27m_$i
1331         [ `$GETSTRIPE $DIR/$tdir/f27m_$i | grep -A 10 obdidx | awk '{print $1}'| grep -w "0"` ] &&
1332                 error "OST0 was full but new created file still use it"
1333         simple_cleanup_common
1334 }
1335 run_test 27m "create file while OST0 was full =================="
1336
1337 sleep_maxage() {
1338         local DELAY=$(do_facet $SINGLEMDS lctl get_param -n lov.*.qos_maxage | head -n 1 | awk '{print $1 * 2}')
1339         sleep $DELAY
1340 }
1341
1342 # OSCs keep a NOSPC flag that will be reset after ~5s (qos_maxage)
1343 # if the OST isn't full anymore.
1344 reset_enospc() {
1345         local OSTIDX=${1:-""}
1346
1347         local list=$(comma_list $(osts_nodes))
1348         [ "$OSTIDX" ] && list=$(facet_host ost$((OSTIDX + 1)))
1349
1350         do_nodes $list lctl set_param fail_loc=0
1351         sync    # initiate all OST_DESTROYs from MDS to OST
1352         sleep_maxage
1353 }
1354
1355 exhaust_precreations() {
1356         local OSTIDX=$1
1357         local FAILLOC=$2
1358         local FAILIDX=${3:-$OSTIDX}
1359
1360         test_mkdir -p $DIR/$tdir
1361         local MDSIDX=$(get_mds_dir "$DIR/$tdir")
1362         echo OSTIDX=$OSTIDX MDSIDX=$MDSIDX
1363
1364         local OST=$(ostname_from_index $OSTIDX)
1365         local MDT_INDEX=$(lfs df | grep "\[MDT:$((MDSIDX - 1))\]" | awk '{print $1}' | \
1366                           sed -e 's/_UUID$//;s/^.*-//')
1367
1368         # on the mdt's osc
1369         local mdtosc_proc1=$(get_mdtosc_proc_path mds${MDSIDX} $OST)
1370         local last_id=$(do_facet mds${MDSIDX} lctl get_param -n \
1371                         osc.$mdtosc_proc1.prealloc_last_id)
1372         local next_id=$(do_facet mds${MDSIDX} lctl get_param -n \
1373                         osc.$mdtosc_proc1.prealloc_next_id)
1374
1375         local mdtosc_proc2=$(get_mdtosc_proc_path mds${MDSIDX})
1376         do_facet mds${MDSIDX} lctl get_param osc.$mdtosc_proc2.prealloc*
1377
1378         test_mkdir -p $DIR/$tdir/${OST}
1379         $SETSTRIPE -i $OSTIDX -c 1 $DIR/$tdir/${OST}
1380 #define OBD_FAIL_OST_ENOSPC              0x215
1381         do_facet ost$((OSTIDX + 1)) lctl set_param fail_val=$FAILIDX
1382         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=0x215
1383         echo "Creating to objid $last_id on ost $OST..."
1384         createmany -o $DIR/$tdir/${OST}/f $next_id $((last_id - next_id + 2))
1385         do_facet mds${MDSIDX} lctl get_param osc.$mdtosc_proc2.prealloc*
1386         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=$FAILLOC
1387         sleep_maxage
1388 }
1389
1390 exhaust_all_precreations() {
1391         local i
1392         for (( i=0; i < OSTCOUNT; i++ )) ; do
1393                 exhaust_precreations $i $1 -1
1394         done
1395 }
1396
1397 test_27n() {
1398         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1399         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1400         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1401         remote_ost_nodsh && skip "remote OST with nodsh" && return
1402
1403         reset_enospc
1404         rm -f $DIR/$tdir/$tfile
1405         exhaust_precreations 0 0x80000215
1406         $SETSTRIPE -c -1 $DIR/$tdir
1407         touch $DIR/$tdir/$tfile || error
1408         $GETSTRIPE $DIR/$tdir/$tfile
1409         reset_enospc
1410 }
1411 run_test 27n "create file with some full OSTs =================="
1412
1413 test_27o() {
1414         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1415         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1416         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1417         remote_ost_nodsh && skip "remote OST with nodsh" && return
1418
1419         reset_enospc
1420         rm -f $DIR/$tdir/$tfile
1421         exhaust_all_precreations 0x215
1422
1423         touch $DIR/$tdir/$tfile && error "able to create $DIR/$tdir/$tfile"
1424
1425         reset_enospc
1426         rm -rf $DIR/$tdir/*
1427 }
1428 run_test 27o "create file with all full OSTs (should error) ===="
1429
1430 test_27p() {
1431         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1432         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1433         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1434         remote_ost_nodsh && skip "remote OST with nodsh" && return
1435
1436         reset_enospc
1437         rm -f $DIR/$tdir/$tfile
1438         test_mkdir -p $DIR/$tdir
1439
1440         $MCREATE $DIR/$tdir/$tfile || error "mcreate failed"
1441         $TRUNCATE $DIR/$tdir/$tfile 80000000 || error "truncate failed"
1442         $CHECKSTAT -s 80000000 $DIR/$tdir/$tfile || error "checkstat failed"
1443
1444         exhaust_precreations 0 0x80000215
1445         echo foo >> $DIR/$tdir/$tfile || error "append failed"
1446         $CHECKSTAT -s 80000004 $DIR/$tdir/$tfile || error "checkstat failed"
1447         $GETSTRIPE $DIR/$tdir/$tfile
1448
1449         reset_enospc
1450 }
1451 run_test 27p "append to a truncated file with some full OSTs ==="
1452
1453 test_27q() {
1454         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1455         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1456         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1457         remote_ost_nodsh && skip "remote OST with nodsh" && return
1458
1459         reset_enospc
1460         rm -f $DIR/$tdir/$tfile
1461
1462         test_mkdir -p $DIR/$tdir
1463         $MCREATE $DIR/$tdir/$tfile || error "mcreate $DIR/$tdir/$tfile failed"
1464         $TRUNCATE $DIR/$tdir/$tfile 80000000 ||error "truncate $DIR/$tdir/$tfile failed"
1465         $CHECKSTAT -s 80000000 $DIR/$tdir/$tfile || error "checkstat failed"
1466
1467         exhaust_all_precreations 0x215
1468
1469         echo foo >> $DIR/$tdir/$tfile && error "append succeeded"
1470         $CHECKSTAT -s 80000000 $DIR/$tdir/$tfile || error "checkstat 2 failed"
1471
1472         reset_enospc
1473 }
1474 run_test 27q "append to truncated file with all OSTs full (should error) ==="
1475
1476 test_27r() {
1477         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1478         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1479         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1480         remote_ost_nodsh && skip "remote OST with nodsh" && return
1481
1482         reset_enospc
1483         rm -f $DIR/$tdir/$tfile
1484         exhaust_precreations 0 0x80000215
1485
1486         $SETSTRIPE -i 0 -c 2 $DIR/$tdir/$tfile # && error
1487
1488         reset_enospc
1489 }
1490 run_test 27r "stripe file with some full OSTs (shouldn't LBUG) ="
1491
1492 test_27s() { # bug 10725
1493         test_mkdir -p $DIR/$tdir
1494         local stripe_size=$((4096 * 1024 * 1024))       # 2^32
1495         local stripe_count=0
1496         [ $OSTCOUNT -eq 1 ] || stripe_count=2
1497         $SETSTRIPE -S $stripe_size -c $stripe_count $DIR/$tdir &&
1498                 error "stripe width >= 2^32 succeeded" || true
1499
1500 }
1501 run_test 27s "lsm_xfersize overflow (should error) (bug 10725)"
1502
1503 test_27t() { # bug 10864
1504         WDIR=`pwd`
1505         WLFS=`which lfs`
1506         cd $DIR
1507         touch $tfile
1508         $WLFS getstripe $tfile
1509         cd $WDIR
1510 }
1511 run_test 27t "check that utils parse path correctly"
1512
1513 test_27u() { # bug 4900
1514         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1515         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1516         local index
1517         local list=$(comma_list $(mdts_nodes))
1518
1519 #define OBD_FAIL_MDS_OSC_PRECREATE      0x139
1520         do_nodes $list $LCTL set_param fail_loc=0x139
1521         test_mkdir -p $DIR/$tdir
1522         rm -rf $DIR/$tdir/*
1523         createmany -o $DIR/$tdir/t- 1000
1524         do_nodes $list $LCTL set_param fail_loc=0
1525
1526         TLOG=$DIR/$tfile.getstripe
1527         $GETSTRIPE $DIR/$tdir > $TLOG
1528         OBJS=`awk -vobj=0 '($1 == 0) { obj += 1 } END { print obj;}' $TLOG`
1529         unlinkmany $DIR/$tdir/t- 1000
1530         [ $OBJS -gt 0 ] && \
1531                 error "$OBJS objects created on OST-0.  See $TLOG" || pass
1532 }
1533 run_test 27u "skip object creation on OSC w/o objects =========="
1534
1535 test_27v() { # bug 4900
1536         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1537         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1538         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1539         remote_ost_nodsh && skip "remote OST with nodsh" && return
1540
1541         exhaust_all_precreations 0x215
1542         reset_enospc
1543
1544         test_mkdir -p $DIR/$tdir
1545         $SETSTRIPE -c 1 $DIR/$tdir         # 1 stripe / file
1546
1547         touch $DIR/$tdir/$tfile
1548         #define OBD_FAIL_TGT_DELAY_PRECREATE     0x705
1549         # all except ost1
1550         for (( i=1; i < OSTCOUNT; i++ )); do
1551                 do_facet ost$i lctl set_param fail_loc=0x705
1552         done
1553         local START=`date +%s`
1554         createmany -o $DIR/$tdir/$tfile 32
1555
1556         local FINISH=`date +%s`
1557         local TIMEOUT=`lctl get_param -n timeout`
1558         local PROCESS=$((FINISH - START))
1559         [ $PROCESS -ge $((TIMEOUT / 2)) ] && \
1560                error "$FINISH - $START >= $TIMEOUT / 2"
1561         sleep $((TIMEOUT / 2 - PROCESS))
1562         reset_enospc
1563 }
1564 run_test 27v "skip object creation on slow OST ================="
1565
1566 test_27w() { # bug 10997
1567         test_mkdir -p $DIR/$tdir || error "mkdir failed"
1568         $SETSTRIPE -S 65536 $DIR/$tdir/f0 || error "setstripe failed"
1569         [ $($GETSTRIPE -S $DIR/$tdir/f0) -ne 65536 ] &&
1570                 error "stripe size $size != 65536" || true
1571         [ $($GETSTRIPE -d $DIR/$tdir | grep -c "stripe_count") -ne 1 ] &&
1572                 error "$GETSTRIPE -d $DIR/$tdir failed" || true
1573 }
1574 run_test 27w "check $SETSTRIPE -S option"
1575
1576 test_27wa() {
1577         [ "$OSTCOUNT" -lt "2" ] &&
1578                 skip_env "skipping multiple stripe count/offset test" && return
1579
1580         test_mkdir -p $DIR/$tdir || error "mkdir failed"
1581         for i in $(seq 1 $OSTCOUNT); do
1582                 offset=$((i - 1))
1583                 $SETSTRIPE -c $i -i $offset $DIR/$tdir/f$i ||
1584                         error "setstripe -c $i -i $offset failed"
1585                 count=$($GETSTRIPE -c $DIR/$tdir/f$i)
1586                 index=$($GETSTRIPE -i $DIR/$tdir/f$i)
1587                 [ $count -ne $i ] && error "stripe count $count != $i" || true
1588                 [ $index -ne $offset ] &&
1589                         error "stripe offset $index != $offset" || true
1590         done
1591 }
1592 run_test 27wa "check $SETSTRIPE -c -i options"
1593
1594 test_27x() {
1595         remote_ost_nodsh && skip "remote OST with nodsh" && return
1596         [ "$OSTCOUNT" -lt "2" ] && skip_env "$OSTCOUNT < 2 OSTs" && return
1597         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1598         OFFSET=$(($OSTCOUNT - 1))
1599         OSTIDX=0
1600         local OST=$(ostname_from_index $OSTIDX)
1601
1602         test_mkdir -p $DIR/$tdir
1603         $SETSTRIPE -c 1 $DIR/$tdir      # 1 stripe per file
1604         do_facet ost$((OSTIDX + 1)) lctl set_param -n obdfilter.$OST.degraded 1
1605         sleep_maxage
1606         createmany -o $DIR/$tdir/$tfile $OSTCOUNT
1607         for i in `seq 0 $OFFSET`; do
1608                 [ `$GETSTRIPE $DIR/$tdir/$tfile$i | grep -A 10 obdidx | awk '{print $1}' | grep -w "$OSTIDX"` ] &&
1609                 error "OST0 was degraded but new created file still use it"
1610         done
1611         do_facet ost$((OSTIDX + 1)) lctl set_param -n obdfilter.$OST.degraded 0
1612 }
1613 run_test 27x "create files while OST0 is degraded"
1614
1615 test_27y() {
1616         [ "$OSTCOUNT" -lt "2" ] && skip_env "$OSTCOUNT < 2 OSTs -- skipping" && return
1617         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1618         remote_ost_nodsh && skip "remote OST with nodsh" && return
1619         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1620
1621         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS $FSNAME-OST0000)
1622         local last_id=$(do_facet $SINGLEMDS lctl get_param -n \
1623             osc.$mdtosc.prealloc_last_id)
1624         local next_id=$(do_facet $SINGLEMDS lctl get_param -n \
1625             osc.$mdtosc.prealloc_next_id)
1626         local fcount=$((last_id - next_id))
1627         [ $fcount -eq 0 ] && skip "not enough space on OST0" && return
1628         [ $fcount -gt $OSTCOUNT ] && fcount=$OSTCOUNT
1629
1630         local MDS_OSCS=$(do_facet $SINGLEMDS lctl dl |
1631                          awk '/[oO][sS][cC].*md[ts]/ { print $4 }')
1632         local OST_DEACTIVE_IDX=-1
1633         local OSC
1634         local OSTIDX
1635         local OST
1636
1637         for OSC in $MDS_OSCS; do
1638                 OST=$(osc_to_ost $OSC)
1639                 OSTIDX=$(index_from_ostuuid $OST)
1640                 if [ $OST_DEACTIVE_IDX == -1 ]; then
1641                         OST_DEACTIVE_IDX=$OSTIDX
1642                 fi
1643                 if [ $OSTIDX != $OST_DEACTIVE_IDX ]; then
1644                         echo $OSC "is Deactivated:"
1645                         do_facet $SINGLEMDS lctl --device  %$OSC deactivate
1646                 fi
1647         done
1648
1649         OSTIDX=$(index_from_ostuuid $OST)
1650         mkdir -p $DIR/$tdir
1651         $SETSTRIPE -c 1 $DIR/$tdir      # 1 stripe / file
1652
1653         for OSC in $MDS_OSCS; do
1654                 OST=$(osc_to_ost $OSC)
1655                 OSTIDX=$(index_from_ostuuid $OST)
1656                 if [ $OSTIDX == $OST_DEACTIVE_IDX ]; then
1657                         echo $OST "is degraded:"
1658                         do_facet ost$((OSTIDX+1)) lctl set_param -n \
1659                                                 obdfilter.$OST.degraded=1
1660                 fi
1661         done
1662
1663         sleep_maxage
1664         createmany -o $DIR/$tdir/$tfile $fcount
1665
1666         for OSC in $MDS_OSCS; do
1667                 OST=$(osc_to_ost $OSC)
1668                 OSTIDX=$(index_from_ostuuid $OST)
1669                 if [ $OSTIDX == $OST_DEACTIVE_IDX ]; then
1670                         echo $OST "is recovered from degraded:"
1671                         do_facet ost$((OSTIDX+1)) lctl set_param -n \
1672                                                 obdfilter.$OST.degraded=0
1673                 else
1674                         do_facet $SINGLEMDS lctl --device %$OSC activate
1675                 fi
1676         done
1677
1678         # all osp devices get activated, hence -1 stripe count restored
1679         local stripecnt=0
1680
1681         # sleep 2*lod_qos_maxage seconds waiting for lod qos to notice osp
1682         # devices get activated.
1683         sleep_maxage
1684         $SETSTRIPE -c -1 $DIR/$tfile
1685         stripecnt=$($GETSTRIPE -c $DIR/$tfile)
1686         rm -f $DIR/$tfile
1687         [ $stripecnt -ne $OSTCOUNT ] &&
1688                 error "Of $OSTCOUNT OSTs, only $stripecnt is available"
1689         return 0
1690 }
1691 run_test 27y "create files while OST0 is degraded and the rest inactive"
1692
1693 check_seq_oid()
1694 {
1695         log "check file $1"
1696
1697         lmm_count=$($GETSTRIPE -c $1)
1698         lmm_seq=$($GETSTRIPE -v $1 | awk '/lmm_seq/ { print $2 }')
1699         lmm_oid=$($GETSTRIPE -v $1 | awk '/lmm_object_id/ { print $2 }')
1700
1701         local old_ifs="$IFS"
1702         IFS=$'[:]'
1703         fid=($($LFS path2fid $1))
1704         IFS="$old_ifs"
1705
1706         log "FID seq ${fid[1]}, oid ${fid[2]} ver ${fid[3]}"
1707         log "LOV seq $lmm_seq, oid $lmm_oid, count: $lmm_count"
1708
1709         # compare lmm_seq and lu_fid->f_seq
1710         [ $lmm_seq = ${fid[1]} ] || { error "SEQ mismatch"; return 1; }
1711         # compare lmm_object_id and lu_fid->oid
1712         [ $lmm_oid = ${fid[2]} ] || { error "OID mismatch"; return 2; }
1713
1714         # check the trusted.fid attribute of the OST objects of the file
1715         local have_obdidx=false
1716         local stripe_nr=0
1717         $GETSTRIPE $1 | while read obdidx oid hex seq; do
1718                 # skip lines up to and including "obdidx"
1719                 [ -z "$obdidx" ] && break
1720                 [ "$obdidx" = "obdidx" ] && have_obdidx=true && continue
1721                 $have_obdidx || continue
1722
1723                 local ost=$((obdidx + 1))
1724                 local dev=$(ostdevname $ost)
1725                 local oid_hex
1726
1727                 log "want: stripe:$stripe_nr ost:$obdidx oid:$oid/$hex seq:$seq"
1728
1729                 seq=$(echo $seq | sed -e "s/^0x//g")
1730                 if [ $seq == 0 ]; then
1731                         oid_hex=$(echo $oid)
1732                 else
1733                         oid_hex=$(echo $hex | sed -e "s/^0x//g")
1734                 fi
1735                 local obj_file="O/$seq/d$((oid %32))/$oid_hex"
1736
1737                 local ff
1738                 #
1739                 # Don't unmount/remount the OSTs if we don't need to do that.
1740                 # LU-2577 changes filter_fid to be smaller, so debugfs needs
1741                 # update too, until that use mount/ll_decode_filter_fid/mount.
1742                 # Re-enable when debugfs will understand new filter_fid.
1743                 #
1744                 if false && [ $(facet_fstype ost$ost) == ldiskfs ]; then
1745                         ff=$(do_facet ost$ost "$DEBUGFS -c -R 'stat $obj_file' \
1746                                 $dev 2>/dev/null" | grep "parent=")
1747                 else
1748                         stop ost$ost
1749                         mount_fstype ost$ost
1750                         ff=$(do_facet ost$ost $LL_DECODE_FILTER_FID \
1751                                 $(facet_mntpt ost$ost)/$obj_file)
1752                         unmount_fstype ost$ost
1753                         start ost$ost $dev $OST_MOUNT_OPTS
1754                 fi
1755
1756                 [ -z "$ff" ] && error "$obj_file: no filter_fid info"
1757
1758                 echo "$ff" | sed -e 's#.*objid=#got: objid=#'
1759
1760                 # /mnt/O/0/d23/23: objid=23 seq=0 parent=[0x200000400:0x1e:0x1]
1761                 # fid: objid=23 seq=0 parent=[0x200000400:0x1e:0x0] stripe=1
1762                 local ff_parent=$(echo $ff|sed -e 's/.*parent=.//')
1763                 local ff_pseq=$(echo $ff_parent | cut -d: -f1)
1764                 local ff_poid=$(echo $ff_parent | cut -d: -f2)
1765                 local ff_pstripe
1766                 if echo $ff_parent | grep -q 'stripe='; then
1767                         ff_pstripe=$(echo $ff_parent | sed -e 's/.*stripe=//')
1768                 else
1769                         #
1770                         # $LL_DECODE_FILTER_FID does not print "stripe="; look
1771                         # into f_ver in this case.  See the comment on
1772                         # ff_parent.
1773                         #
1774                         ff_pstripe=$(echo $ff_parent | cut -d: -f3 |
1775                                 sed -e 's/\]//')
1776                 fi
1777
1778                 # compare lmm_seq and filter_fid->ff_parent.f_seq
1779                 [ $ff_pseq = $lmm_seq ] ||
1780                         error "FF parent SEQ $ff_pseq != $lmm_seq"
1781                 # compare lmm_object_id and filter_fid->ff_parent.f_oid
1782                 [ $ff_poid = $lmm_oid ] ||
1783                         error "FF parent OID $ff_poid != $lmm_oid"
1784                 (($ff_pstripe == $stripe_nr)) ||
1785                         error "FF stripe $ff_pstripe != $stripe_nr"
1786
1787                 stripe_nr=$((stripe_nr + 1))
1788         done
1789 }
1790
1791 test_27z() {
1792         remote_ost_nodsh && skip "remote OST with nodsh" && return
1793         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1794         test_mkdir -p $DIR/$tdir
1795
1796         $SETSTRIPE -c 1 -i 0 -S 64k $DIR/$tdir/$tfile-1 ||
1797                 { error "setstripe -c -1 failed"; return 1; }
1798         # We need to send a write to every object to get parent FID info set.
1799         # This _should_ also work for setattr, but does not currently.
1800         # touch $DIR/$tdir/$tfile-1 ||
1801         dd if=/dev/zero of=$DIR/$tdir/$tfile-1 bs=1M count=1 ||
1802                 { error "dd $tfile-1 failed"; return 2; }
1803         $SETSTRIPE -c -1 -i $((OSTCOUNT - 1)) -S 1M $DIR/$tdir/$tfile-2 ||
1804                 { error "setstripe -c -1 failed"; return 3; }
1805         dd if=/dev/zero of=$DIR/$tdir/$tfile-2 bs=1M count=$OSTCOUNT ||
1806                 { error "dd $tfile-2 failed"; return 4; }
1807
1808         # make sure write RPCs have been sent to OSTs
1809         sync; sleep 5; sync
1810
1811         check_seq_oid $DIR/$tdir/$tfile-1 || return 5
1812         check_seq_oid $DIR/$tdir/$tfile-2 || return 6
1813 }
1814 run_test 27z "check SEQ/OID on the MDT and OST filesystems"
1815
1816 test_27A() { # b=19102
1817         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1818         local restore_size=$($GETSTRIPE -S $MOUNT)
1819         local restore_count=$($GETSTRIPE -c $MOUNT)
1820         local restore_offset=$($GETSTRIPE -i $MOUNT)
1821         $SETSTRIPE -c 0 -i -1 -S 0 $MOUNT
1822         wait_update $HOSTNAME "$GETSTRIPE -c $MOUNT | sed 's/  *//g'" "1" 20 ||
1823                 error "stripe count $($GETSTRIPE -c $MOUNT) != 1"
1824         local default_size=$($GETSTRIPE -S $MOUNT)
1825         local default_offset=$($GETSTRIPE -i $MOUNT)
1826         local dsize=$((1024 * 1024))
1827         [ $default_size -eq $dsize ] ||
1828                 error "stripe size $default_size != $dsize"
1829         [ $default_offset -eq -1 ] ||error "stripe offset $default_offset != -1"
1830         $SETSTRIPE -c $restore_count -i $restore_offset -S $restore_size $MOUNT
1831 }
1832 run_test 27A "check filesystem-wide default LOV EA values"
1833
1834 test_27B() { # LU-2523
1835         test_mkdir -p $DIR/$tdir
1836         rm -f $DIR/$tdir/f0 $DIR/$tdir/f1
1837         touch $DIR/$tdir/f0
1838         # open f1 with O_LOV_DELAY_CREATE
1839         # rename f0 onto f1
1840         # call setstripe ioctl on open file descriptor for f1
1841         # close
1842         multiop $DIR/$tdir/f1 oO_RDWR:O_CREAT:O_LOV_DELAY_CREATE:nB1c \
1843                 $DIR/$tdir/f0
1844
1845         rm -f $DIR/$tdir/f1
1846         # open f1 with O_LOV_DELAY_CREATE
1847         # unlink f1
1848         # call setstripe ioctl on open file descriptor for f1
1849         # close
1850         multiop $DIR/$tdir/f1 oO_RDWR:O_CREAT:O_LOV_DELAY_CREATE:uB1c
1851
1852         # Allow multiop to fail in imitation of NFS's busted semantics.
1853         true
1854 }
1855 run_test 27B "call setstripe on open unlinked file/rename victim"
1856
1857 test_27C() { #LU-2871
1858         [ $OSTCOUNT -lt 2 ] && skip "needs >= 2 OSTs" && return
1859
1860         declare -a ost_idx
1861         local index
1862         local found
1863         local i
1864         local j
1865
1866         test_mkdir -p $DIR/$tdir
1867         cd $DIR/$tdir
1868         for i in $(seq 0 $((OSTCOUNT - 1))); do
1869                 # set stripe across all OSTs starting from OST$i
1870                 $SETSTRIPE -i $i -c -1 $tfile$i
1871                 # get striping information
1872                 ost_idx=($($GETSTRIPE $tfile$i |
1873                          tail -n $((OSTCOUNT + 1)) | awk '{print $1}'))
1874                 echo ${ost_idx[@]}
1875
1876                 # check the layout
1877                 [ ${#ost_idx[@]} -eq $OSTCOUNT ] ||
1878                         error "${#ost_idx[@]} != $OSTCOUNT"
1879
1880                 for index in $(seq 0 $((OSTCOUNT - 1))); do
1881                         found=0
1882                         for j in $(echo ${ost_idx[@]}); do
1883                                 if [ $index -eq $j ]; then
1884                                         found=1
1885                                         break
1886                                 fi
1887                         done
1888                         [ $found = 1 ] ||
1889                                 error "Can not find $index in ${ost_idx[@]}"
1890                 done
1891         done
1892 }
1893 run_test 27C "check full striping across all OSTs"
1894
1895 # createtest also checks that device nodes are created and
1896 # then visible correctly (#2091)
1897 test_28() { # bug 2091
1898         test_mkdir $DIR/d28
1899         $CREATETEST $DIR/d28/ct || error
1900 }
1901 run_test 28 "create/mknod/mkdir with bad file types ============"
1902
1903 test_29() {
1904         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1905         cancel_lru_locks mdc
1906         test_mkdir $DIR/d29
1907         touch $DIR/d29/foo
1908         log 'first d29'
1909         ls -l $DIR/d29
1910
1911         declare -i LOCKCOUNTORIG=0
1912         for lock_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_count); do
1913                 let LOCKCOUNTORIG=$LOCKCOUNTORIG+$lock_count
1914         done
1915         [ $LOCKCOUNTORIG -eq 0 ] && echo "No mdc lock count" && return 1
1916
1917         declare -i LOCKUNUSEDCOUNTORIG=0
1918         for unused_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_unused_count); do
1919                 let LOCKUNUSEDCOUNTORIG=$LOCKUNUSEDCOUNTORIG+$unused_count
1920         done
1921
1922         log 'second d29'
1923         ls -l $DIR/d29
1924         log 'done'
1925
1926         declare -i LOCKCOUNTCURRENT=0
1927         for lock_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_count); do
1928                 let LOCKCOUNTCURRENT=$LOCKCOUNTCURRENT+$lock_count
1929         done
1930
1931         declare -i LOCKUNUSEDCOUNTCURRENT=0
1932         for unused_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_unused_count); do
1933                 let LOCKUNUSEDCOUNTCURRENT=$LOCKUNUSEDCOUNTCURRENT+$unused_count
1934         done
1935
1936         if [ "$LOCKCOUNTCURRENT" -gt "$LOCKCOUNTORIG" ]; then
1937                 lctl set_param -n ldlm.dump_namespaces ""
1938                 error "CURRENT: $LOCKCOUNTCURRENT > $LOCKCOUNTORIG"
1939                 $LCTL dk | sort -k4 -t: > $TMP/test_29.dk
1940                 log "dumped log to $TMP/test_29.dk (bug 5793)"
1941                 return 2
1942         fi
1943         if [ "$LOCKUNUSEDCOUNTCURRENT" -gt "$LOCKUNUSEDCOUNTORIG" ]; then
1944                 error "UNUSED: $LOCKUNUSEDCOUNTCURRENT > $LOCKUNUSEDCOUNTORIG"
1945                 $LCTL dk | sort -k4 -t: > $TMP/test_29.dk
1946                 log "dumped log to $TMP/test_29.dk (bug 5793)"
1947                 return 3
1948         fi
1949 }
1950 run_test 29 "IT_GETATTR regression  ============================"
1951
1952 test_30a() { # was test_30
1953         cp `which ls` $DIR || cp /bin/ls $DIR
1954         $DIR/ls / || error
1955         rm $DIR/ls
1956 }
1957 run_test 30a "execute binary from Lustre (execve) =============="
1958
1959 test_30b() {
1960         cp `which ls` $DIR || cp /bin/ls $DIR
1961         chmod go+rx $DIR/ls
1962         $RUNAS $DIR/ls / || error
1963         rm $DIR/ls
1964 }
1965 run_test 30b "execute binary from Lustre as non-root ==========="
1966
1967 test_30c() { # b=22376
1968         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1969         cp `which ls` $DIR || cp /bin/ls $DIR
1970         chmod a-rw $DIR/ls
1971         cancel_lru_locks mdc
1972         cancel_lru_locks osc
1973         $RUNAS $DIR/ls / || error
1974         rm -f $DIR/ls
1975 }
1976 run_test 30c "execute binary from Lustre without read perms ===="
1977
1978 test_31a() {
1979         $OPENUNLINK $DIR/f31 $DIR/f31 || error
1980         $CHECKSTAT -a $DIR/f31 || error
1981 }
1982 run_test 31a "open-unlink file =================================="
1983
1984 test_31b() {
1985         touch $DIR/f31 || error
1986         ln $DIR/f31 $DIR/f31b || error
1987         $MULTIOP $DIR/f31b Ouc || error
1988         $CHECKSTAT -t file $DIR/f31 || error
1989 }
1990 run_test 31b "unlink file with multiple links while open ======="
1991
1992 test_31c() {
1993         touch $DIR/f31 || error
1994         ln $DIR/f31 $DIR/f31c || error
1995         multiop_bg_pause $DIR/f31 O_uc || return 1
1996         MULTIPID=$!
1997         $MULTIOP $DIR/f31c Ouc
1998         kill -USR1 $MULTIPID
1999         wait $MULTIPID
2000 }
2001 run_test 31c "open-unlink file with multiple links ============="
2002
2003 test_31d() {
2004         opendirunlink $DIR/d31d $DIR/d31d || error
2005         $CHECKSTAT -a $DIR/d31d || error
2006 }
2007 run_test 31d "remove of open directory ========================="
2008
2009 test_31e() { # bug 2904
2010         check_kernel_version 34 || return 0
2011         openfilleddirunlink $DIR/d31e || error
2012 }
2013 run_test 31e "remove of open non-empty directory ==============="
2014
2015 test_31f() { # bug 4554
2016         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2017         set -vx
2018         test_mkdir $DIR/d31f
2019         $SETSTRIPE -S 1048576 -c 1 $DIR/d31f
2020         cp /etc/hosts $DIR/d31f
2021         ls -l $DIR/d31f
2022         $GETSTRIPE $DIR/d31f/hosts
2023         multiop_bg_pause $DIR/d31f D_c || return 1
2024         MULTIPID=$!
2025
2026         rm -rv $DIR/d31f || error "first of $DIR/d31f"
2027         test_mkdir $DIR/d31f
2028         $SETSTRIPE -S 1048576 -c 1 $DIR/d31f
2029         cp /etc/hosts $DIR/d31f
2030         ls -l $DIR/d31f
2031         $GETSTRIPE $DIR/d31f/hosts
2032         multiop_bg_pause $DIR/d31f D_c || return 1
2033         MULTIPID2=$!
2034
2035         kill -USR1 $MULTIPID || error "first opendir $MULTIPID not running"
2036         wait $MULTIPID || error "first opendir $MULTIPID failed"
2037
2038         sleep 6
2039
2040         kill -USR1 $MULTIPID2 || error "second opendir $MULTIPID not running"
2041         wait $MULTIPID2 || error "second opendir $MULTIPID2 failed"
2042         set +vx
2043 }
2044 run_test 31f "remove of open directory with open-unlink file ==="
2045
2046 test_31g() {
2047         echo "-- cross directory link --"
2048         test_mkdir $DIR/d31ga
2049         test_mkdir $DIR/d31gb
2050         touch $DIR/d31ga/f
2051         ln $DIR/d31ga/f $DIR/d31gb/g
2052         $CHECKSTAT -t file $DIR/d31ga/f || error "source"
2053         [ `stat -c%h $DIR/d31ga/f` == '2' ] || error "source nlink"
2054         $CHECKSTAT -t file $DIR/d31gb/g || error "target"
2055         [ `stat -c%h $DIR/d31gb/g` == '2' ] || error "target nlink"
2056 }
2057 run_test 31g "cross directory link==============="
2058
2059 test_31h() {
2060         echo "-- cross directory link --"
2061         test_mkdir $DIR/d31h
2062         test_mkdir $DIR/d31h/dir
2063         touch $DIR/d31h/f
2064         ln $DIR/d31h/f $DIR/d31h/dir/g
2065         $CHECKSTAT -t file $DIR/d31h/f || error "source"
2066         [ `stat -c%h $DIR/d31h/f` == '2' ] || error "source nlink"
2067         $CHECKSTAT -t file $DIR/d31h/dir/g || error "target"
2068         [ `stat -c%h $DIR/d31h/dir/g` == '2' ] || error "target nlink"
2069 }
2070 run_test 31h "cross directory link under child==============="
2071
2072 test_31i() {
2073         echo "-- cross directory link --"
2074         test_mkdir $DIR/d31i
2075         test_mkdir $DIR/d31i/dir
2076         touch $DIR/d31i/dir/f
2077         ln $DIR/d31i/dir/f $DIR/d31i/g
2078         $CHECKSTAT -t file $DIR/d31i/dir/f || error "source"
2079         [ `stat -c%h $DIR/d31i/dir/f` == '2' ] || error "source nlink"
2080         $CHECKSTAT -t file $DIR/d31i/g || error "target"
2081         [ `stat -c%h $DIR/d31i/g` == '2' ] || error "target nlink"
2082 }
2083 run_test 31i "cross directory link under parent==============="
2084
2085
2086 test_31j() {
2087         test_mkdir $DIR/d31j
2088         test_mkdir $DIR/d31j/dir1
2089         ln $DIR/d31j/dir1 $DIR/d31j/dir2 && error "ln for dir"
2090         link $DIR/d31j/dir1 $DIR/d31j/dir3 && error "link for dir"
2091         mlink $DIR/d31j/dir1 $DIR/d31j/dir4 && error "mlink for dir"
2092         mlink $DIR/d31j/dir1 $DIR/d31j/dir1 && error "mlink to the same dir"
2093         return 0
2094 }
2095 run_test 31j "link for directory==============="
2096
2097
2098 test_31k() {
2099         test_mkdir $DIR/d31k
2100         touch $DIR/d31k/s
2101         touch $DIR/d31k/exist
2102         mlink $DIR/d31k/s $DIR/d31k/t || error "mlink"
2103         mlink $DIR/d31k/s $DIR/d31k/exist && error "mlink to exist file"
2104         mlink $DIR/d31k/s $DIR/d31k/s && error "mlink to the same file"
2105         mlink $DIR/d31k/s $DIR/d31k && error "mlink to parent dir"
2106         mlink $DIR/d31k $DIR/d31k/s && error "mlink parent dir to target"
2107         mlink $DIR/d31k/not-exist $DIR/d31k/foo && error "mlink non-existing to new"
2108         mlink $DIR/d31k/not-exist $DIR/d31k/s && error "mlink non-existing to exist"
2109         return 0
2110 }
2111 run_test 31k "link to file: the same, non-existing, dir==============="
2112
2113 test_31m() {
2114         test_mkdir $DIR/d31m
2115         touch $DIR/d31m/s
2116         test_mkdir $DIR/d31m2
2117         touch $DIR/d31m2/exist
2118         mlink $DIR/d31m/s $DIR/d31m2/t || error "mlink"
2119         mlink $DIR/d31m/s $DIR/d31m2/exist && error "mlink to exist file"
2120         mlink $DIR/d31m/s $DIR/d31m2 && error "mlink to parent dir"
2121         mlink $DIR/d31m2 $DIR/d31m/s && error "mlink parent dir to target"
2122         mlink $DIR/d31m/not-exist $DIR/d31m2/foo && error "mlink non-existing to new"
2123         mlink $DIR/d31m/not-exist $DIR/d31m2/s && error "mlink non-existing to exist"
2124         return 0
2125 }
2126 run_test 31m "link to file: the same, non-existing, dir==============="
2127
2128 test_31n() {
2129         touch $DIR/$tfile || error "cannot create '$DIR/$tfile'"
2130         nlink=$(stat --format=%h $DIR/$tfile)
2131         [ ${nlink:--1} -eq 1 ] || error "nlink is $nlink, expected 1"
2132         local fd=$(free_fd)
2133         local cmd="exec $fd<$DIR/$tfile"
2134         eval $cmd
2135         cmd="exec $fd<&-"
2136         trap "eval $cmd" EXIT
2137         nlink=$(stat --dereference --format=%h /proc/self/fd/$fd)
2138         [ ${nlink:--1} -eq 1 ] || error "nlink is $nlink, expected 1"
2139         rm $DIR/$tfile || error "cannot remove '$DIR/$tfile'"
2140         nlink=$(stat --dereference --format=%h /proc/self/fd/$fd)
2141         [ ${nlink:--1} -eq 0 ] || error "nlink is $nlink, expected 0"
2142         eval $cmd
2143 }
2144 run_test 31n "check link count of unlinked file"
2145
2146 link_one() {
2147         local TEMPNAME=$(mktemp $1_XXXXXX)
2148         mlink $TEMPNAME $1 2> /dev/null &&
2149                 echo "$BASHPID: link $TEMPNAME to $1 succeeded"
2150         munlink $TEMPNAME
2151 }
2152
2153 test_31o() { # LU-2901
2154         mkdir -p $DIR/$tdir
2155         for LOOP in $(seq 100); do
2156                 rm -f $DIR/$tdir/$tfile*
2157                 for THREAD in $(seq 8); do
2158                         link_one $DIR/$tdir/$tfile.$LOOP &
2159                 done
2160                 wait
2161                 local LINKS=$(ls -1 $DIR/$tdir | grep -c $tfile.$LOOP)
2162                 [ $LINKS -gt 1 ] && ls $DIR/$tdir &&
2163                         error "$LINKS duplicate links to $tfile.$LOOP" &&
2164                         break || true
2165         done
2166 }
2167 run_test 31o "duplicate hard links with same filename"
2168
2169 cleanup_test32_mount() {
2170         trap 0
2171         $UMOUNT -d $DIR/$tdir/ext2-mountpoint
2172 }
2173
2174 test_32a() {
2175         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2176         echo "== more mountpoints and symlinks ================="
2177         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2178         trap cleanup_test32_mount EXIT
2179         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2180         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2181         $CHECKSTAT -t dir $DIR/$tdir/ext2-mountpoint/.. || error
2182         cleanup_test32_mount
2183 }
2184 run_test 32a "stat d32a/ext2-mountpoint/.. ====================="
2185
2186 test_32b() {
2187         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2188         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2189         trap cleanup_test32_mount EXIT
2190         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2191         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2192         ls -al $DIR/$tdir/ext2-mountpoint/.. || error
2193         cleanup_test32_mount
2194 }
2195 run_test 32b "open d32b/ext2-mountpoint/.. ====================="
2196
2197 test_32c() {
2198         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2199         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2200         trap cleanup_test32_mount EXIT
2201         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2202         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2203         test_mkdir -p $DIR/$tdir/d2/test_dir
2204         $CHECKSTAT -t dir $DIR/$tdir/ext2-mountpoint/../d2/test_dir || error
2205         cleanup_test32_mount
2206 }
2207 run_test 32c "stat d32c/ext2-mountpoint/../d2/test_dir ========="
2208
2209 test_32d() {
2210         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2211         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2212         trap cleanup_test32_mount EXIT
2213         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2214         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2215         test_mkdir -p $DIR/$tdir/d2/test_dir
2216         ls -al $DIR/$tdir/ext2-mountpoint/../d2/test_dir || error
2217         cleanup_test32_mount
2218 }
2219 run_test 32d "open d32d/ext2-mountpoint/../d2/test_dir ========="
2220
2221 test_32e() {
2222         [ -e $DIR/d32e ] && rm -fr $DIR/d32e
2223         test_mkdir -p $DIR/d32e/tmp
2224         TMP_DIR=$DIR/d32e/tmp
2225         ln -s $DIR/d32e $TMP_DIR/symlink11
2226         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
2227         $CHECKSTAT -t link $DIR/d32e/tmp/symlink11 || error
2228         $CHECKSTAT -t link $DIR/d32e/symlink01 || error
2229 }
2230 run_test 32e "stat d32e/symlink->tmp/symlink->lustre-subdir ===="
2231
2232 test_32f() {
2233         [ -e $DIR/d32f ] && rm -fr $DIR/d32f
2234         test_mkdir -p $DIR/d32f/tmp
2235         TMP_DIR=$DIR/d32f/tmp
2236         ln -s $DIR/d32f $TMP_DIR/symlink11
2237         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
2238         ls $DIR/d32f/tmp/symlink11  || error
2239         ls $DIR/d32f/symlink01 || error
2240 }
2241 run_test 32f "open d32f/symlink->tmp/symlink->lustre-subdir ===="
2242
2243 test_32g() {
2244         TMP_DIR=$DIR/$tdir/tmp
2245         test_mkdir -p $DIR/$tdir/tmp
2246         test_mkdir $DIR/${tdir}2
2247         ln -s $DIR/${tdir}2 $TMP_DIR/symlink12
2248         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
2249         $CHECKSTAT -t link $TMP_DIR/symlink12 || error
2250         $CHECKSTAT -t link $DIR/$tdir/symlink02 || error
2251         $CHECKSTAT -t dir -f $TMP_DIR/symlink12 || error
2252         $CHECKSTAT -t dir -f $DIR/$tdir/symlink02 || error
2253 }
2254 run_test 32g "stat d32g/symlink->tmp/symlink->lustre-subdir/${tdir}2"
2255
2256 test_32h() {
2257         rm -fr $DIR/$tdir $DIR/${tdir}2
2258         TMP_DIR=$DIR/$tdir/tmp
2259         test_mkdir -p $DIR/$tdir/tmp
2260         test_mkdir $DIR/${tdir}2
2261         ln -s $DIR/${tdir}2 $TMP_DIR/symlink12
2262         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
2263         ls $TMP_DIR/symlink12 || error
2264         ls $DIR/$tdir/symlink02  || error
2265 }
2266 run_test 32h "open d32h/symlink->tmp/symlink->lustre-subdir/${tdir}2"
2267
2268 test_32i() {
2269         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2270         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2271         trap cleanup_test32_mount EXIT
2272         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2273         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2274         touch $DIR/$tdir/test_file
2275         $CHECKSTAT -t file $DIR/$tdir/ext2-mountpoint/../test_file || error
2276         cleanup_test32_mount
2277 }
2278 run_test 32i "stat d32i/ext2-mountpoint/../test_file ==========="
2279
2280 test_32j() {
2281         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2282         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2283         trap cleanup_test32_mount EXIT
2284         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2285         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2286         touch $DIR/$tdir/test_file
2287         cat $DIR/$tdir/ext2-mountpoint/../test_file || error
2288         cleanup_test32_mount
2289 }
2290 run_test 32j "open d32j/ext2-mountpoint/../test_file ==========="
2291
2292 test_32k() {
2293         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2294         rm -fr $DIR/$tdir
2295         trap cleanup_test32_mount EXIT
2296         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2297         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint
2298         test_mkdir -p $DIR/$tdir/d2
2299         touch $DIR/$tdir/d2/test_file || error
2300         $CHECKSTAT -t file $DIR/$tdir/ext2-mountpoint/../d2/test_file || error
2301         cleanup_test32_mount
2302 }
2303 run_test 32k "stat d32k/ext2-mountpoint/../d2/test_file ========"
2304
2305 test_32l() {
2306         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2307         rm -fr $DIR/$tdir
2308         trap cleanup_test32_mount EXIT
2309         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2310         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2311         test_mkdir -p $DIR/$tdir/d2
2312         touch $DIR/$tdir/d2/test_file
2313         cat  $DIR/$tdir/ext2-mountpoint/../d2/test_file || error
2314         cleanup_test32_mount
2315 }
2316 run_test 32l "open d32l/ext2-mountpoint/../d2/test_file ========"
2317
2318 test_32m() {
2319         rm -fr $DIR/d32m
2320         test_mkdir -p $DIR/d32m/tmp
2321         TMP_DIR=$DIR/d32m/tmp
2322         ln -s $DIR $TMP_DIR/symlink11
2323         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
2324         $CHECKSTAT -t link $DIR/d32m/tmp/symlink11 || error
2325         $CHECKSTAT -t link $DIR/d32m/symlink01 || error
2326 }
2327 run_test 32m "stat d32m/symlink->tmp/symlink->lustre-root ======"
2328
2329 test_32n() {
2330         rm -fr $DIR/d32n
2331         test_mkdir -p $DIR/d32n/tmp
2332         TMP_DIR=$DIR/d32n/tmp
2333         ln -s $DIR $TMP_DIR/symlink11
2334         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
2335         ls -l $DIR/d32n/tmp/symlink11  || error
2336         ls -l $DIR/d32n/symlink01 || error
2337 }
2338 run_test 32n "open d32n/symlink->tmp/symlink->lustre-root ======"
2339
2340 test_32o() {
2341         rm -fr $DIR/d32o $DIR/$tfile
2342         touch $DIR/$tfile
2343         test_mkdir -p $DIR/d32o/tmp
2344         TMP_DIR=$DIR/d32o/tmp
2345         ln -s $DIR/$tfile $TMP_DIR/symlink12
2346         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
2347         $CHECKSTAT -t link $DIR/d32o/tmp/symlink12 || error
2348         $CHECKSTAT -t link $DIR/d32o/symlink02 || error
2349         $CHECKSTAT -t file -f $DIR/d32o/tmp/symlink12 || error
2350         $CHECKSTAT -t file -f $DIR/d32o/symlink02 || error
2351 }
2352 run_test 32o "stat d32o/symlink->tmp/symlink->lustre-root/$tfile"
2353
2354 test_32p() {
2355     log 32p_1
2356         rm -fr $DIR/d32p
2357     log 32p_2
2358         rm -f $DIR/$tfile
2359     log 32p_3
2360         touch $DIR/$tfile
2361     log 32p_4
2362         test_mkdir -p $DIR/d32p/tmp
2363     log 32p_5
2364         TMP_DIR=$DIR/d32p/tmp
2365     log 32p_6
2366         ln -s $DIR/$tfile $TMP_DIR/symlink12
2367     log 32p_7
2368         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
2369     log 32p_8
2370         cat $DIR/d32p/tmp/symlink12 || error
2371     log 32p_9
2372         cat $DIR/d32p/symlink02 || error
2373     log 32p_10
2374 }
2375 run_test 32p "open d32p/symlink->tmp/symlink->lustre-root/$tfile"
2376
2377 cleanup_testdir_mount() {
2378         trap 0
2379         $UMOUNT -d $DIR/$tdir
2380 }
2381
2382 test_32q() {
2383         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2384         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2385         trap cleanup_testdir_mount EXIT
2386         test_mkdir -p $DIR/$tdir
2387         touch $DIR/$tdir/under_the_mount
2388         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir
2389         ls $DIR/$tdir | grep "\<under_the_mount\>" && error
2390         cleanup_testdir_mount
2391 }
2392 run_test 32q "stat follows mountpoints in Lustre (should return error)"
2393
2394 test_32r() {
2395         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2396         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2397         trap cleanup_testdir_mount EXIT
2398         test_mkdir -p $DIR/$tdir
2399         touch $DIR/$tdir/under_the_mount
2400         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir
2401         ls $DIR/$tdir | grep -q under_the_mount && error || true
2402         cleanup_testdir_mount
2403 }
2404 run_test 32r "opendir follows mountpoints in Lustre (should return error)"
2405
2406 test_33aa() {
2407         rm -f $DIR/$tfile
2408         touch $DIR/$tfile
2409         chmod 444 $DIR/$tfile
2410         chown $RUNAS_ID $DIR/$tfile
2411         log 33_1
2412         $RUNAS $OPENFILE -f O_RDWR $DIR/$tfile && error || true
2413         log 33_2
2414 }
2415 run_test 33aa "write file with mode 444 (should return error) ===="
2416
2417 test_33a() {
2418         rm -fr $DIR/d33
2419         test_mkdir -p $DIR/d33
2420         chown $RUNAS_ID $DIR/d33
2421         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/d33/f33|| error "create"
2422         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/d33/f33 && \
2423                 error "open RDWR" || true
2424 }
2425 run_test 33a "test open file(mode=0444) with O_RDWR (should return error)"
2426
2427 test_33b() {
2428         rm -fr $DIR/d33
2429         test_mkdir -p $DIR/d33
2430         chown $RUNAS_ID $DIR/d33
2431         $RUNAS $OPENFILE -f 1286739555 $DIR/d33/f33 && error "create" || true
2432 }
2433 run_test 33b "test open file with malformed flags (No panic and return error)"
2434
2435 test_33c() {
2436         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2437         local ostnum
2438         local ostname
2439         local write_bytes
2440         local all_zeros
2441
2442         remote_ost_nodsh && skip "remote OST with nodsh" && return
2443         all_zeros=:
2444         rm -fr $DIR/d33
2445         test_mkdir -p $DIR/d33
2446         # Read: 0, Write: 4, create/destroy: 2/0, stat: 1, punch: 0
2447
2448         sync
2449         for ostnum in $(seq $OSTCOUNT); do
2450                 # test-framework's OST numbering is one-based, while Lustre's
2451                 # is zero-based
2452                 ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
2453                 # Parsing llobdstat's output sucks; we could grep the /proc
2454                 # path, but that's likely to not be as portable as using the
2455                 # llobdstat utility.  So we parse lctl output instead.
2456                 write_bytes=$(do_facet ost$ostnum lctl get_param -n \
2457                         obdfilter/$ostname/stats |
2458                         awk '/^write_bytes/ {print $7}' )
2459                 echo "baseline_write_bytes@$OSTnum/$ostname=$write_bytes"
2460                 if (( ${write_bytes:-0} > 0 ))
2461                 then
2462                         all_zeros=false
2463                         break;
2464                 fi
2465         done
2466
2467         $all_zeros || return 0
2468
2469         # Write four bytes
2470         echo foo > $DIR/d33/bar
2471         # Really write them
2472         sync
2473
2474         # Total up write_bytes after writing.  We'd better find non-zeros.
2475         for ostnum in $(seq $OSTCOUNT); do
2476                 ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
2477                 write_bytes=$(do_facet ost$ostnum lctl get_param -n \
2478                         obdfilter/$ostname/stats |
2479                         awk '/^write_bytes/ {print $7}' )
2480                 echo "write_bytes@$OSTnum/$ostname=$write_bytes"
2481                 if (( ${write_bytes:-0} > 0 ))
2482                 then
2483                         all_zeros=false
2484                         break;
2485                 fi
2486         done
2487
2488         if $all_zeros
2489         then
2490                 for ostnum in $(seq $OSTCOUNT); do
2491                         ostname=$(printf "$FSNAME-OST%.4x" $((ostnum - 1)))
2492                         echo "Check that write_bytes is present in obdfilter/*/stats:"
2493                         do_facet ost$ostnum lctl get_param -n \
2494                                 obdfilter/$ostname/stats
2495                 done
2496                 error "OST not keeping write_bytes stats (b22312)"
2497         fi
2498 }
2499 run_test 33c "test llobdstat and write_bytes"
2500
2501 test_33d() {
2502         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2503         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2504         local MDTIDX=1
2505         local remote_dir=$DIR/$tdir/remote_dir
2506
2507         mkdir -p $DIR/$tdir
2508         $LFS mkdir -i $MDTIDX $remote_dir ||
2509                 error "create remote directory failed"
2510
2511         touch $remote_dir/$tfile
2512         chmod 444 $remote_dir/$tfile
2513         chown $RUNAS_ID $remote_dir/$tfile
2514
2515         $RUNAS $OPENFILE -f O_RDWR $DIR/$tfile && error || true
2516
2517         chown $RUNAS_ID $remote_dir
2518         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $remote_dir/f33 ||
2519                                         error "create" || true
2520         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $remote_dir/f33 &&
2521                                     error "open RDWR" || true
2522         $RUNAS $OPENFILE -f 1286739555 $remote_dir/f33 &&
2523                                     error "create" || true
2524 }
2525 run_test 33d "openfile with 444 modes and malformed flags under remote dir"
2526
2527 TEST_34_SIZE=${TEST_34_SIZE:-2000000000000}
2528 test_34a() {
2529         rm -f $DIR/f34
2530         $MCREATE $DIR/f34 || error
2531         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" || error
2532         $TRUNCATE $DIR/f34 $TEST_34_SIZE || error
2533         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" || error
2534         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
2535 }
2536 run_test 34a "truncate file that has not been opened ==========="
2537
2538 test_34b() {
2539         [ ! -f $DIR/f34 ] && test_34a
2540         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
2541         $OPENFILE -f O_RDONLY $DIR/f34
2542         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" || error
2543         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
2544 }
2545 run_test 34b "O_RDONLY opening file doesn't create objects ====="
2546
2547 test_34c() {
2548         [ ! -f $DIR/f34 ] && test_34a
2549         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
2550         $OPENFILE -f O_RDWR $DIR/f34
2551         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" && error
2552         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
2553 }
2554 run_test 34c "O_RDWR opening file-with-size works =============="
2555
2556 test_34d() {
2557         [ ! -f $DIR/f34 ] && test_34a
2558         dd if=/dev/zero of=$DIR/f34 conv=notrunc bs=4k count=1 || error
2559         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
2560         rm $DIR/f34
2561 }
2562 run_test 34d "write to sparse file ============================="
2563
2564 test_34e() {
2565         rm -f $DIR/f34e
2566         $MCREATE $DIR/f34e || error
2567         $TRUNCATE $DIR/f34e 1000 || error
2568         $CHECKSTAT -s 1000 $DIR/f34e || error
2569         $OPENFILE -f O_RDWR $DIR/f34e
2570         $CHECKSTAT -s 1000 $DIR/f34e || error
2571 }
2572 run_test 34e "create objects, some with size and some without =="
2573
2574 test_34f() { # bug 6242, 6243
2575         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2576         SIZE34F=48000
2577         rm -f $DIR/f34f
2578         $MCREATE $DIR/f34f || error
2579         $TRUNCATE $DIR/f34f $SIZE34F || error "truncating $DIR/f3f to $SIZE34F"
2580         dd if=$DIR/f34f of=$TMP/f34f
2581         $CHECKSTAT -s $SIZE34F $TMP/f34f || error "$TMP/f34f not $SIZE34F bytes"
2582         dd if=/dev/zero of=$TMP/f34fzero bs=$SIZE34F count=1
2583         cmp $DIR/f34f $TMP/f34fzero || error "$DIR/f34f not all zero"
2584         cmp $TMP/f34f $TMP/f34fzero || error "$TMP/f34f not all zero"
2585         rm $TMP/f34f $TMP/f34fzero $DIR/f34f
2586 }
2587 run_test 34f "read from a file with no objects until EOF ======="
2588
2589 test_34g() {
2590         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2591         dd if=/dev/zero of=$DIR/$tfile bs=1 count=100 seek=$TEST_34_SIZE || error
2592         $TRUNCATE $DIR/$tfile $((TEST_34_SIZE / 2))|| error
2593         $CHECKSTAT -s $((TEST_34_SIZE / 2)) $DIR/$tfile || error "truncate failed"
2594         cancel_lru_locks osc
2595         $CHECKSTAT -s $((TEST_34_SIZE / 2)) $DIR/$tfile || \
2596                 error "wrong size after lock cancel"
2597
2598         $TRUNCATE $DIR/$tfile $TEST_34_SIZE || error
2599         $CHECKSTAT -s $TEST_34_SIZE $DIR/$tfile || \
2600                 error "expanding truncate failed"
2601         cancel_lru_locks osc
2602         $CHECKSTAT -s $TEST_34_SIZE $DIR/$tfile || \
2603                 error "wrong expanded size after lock cancel"
2604 }
2605 run_test 34g "truncate long file ==============================="
2606
2607 test_34h() {
2608         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2609         local gid=10
2610         local sz=1000
2611
2612         dd if=/dev/zero of=$DIR/$tfile bs=1M count=10 || error
2613         sync # Flush the cache so that multiop below does not block on cache
2614              # flush when getting the group lock
2615         $MULTIOP $DIR/$tfile OG${gid}T${sz}g${gid}c &
2616         MULTIPID=$!
2617
2618         # Since just timed wait is not good enough, let's do a sync write
2619         # that way we are sure enough time for a roundtrip + processing
2620         # passed + 2 seconds of extra margin.
2621         dd if=/dev/zero of=$DIR/${tfile}-1 bs=4096 oflag=direct count=1
2622         rm $DIR/${tfile}-1
2623         sleep 2
2624
2625         if [[ `ps h -o comm -p $MULTIPID` == "multiop" ]]; then
2626                 error "Multiop blocked on ftruncate, pid=$MULTIPID"
2627                 kill -9 $MULTIPID
2628         fi
2629         wait $MULTIPID
2630         local nsz=`stat -c %s $DIR/$tfile`
2631         [[ $nsz == $sz ]] || error "New size wrong $nsz != $sz"
2632 }
2633 run_test 34h "ftruncate file under grouplock should not block"
2634
2635 test_35a() {
2636         cp /bin/sh $DIR/f35a
2637         chmod 444 $DIR/f35a
2638         chown $RUNAS_ID $DIR/f35a
2639         $RUNAS $DIR/f35a && error || true
2640         rm $DIR/f35a
2641 }
2642 run_test 35a "exec file with mode 444 (should return and not leak) ====="
2643
2644 test_36a() {
2645         rm -f $DIR/f36
2646         utime $DIR/f36 || error
2647 }
2648 run_test 36a "MDS utime check (mknod, utime) ==================="
2649
2650 test_36b() {
2651         echo "" > $DIR/f36
2652         utime $DIR/f36 || error
2653 }
2654 run_test 36b "OST utime check (open, utime) ===================="
2655
2656 test_36c() {
2657         rm -f $DIR/d36/f36
2658         test_mkdir $DIR/d36
2659         chown $RUNAS_ID $DIR/d36
2660         $RUNAS utime $DIR/d36/f36 || error
2661 }
2662 run_test 36c "non-root MDS utime check (mknod, utime) =========="
2663
2664 test_36d() {
2665         [ ! -d $DIR/d36 ] && test_36c
2666         echo "" > $DIR/d36/f36
2667         $RUNAS utime $DIR/d36/f36 || error
2668 }
2669 run_test 36d "non-root OST utime check (open, utime) ==========="
2670
2671 test_36e() {
2672         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
2673         test_mkdir -p $DIR/$tdir
2674         touch $DIR/$tdir/$tfile
2675         $RUNAS utime $DIR/$tdir/$tfile && \
2676                 error "utime worked, expected failure" || true
2677 }
2678 run_test 36e "utime on non-owned file (should return error) ===="
2679
2680 subr_36fh() {
2681         local fl="$1"
2682         local LANG_SAVE=$LANG
2683         local LC_LANG_SAVE=$LC_LANG
2684         export LANG=C LC_LANG=C # for date language
2685
2686         DATESTR="Dec 20  2000"
2687         test_mkdir -p $DIR/$tdir
2688         lctl set_param fail_loc=$fl
2689         date; date +%s
2690         cp /etc/hosts $DIR/$tdir/$tfile
2691         sync & # write RPC generated with "current" inode timestamp, but delayed
2692         sleep 1
2693         touch --date="$DATESTR" $DIR/$tdir/$tfile # setattr timestamp in past
2694         LS_BEFORE="`ls -l $DIR/$tdir/$tfile`" # old timestamp from client cache
2695         cancel_lru_locks osc
2696         LS_AFTER="`ls -l $DIR/$tdir/$tfile`"  # timestamp from OST object
2697         date; date +%s
2698         [ "$LS_BEFORE" != "$LS_AFTER" ] && \
2699                 echo "BEFORE: $LS_BEFORE" && \
2700                 echo "AFTER : $LS_AFTER" && \
2701                 echo "WANT  : $DATESTR" && \
2702                 error "$DIR/$tdir/$tfile timestamps changed" || true
2703
2704         export LANG=$LANG_SAVE LC_LANG=$LC_LANG_SAVE
2705 }
2706
2707 test_36f() {
2708         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2709         #define OBD_FAIL_OST_BRW_PAUSE_BULK 0x214
2710         subr_36fh "0x80000214"
2711 }
2712 run_test 36f "utime on file racing with OST BRW write =========="
2713
2714 test_36g() {
2715         remote_ost_nodsh && skip "remote OST with nodsh" && return
2716         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2717         local fmd_max_age
2718         local fmd_before
2719         local fmd_after
2720
2721         test_mkdir -p $DIR/$tdir
2722         fmd_max_age=$(do_facet ost1 \
2723                 "lctl get_param -n obdfilter.*.client_cache_seconds 2> /dev/null | \
2724                 head -n 1")
2725
2726         fmd_before=$(do_facet ost1 \
2727                 "awk '/ll_fmd_cache/ {print \\\$2}' /proc/slabinfo")
2728         touch $DIR/$tdir/$tfile
2729         sleep $((fmd_max_age + 12))
2730         fmd_after=$(do_facet ost1 \
2731                 "awk '/ll_fmd_cache/ {print \\\$2}' /proc/slabinfo")
2732
2733         echo "fmd_before: $fmd_before"
2734         echo "fmd_after: $fmd_after"
2735         [ "$fmd_after" -gt "$fmd_before" ] && \
2736                 echo "AFTER: $fmd_after > BEFORE: $fmd_before" && \
2737                 error "fmd didn't expire after ping" || true
2738 }
2739 run_test 36g "filter mod data cache expiry ====================="
2740
2741 test_36h() {
2742         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2743         #define OBD_FAIL_OST_BRW_PAUSE_BULK2 0x227
2744         subr_36fh "0x80000227"
2745 }
2746 run_test 36h "utime on file racing with OST BRW write =========="
2747
2748 # test_37 - duplicate with tests 32q 32r
2749
2750 test_38() {
2751         local file=$DIR/$tfile
2752         touch $file
2753         openfile -f O_DIRECTORY $file
2754         local RC=$?
2755         local ENOTDIR=20
2756         [ $RC -eq 0 ] && error "opened file $file with O_DIRECTORY" || true
2757         [ $RC -eq $ENOTDIR ] || error "error $RC should be ENOTDIR ($ENOTDIR)"
2758 }
2759 run_test 38 "open a regular file with O_DIRECTORY should return -ENOTDIR ==="
2760
2761 test_39() {
2762         touch $DIR/$tfile
2763         touch $DIR/${tfile}2
2764 #       ls -l  $DIR/$tfile $DIR/${tfile}2
2765 #       ls -lu  $DIR/$tfile $DIR/${tfile}2
2766 #       ls -lc  $DIR/$tfile $DIR/${tfile}2
2767         sleep 2
2768         $OPENFILE -f O_CREAT:O_TRUNC:O_WRONLY $DIR/${tfile}2
2769         if [ ! $DIR/${tfile}2 -nt $DIR/$tfile ]; then
2770                 echo "mtime"
2771                 ls -l --full-time $DIR/$tfile $DIR/${tfile}2
2772                 echo "atime"
2773                 ls -lu --full-time $DIR/$tfile $DIR/${tfile}2
2774                 echo "ctime"
2775                 ls -lc --full-time $DIR/$tfile $DIR/${tfile}2
2776                 error "O_TRUNC didn't change timestamps"
2777         fi
2778 }
2779 run_test 39 "mtime changed on create ==========================="
2780
2781 test_39b() {
2782         test_mkdir -p $DIR/$tdir
2783         cp -p /etc/passwd $DIR/$tdir/fopen
2784         cp -p /etc/passwd $DIR/$tdir/flink
2785         cp -p /etc/passwd $DIR/$tdir/funlink
2786         cp -p /etc/passwd $DIR/$tdir/frename
2787         ln $DIR/$tdir/funlink $DIR/$tdir/funlink2
2788
2789         sleep 1
2790         echo "aaaaaa" >> $DIR/$tdir/fopen
2791         echo "aaaaaa" >> $DIR/$tdir/flink
2792         echo "aaaaaa" >> $DIR/$tdir/funlink
2793         echo "aaaaaa" >> $DIR/$tdir/frename
2794
2795         local open_new=`stat -c %Y $DIR/$tdir/fopen`
2796         local link_new=`stat -c %Y $DIR/$tdir/flink`
2797         local unlink_new=`stat -c %Y $DIR/$tdir/funlink`
2798         local rename_new=`stat -c %Y $DIR/$tdir/frename`
2799
2800         cat $DIR/$tdir/fopen > /dev/null
2801         ln $DIR/$tdir/flink $DIR/$tdir/flink2
2802         rm -f $DIR/$tdir/funlink2
2803         mv -f $DIR/$tdir/frename $DIR/$tdir/frename2
2804
2805         for (( i=0; i < 2; i++ )) ; do
2806                 local open_new2=`stat -c %Y $DIR/$tdir/fopen`
2807                 local link_new2=`stat -c %Y $DIR/$tdir/flink`
2808                 local unlink_new2=`stat -c %Y $DIR/$tdir/funlink`
2809                 local rename_new2=`stat -c %Y $DIR/$tdir/frename2`
2810
2811                 [ $open_new2 -eq $open_new ] || error "open file reverses mtime"
2812                 [ $link_new2 -eq $link_new ] || error "link file reverses mtime"
2813                 [ $unlink_new2 -eq $unlink_new ] || error "unlink file reverses mtime"
2814                 [ $rename_new2 -eq $rename_new ] || error "rename file reverses mtime"
2815
2816                 cancel_lru_locks osc
2817                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2818         done
2819 }
2820 run_test 39b "mtime change on open, link, unlink, rename  ======"
2821
2822 # this should be set to past
2823 TEST_39_MTIME=`date -d "1 year ago" +%s`
2824
2825 # bug 11063
2826 test_39c() {
2827         touch $DIR1/$tfile
2828         sleep 2
2829         local mtime0=`stat -c %Y $DIR1/$tfile`
2830
2831         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
2832         local mtime1=`stat -c %Y $DIR1/$tfile`
2833         [ "$mtime1" = $TEST_39_MTIME ] || \
2834                 error "mtime is not set to past: $mtime1, should be $TEST_39_MTIME"
2835
2836         local d1=`date +%s`
2837         echo hello >> $DIR1/$tfile
2838         local d2=`date +%s`
2839         local mtime2=`stat -c %Y $DIR1/$tfile`
2840         [ "$mtime2" -ge "$d1" ] && [ "$mtime2" -le "$d2" ] || \
2841                 error "mtime is not updated on write: $d1 <= $mtime2 <= $d2"
2842
2843         mv $DIR1/$tfile $DIR1/$tfile-1
2844
2845         for (( i=0; i < 2; i++ )) ; do
2846                 local mtime3=`stat -c %Y $DIR1/$tfile-1`
2847                 [ "$mtime2" = "$mtime3" ] || \
2848                         error "mtime ($mtime2) changed (to $mtime3) on rename"
2849
2850                 cancel_lru_locks osc
2851                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2852         done
2853 }
2854 run_test 39c "mtime change on rename ==========================="
2855
2856 # bug 21114
2857 test_39d() {
2858         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2859         touch $DIR1/$tfile
2860
2861         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
2862
2863         for (( i=0; i < 2; i++ )) ; do
2864                 local mtime=`stat -c %Y $DIR1/$tfile`
2865                 [ $mtime = $TEST_39_MTIME ] || \
2866                         error "mtime($mtime) is not set to $TEST_39_MTIME"
2867
2868                 cancel_lru_locks osc
2869                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2870         done
2871 }
2872 run_test 39d "create, utime, stat =============================="
2873
2874 # bug 21114
2875 test_39e() {
2876         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2877         touch $DIR1/$tfile
2878         local mtime1=`stat -c %Y $DIR1/$tfile`
2879
2880         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
2881
2882         for (( i=0; i < 2; i++ )) ; do
2883                 local mtime2=`stat -c %Y $DIR1/$tfile`
2884                 [ $mtime2 = $TEST_39_MTIME ] || \
2885                         error "mtime($mtime2) is not set to $TEST_39_MTIME"
2886
2887                 cancel_lru_locks osc
2888                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2889         done
2890 }
2891 run_test 39e "create, stat, utime, stat ========================"
2892
2893 # bug 21114
2894 test_39f() {
2895         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2896         touch $DIR1/$tfile
2897         mtime1=`stat -c %Y $DIR1/$tfile`
2898
2899         sleep 2
2900         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
2901
2902         for (( i=0; i < 2; i++ )) ; do
2903                 local mtime2=`stat -c %Y $DIR1/$tfile`
2904                 [ $mtime2 = $TEST_39_MTIME ] || \
2905                         error "mtime($mtime2) is not set to $TEST_39_MTIME"
2906
2907                 cancel_lru_locks osc
2908                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2909         done
2910 }
2911 run_test 39f "create, stat, sleep, utime, stat ================="
2912
2913 # bug 11063
2914 test_39g() {
2915         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2916         echo hello >> $DIR1/$tfile
2917         local mtime1=`stat -c %Y $DIR1/$tfile`
2918
2919         sleep 2
2920         chmod o+r $DIR1/$tfile
2921
2922         for (( i=0; i < 2; i++ )) ; do
2923                 local mtime2=`stat -c %Y $DIR1/$tfile`
2924                 [ "$mtime1" = "$mtime2" ] || \
2925                         error "lost mtime: $mtime2, should be $mtime1"
2926
2927                 cancel_lru_locks osc
2928                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2929         done
2930 }
2931 run_test 39g "write, chmod, stat ==============================="
2932
2933 # bug 11063
2934 test_39h() {
2935         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2936         touch $DIR1/$tfile
2937         sleep 1
2938
2939         local d1=`date`
2940         echo hello >> $DIR1/$tfile
2941         local mtime1=`stat -c %Y $DIR1/$tfile`
2942
2943         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
2944         local d2=`date`
2945         if [ "$d1" != "$d2" ]; then
2946                 echo "write and touch not within one second"
2947         else
2948                 for (( i=0; i < 2; i++ )) ; do
2949                         local mtime2=`stat -c %Y $DIR1/$tfile`
2950                         [ "$mtime2" = $TEST_39_MTIME ] || \
2951                                 error "lost mtime: $mtime2, should be $TEST_39_MTIME"
2952
2953                         cancel_lru_locks osc
2954                         if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2955                 done
2956         fi
2957 }
2958 run_test 39h "write, utime within one second, stat ============="
2959
2960 test_39i() {
2961         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2962         touch $DIR1/$tfile
2963         sleep 1
2964
2965         echo hello >> $DIR1/$tfile
2966         local mtime1=`stat -c %Y $DIR1/$tfile`
2967
2968         mv $DIR1/$tfile $DIR1/$tfile-1
2969
2970         for (( i=0; i < 2; i++ )) ; do
2971                 local mtime2=`stat -c %Y $DIR1/$tfile-1`
2972
2973                 [ "$mtime1" = "$mtime2" ] || \
2974                         error "lost mtime: $mtime2, should be $mtime1"
2975
2976                 cancel_lru_locks osc
2977                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2978         done
2979 }
2980 run_test 39i "write, rename, stat =============================="
2981
2982 test_39j() {
2983         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2984         start_full_debug_logging
2985         touch $DIR1/$tfile
2986         sleep 1
2987
2988         #define OBD_FAIL_OSC_DELAY_SETTIME       0x412
2989         lctl set_param fail_loc=0x80000412
2990         multiop_bg_pause $DIR1/$tfile oO_RDWR:w2097152_c ||
2991                 error "multiop failed"
2992         local multipid=$!
2993         local mtime1=`stat -c %Y $DIR1/$tfile`
2994
2995         mv $DIR1/$tfile $DIR1/$tfile-1
2996
2997         kill -USR1 $multipid
2998         wait $multipid || error "multiop close failed"
2999
3000         for (( i=0; i < 2; i++ )) ; do
3001                 local mtime2=`stat -c %Y $DIR1/$tfile-1`
3002                 [ "$mtime1" = "$mtime2" ] ||
3003                         error "mtime is lost on close: $mtime2, " \
3004                               "should be $mtime1"
3005
3006                 cancel_lru_locks osc
3007                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
3008         done
3009         lctl set_param fail_loc=0
3010         stop_full_debug_logging
3011 }
3012 run_test 39j "write, rename, close, stat ======================="
3013
3014 test_39k() {
3015         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3016         touch $DIR1/$tfile
3017         sleep 1
3018
3019         multiop_bg_pause $DIR1/$tfile oO_RDWR:w2097152_c || error "multiop failed"
3020         local multipid=$!
3021         local mtime1=`stat -c %Y $DIR1/$tfile`
3022
3023         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
3024
3025         kill -USR1 $multipid
3026         wait $multipid || error "multiop close failed"
3027
3028         for (( i=0; i < 2; i++ )) ; do
3029                 local mtime2=`stat -c %Y $DIR1/$tfile`
3030
3031                 [ "$mtime2" = $TEST_39_MTIME ] || \
3032                         error "mtime is lost on close: $mtime2, should be $TEST_39_MTIME"
3033
3034                 cancel_lru_locks osc
3035                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
3036         done
3037 }
3038 run_test 39k "write, utime, close, stat ========================"
3039
3040 # this should be set to future
3041 TEST_39_ATIME=`date -d "1 year" +%s`
3042
3043 test_39l() {
3044         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3045         remote_mds_nodsh && skip "remote MDS with nodsh" && return
3046         local atime_diff=$(do_facet $SINGLEMDS \
3047                                 lctl get_param -n mdd.*MDT0000*.atime_diff)
3048         rm -rf $DIR/$tdir
3049         mkdir -p $DIR/$tdir
3050
3051         # test setting directory atime to future
3052         touch -a -d @$TEST_39_ATIME $DIR/$tdir
3053         local atime=$(stat -c %X $DIR/$tdir)
3054         [ "$atime" = $TEST_39_ATIME ] || \
3055                 error "atime is not set to future: $atime, $TEST_39_ATIME"
3056
3057         # test setting directory atime from future to now
3058         local d1=$(date +%s)
3059         ls $DIR/$tdir
3060         local d2=$(date +%s)
3061
3062         cancel_lru_locks mdc
3063         atime=$(stat -c %X $DIR/$tdir)
3064         [ "$atime" -ge "$d1" -a "$atime" -le "$d2" ] || \
3065                 error "atime is not updated from future: $atime, $d1<atime<$d2"
3066
3067         do_facet $SINGLEMDS lctl set_param -n mdd.*MDT0000*.atime_diff=2
3068         sleep 3
3069
3070         # test setting directory atime when now > dir atime + atime_diff
3071         d1=$(date +%s)
3072         ls $DIR/$tdir
3073         d2=$(date +%s)
3074         cancel_lru_locks mdc
3075         atime=$(stat -c %X $DIR/$tdir)
3076         [ "$atime" -ge "$d1" -a "$atime" -le "$d2" ] || \
3077                 error "atime is not updated  : $atime, should be $d2"
3078
3079         do_facet $SINGLEMDS lctl set_param -n mdd.*MDT0000*.atime_diff=60
3080         sleep 3
3081
3082         # test not setting directory atime when now < dir atime + atime_diff
3083         ls $DIR/$tdir
3084         cancel_lru_locks mdc
3085         atime=$(stat -c %X $DIR/$tdir)
3086         [ "$atime" -ge "$d1" -a "$atime" -le "$d2" ] || \
3087                 error "atime is updated to $atime, should remain $d1<atime<$d2"
3088
3089         do_facet $SINGLEMDS \
3090                 lctl set_param -n mdd.*MDT0000*.atime_diff=$atime_diff
3091 }
3092 run_test 39l "directory atime update ==========================="
3093
3094 test_39m() {
3095         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3096         touch $DIR1/$tfile
3097         sleep 2
3098         local far_past_mtime=$(date -d "May 29 1953" +%s)
3099         local far_past_atime=$(date -d "Dec 17 1903" +%s)
3100
3101         touch -m -d @$far_past_mtime $DIR1/$tfile
3102         touch -a -d @$far_past_atime $DIR1/$tfile
3103
3104         for (( i=0; i < 2; i++ )) ; do
3105                 local timestamps=$(stat -c "%X %Y" $DIR1/$tfile)
3106                 [ "$timestamps" = "$far_past_atime $far_past_mtime" ] || \
3107                         error "atime or mtime set incorrectly"
3108
3109                 cancel_lru_locks osc
3110                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
3111         done
3112 }
3113 run_test 39m "test atime and mtime before 1970"
3114
3115 test_39n() { # LU-3832
3116         local atime_diff=$(do_facet $SINGLEMDS \
3117                 lctl get_param -n mdd.*MDT0000*.atime_diff)
3118         local atime0
3119         local atime1
3120         local atime2
3121
3122         do_facet $SINGLEMDS lctl set_param -n mdd.*MDT0000*.atime_diff=1
3123
3124         rm -rf $DIR/$tfile
3125         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 status=noxfer
3126         atime0=$(stat -c %X $DIR/$tfile)
3127
3128         sleep 5
3129         $MULTIOP $DIR/$tfile oO_RDONLY:O_NOATIME:r4096c
3130         atime1=$(stat -c %X $DIR/$tfile)
3131
3132         sleep 5
3133         cancel_lru_locks mdc
3134         cancel_lru_locks osc
3135         $MULTIOP $DIR/$tfile oO_RDONLY:O_NOATIME:r4096c
3136         atime2=$(stat -c %X $DIR/$tfile)
3137
3138         do_facet $SINGLEMDS \
3139                 lctl set_param -n mdd.*MDT0000*.atime_diff=$atime_diff
3140
3141         [ "$atime0" -eq "$atime1" ] || error "atime0 $atime0 != atime1 $atime1"
3142         [ "$atime1" -eq "$atime2" ] || error "atime0 $atime0 != atime1 $atime1"
3143 }
3144 run_test 39n "check that O_NOATIME is honored"
3145
3146 test_39o() {
3147         TESTDIR=$DIR/$tdir/$tfile
3148         [ -e $TESTDIR ] && rm -rf $TESTDIR
3149         test_mkdir -p $TESTDIR
3150         cd $TESTDIR
3151         links1=2
3152         ls
3153         mkdir a b
3154         ls
3155         links2=$(stat -c %h .)
3156         [ $(($links1 + 2)) != $links2 ] &&
3157                 error "wrong links count $(($links1 + 2)) != $links2"
3158         rmdir b
3159         links3=$(stat -c %h .)
3160         [ $(($links1 + 1)) != $links3 ] &&
3161                 error "wrong links count $links1 != $links3"
3162         return 0
3163 }
3164 run_test 39o "directory cached attributes updated after create ========"
3165
3166 test_39p() {
3167         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
3168         local MDTIDX=1
3169         TESTDIR=$DIR/$tdir/$tfile
3170         [ -e $TESTDIR ] && rm -rf $TESTDIR
3171         mkdir -p $TESTDIR
3172         cd $TESTDIR
3173         links1=2
3174         ls
3175         $LFS mkdir -i $MDTIDX $TESTDIR/remote_dir1
3176         $LFS mkdir -i $MDTIDX $TESTDIR/remote_dir2
3177         ls
3178         links2=$(stat -c %h .)
3179         [ $(($links1 + 2)) != $links2 ] &&
3180                 error "wrong links count $(($links1 + 2)) != $links2"
3181         rmdir remote_dir2
3182         links3=$(stat -c %h .)
3183         [ $(($links1 + 1)) != $links3 ] &&
3184                 error "wrong links count $links1 != $links3"
3185         return 0
3186 }
3187 run_test 39p "remote directory cached attributes updated after create ========"
3188
3189
3190 test_40() {
3191         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1
3192         $RUNAS $OPENFILE -f O_WRONLY:O_TRUNC $DIR/$tfile &&
3193                 error "openfile O_WRONLY:O_TRUNC $tfile failed"
3194         $CHECKSTAT -t file -s 4096 $DIR/$tfile ||
3195                 error "$tfile is not 4096 bytes in size"
3196 }
3197 run_test 40 "failed open(O_TRUNC) doesn't truncate ============="
3198
3199 test_41() {
3200         # bug 1553
3201         small_write $DIR/f41 18
3202 }
3203 run_test 41 "test small file write + fstat ====================="
3204
3205 count_ost_writes() {
3206         lctl get_param -n osc.*.stats |
3207             awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }'
3208 }
3209
3210 # decent default
3211 WRITEBACK_SAVE=500
3212 DIRTY_RATIO_SAVE=40
3213 MAX_DIRTY_RATIO=50
3214 BG_DIRTY_RATIO_SAVE=10
3215 MAX_BG_DIRTY_RATIO=25
3216
3217 start_writeback() {
3218         trap 0
3219         # in 2.6, restore /proc/sys/vm/dirty_writeback_centisecs,
3220         # dirty_ratio, dirty_background_ratio
3221         if [ -f /proc/sys/vm/dirty_writeback_centisecs ]; then
3222                 sysctl -w vm.dirty_writeback_centisecs=$WRITEBACK_SAVE
3223                 sysctl -w vm.dirty_background_ratio=$BG_DIRTY_RATIO_SAVE
3224                 sysctl -w vm.dirty_ratio=$DIRTY_RATIO_SAVE
3225         else
3226                 # if file not here, we are a 2.4 kernel
3227                 kill -CONT `pidof kupdated`
3228         fi
3229 }
3230
3231 stop_writeback() {
3232         # setup the trap first, so someone cannot exit the test at the
3233         # exact wrong time and mess up a machine
3234         trap start_writeback EXIT
3235         # in 2.6, save and 0 /proc/sys/vm/dirty_writeback_centisecs
3236         if [ -f /proc/sys/vm/dirty_writeback_centisecs ]; then
3237                 WRITEBACK_SAVE=`sysctl -n vm.dirty_writeback_centisecs`
3238                 sysctl -w vm.dirty_writeback_centisecs=0
3239                 sysctl -w vm.dirty_writeback_centisecs=0
3240                 # save and increase /proc/sys/vm/dirty_ratio
3241                 DIRTY_RATIO_SAVE=`sysctl -n vm.dirty_ratio`
3242                 sysctl -w vm.dirty_ratio=$MAX_DIRTY_RATIO
3243                 # save and increase /proc/sys/vm/dirty_background_ratio
3244                 BG_DIRTY_RATIO_SAVE=`sysctl -n vm.dirty_background_ratio`
3245                 sysctl -w vm.dirty_background_ratio=$MAX_BG_DIRTY_RATIO
3246         else
3247                 # if file not here, we are a 2.4 kernel
3248                 kill -STOP `pidof kupdated`
3249         fi
3250 }
3251
3252 # ensure that all stripes have some grant before we test client-side cache
3253 setup_test42() {
3254         for i in `seq -f $DIR/f42-%g 1 $OSTCOUNT`; do
3255                 dd if=/dev/zero of=$i bs=4k count=1
3256                 rm $i
3257         done
3258 }
3259
3260 # Tests 42* verify that our behaviour is correct WRT caching, file closure,
3261 # file truncation, and file removal.
3262 test_42a() {
3263         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3264         setup_test42
3265         cancel_lru_locks osc
3266         stop_writeback
3267         sync; sleep 1; sync # just to be safe
3268         BEFOREWRITES=`count_ost_writes`
3269         lctl get_param -n osc.*[oO][sS][cC][_-]*.cur_grant_bytes | grep "[0-9]"
3270         dd if=/dev/zero of=$DIR/f42a bs=1024 count=100
3271         AFTERWRITES=`count_ost_writes`
3272         [ $BEFOREWRITES -eq $AFTERWRITES ] || \
3273                 error "$BEFOREWRITES < $AFTERWRITES"
3274         start_writeback
3275 }
3276 run_test 42a "ensure that we don't flush on close =============="
3277
3278 test_42b() {
3279         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3280         setup_test42
3281         cancel_lru_locks osc
3282         stop_writeback
3283         sync
3284         dd if=/dev/zero of=$DIR/f42b bs=1024 count=100
3285         BEFOREWRITES=`count_ost_writes`
3286         $MUNLINK $DIR/f42b || error "$MUNLINK $DIR/f42b: $?"
3287         AFTERWRITES=`count_ost_writes`
3288         if [ $BEFOREWRITES -lt $AFTERWRITES ]; then
3289                 error "$BEFOREWRITES < $AFTERWRITES on unlink"
3290         fi
3291         BEFOREWRITES=`count_ost_writes`
3292         sync || error "sync: $?"
3293         AFTERWRITES=`count_ost_writes`
3294         if [ $BEFOREWRITES -lt $AFTERWRITES ]; then
3295                 error "$BEFOREWRITES < $AFTERWRITES on sync"
3296         fi
3297         dmesg | grep 'error from obd_brw_async' && error 'error writing back'
3298         start_writeback
3299         return 0
3300 }
3301 run_test 42b "test destroy of file with cached dirty data ======"
3302
3303 # if these tests just want to test the effect of truncation,
3304 # they have to be very careful.  consider:
3305 # - the first open gets a {0,EOF}PR lock
3306 # - the first write conflicts and gets a {0, count-1}PW
3307 # - the rest of the writes are under {count,EOF}PW
3308 # - the open for truncate tries to match a {0,EOF}PR
3309 #   for the filesize and cancels the PWs.
3310 # any number of fixes (don't get {0,EOF} on open, match
3311 # composite locks, do smarter file size management) fix
3312 # this, but for now we want these tests to verify that
3313 # the cancellation with truncate intent works, so we
3314 # start the file with a full-file pw lock to match against
3315 # until the truncate.
3316 trunc_test() {
3317         test=$1
3318         file=$DIR/$test
3319         offset=$2
3320         cancel_lru_locks osc
3321         stop_writeback
3322         # prime the file with 0,EOF PW to match
3323         touch $file
3324         $TRUNCATE $file 0
3325         sync; sync
3326         # now the real test..
3327         dd if=/dev/zero of=$file bs=1024 count=100
3328         BEFOREWRITES=`count_ost_writes`
3329         $TRUNCATE $file $offset
3330         cancel_lru_locks osc
3331         AFTERWRITES=`count_ost_writes`
3332         start_writeback
3333 }
3334
3335 test_42c() {
3336         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3337         trunc_test 42c 1024
3338         [ $BEFOREWRITES -eq $AFTERWRITES ] && \
3339             error "beforewrites $BEFOREWRITES == afterwrites $AFTERWRITES on truncate"
3340         rm $file
3341 }
3342 run_test 42c "test partial truncate of file with cached dirty data"
3343
3344 test_42d() {
3345         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3346         trunc_test 42d 0
3347         [ $BEFOREWRITES -eq $AFTERWRITES ] || \
3348             error "beforewrites $BEFOREWRITES != afterwrites $AFTERWRITES on truncate"
3349         rm $file
3350 }
3351 run_test 42d "test complete truncate of file with cached dirty data"
3352
3353 test_42e() { # bug22074
3354         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3355         local TDIR=$DIR/${tdir}e
3356         local pagesz=$(page_size)
3357         local pages=16 # hardcoded 16 pages, don't change it.
3358         local files=$((OSTCOUNT * 500)) # hopefully 500 files on each OST
3359         local proc_osc0="osc.${FSNAME}-OST0000-osc-[^MDT]*"
3360         local max_dirty_mb
3361         local warmup_files
3362
3363         test_mkdir -p $DIR/${tdir}e
3364         $SETSTRIPE -c 1 $TDIR
3365         createmany -o $TDIR/f $files
3366
3367         max_dirty_mb=$($LCTL get_param -n $proc_osc0/max_dirty_mb)
3368
3369         # we assume that with $OSTCOUNT files, at least one of them will
3370         # be allocated on OST0.
3371         warmup_files=$((OSTCOUNT * max_dirty_mb))
3372         createmany -o $TDIR/w $warmup_files
3373
3374         # write a large amount of data into one file and sync, to get good
3375         # avail_grant number from OST.
3376         for ((i=0; i<$warmup_files; i++)); do
3377                 idx=$($GETSTRIPE -i $TDIR/w$i)
3378                 [ $idx -ne 0 ] && continue
3379                 dd if=/dev/zero of=$TDIR/w$i bs="$max_dirty_mb"M count=1
3380                 break
3381         done
3382         [ $i -gt $warmup_files ] && error "OST0 is still cold"
3383         sync
3384         $LCTL get_param $proc_osc0/cur_dirty_bytes
3385         $LCTL get_param $proc_osc0/cur_grant_bytes
3386
3387         # create as much dirty pages as we can while not to trigger the actual
3388         # RPCs directly. but depends on the env, VFS may trigger flush during this
3389         # period, hopefully we are good.
3390         for ((i=0; i<$warmup_files; i++)); do
3391                 idx=$($GETSTRIPE -i $TDIR/w$i)
3392                 [ $idx -ne 0 ] && continue
3393                 dd if=/dev/zero of=$TDIR/w$i bs=1M count=1 2>/dev/null
3394         done
3395         $LCTL get_param $proc_osc0/cur_dirty_bytes
3396         $LCTL get_param $proc_osc0/cur_grant_bytes
3397
3398         # perform the real test
3399         $LCTL set_param $proc_osc0/rpc_stats 0
3400         for ((;i<$files; i++)); do
3401                 [ $($GETSTRIPE -i $TDIR/f$i) -eq 0 ] || continue
3402                 dd if=/dev/zero of=$TDIR/f$i bs=$pagesz count=$pages 2>/dev/null
3403         done
3404         sync
3405         $LCTL get_param $proc_osc0/rpc_stats
3406
3407         local percent=0
3408         local have_ppr=false
3409         $LCTL get_param $proc_osc0/rpc_stats |
3410                 while read PPR RRPC RPCT RCUM BAR WRPC WPCT WCUM; do
3411                         # skip lines until we are at the RPC histogram data
3412                         [ "$PPR" == "pages" ] && have_ppr=true && continue
3413                         $have_ppr || continue
3414
3415                         # we only want the percent stat for < 16 pages
3416                         [ $(echo $PPR | tr -d ':') -ge $pages ] && break
3417
3418                         percent=$((percent + WPCT))
3419                         if [ $percent -gt 15 ]; then
3420                                 error "less than 16-pages write RPCs" \
3421                                       "$percent% > 15%"
3422                                 break
3423                         fi
3424                 done
3425         rm -rf $TDIR
3426 }
3427 run_test 42e "verify sub-RPC writes are not done synchronously"
3428
3429 test_43() {
3430         test_mkdir -p $DIR/$tdir
3431         cp -p /bin/ls $DIR/$tdir/$tfile
3432         $MULTIOP $DIR/$tdir/$tfile Ow_c &
3433         pid=$!
3434         # give multiop a chance to open
3435         sleep 1
3436
3437         $DIR/$tdir/$tfile && error || true
3438         kill -USR1 $pid
3439 }
3440 run_test 43 "execution of file opened for write should return -ETXTBSY"
3441
3442 test_43a() {
3443         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3444         test_mkdir -p $DIR/$tdir
3445         cp -p `which $MULTIOP` $DIR/$tdir/multiop ||
3446                         cp -p multiop $DIR/$tdir/multiop
3447         MULTIOP_PROG=$DIR/$tdir/multiop multiop_bg_pause $TMP/$tfile.junk O_c ||
3448                         return 1
3449         MULTIOP_PID=$!
3450         $MULTIOP $DIR/$tdir/multiop Oc && error "expected error, got success"
3451         kill -USR1 $MULTIOP_PID || return 2
3452         wait $MULTIOP_PID || return 3
3453         rm $TMP/$tfile.junk $DIR/$tdir/multiop
3454 }
3455 run_test 43a "open(RDWR) of file being executed should return -ETXTBSY"
3456
3457 test_43b() {
3458         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3459         test_mkdir -p $DIR/$tdir
3460         cp -p `which $MULTIOP` $DIR/$tdir/multiop ||
3461                         cp -p multiop $DIR/$tdir/multiop
3462         MULTIOP_PROG=$DIR/$tdir/multiop multiop_bg_pause $TMP/$tfile.junk O_c ||
3463                         return 1
3464         MULTIOP_PID=$!
3465         $TRUNCATE $DIR/$tdir/multiop 0 && error "expected error, got success"
3466         kill -USR1 $MULTIOP_PID || return 2
3467         wait $MULTIOP_PID || return 3
3468         rm $TMP/$tfile.junk $DIR/$tdir/multiop
3469 }
3470 run_test 43b "truncate of file being executed should return -ETXTBSY"
3471
3472 test_43c() {
3473         local testdir="$DIR/$tdir"
3474         test_mkdir -p $DIR/$tdir
3475         cp $SHELL $testdir/
3476         ( cd $(dirname $SHELL) && md5sum $(basename $SHELL) ) | \
3477                 ( cd $testdir && md5sum -c)
3478 }
3479 run_test 43c "md5sum of copy into lustre========================"
3480
3481 test_44() {
3482         [  "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
3483         dd if=/dev/zero of=$DIR/f1 bs=4k count=1 seek=1023
3484         dd if=$DIR/f1 bs=4k count=1 > /dev/null
3485 }
3486 run_test 44 "zero length read from a sparse stripe ============="
3487
3488 test_44a() {
3489     local nstripe=`$LCTL lov_getconfig $DIR | grep default_stripe_count: | \
3490                          awk '{print $2}'`
3491     [ -z "$nstripe" ] && skip "can't get stripe info" && return
3492     [ "$nstripe" -gt "$OSTCOUNT" ] && skip "Wrong default_stripe_count: $nstripe (OSTCOUNT: $OSTCOUNT)" && return
3493     local stride=`$LCTL lov_getconfig $DIR | grep default_stripe_size: | \
3494                       awk '{print $2}'`
3495     if [ $nstripe -eq 0 -o $nstripe -eq -1 ] ; then
3496         nstripe=`$LCTL lov_getconfig $DIR | grep obd_count: | awk '{print $2}'`
3497     fi
3498
3499     OFFSETS="0 $((stride/2)) $((stride-1))"
3500     for offset in $OFFSETS ; do
3501       for i in `seq 0 $((nstripe-1))`; do
3502         local GLOBALOFFSETS=""
3503         local size=$((((i + 2 * $nstripe )*$stride + $offset)))  # Bytes
3504         local myfn=$DIR/d44a-$size
3505         echo "--------writing $myfn at $size"
3506         ll_sparseness_write $myfn $size  || error "ll_sparseness_write"
3507         GLOBALOFFSETS="$GLOBALOFFSETS $size"
3508         ll_sparseness_verify $myfn $GLOBALOFFSETS \
3509                             || error "ll_sparseness_verify $GLOBALOFFSETS"
3510
3511         for j in `seq 0 $((nstripe-1))`; do
3512             size=$((((j + $nstripe )*$stride + $offset)))  # Bytes
3513             ll_sparseness_write $myfn $size || error "ll_sparseness_write"
3514             GLOBALOFFSETS="$GLOBALOFFSETS $size"
3515         done
3516         ll_sparseness_verify $myfn $GLOBALOFFSETS \
3517                             || error "ll_sparseness_verify $GLOBALOFFSETS"
3518         rm -f $myfn
3519       done
3520     done
3521 }
3522 run_test 44a "test sparse pwrite ==============================="
3523
3524 dirty_osc_total() {
3525         tot=0
3526         for d in `lctl get_param -n osc.*.cur_dirty_bytes`; do
3527                 tot=$(($tot + $d))
3528         done
3529         echo $tot
3530 }
3531 do_dirty_record() {
3532         before=`dirty_osc_total`
3533         echo executing "\"$*\""
3534         eval $*
3535         after=`dirty_osc_total`
3536         echo before $before, after $after
3537 }
3538 test_45() {
3539         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3540         f="$DIR/f45"
3541         # Obtain grants from OST if it supports it
3542         echo blah > ${f}_grant
3543         stop_writeback
3544         sync
3545         do_dirty_record "echo blah > $f"
3546         [ $before -eq $after ] && error "write wasn't cached"
3547         do_dirty_record "> $f"
3548         [ $before -gt $after ] || error "truncate didn't lower dirty count"
3549         do_dirty_record "echo blah > $f"
3550         [ $before -eq $after ] && error "write wasn't cached"
3551         do_dirty_record "sync"
3552         [ $before -gt $after ] || error "writeback didn't lower dirty count"
3553         do_dirty_record "echo blah > $f"
3554         [ $before -eq $after ] && error "write wasn't cached"
3555         do_dirty_record "cancel_lru_locks osc"
3556         [ $before -gt $after ] || error "lock cancellation didn't lower dirty count"
3557         start_writeback
3558 }
3559 run_test 45 "osc io page accounting ============================"
3560
3561 # in a 2 stripe file (lov.sh), page 1023 maps to page 511 in its object.  this
3562 # test tickles a bug where re-dirtying a page was failing to be mapped to the
3563 # objects offset and an assert hit when an rpc was built with 1023's mapped
3564 # offset 511 and 511's raw 511 offset. it also found general redirtying bugs.
3565 test_46() {
3566         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3567         f="$DIR/f46"
3568         stop_writeback
3569         sync
3570         dd if=/dev/zero of=$f bs=`page_size` seek=511 count=1
3571         sync
3572         dd conv=notrunc if=/dev/zero of=$f bs=`page_size` seek=1023 count=1
3573         dd conv=notrunc if=/dev/zero of=$f bs=`page_size` seek=511 count=1
3574         sync
3575         start_writeback
3576 }
3577 run_test 46 "dirtying a previously written page ================"
3578
3579 # test_47 is removed "Device nodes check" is moved to test_28
3580
3581 test_48a() { # bug 2399
3582         check_kernel_version 34 || return 0
3583         test_mkdir -p $DIR/$tdir
3584         cd $DIR/$tdir
3585         mv $DIR/$tdir $DIR/d48.new || error "move directory failed"
3586         test_mkdir $DIR/$tdir || error "recreate directory failed"
3587         touch foo || error "'touch foo' failed after recreating cwd"
3588         test_mkdir $DIR/$tdir/bar ||
3589                      error "'mkdir foo' failed after recreating cwd"
3590         if check_kernel_version 44; then
3591                 touch .foo || error "'touch .foo' failed after recreating cwd"
3592                 test_mkdir $DIR/$tdir/.bar ||
3593                               error "'mkdir .foo' failed after recreating cwd"
3594         fi
3595         ls . > /dev/null || error "'ls .' failed after recreating cwd"
3596         ls .. > /dev/null || error "'ls ..' failed after removing cwd"
3597         cd . || error "'cd .' failed after recreating cwd"
3598         test_mkdir . && error "'mkdir .' worked after recreating cwd"
3599         rmdir . && error "'rmdir .' worked after recreating cwd"
3600         ln -s . baz || error "'ln -s .' failed after recreating cwd"
3601         cd .. || error "'cd ..' failed after recreating cwd"
3602 }
3603 run_test 48a "Access renamed working dir (should return errors)="
3604
3605 test_48b() { # bug 2399
3606         check_kernel_version 34 || return 0
3607         rm -rf $DIR/$tdir
3608         test_mkdir -p $DIR/$tdir
3609         cd $DIR/$tdir
3610         rmdir $DIR/$tdir || error "remove cwd $DIR/$tdir failed"
3611         touch foo && error "'touch foo' worked after removing cwd"
3612         test_mkdir $DIR/$tdir/foo &&
3613                      error "'mkdir foo' worked after removing cwd"
3614         if check_kernel_version 44; then
3615                 touch .foo && error "'touch .foo' worked after removing cwd"
3616                 test_mkdir $DIR/$tdir/.foo &&
3617                               error "'mkdir .foo' worked after removing cwd"
3618         fi
3619         ls . > /dev/null && error "'ls .' worked after removing cwd"
3620         ls .. > /dev/null || error "'ls ..' failed after removing cwd"
3621         is_patchless || ( cd . && error "'cd .' worked after removing cwd" )
3622         test_mkdir $DIR/$tdir/. && error "'mkdir .' worked after removing cwd"
3623         rmdir . && error "'rmdir .' worked after removing cwd"
3624         ln -s . foo && error "'ln -s .' worked after removing cwd"
3625         cd .. || echo "'cd ..' failed after removing cwd `pwd`"  #bug 3517
3626 }
3627 run_test 48b "Access removed working dir (should return errors)="
3628
3629 test_48c() { # bug 2350
3630         check_kernel_version 36 || return 0
3631         #lctl set_param debug=-1
3632         #set -vx
3633         rm -rf $DIR/$tdir
3634         test_mkdir -p $DIR/$tdir/dir
3635         cd $DIR/$tdir/dir
3636         $TRACE rmdir $DIR/$tdir/dir || error "remove cwd $DIR/$tdir/dir failed"
3637         $TRACE touch foo && error "touch foo worked after removing cwd"
3638         $TRACE test_mkdir foo && error "'mkdir foo' worked after removing cwd"
3639         if check_kernel_version 44; then
3640                 touch .foo && error "touch .foo worked after removing cwd"
3641                 test_mkdir .foo && error "mkdir .foo worked after removing cwd"
3642         fi
3643         $TRACE ls . && error "'ls .' worked after removing cwd"
3644         $TRACE ls .. || error "'ls ..' failed after removing cwd"
3645         is_patchless || ( $TRACE cd . &&
3646                         error "'cd .' worked after removing cwd" )
3647         $TRACE test_mkdir . && error "'mkdir .' worked after removing cwd"
3648         $TRACE rmdir . && error "'rmdir .' worked after removing cwd"
3649         $TRACE ln -s . foo && error "'ln -s .' worked after removing cwd"
3650         $TRACE cd .. || echo "'cd ..' failed after removing cwd `pwd`" #bug 3415
3651 }
3652 run_test 48c "Access removed working subdir (should return errors)"
3653
3654 test_48d() { # bug 2350
3655         check_kernel_version 36 || return 0
3656         #lctl set_param debug=-1
3657         #set -vx
3658         rm -rf $DIR/$tdir
3659         test_mkdir -p $DIR/$tdir/dir
3660         cd $DIR/$tdir/dir
3661         $TRACE rmdir $DIR/$tdir/dir || error "remove cwd $DIR/$tdir/dir failed"
3662         $TRACE rmdir $DIR/$tdir || error "remove parent $DIR/$tdir failed"
3663         $TRACE touch foo && error "'touch foo' worked after removing parent"
3664         $TRACE test_mkdir foo && error "mkdir foo worked after removing parent"
3665         if check_kernel_version 44; then
3666                 touch .foo && error "'touch .foo' worked after removing parent"
3667                 test_mkdir .foo &&
3668                               error "mkdir .foo worked after removing parent"
3669         fi
3670         $TRACE ls . && error "'ls .' worked after removing parent"
3671         $TRACE ls .. && error "'ls ..' worked after removing parent"
3672         is_patchless || ( $TRACE cd . &&
3673                         error "'cd .' worked after recreate parent" )
3674         $TRACE test_mkdir . && error "'mkdir .' worked after removing parent"
3675         $TRACE rmdir . && error "'rmdir .' worked after removing parent"
3676         $TRACE ln -s . foo && error "'ln -s .' worked after removing parent"
3677         is_patchless || ( $TRACE cd .. &&
3678                         error "'cd ..' worked after removing parent" || true )
3679 }
3680 run_test 48d "Access removed parent subdir (should return errors)"
3681
3682 test_48e() { # bug 4134
3683         check_kernel_version 41 || return 0
3684         #lctl set_param debug=-1
3685         #set -vx
3686         rm -rf $DIR/$tdir
3687         test_mkdir -p $DIR/$tdir/dir
3688         cd $DIR/$tdir/dir
3689         $TRACE rmdir $DIR/$tdir/dir || error "remove cwd $DIR/$tdir/dir failed"
3690         $TRACE rmdir $DIR/$tdir || error "remove parent $DIR/$tdir failed"
3691         $TRACE touch $DIR/$tdir || error "'touch $DIR/$tdir' failed"
3692         $TRACE chmod +x $DIR/$tdir || error "'chmod +x $DIR/$tdir' failed"
3693         # On a buggy kernel addition of "touch foo" after cd .. will
3694         # produce kernel oops in lookup_hash_it
3695         touch ../foo && error "'cd ..' worked after recreate parent"
3696         cd $DIR
3697         $TRACE rm $DIR/$tdir || error "rm '$DIR/$tdir' failed"
3698 }
3699 run_test 48e "Access to recreated parent subdir (should return errors)"
3700
3701 test_49() { # LU-1030
3702         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3703         # get ost1 size - lustre-OST0000
3704         ost1_size=$(do_facet ost1 lfs df |grep ${ost1_svc} |awk '{print $4}')
3705         # write 800M at maximum
3706         [ $ost1_size -gt 819200 ] && ost1_size=819200
3707
3708         lfs setstripe -c 1 -i 0 $DIR/$tfile
3709         dd if=/dev/zero of=$DIR/$tfile bs=4k count=$((ost1_size >> 2)) &
3710         local dd_pid=$!
3711
3712         # change max_pages_per_rpc while writing the file
3713         local osc1_mppc=osc.$(get_osc_import_name client ost1).max_pages_per_rpc
3714         local orig_mppc=`$LCTL get_param -n $osc1_mppc`
3715         # loop until dd process exits
3716         while ps ax -opid | grep -wq $dd_pid; do
3717                 $LCTL set_param $osc1_mppc=$((RANDOM % 256 + 1))
3718                 sleep $((RANDOM % 5 + 1))
3719         done
3720         # restore original max_pages_per_rpc
3721         $LCTL set_param $osc1_mppc=$orig_mppc
3722         rm $DIR/$tfile || error "rm $DIR/$tfile failed"
3723 }
3724 run_test 49 "Change max_pages_per_rpc won't break osc extent"
3725
3726 test_50() {
3727         # bug 1485
3728         test_mkdir $DIR/$tdir
3729         cd $DIR/$tdir
3730         ls /proc/$$/cwd || error "ls /proc/$$/cwd failed"
3731 }
3732 run_test 50 "special situations: /proc symlinks  ==============="
3733
3734 test_51a() {    # was test_51
3735         # bug 1516 - create an empty entry right after ".." then split dir
3736         test_mkdir -p $DIR/$tdir
3737         touch $DIR/$tdir/foo
3738         $MCREATE $DIR/$tdir/bar
3739         rm $DIR/$tdir/foo
3740         createmany -m $DIR/$tdir/longfile 201
3741         FNUM=202
3742         while [ $(ls -sd $DIR/$tdir | awk '{ print $1 }') -eq 4 ]; do
3743                 $MCREATE $DIR/$tdir/longfile$FNUM
3744                 FNUM=$(($FNUM + 1))
3745                 echo -n "+"
3746         done
3747         echo
3748         ls -l $DIR/$tdir > /dev/null || error "ls -l $DIR/$tdir failed"
3749 }
3750 run_test 51a "special situations: split htree with empty entry =="
3751
3752 export NUMTEST=70000
3753 test_51b() {
3754         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3755         local BASE=$DIR/d${base}.${TESTSUITE}
3756
3757         # cleanup the directory
3758         rm -fr $BASE
3759
3760         test_mkdir -p $BASE
3761
3762         local mdtidx=$(printf "%04x" $($LFS getstripe -M $BASE))
3763         local numfree=$(lctl get_param -n mdc.$FSNAME-MDT$mdtidx*.filesfree)
3764         [ $numfree -lt 21000 ] && skip "not enough free inodes ($numfree)" &&
3765                 return
3766
3767         [ $numfree -lt $NUMTEST ] && NUMTEST=$(($numfree - 50)) &&
3768                 echo "reduced count to $NUMTEST due to inodes"
3769
3770         # need to check free space for the directories as well
3771         local blkfree=$(lctl get_param -n mdc.$FSNAME-MDT$mdtidx*.kbytesavail)
3772         numfree=$((blkfree / 4))
3773         [ $numfree -lt $NUMTEST ] && NUMTEST=$(($numfree - 50)) &&
3774                 echo "reduced count to $NUMTEST due to blocks"
3775
3776         createmany -d $BASE/d $NUMTEST && echo $NUMTEST > $BASE/fnum ||
3777                 echo "failed" > $BASE/fnum
3778 }
3779 run_test 51b "exceed 64k subdirectory nlink limit"
3780
3781 test_51ba() { # LU-993
3782         local BASE=$DIR/d${base}.${TESTSUITE}
3783         # unlink all but 100 subdirectories, then check it still works
3784         local LEFT=100
3785         [ -f $BASE/fnum ] && local NUMPREV=$(cat $BASE/fnum) && rm $BASE/fnum
3786
3787         [ "$NUMPREV" != "failed" ] && NUMTEST=$NUMPREV
3788         local DELETE=$((NUMTEST - LEFT))
3789
3790         # continue on to run this test even if 51b didn't finish,
3791         # just to delete the many subdirectories created.
3792         [ ! -d "${BASE}/d1" ] && skip "test_51b() not run" && return 0
3793
3794         # for ldiskfs the nlink count should be 1, but this is OSD specific
3795         # and so this is listed for informational purposes only
3796         echo "nlink before: $(stat -c %h $BASE), created before: $NUMTEST"
3797         unlinkmany -d $BASE/d $DELETE
3798         RC=$?
3799
3800         if [ $RC -ne 0 ]; then
3801                 if [ "$NUMPREV" == "failed" ]; then
3802                         skip "previous setup failed"
3803                         return 0
3804                 else
3805                         error "unlink of first $DELETE subdirs failed"
3806                         return $RC
3807                 fi
3808         fi
3809
3810         echo "nlink between: $(stat -c %h $BASE)"
3811         # trim the first line of ls output
3812         local FOUND=$(($(ls -l ${BASE} | wc -l) - 1))
3813         [ $FOUND -ne $LEFT ] &&
3814                 error "can't find subdirs: found only $FOUND/$LEFT"
3815
3816         unlinkmany -d $BASE/d $DELETE $LEFT ||
3817                 error "unlink of second $LEFT subdirs failed"
3818         # regardless of whether the backing filesystem tracks nlink accurately
3819         # or not, the nlink count shouldn't be more than "." and ".." here
3820         local AFTER=$(stat -c %h $BASE)
3821         [ $AFTER -gt 2 ] && error "nlink after: $AFTER > 2" ||
3822                 echo "nlink after: $AFTER"
3823 }
3824 run_test 51ba "verify nlink for many subdirectory cleanup"
3825
3826 test_51d() {
3827         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3828         [  "$OSTCOUNT" -lt "3" ] && skip_env "skipping test with few OSTs" && return
3829         test_mkdir -p $DIR/$tdir
3830         createmany -o $DIR/$tdir/t- 1000
3831         $GETSTRIPE $DIR/$tdir > $TMP/files
3832         for N in `seq 0 $((OSTCOUNT - 1))`; do
3833             OBJS[$N]=`awk -vobjs=0 '($1 == '$N') { objs += 1 } END { print objs;}' $TMP/files`
3834             OBJS0[$N]=`grep -A 1 idx $TMP/files | awk -vobjs=0 '($1 == '$N') { objs += 1 } END { print objs;}'`
3835             log "OST$N has ${OBJS[$N]} objects, ${OBJS0[$N]} are index 0"
3836         done
3837         unlinkmany $DIR/$tdir/t- 1000
3838
3839         NLAST=0
3840         for N in `seq 1 $((OSTCOUNT - 1))`; do
3841             [ ${OBJS[$N]} -lt $((${OBJS[$NLAST]} - 20)) ] && \
3842                 error "OST $N has less objects vs OST $NLAST (${OBJS[$N]} < ${OBJS[$NLAST]}"
3843             [ ${OBJS[$N]} -gt $((${OBJS[$NLAST]} + 20)) ] && \
3844                 error "OST $N has less objects vs OST $NLAST (${OBJS[$N]} < ${OBJS[$NLAST]}"
3845
3846             [ ${OBJS0[$N]} -lt $((${OBJS0[$NLAST]} - 20)) ] && \
3847                 error "OST $N has less #0 objects vs OST $NLAST (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
3848             [ ${OBJS0[$N]} -gt $((${OBJS0[$NLAST]} + 20)) ] && \
3849                 error "OST $N has less #0 objects vs OST $NLAST (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
3850             NLAST=$N
3851         done
3852 }
3853 run_test 51d "check object distribution ===================="
3854
3855 test_52a() {
3856         [ -f $DIR/$tdir/foo ] && chattr -a $DIR/$tdir/foo
3857         test_mkdir -p $DIR/$tdir
3858         touch $DIR/$tdir/foo
3859         chattr +a $DIR/$tdir/foo || error "chattr +a failed"
3860         echo bar >> $DIR/$tdir/foo || error "append bar failed"
3861         cp /etc/hosts $DIR/$tdir/foo && error "cp worked"
3862         rm -f $DIR/$tdir/foo 2>/dev/null && error "rm worked"
3863         link $DIR/$tdir/foo $DIR/$tdir/foo_link 2>/dev/null &&
3864                                         error "link worked"
3865         echo foo >> $DIR/$tdir/foo || error "append foo failed"
3866         mrename $DIR/$tdir/foo $DIR/$tdir/foo_ren && error "rename worked"
3867         lsattr $DIR/$tdir/foo | egrep -q "^-+a[-e]+ $DIR/$tdir/foo" ||
3868                                                      error "lsattr"
3869         chattr -a $DIR/$tdir/foo || error "chattr -a failed"
3870         cp -r $DIR/$tdir /tmp/
3871         rm -fr $DIR/$tdir || error "cleanup rm failed"
3872 }
3873 run_test 52a "append-only flag test (should return errors) ====="
3874
3875 test_52b() {
3876         [ -f $DIR/$tdir/foo ] && chattr -i $DIR/$tdir/foo
3877         test_mkdir -p $DIR/$tdir
3878         touch $DIR/$tdir/foo
3879         chattr +i $DIR/$tdir/foo || error "chattr +i failed"
3880         cat test > $DIR/$tdir/foo && error "cat test worked"
3881         cp /etc/hosts $DIR/$tdir/foo && error "cp worked"
3882         rm -f $DIR/$tdir/foo 2>/dev/null && error "rm worked"
3883         link $DIR/$tdir/foo $DIR/$tdir/foo_link 2>/dev/null &&
3884                                         error "link worked"
3885         echo foo >> $DIR/$tdir/foo && error "echo worked"
3886         mrename $DIR/$tdir/foo $DIR/$tdir/foo_ren && error "rename worked"
3887         [ -f $DIR/$tdir/foo ] || error "$tdir/foo is not a file"
3888         [ -f $DIR/$tdir/foo_ren ] && error "$tdir/foo_ren is not a file"
3889         lsattr $DIR/$tdir/foo | egrep -q "^-+i[-e]+ $DIR/$tdir/foo" ||
3890                                                         error "lsattr"
3891         chattr -i $DIR/$tdir/foo || error "chattr failed"
3892
3893         rm -fr $DIR/$tdir || error "unable to remove $DIR/$tdir"
3894 }
3895 run_test 52b "immutable flag test (should return errors) ======="
3896
3897 test_53() {
3898         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3899         remote_mds_nodsh && skip "remote MDS with nodsh" && return
3900         remote_ost_nodsh && skip "remote OST with nodsh" && return
3901
3902         local param
3903         local param_seq
3904         local ostname
3905         local mds_last
3906         local mds_last_seq
3907         local ost_last
3908         local ost_last_seq
3909         local ost_last_id
3910         local ostnum
3911         local node
3912         local found=false
3913         local support_last_seq=true
3914
3915         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.3.60) ]] ||
3916                 support_last_seq=false
3917
3918         # only test MDT0000
3919         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS)
3920         local value
3921         for value in $(do_facet $SINGLEMDS \
3922                        $LCTL get_param osc.$mdtosc.prealloc_last_id) ; do
3923                 param=$(echo ${value[0]} | cut -d "=" -f1)
3924                 ostname=$(echo $param | cut -d "." -f2 | cut -d - -f 1-2)
3925
3926                 if $support_last_seq; then
3927                         param_seq=$(echo $param |
3928                                 sed -e s/prealloc_last_id/prealloc_last_seq/g)
3929                         mds_last_seq=$(do_facet $SINGLEMDS \
3930                                        $LCTL get_param -n $param_seq)
3931                 fi
3932                 mds_last=$(do_facet $SINGLEMDS $LCTL get_param -n $param)
3933
3934                 ostnum=$(index_from_ostuuid ${ostname}_UUID)
3935                 node=$(facet_active_host ost$((ostnum+1)))
3936                 param="obdfilter.$ostname.last_id"
3937                 for ost_last in $(do_node $node $LCTL get_param -n $param) ; do
3938                         echo "$ostname.last_id=$ost_last; MDS.last_id=$mds_last"
3939                         ost_last_id=$ost_last
3940
3941                         if $support_last_seq; then
3942                                 ost_last_id=$(echo $ost_last |
3943                                               awk -F':' '{print $2}' |
3944                                               sed -e "s/^0x//g")
3945                                 ost_last_seq=$(echo $ost_last |
3946                                                awk -F':' '{print $1}')
3947                                 [[ $ost_last_seq = $mds_last_seq ]] || continue
3948                         fi
3949
3950                         if [[ $ost_last_id != $mds_last ]]; then
3951                                 error "$ost_last_id != $mds_last"
3952                         else
3953                                 found=true
3954                                 break
3955                         fi
3956                 done
3957         done
3958         $found || error "can not match last_seq/last_id for $mdtosc"
3959         return 0
3960 }
3961 run_test 53 "verify that MDS and OSTs agree on pre-creation ===="
3962
3963 test_54a() {
3964         $SOCKETSERVER $DIR/socket ||
3965                 error "$SOCKETSERVER $DIR/socket failed: $?"
3966         $SOCKETCLIENT $DIR/socket ||
3967                 error "$SOCKETCLIENT $DIR/socket failed: $?"
3968         $MUNLINK $DIR/socket || error "$MUNLINK $DIR/socket failed: $?"
3969 }
3970 run_test 54a "unix domain socket test =========================="
3971
3972 test_54b() {
3973         f="$DIR/f54b"
3974         mknod $f c 1 3
3975         chmod 0666 $f
3976         dd if=/dev/zero of=$f bs=$(page_size) count=1
3977 }
3978 run_test 54b "char device works in lustre ======================"
3979
3980 find_loop_dev() {
3981         [ -b /dev/loop/0 ] && LOOPBASE=/dev/loop/
3982         [ -b /dev/loop0 ] && LOOPBASE=/dev/loop
3983         [ -z "$LOOPBASE" ] && echo "/dev/loop/0 and /dev/loop0 gone?" && return
3984
3985         for i in $(seq 3 7); do
3986                 losetup $LOOPBASE$i > /dev/null 2>&1 && continue
3987                 LOOPDEV=$LOOPBASE$i
3988                 LOOPNUM=$i
3989                 break
3990         done
3991 }
3992
3993 test_54c() {
3994         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3995         tfile="$DIR/f54c"
3996         tdir="$DIR/d54c"
3997         loopdev="$DIR/loop54c"
3998
3999         find_loop_dev
4000         [ -z "$LOOPNUM" ] && echo "couldn't find empty loop device" && return
4001         mknod $loopdev b 7 $LOOPNUM
4002         echo "make a loop file system with $tfile on $loopdev ($LOOPNUM)..."
4003         dd if=/dev/zero of=$tfile bs=`page_size` seek=1024 count=1 > /dev/null
4004         losetup $loopdev $tfile || error "can't set up $loopdev for $tfile"
4005         mkfs.ext2 $loopdev || error "mke2fs on $loopdev"
4006         test_mkdir -p $tdir
4007         mount -t ext2 $loopdev $tdir || error "error mounting $loopdev on $tdir"
4008         dd if=/dev/zero of=$tdir/tmp bs=`page_size` count=30 || error "dd write"
4009         df $tdir
4010         dd if=$tdir/tmp of=/dev/zero bs=`page_size` count=30 || error "dd read"
4011         $UMOUNT -d $tdir
4012         losetup -d $loopdev
4013         rm $loopdev
4014 }
4015 run_test 54c "block device works in lustre ====================="
4016
4017 test_54d() {
4018         f="$DIR/f54d"
4019         string="aaaaaa"
4020         mknod $f p
4021         [ "$string" = $(echo $string > $f | cat $f) ] || error "$f != $string"
4022 }
4023 run_test 54d "fifo device works in lustre ======================"
4024
4025 test_54e() {
4026         check_kernel_version 46 || return 0
4027         f="$DIR/f54e"
4028         string="aaaaaa"
4029         cp -aL /dev/console $f
4030         echo $string > $f || error "echo $string to $f failed"
4031 }
4032 run_test 54e "console/tty device works in lustre ======================"
4033
4034 #The test_55 used to be iopen test and it was removed by bz#24037.
4035 #run_test 55 "check iopen_connect_dentry() ======================"
4036
4037 test_56a() {    # was test_56
4038         rm -rf $DIR/$tdir
4039         $SETSTRIPE -d $DIR
4040         test_mkdir -p $DIR/$tdir/dir
4041         NUMFILES=3
4042         NUMFILESx2=$(($NUMFILES * 2))
4043         for i in `seq 1 $NUMFILES` ; do
4044                 touch $DIR/$tdir/file$i
4045                 touch $DIR/$tdir/dir/file$i
4046         done
4047
4048         # test lfs getstripe with --recursive
4049         FILENUM=`$GETSTRIPE --recursive $DIR/$tdir | grep -c obdidx`
4050         [ $FILENUM -eq $NUMFILESx2 ] ||
4051                 error "$GETSTRIPE --recursive: found $FILENUM, not $NUMFILESx2"
4052         FILENUM=`$GETSTRIPE $DIR/$tdir | grep -c obdidx`
4053         [ $FILENUM -eq $NUMFILES ] ||
4054                 error "$GETSTRIPE $DIR/$tdir: found $FILENUM, not $NUMFILES"
4055         echo "$GETSTRIPE --recursive passed."
4056
4057         # test lfs getstripe with file instead of dir
4058         FILENUM=`$GETSTRIPE $DIR/$tdir/file1 | grep -c obdidx`
4059         [ $FILENUM  -eq 1 ] || error \
4060                  "$GETSTRIPE $DIR/$tdir/file1: found $FILENUM, not 1"
4061         echo "$GETSTRIPE file1 passed."
4062
4063         #test lfs getstripe with --verbose
4064         [ `$GETSTRIPE --verbose $DIR/$tdir |
4065                         grep -c lmm_magic` -eq $NUMFILES ] ||
4066                 error "$GETSTRIPE --verbose $DIR/$tdir: want $NUMFILES"
4067         [ `$GETSTRIPE $DIR/$tdir | grep -c lmm_magic` -eq 0 ] ||
4068             error "$GETSTRIPE $DIR/$tdir: showed lmm_magic"
4069         echo "$GETSTRIPE --verbose passed."
4070
4071         #test lfs getstripe with --obd
4072         $GETSTRIPE --obd wrong_uuid $DIR/$tdir 2>&1 |
4073                                         grep -q "unknown obduuid" ||
4074                 error "$GETSTRIPE --obd wrong_uuid should return error message"
4075
4076         [  "$OSTCOUNT" -lt 2 ] &&
4077                 skip_env "skipping other $GETSTRIPE --obd test" && return
4078
4079         OSTIDX=1
4080         OBDUUID=$(ostuuid_from_index $OSTIDX)
4081         FILENUM=`$GETSTRIPE -ir $DIR/$tdir | grep -x $OSTIDX | wc -l`
4082         FOUND=`$GETSTRIPE -r --obd $OBDUUID $DIR/$tdir | grep obdidx | wc -l`
4083         [ $FOUND -eq $FILENUM ] ||
4084                 error "$GETSTRIPE --obd wrong: found $FOUND, expected $FILENUM"
4085         [ `$GETSTRIPE -r -v --obd $OBDUUID $DIR/$tdir |
4086                 sed '/^[         ]*'${OSTIDX}'[  ]/d' |
4087                 sed -n '/^[      ]*[0-9][0-9]*[  ]/p' | wc -l` -eq 0 ] ||
4088                 error "$GETSTRIPE --obd: should not show file on other obd"
4089         echo "$GETSTRIPE --obd passed"
4090 }
4091 run_test 56a "check $GETSTRIPE"
4092
4093 NUMFILES=3
4094 NUMDIRS=3
4095 setup_56() {
4096         local LOCAL_NUMFILES="$1"
4097         local LOCAL_NUMDIRS="$2"
4098         local MKDIR_PARAMS="$3"
4099
4100         if [ ! -d "$TDIR" ] ; then
4101                 test_mkdir -p $TDIR
4102                 [ "$MKDIR_PARAMS" ] && $SETSTRIPE $MKDIR_PARAMS $TDIR
4103                 for i in `seq 1 $LOCAL_NUMFILES` ; do
4104                         touch $TDIR/file$i
4105                 done
4106                 for i in `seq 1 $LOCAL_NUMDIRS` ; do
4107                         test_mkdir $TDIR/dir$i
4108                         for j in `seq 1 $LOCAL_NUMFILES` ; do
4109                                 touch $TDIR/dir$i/file$j
4110                         done
4111                 done
4112         fi
4113 }
4114
4115 setup_56_special() {
4116         LOCAL_NUMFILES=$1
4117         LOCAL_NUMDIRS=$2
4118         setup_56 $1 $2
4119         if [ ! -e "$TDIR/loop1b" ] ; then
4120                 for i in `seq 1 $LOCAL_NUMFILES` ; do
4121                         mknod $TDIR/loop${i}b b 7 $i
4122                         mknod $TDIR/null${i}c c 1 3
4123                         ln -s $TDIR/file1 $TDIR/link${i}l
4124                 done
4125                 for i in `seq 1 $LOCAL_NUMDIRS` ; do
4126                         mknod $TDIR/dir$i/loop${i}b b 7 $i
4127                         mknod $TDIR/dir$i/null${i}c c 1 3
4128                         ln -s $TDIR/dir$i/file1 $TDIR/dir$i/link${i}l
4129                 done
4130         fi
4131 }
4132
4133 test_56g() {
4134         $SETSTRIPE -d $DIR
4135
4136         TDIR=$DIR/${tdir}g
4137         setup_56 $NUMFILES $NUMDIRS
4138
4139         EXPECTED=$(($NUMDIRS + 2))
4140         # test lfs find with -name
4141         for i in $(seq 1 $NUMFILES) ; do
4142                 NUMS=$($LFIND -name "*$i" $TDIR | wc -l)
4143                 [ $NUMS -eq $EXPECTED ] ||
4144                         error "lfs find -name \"*$i\" $TDIR wrong: "\
4145                               "found $NUMS, expected $EXPECTED"
4146         done
4147 }
4148 run_test 56g "check lfs find -name ============================="
4149
4150 test_56h() {
4151         $SETSTRIPE -d $DIR
4152
4153         TDIR=$DIR/${tdir}g
4154         setup_56 $NUMFILES $NUMDIRS
4155
4156         EXPECTED=$(((NUMDIRS + 1) * (NUMFILES - 1) + NUMFILES))
4157         # test lfs find with ! -name
4158         for i in $(seq 1 $NUMFILES) ; do
4159                 NUMS=$($LFIND ! -name "*$i" $TDIR | wc -l)
4160                 [ $NUMS -eq $EXPECTED ] ||
4161                         error "lfs find ! -name \"*$i\" $TDIR wrong: "\
4162                               "found $NUMS, expected $EXPECTED"
4163         done
4164 }
4165 run_test 56h "check lfs find ! -name ============================="
4166
4167 test_56i() {
4168        tdir=${tdir}i
4169        test_mkdir -p $DIR/$tdir
4170        UUID=$(ostuuid_from_index 0 $DIR/$tdir)
4171        CMD="$LFIND -ost $UUID $DIR/$tdir"
4172        OUT=$($CMD)
4173        [ -z "$OUT" ] || error "\"$CMD\" returned directory '$OUT'"
4174 }
4175 run_test 56i "check 'lfs find -ost UUID' skips directories ======="
4176
4177 test_56j() {
4178         TDIR=$DIR/${tdir}g
4179         setup_56_special $NUMFILES $NUMDIRS
4180
4181         EXPECTED=$((NUMDIRS + 1))
4182         CMD="$LFIND -type d $TDIR"
4183         NUMS=$($CMD | wc -l)
4184         [ $NUMS -eq $EXPECTED ] ||
4185                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4186 }
4187 run_test 56j "check lfs find -type d ============================="
4188
4189 test_56k() {
4190         TDIR=$DIR/${tdir}g
4191         setup_56_special $NUMFILES $NUMDIRS
4192
4193         EXPECTED=$(((NUMDIRS + 1) * NUMFILES))
4194         CMD="$LFIND -type f $TDIR"
4195         NUMS=$($CMD | wc -l)
4196         [ $NUMS -eq $EXPECTED ] ||
4197                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4198 }
4199 run_test 56k "check lfs find -type f ============================="
4200
4201 test_56l() {
4202         TDIR=$DIR/${tdir}g
4203         setup_56_special $NUMFILES $NUMDIRS
4204
4205         EXPECTED=$((NUMDIRS + NUMFILES))
4206         CMD="$LFIND -type b $TDIR"
4207         NUMS=$($CMD | wc -l)
4208         [ $NUMS -eq $EXPECTED ] ||
4209                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4210 }
4211 run_test 56l "check lfs find -type b ============================="
4212
4213 test_56m() {
4214         TDIR=$DIR/${tdir}g
4215         setup_56_special $NUMFILES $NUMDIRS
4216
4217         EXPECTED=$((NUMDIRS + NUMFILES))
4218         CMD="$LFIND -type c $TDIR"
4219         NUMS=$($CMD | wc -l)
4220         [ $NUMS -eq $EXPECTED ] ||
4221                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4222 }
4223 run_test 56m "check lfs find -type c ============================="
4224
4225 test_56n() {
4226         TDIR=$DIR/${tdir}g
4227         setup_56_special $NUMFILES $NUMDIRS
4228
4229         EXPECTED=$((NUMDIRS + NUMFILES))
4230         CMD="$LFIND -type l $TDIR"
4231         NUMS=$($CMD | wc -l)
4232         [ $NUMS -eq $EXPECTED ] ||
4233                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4234 }
4235 run_test 56n "check lfs find -type l ============================="
4236
4237 test_56o() {
4238         TDIR=$DIR/${tdir}o
4239         setup_56 $NUMFILES $NUMDIRS
4240
4241         utime $TDIR/file1 > /dev/null || error "utime (1)"
4242         utime $TDIR/file2 > /dev/null || error "utime (2)"
4243         utime $TDIR/dir1 > /dev/null || error "utime (3)"
4244         utime $TDIR/dir2 > /dev/null || error "utime (4)"
4245         utime $TDIR/dir1/file1 > /dev/null || error "utime (5)"
4246         dd if=/dev/zero count=1 >> $TDIR/dir1/file1 && sync
4247
4248         EXPECTED=4
4249         NUMS=`$LFIND -mtime +0 $TDIR | wc -l`
4250         [ $NUMS -eq $EXPECTED ] || \
4251                 error "lfs find -mtime +0 $TDIR wrong: found $NUMS, expected $EXPECTED"
4252
4253         EXPECTED=12
4254         CMD="$LFIND -mtime 0 $TDIR"
4255         NUMS=$($CMD | wc -l)
4256         [ $NUMS -eq $EXPECTED ] ||
4257                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4258 }
4259 run_test 56o "check lfs find -mtime for old files =========================="
4260
4261 test_56p() {
4262         [ $RUNAS_ID -eq $UID ] &&
4263                 skip_env "RUNAS_ID = UID = $UID -- skipping" && return
4264
4265         TDIR=$DIR/${tdir}p
4266         setup_56 $NUMFILES $NUMDIRS
4267
4268         chown $RUNAS_ID $TDIR/file* || error "chown $DIR/${tdir}g/file$i failed"
4269         EXPECTED=$NUMFILES
4270         CMD="$LFIND -uid $RUNAS_ID $TDIR"
4271         NUMS=$($CMD | wc -l)
4272         [ $NUMS -eq $EXPECTED ] || \
4273                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4274
4275         EXPECTED=$(((NUMFILES + 1) * NUMDIRS + 1))
4276         CMD="$LFIND ! -uid $RUNAS_ID $TDIR"
4277         NUMS=$($CMD | wc -l)
4278         [ $NUMS -eq $EXPECTED ] || \
4279                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4280 }
4281 run_test 56p "check lfs find -uid and ! -uid ==============================="
4282
4283 test_56q() {
4284         [ $RUNAS_ID -eq $UID ] &&
4285                 skip_env "RUNAS_ID = UID = $UID -- skipping" && return
4286
4287         TDIR=$DIR/${tdir}q
4288         setup_56 $NUMFILES $NUMDIRS
4289
4290         chgrp $RUNAS_GID $TDIR/file* || error "chown $TDIR/file$i failed"
4291
4292         EXPECTED=$NUMFILES
4293         CMD="$LFIND -gid $RUNAS_GID $TDIR"
4294         NUMS=$($CMD | wc -l)
4295         [ $NUMS -eq $EXPECTED ] ||
4296                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4297
4298         EXPECTED=$(( ($NUMFILES+1) * $NUMDIRS + 1))
4299         CMD="$LFIND ! -gid $RUNAS_GID $TDIR"
4300         NUMS=$($CMD | wc -l)
4301         [ $NUMS -eq $EXPECTED ] ||
4302                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4303 }
4304 run_test 56q "check lfs find -gid and ! -gid ==============================="
4305
4306 test_56r() {
4307         TDIR=$DIR/${tdir}r
4308         setup_56 $NUMFILES $NUMDIRS
4309
4310         EXPECTED=12
4311         CMD="$LFIND -size 0 -type f $TDIR"
4312         NUMS=$($CMD | wc -l)
4313         [ $NUMS -eq $EXPECTED ] ||
4314                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4315         EXPECTED=0
4316         CMD="$LFIND ! -size 0 -type f $TDIR"
4317         NUMS=$($CMD | wc -l)
4318         [ $NUMS -eq $EXPECTED ] ||
4319                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4320         echo "test" > $TDIR/$tfile
4321         echo "test2" > $TDIR/$tfile.2 && sync
4322         EXPECTED=1
4323         CMD="$LFIND -size 5 -type f $TDIR"
4324         NUMS=$($CMD | wc -l)
4325         [ $NUMS -eq $EXPECTED ] ||
4326                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4327         EXPECTED=1
4328         CMD="$LFIND -size +5 -type f $TDIR"
4329         NUMS=$($CMD | wc -l)
4330         [ $NUMS -eq $EXPECTED ] ||
4331                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4332         EXPECTED=2
4333         CMD="$LFIND -size +0 -type f $TDIR"
4334         NUMS=$($CMD | wc -l)
4335         [ $NUMS -eq $EXPECTED ] ||
4336                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4337         EXPECTED=2
4338         CMD="$LFIND ! -size -5 -type f $TDIR"
4339         NUMS=$($CMD | wc -l)
4340         [ $NUMS -eq $EXPECTED ] ||
4341                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4342         EXPECTED=12
4343         CMD="$LFIND -size -5 -type f $TDIR"
4344         NUMS=$($CMD | wc -l)
4345         [ $NUMS -eq $EXPECTED ] ||
4346                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4347 }
4348 run_test 56r "check lfs find -size works =========================="
4349
4350 test_56s() { # LU-611
4351         TDIR=$DIR/${tdir}s
4352         setup_56 $NUMFILES $NUMDIRS "-c $OSTCOUNT"
4353
4354         if [ $OSTCOUNT -gt 1 ]; then
4355                 $SETSTRIPE -c 1 $TDIR/$tfile.{0,1,2,3}
4356                 ONESTRIPE=4
4357                 EXTRA=4
4358         else
4359                 ONESTRIPE=$(((NUMDIRS + 1) * NUMFILES))
4360                 EXTRA=0
4361         fi
4362
4363         EXPECTED=$(((NUMDIRS + 1) * NUMFILES))
4364         CMD="$LFIND -stripe-count $OSTCOUNT -type f $TDIR"
4365         NUMS=$($CMD | wc -l)
4366         [ $NUMS -eq $EXPECTED ] ||
4367                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4368
4369         EXPECTED=$(((NUMDIRS + 1) * NUMFILES + EXTRA))
4370         CMD="$LFIND -stripe-count +0 -type f $TDIR"
4371         NUMS=$($CMD | wc -l)
4372         [ $NUMS -eq $EXPECTED ] ||
4373                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4374
4375         EXPECTED=$ONESTRIPE
4376         CMD="$LFIND -stripe-count 1 -type f $TDIR"
4377         NUMS=$($CMD | wc -l)
4378         [ $NUMS -eq $EXPECTED ] ||
4379                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4380
4381         CMD="$LFIND -stripe-count -2 -type f $TDIR"
4382         NUMS=$($CMD | wc -l)
4383         [ $NUMS -eq $EXPECTED ] ||
4384                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4385
4386         EXPECTED=0
4387         CMD="$LFIND -stripe-count $((OSTCOUNT + 1)) -type f $TDIR"
4388         NUMS=$($CMD | wc -l)
4389         [ $NUMS -eq $EXPECTED ] ||
4390                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4391 }
4392 run_test 56s "check lfs find -stripe-count works"
4393
4394 test_56t() { # LU-611
4395         TDIR=$DIR/${tdir}t
4396         setup_56 $NUMFILES $NUMDIRS "-s 512k"
4397
4398         $SETSTRIPE -S 256k $TDIR/$tfile.{0,1,2,3}
4399
4400         EXPECTED=$(((NUMDIRS + 1) * NUMFILES))
4401         CMD="$LFIND -stripe-size 512k -type f $TDIR"
4402         NUMS=$($CMD | wc -l)
4403         [ $NUMS -eq $EXPECTED ] ||
4404                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4405
4406         CMD="$LFIND -stripe-size +320k -type f $TDIR"
4407         NUMS=$($CMD | wc -l)
4408         [ $NUMS -eq $EXPECTED ] ||
4409                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4410
4411         EXPECTED=$(((NUMDIRS + 1) * NUMFILES + 4))
4412         CMD="$LFIND -stripe-size +200k -type f $TDIR"
4413         NUMS=$($CMD | wc -l)
4414         [ $NUMS -eq $EXPECTED ] ||
4415                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4416
4417         CMD="$LFIND -stripe-size -640k -type f $TDIR"
4418         NUMS=$($CMD | wc -l)
4419         [ $NUMS -eq $EXPECTED ] ||
4420                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4421
4422         EXPECTED=4
4423         CMD="$LFIND -stripe-size 256k -type f $TDIR"
4424         NUMS=$($CMD | wc -l)
4425         [ $NUMS -eq $EXPECTED ] ||
4426                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4427
4428         CMD="$LFIND -stripe-size -320k -type f $TDIR"
4429         NUMS=$($CMD | wc -l)
4430         [ $NUMS -eq $EXPECTED ] ||
4431                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4432
4433         EXPECTED=0
4434         CMD="$LFIND -stripe-size 1024k -type f $TDIR"
4435         NUMS=$($CMD | wc -l)
4436         [ $NUMS -eq $EXPECTED ] ||
4437                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4438 }
4439 run_test 56t "check lfs find -stripe-size works"
4440
4441 test_56u() { # LU-611
4442         TDIR=$DIR/${tdir}u
4443         setup_56 $NUMFILES $NUMDIRS "-i 0"
4444
4445         if [ $OSTCOUNT -gt 1 ]; then
4446                 $SETSTRIPE -i 1 $TDIR/$tfile.{0,1,2,3}
4447                 ONESTRIPE=4
4448         else
4449                 ONESTRIPE=0
4450         fi
4451
4452         EXPECTED=$(((NUMDIRS + 1) * NUMFILES))
4453         CMD="$LFIND -stripe-index 0 -type f $TDIR"
4454         NUMS=$($CMD | wc -l)
4455         [ $NUMS -eq $EXPECTED ] ||
4456                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4457
4458         EXPECTED=$ONESTRIPE
4459         CMD="$LFIND -stripe-index 1 -type f $TDIR"
4460         NUMS=$($CMD | wc -l)
4461         [ $NUMS -eq $EXPECTED ] ||
4462                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4463
4464         CMD="$LFIND ! -stripe-index 0 -type f $TDIR"
4465         NUMS=$($CMD | wc -l)
4466         [ $NUMS -eq $EXPECTED ] ||
4467                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4468
4469         EXPECTED=0
4470         # This should produce an error and not return any files
4471         CMD="$LFIND -stripe-index $OSTCOUNT -type f $TDIR"
4472         NUMS=$($CMD 2>/dev/null | wc -l)
4473         [ $NUMS -eq $EXPECTED ] ||
4474                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4475
4476         if [ $OSTCOUNT -gt 1 ]; then
4477                 EXPECTED=$(((NUMDIRS + 1) * NUMFILES + ONESTRIPE))
4478                 CMD="$LFIND -stripe-index 0,1 -type f $TDIR"
4479                 NUMS=$($CMD | wc -l)
4480                 [ $NUMS -eq $EXPECTED ] ||
4481                         error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4482         fi
4483 }
4484 run_test 56u "check lfs find -stripe-index works"
4485
4486 test_56v() {
4487     local MDT_IDX=0
4488
4489     TDIR=$DIR/${tdir}v
4490     rm -rf $TDIR
4491     setup_56 $NUMFILES $NUMDIRS
4492
4493     UUID=$(mdtuuid_from_index $MDT_IDX $TDIR)
4494     [ -z "$UUID" ] && error "mdtuuid_from_index cannot find MDT index $MDT_IDX"
4495
4496     for file in $($LFIND -mdt $UUID $TDIR); do
4497         file_mdt_idx=$($GETSTRIPE -M $file)
4498         [ $file_mdt_idx -eq $MDT_IDX ] ||
4499             error "'lfind -mdt $UUID' != 'getstripe -M' ($file_mdt_idx)"
4500     done
4501 }
4502 run_test 56v "check 'lfs find -mdt match with lfs getstripe -M' ======="
4503
4504 # Get and check the actual stripe count of one file.
4505 # Usage: check_stripe_count <file> <expected_stripe_count>
4506 check_stripe_count() {
4507     local file=$1
4508     local expected=$2
4509     local actual
4510
4511     [[ -z "$file" || -z "$expected" ]] &&
4512         error "check_stripe_count: invalid argument!"
4513
4514     local cmd="$GETSTRIPE -c $file"
4515     actual=$($cmd) || error "$cmd failed"
4516     actual=${actual%% *}
4517
4518     if [[ $actual -ne $expected ]]; then
4519         [[ $expected -eq -1 ]] ||
4520             error "$cmd wrong: found $actual, expected $expected"
4521         [[ $actual -eq $OSTCOUNT ]] ||
4522             error "$cmd wrong: found $actual, expected $OSTCOUNT"
4523     fi
4524 }
4525
4526 test_56w() {
4527         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4528         TDIR=$DIR/${tdir}w
4529
4530     rm -rf $TDIR || error "remove $TDIR failed"
4531     setup_56 $NUMFILES $NUMDIRS "-c $OSTCOUNT"
4532
4533     local stripe_size
4534     stripe_size=$($GETSTRIPE -S -d $TDIR) ||
4535         error "$GETSTRIPE -S -d $TDIR failed"
4536     stripe_size=${stripe_size%% *}
4537
4538     local file_size=$((stripe_size * OSTCOUNT))
4539     local file_num=$((NUMDIRS * NUMFILES + NUMFILES))
4540     local required_space=$((file_num * file_size))
4541     local free_space=$($LCTL get_param -n lov.$LOVNAME.kbytesavail)
4542     [[ $free_space -le $((required_space / 1024)) ]] &&
4543         skip_env "need at least $required_space bytes free space," \
4544                  "have $free_space kbytes" && return
4545
4546     local dd_bs=65536
4547     local dd_count=$((file_size / dd_bs))
4548
4549     # write data into the files
4550     local i
4551     local j
4552     local file
4553     for i in $(seq 1 $NUMFILES); do
4554         file=$TDIR/file$i
4555         yes | dd bs=$dd_bs count=$dd_count of=$file >/dev/null 2>&1 ||
4556             error "write data into $file failed"
4557     done
4558     for i in $(seq 1 $NUMDIRS); do
4559         for j in $(seq 1 $NUMFILES); do
4560             file=$TDIR/dir$i/file$j
4561             yes | dd bs=$dd_bs count=$dd_count of=$file \
4562                 >/dev/null 2>&1 ||
4563                 error "write data into $file failed"
4564         done
4565     done
4566
4567     local expected=-1
4568     [[ $OSTCOUNT -gt 1 ]] && expected=$((OSTCOUNT - 1))
4569
4570     # lfs_migrate file
4571     local cmd="$LFS_MIGRATE -y -c $expected $TDIR/file1"
4572     echo "$cmd"
4573     eval $cmd || error "$cmd failed"
4574
4575     check_stripe_count $TDIR/file1 $expected
4576
4577     # lfs_migrate dir
4578     cmd="$LFS_MIGRATE -y -c $expected $TDIR/dir1"
4579     echo "$cmd"
4580     eval $cmd || error "$cmd failed"
4581
4582     for j in $(seq 1 $NUMFILES); do
4583         check_stripe_count $TDIR/dir1/file$j $expected
4584     done
4585
4586     # lfs_migrate works with lfs find
4587     cmd="$LFIND -stripe_count $OSTCOUNT -type f $TDIR |
4588          $LFS_MIGRATE -y -c $expected"
4589     echo "$cmd"
4590     eval $cmd || error "$cmd failed"
4591
4592     for i in $(seq 2 $NUMFILES); do
4593         check_stripe_count $TDIR/file$i $expected
4594     done
4595     for i in $(seq 2 $NUMDIRS); do
4596         for j in $(seq 1 $NUMFILES); do
4597             check_stripe_count $TDIR/dir$i/file$j $expected
4598         done
4599     done
4600 }
4601 run_test 56w "check lfs_migrate -c stripe_count works"
4602
4603 test_56x() {
4604         check_swap_layouts_support && return 0
4605         [ "$OSTCOUNT" -lt "2" ] &&
4606                 skip_env "need 2 OST, skipping test" && return
4607
4608         local dir0=$DIR/$tdir/$testnum
4609         mkdir -p $dir0 || error "creating dir $dir0"
4610
4611         local ref1=/etc/passwd
4612         local file1=$dir0/file1
4613
4614         $SETSTRIPE -c 2 $file1
4615         cp $ref1 $file1
4616         $LFS migrate -c 1 $file1 || error "migrate failed rc = $?"
4617         stripe=$($GETSTRIPE -c $file1)
4618         [[ $stripe == 1 ]] || error "stripe of $file1 is $stripe != 1"
4619         cmp $file1 $ref1 || error "content mismatch $file1 differs from $ref1"
4620
4621         # clean up
4622         rm -f $file1
4623 }
4624 run_test 56x "lfs migration support"
4625
4626 test_56y() {
4627         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.4.53) ] &&
4628                 skip "No HSM support on MDS of $(get_lustre_version)," \
4629                          "need 2.4.53 at least" && return
4630         local res=""
4631
4632         local dir0=$DIR/$tdir/$testnum
4633         mkdir -p $dir0 || error "creating dir $dir0"
4634         local f1=$dir0/file1
4635         local f2=$dir0/file2
4636
4637         touch $f1 || error "creating std file $f1"
4638         $MULTIOP $f2 H2c || error "creating released file $f2"
4639
4640         # a directory can be raid0, so ask only for files
4641         res=$($LFIND $dir0 -L raid0 -type f | wc -l)
4642         [[ $res == 2 ]] || error "search raid0: found $res files != 2"
4643
4644         res=$($LFIND $dir0 \! -L raid0 -type f | wc -l)
4645         [[ $res == 0 ]] || error "search !raid0: found $res files != 0"
4646
4647         # only files can be released, so no need to force file search
4648         res=$($LFIND $dir0 -L released)
4649         [[ $res == $f2 ]] || error "search released: found $res != $f2"
4650
4651         res=$($LFIND $dir0 \! -L released)
4652         [[ $res == $f1 ]] || error "search !released: found $res != $f1"
4653
4654 }
4655 run_test 56y "lfs find -L raid0|released"
4656
4657 test_57a() {
4658         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4659         # note test will not do anything if MDS is not local
4660         if [ "$(facet_fstype $SINGLEMDS)" != ldiskfs ]; then
4661                 skip "Only applicable to ldiskfs-based MDTs"
4662                 return
4663         fi
4664
4665         remote_mds_nodsh && skip "remote MDS with nodsh" && return
4666         local MNTDEV="osd*.*MDT*.mntdev"
4667         DEV=$(do_facet $SINGLEMDS lctl get_param -n $MNTDEV)
4668         [ -z "$DEV" ] && error "can't access $MNTDEV"
4669         for DEV in $(do_facet $SINGLEMDS lctl get_param -n $MNTDEV); do
4670                 do_facet $SINGLEMDS $DUMPE2FS -h $DEV > $TMP/t57a.dump ||
4671                         error "can't access $DEV"
4672                 DEVISIZE=`awk '/Inode size:/ { print $3 }' $TMP/t57a.dump`
4673                 [ "$DEVISIZE" -gt 128 ] || error "inode size $DEVISIZE"
4674                 rm $TMP/t57a.dump
4675         done
4676 }
4677 run_test 57a "verify MDS filesystem created with large inodes =="
4678
4679 test_57b() {
4680         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4681         if [ "$(facet_fstype $SINGLEMDS)" != ldiskfs ]; then
4682                 skip "Only applicable to ldiskfs-based MDTs"
4683                 return
4684         fi
4685
4686         remote_mds_nodsh && skip "remote MDS with nodsh" && return
4687         local dir=$DIR/d57b
4688
4689         local FILECOUNT=100
4690         local FILE1=$dir/f1
4691         local FILEN=$dir/f$FILECOUNT
4692
4693         rm -rf $dir || error "removing $dir"
4694         test_mkdir -p $dir || error "creating $dir"
4695         local num=$(get_mds_dir $dir)
4696         local mymds=mds$num
4697
4698         echo "mcreating $FILECOUNT files"
4699         createmany -m $dir/f 1 $FILECOUNT || \
4700                 error "creating files in $dir"
4701
4702         # verify that files do not have EAs yet
4703         $GETSTRIPE $FILE1 2>&1 | grep -q "no stripe" || error "$FILE1 has an EA"
4704         $GETSTRIPE $FILEN 2>&1 | grep -q "no stripe" || error "$FILEN has an EA"
4705
4706         sync
4707         sleep 1
4708         df $dir  #make sure we get new statfs data
4709         local MDSFREE=$(do_facet $mymds \
4710                 lctl get_param -n osd*.*MDT000$((num -1)).kbytesfree)
4711         local MDCFREE=$(lctl get_param -n mdc.*MDT000$((num -1))-mdc-*.kbytesfree)
4712         echo "opening files to create objects/EAs"
4713         local FILE
4714         for FILE in `seq -f $dir/f%g 1 $FILECOUNT`; do
4715                 $OPENFILE -f O_RDWR $FILE > /dev/null 2>&1 || error "opening $FILE"
4716         done
4717
4718         # verify that files have EAs now
4719         $GETSTRIPE $FILE1 | grep -q "obdidx" || error "$FILE1 missing EA"
4720         $GETSTRIPE $FILEN | grep -q "obdidx" || error "$FILEN missing EA"
4721
4722         sleep 1  #make sure we get new statfs data
4723         df $dir
4724         local MDSFREE2=$(do_facet $mymds \
4725                 lctl get_param -n osd*.*MDT000$((num -1)).kbytesfree)
4726         local MDCFREE2=$(lctl get_param -n mdc.*MDT000$((num -1))-mdc-*.kbytesfree)
4727         if [ "$MDCFREE2" -lt "$((MDCFREE - 16))" ]; then
4728                 if [ "$MDSFREE" != "$MDSFREE2" ]; then
4729                         error "MDC before $MDCFREE != after $MDCFREE2"
4730                 else
4731                         echo "MDC before $MDCFREE != after $MDCFREE2"
4732                         echo "unable to confirm if MDS has large inodes"
4733                 fi
4734         fi
4735         rm -rf $dir
4736 }
4737 run_test 57b "default LOV EAs are stored inside large inodes ==="
4738
4739 test_58() {
4740         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4741         [ -z "$(which wiretest 2>/dev/null)" ] &&
4742                         skip_env "could not find wiretest" && return
4743         wiretest
4744 }
4745 run_test 58 "verify cross-platform wire constants =============="
4746
4747 test_59() {
4748         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4749         echo "touch 130 files"
4750         createmany -o $DIR/f59- 130
4751         echo "rm 130 files"
4752         unlinkmany $DIR/f59- 130
4753         sync
4754         # wait for commitment of removal
4755         wait_delete_completed
4756 }
4757 run_test 59 "verify cancellation of llog records async ========="
4758
4759 TEST60_HEAD="test_60 run $RANDOM"
4760 test_60a() {
4761         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4762         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
4763         do_facet mgs "! which run-llog.sh &> /dev/null" &&
4764                 skip_env "missing subtest run-llog.sh" && return
4765         log "$TEST60_HEAD - from kernel mode"
4766         do_facet mgs sh run-llog.sh
4767 }
4768 run_test 60a "llog sanity tests run from kernel module =========="
4769
4770 test_60b() { # bug 6411
4771         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4772         dmesg > $DIR/$tfile
4773         LLOG_COUNT=`dmesg | awk "/$TEST60_HEAD/{marker = 1; from_marker = 0;}
4774                                  /llog.test/ {
4775                                          if (marker)
4776                                                  from_marker++
4777                                          from_begin++
4778                                  }
4779                                  END {
4780                                          if (marker)
4781                                                  print from_marker
4782                                          else
4783                                                  print from_begin
4784                                  }"`
4785         [ $LLOG_COUNT -gt 50 ] && error "CDEBUG_LIMIT not limiting messages ($LLOG_COUNT)"|| true
4786 }
4787 run_test 60b "limit repeated messages from CERROR/CWARN ========"
4788
4789 test_60c() {
4790         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4791         echo "create 5000 files"
4792         createmany -o $DIR/f60c- 5000
4793 #define OBD_FAIL_MDS_LLOG_CREATE_FAILED  0x137
4794         lctl set_param fail_loc=0x80000137
4795         unlinkmany $DIR/f60c- 5000
4796         lctl set_param fail_loc=0
4797 }
4798 run_test 60c "unlink file when mds full"
4799
4800 test_60d() {
4801         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4802         SAVEPRINTK=$(lctl get_param -n printk)
4803
4804         # verify "lctl mark" is even working"
4805         MESSAGE="test message ID $RANDOM $$"
4806         $LCTL mark "$MESSAGE" || error "$LCTL mark failed"
4807         dmesg | grep -q "$MESSAGE" || error "didn't find debug marker in log"
4808
4809         lctl set_param printk=0 || error "set lnet.printk failed"
4810         lctl get_param -n printk | grep emerg || error "lnet.printk dropped emerg"
4811         MESSAGE="new test message ID $RANDOM $$"
4812         # Assume here that libcfs_debug_mark_buffer() uses D_WARNING
4813         $LCTL mark "$MESSAGE" || error "$LCTL mark failed"
4814         dmesg | grep -q "$MESSAGE" && error "D_WARNING wasn't masked" || true
4815
4816         lctl set_param -n printk="$SAVEPRINTK"
4817 }
4818 run_test 60d "test printk console message masking"
4819
4820 test_61() {
4821         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4822         f="$DIR/f61"
4823         dd if=/dev/zero of=$f bs=$(page_size) count=1 || error "dd $f failed"
4824         cancel_lru_locks osc
4825         $MULTIOP $f OSMWUc || error "$MULTIOP $f failed"
4826         sync
4827 }
4828 run_test 61 "mmap() writes don't make sync hang ================"
4829
4830 # bug 2330 - insufficient obd_match error checking causes LBUG
4831 test_62() {
4832         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4833         f="$DIR/f62"
4834         echo foo > $f
4835         cancel_lru_locks osc
4836         lctl set_param fail_loc=0x405
4837         cat $f && error "cat succeeded, expect -EIO"
4838         lctl set_param fail_loc=0
4839 }
4840 # This test is now irrelevant (as of bug 10718 inclusion), we no longer
4841 # match every page all of the time.
4842 #run_test 62 "verify obd_match failure doesn't LBUG (should -EIO)"
4843
4844 # bug 2319 - oig_wait() interrupted causes crash because of invalid waitq.
4845 # Though this test is irrelevant anymore, it helped to reveal some
4846 # other grant bugs (LU-4482), let's keep it.
4847 test_63a() {   # was test_63
4848         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4849         MAX_DIRTY_MB=`lctl get_param -n osc.*.max_dirty_mb | head -n 1`
4850         for i in `seq 10` ; do
4851                 dd if=/dev/zero of=$DIR/f63 bs=8k &
4852                 sleep 5
4853                 kill $!
4854                 sleep 1
4855         done
4856
4857         rm -f $DIR/f63 || true
4858 }
4859 run_test 63a "Verify oig_wait interruption does not crash ======="
4860
4861 # bug 2248 - async write errors didn't return to application on sync
4862 # bug 3677 - async write errors left page locked
4863 test_63b() {
4864         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4865         debugsave
4866         lctl set_param debug=-1
4867
4868         # ensure we have a grant to do async writes
4869         dd if=/dev/zero of=$DIR/$tfile bs=4k count=1
4870         rm $DIR/$tfile
4871
4872         #define OBD_FAIL_OSC_BRW_PREP_REQ        0x406
4873         lctl set_param fail_loc=0x80000406
4874         $MULTIOP $DIR/$tfile Owy && \
4875                 error "sync didn't return ENOMEM"
4876         sync; sleep 2; sync     # do a real sync this time to flush page
4877         lctl get_param -n llite.*.dump_page_cache | grep locked && \
4878                 error "locked page left in cache after async error" || true
4879         debugrestore
4880 }
4881 run_test 63b "async write errors should be returned to fsync ==="
4882
4883 test_64a () {
4884         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4885         df $DIR
4886         lctl get_param -n osc.*[oO][sS][cC][_-]*.cur* | grep "[0-9]"
4887 }
4888 run_test 64a "verify filter grant calculations (in kernel) ====="
4889
4890 test_64b () {
4891         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4892         sh oos.sh $MOUNT || error "oos.sh failed: $?"
4893 }
4894 run_test 64b "check out-of-space detection on client ==========="
4895
4896 test_64c() {
4897         $LCTL set_param osc.*OST0000-osc-[^mM]*.cur_grant_bytes=0
4898 }
4899 run_test 64c "verify grant shrink ========================------"
4900
4901 # bug 1414 - set/get directories' stripe info
4902 test_65a() {
4903         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4904         test_mkdir -p $DIR/$tdir
4905         touch $DIR/$tdir/f1
4906         $LVERIFY $DIR/$tdir $DIR/$tdir/f1 || error "lverify failed"
4907 }
4908 run_test 65a "directory with no stripe info ===================="
4909
4910 test_65b() {
4911         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4912         test_mkdir -p $DIR/$tdir
4913         $SETSTRIPE -S $((STRIPESIZE * 2)) -i 0 -c 1 $DIR/$tdir ||
4914                                                 error "setstripe"
4915         touch $DIR/$tdir/f2
4916         $LVERIFY $DIR/$tdir $DIR/$tdir/f2 || error "lverify failed"
4917 }
4918 run_test 65b "directory setstripe -S $((STRIPESIZE * 2)) -i 0 -c 1"
4919
4920 test_65c() {
4921         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4922         if [ $OSTCOUNT -gt 1 ]; then
4923                 test_mkdir -p $DIR/$tdir
4924                 $SETSTRIPE -S $(($STRIPESIZE * 4)) -i 1 \
4925                         -c $(($OSTCOUNT - 1)) $DIR/$tdir || error "setstripe"
4926                 touch $DIR/$tdir/f3
4927                 $LVERIFY $DIR/$tdir $DIR/$tdir/f3 || error "lverify failed"
4928         fi
4929 }
4930 run_test 65c "directory setstripe -S $((STRIPESIZE*4)) -i 1 -c $((OSTCOUNT-1))"
4931
4932 test_65d() {
4933         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4934         test_mkdir -p $DIR/$tdir
4935         if [ $STRIPECOUNT -le 0 ]; then
4936                 sc=1
4937         elif [ $STRIPECOUNT -gt 2000 ]; then
4938 #LOV_MAX_STRIPE_COUNT is 2000
4939                 [ $OSTCOUNT -gt 2000 ] && sc=2000 || sc=$(($OSTCOUNT - 1))
4940         else
4941                 sc=$(($STRIPECOUNT - 1))
4942         fi
4943         $SETSTRIPE -S $STRIPESIZE -c $sc $DIR/$tdir || error "setstripe"
4944         touch $DIR/$tdir/f4 $DIR/$tdir/f5
4945         $LVERIFY $DIR/$tdir $DIR/$tdir/f4 $DIR/$tdir/f5 ||
4946                                                 error "lverify failed"
4947 }
4948 run_test 65d "directory setstripe -S $STRIPESIZE -c stripe_count"
4949
4950 test_65e() {
4951         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4952         test_mkdir -p $DIR/$tdir
4953
4954         $SETSTRIPE $DIR/$tdir || error "setstripe"
4955         $GETSTRIPE -v $DIR/$tdir | grep "Default" ||
4956                                         error "no stripe info failed"
4957         touch $DIR/$tdir/f6
4958         $LVERIFY $DIR/$tdir $DIR/$tdir/f6 || error "lverify failed"
4959 }
4960 run_test 65e "directory setstripe defaults ======================="
4961
4962 test_65f() {
4963         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4964         test_mkdir -p $DIR/${tdir}f
4965         $RUNAS $SETSTRIPE $DIR/${tdir}f && error "setstripe succeeded" || true
4966 }
4967 run_test 65f "dir setstripe permission (should return error) ==="
4968
4969 test_65g() {
4970         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4971         test_mkdir -p $DIR/$tdir
4972         $SETSTRIPE -S $((STRIPESIZE * 2)) -i 0 -c 1 $DIR/$tdir ||
4973                                                         error "setstripe"
4974         $SETSTRIPE -d $DIR/$tdir || error "setstripe"
4975         $GETSTRIPE -v $DIR/$tdir | grep "Default" ||
4976                 error "delete default stripe failed"
4977 }
4978 run_test 65g "directory setstripe -d ==========================="
4979
4980 test_65h() {
4981         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4982         test_mkdir -p $DIR/$tdir
4983         $SETSTRIPE -S $((STRIPESIZE * 2)) -i 0 -c 1 $DIR/$tdir ||
4984                                                         error "setstripe"
4985         test_mkdir -p $DIR/$tdir/dd1
4986         [ $($GETSTRIPE -c $DIR/$tdir) == $($GETSTRIPE -c $DIR/$tdir/dd1) ] ||
4987                 error "stripe info inherit failed"
4988 }
4989 run_test 65h "directory stripe info inherit ===================="
4990
4991 test_65i() { # bug6367
4992         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4993         $SETSTRIPE -S 65536 -c -1 $MOUNT
4994 }
4995 run_test 65i "set non-default striping on root directory (bug 6367)="
4996
4997 test_65ia() { # bug12836
4998         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4999         $GETSTRIPE $MOUNT || error "getstripe $MOUNT failed"
5000 }
5001 run_test 65ia "getstripe on -1 default directory striping"
5002
5003 test_65ib() { # bug12836
5004         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5005         $GETSTRIPE -v $MOUNT || error "getstripe -v $MOUNT failed"
5006 }
5007 run_test 65ib "getstripe -v on -1 default directory striping"
5008
5009 test_65ic() { # bug12836
5010         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5011         $LFS find -mtime -1 $MOUNT > /dev/null || error "find $MOUNT failed"
5012 }
5013 run_test 65ic "new find on -1 default directory striping"
5014
5015 test_65j() { # bug6367
5016         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5017         sync; sleep 1
5018         # if we aren't already remounting for each test, do so for this test
5019         if [ "$CLEANUP" = ":" -a "$I_MOUNTED" = "yes" ]; then
5020                 cleanup || error "failed to unmount"
5021                 setup
5022         fi
5023         $SETSTRIPE -d $MOUNT || error "setstripe failed"
5024 }
5025 run_test 65j "set default striping on root directory (bug 6367)="
5026
5027 test_65k() { # bug11679
5028         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5029         [ "$OSTCOUNT" -lt 2 ] && skip_env "too few OSTs" && return
5030         remote_mds_nodsh && skip "remote MDS with nodsh" && return
5031
5032     echo "Check OST status: "
5033     local MDS_OSCS=`do_facet $SINGLEMDS lctl dl |
5034               awk '/[oO][sS][cC].*md[ts]/ { print $4 }'`
5035
5036     for OSC in $MDS_OSCS; do
5037         echo $OSC "is activate"
5038         do_facet $SINGLEMDS lctl --device %$OSC activate
5039     done
5040
5041     mkdir -p $DIR/$tdir
5042     for INACTIVE_OSC in $MDS_OSCS; do
5043         echo "Deactivate: " $INACTIVE_OSC
5044         do_facet $SINGLEMDS lctl --device %$INACTIVE_OSC deactivate
5045         for STRIPE_OSC in $MDS_OSCS; do
5046             OST=`osc_to_ost $STRIPE_OSC`
5047             IDX=`do_facet $SINGLEMDS lctl get_param -n lov.*md*.target_obd |
5048                  awk -F: /$OST/'{ print $1 }' | head -n 1`
5049
5050             [ -f $DIR/$tdir/$IDX ] && continue
5051             echo "$SETSTRIPE -i $IDX -c 1 $DIR/$tdir/$IDX"
5052             $SETSTRIPE -i $IDX -c 1 $DIR/$tdir/$IDX
5053             RC=$?
5054             [ $RC -ne 0 ] && error "setstripe should have succeeded"
5055         done
5056         rm -f $DIR/$tdir/*
5057         echo $INACTIVE_OSC "is Activate."
5058         do_facet $SINGLEMDS lctl --device  %$INACTIVE_OSC activate
5059     done
5060 }
5061 run_test 65k "validate manual striping works properly with deactivated OSCs"
5062
5063 test_65l() { # bug 12836
5064         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5065         test_mkdir -p $DIR/$tdir/test_dir
5066         $SETSTRIPE -c -1 $DIR/$tdir/test_dir
5067         $LFS find -mtime -1 $DIR/$tdir >/dev/null
5068 }
5069 run_test 65l "lfs find on -1 stripe dir ========================"
5070
5071 # bug 2543 - update blocks count on client
5072 test_66() {
5073         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5074         COUNT=${COUNT:-8}
5075         dd if=/dev/zero of=$DIR/f66 bs=1k count=$COUNT
5076         sync; sync_all_data; sync; sync_all_data
5077         cancel_lru_locks osc
5078         BLOCKS=`ls -s $DIR/f66 | awk '{ print $1 }'`
5079         [ $BLOCKS -ge $COUNT ] || error "$DIR/f66 blocks $BLOCKS < $COUNT"
5080 }
5081 run_test 66 "update inode blocks count on client ==============="
5082
5083 LLOOP=
5084 LLITELOOPLOAD=
5085 cleanup_68() {
5086         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5087         trap 0
5088         if [ ! -z "$LLOOP" ]; then
5089                 if swapon -s | grep -q $LLOOP; then
5090                         swapoff $LLOOP || error "swapoff failed"
5091                 fi
5092
5093                 $LCTL blockdev_detach $LLOOP || error "detach failed"
5094                 rm -f $LLOOP
5095                 unset LLOOP
5096         fi
5097         if [ ! -z "$LLITELOOPLOAD" ]; then
5098                 rmmod llite_lloop
5099                 unset LLITELOOPLOAD
5100         fi
5101         rm -f $DIR/f68*
5102 }
5103
5104 meminfo() {
5105         awk '($1 == "'$1':") { print $2 }' /proc/meminfo
5106 }
5107
5108 swap_used() {
5109         swapon -s | awk '($1 == "'$1'") { print $4 }'
5110 }
5111
5112 # test case for lloop driver, basic function
5113 test_68a() {
5114         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5115         [ "$UID" != 0 ] && skip_env "must run as root" && return
5116         llite_lloop_enabled || \
5117                 { skip_env "llite_lloop module disabled" && return; }
5118
5119         trap cleanup_68 EXIT
5120
5121         if ! module_loaded llite_lloop; then
5122                 if load_module llite/llite_lloop; then
5123                         LLITELOOPLOAD=yes
5124                 else
5125                         skip_env "can't find module llite_lloop"
5126                         return
5127                 fi
5128         fi
5129
5130         LLOOP=$TMP/lloop.`date +%s`.`date +%N`
5131         dd if=/dev/zero of=$DIR/f68a bs=4k count=1024
5132         $LCTL blockdev_attach $DIR/f68a $LLOOP || error "attach failed"
5133
5134         directio rdwr $LLOOP 0 1024 4096 || error "direct write failed"
5135         directio rdwr $LLOOP 0 1025 4096 && error "direct write should fail"
5136
5137         cleanup_68
5138 }
5139 run_test 68a "lloop driver - basic test ========================"
5140
5141 # excercise swapping to lustre by adding a high priority swapfile entry
5142 # and then consuming memory until it is used.
5143 test_68b() {  # was test_68
5144         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5145         [ "$UID" != 0 ] && skip_env "must run as root" && return
5146         lctl get_param -n devices | grep -q obdfilter && \
5147                 skip "local OST" && return
5148
5149         grep -q llite_lloop /proc/modules
5150         [ $? -ne 0 ] && skip "can't find module llite_lloop" && return
5151
5152         [ -z "`$LCTL list_nids | grep -v tcp`" ] && \
5153                 skip "can't reliably test swap with TCP" && return
5154
5155         MEMTOTAL=`meminfo MemTotal`
5156         NR_BLOCKS=$((MEMTOTAL>>8))
5157         [[ $NR_BLOCKS -le 2048 ]] && NR_BLOCKS=2048
5158
5159         LLOOP=$TMP/lloop.`date +%s`.`date +%N`
5160         dd if=/dev/zero of=$DIR/f68b bs=64k seek=$NR_BLOCKS count=1
5161         mkswap $DIR/f68b
5162
5163         $LCTL blockdev_attach $DIR/f68b $LLOOP || error "attach failed"
5164
5165         trap cleanup_68 EXIT
5166
5167         swapon -p 32767 $LLOOP || error "swapon $LLOOP failed"
5168
5169         echo "before: `swapon -s | grep $LLOOP`"
5170         $MEMHOG $MEMTOTAL || error "error allocating $MEMTOTAL kB"
5171         echo "after: `swapon -s | grep $LLOOP`"
5172         SWAPUSED=`swap_used $LLOOP`
5173
5174         cleanup_68
5175
5176         [ $SWAPUSED -eq 0 ] && echo "no swap used???" || true
5177 }
5178 run_test 68b "support swapping to Lustre ========================"
5179
5180 # bug5265, obdfilter oa2dentry return -ENOENT
5181 # #define OBD_FAIL_OST_ENOENT 0x217
5182 test_69() {
5183         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5184         remote_ost_nodsh && skip "remote OST with nodsh" && return
5185
5186         f="$DIR/$tfile"
5187         $SETSTRIPE -c 1 -i 0 $f
5188
5189         $DIRECTIO write ${f}.2 0 1 || error "directio write error"
5190
5191         do_facet ost1 lctl set_param fail_loc=0x217
5192         $TRUNCATE $f 1 # vmtruncate() will ignore truncate() error.
5193         $DIRECTIO write $f 0 2 && error "write succeeded, expect -ENOENT"
5194
5195         do_facet ost1 lctl set_param fail_loc=0
5196         $DIRECTIO write $f 0 2 || error "write error"
5197
5198         cancel_lru_locks osc
5199         $DIRECTIO read $f 0 1 || error "read error"
5200
5201         do_facet ost1 lctl set_param fail_loc=0x217
5202         $DIRECTIO read $f 1 1 && error "read succeeded, expect -ENOENT"
5203
5204         do_facet ost1 lctl set_param fail_loc=0
5205         rm -f $f
5206 }
5207 run_test 69 "verify oa2dentry return -ENOENT doesn't LBUG ======"
5208
5209 test_71() {
5210     test_mkdir -p $DIR/$tdir
5211     sh rundbench -C -D $DIR/$tdir 2 || error "dbench failed!"
5212 }
5213 run_test 71 "Running dbench on lustre (don't segment fault) ===="
5214
5215 test_72a() { # bug 5695 - Test that on 2.6 remove_suid works properly
5216         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5217         [ "$RUNAS_ID" = "$UID" ] &&
5218                 skip_env "RUNAS_ID = UID = $UID -- skipping" && return
5219
5220         # Check that testing environment is properly set up. Skip if not
5221         FAIL_ON_ERROR=false check_runas_id_ret $RUNAS_ID $RUNAS_GID $RUNAS || {
5222                 skip_env "User $RUNAS_ID does not exist - skipping"
5223                 return 0
5224         }
5225         # We had better clear the $DIR to get enough space for dd
5226         rm -rf $DIR/*
5227         touch $DIR/$tfile
5228         chmod 777 $DIR/$tfile
5229         chmod ug+s $DIR/$tfile
5230         $RUNAS dd if=/dev/zero of=$DIR/$tfile bs=512 count=1 ||
5231                 error "$RUNAS dd $DIR/$tfile failed"
5232         # See if we are still setuid/sgid
5233         test -u $DIR/$tfile -o -g $DIR/$tfile &&
5234                 error "S/gid is not dropped on write"
5235         # Now test that MDS is updated too
5236         cancel_lru_locks mdc
5237         test -u $DIR/$tfile -o -g $DIR/$tfile &&
5238                 error "S/gid is not dropped on MDS"
5239         rm -f $DIR/$tfile
5240 }
5241 run_test 72a "Test that remove suid works properly (bug5695) ===="
5242
5243 test_72b() { # bug 24226 -- keep mode setting when size is not changing
5244         local perm
5245
5246         [ "$RUNAS_ID" = "$UID" ] && \
5247                 skip_env "RUNAS_ID = UID = $UID -- skipping" && return
5248         [ "$RUNAS_ID" -eq 0 ] && \
5249                 skip_env "RUNAS_ID = 0 -- skipping" && return
5250
5251         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5252         # Check that testing environment is properly set up. Skip if not
5253         FAIL_ON_ERROR=false check_runas_id_ret $RUNAS_ID $RUNAS_ID $RUNAS || {
5254                 skip_env "User $RUNAS_ID does not exist - skipping"
5255                 return 0
5256         }
5257         touch $DIR/${tfile}-f{g,u}
5258         test_mkdir $DIR/${tfile}-dg
5259         test_mkdir $DIR/${tfile}-du
5260         chmod 770 $DIR/${tfile}-{f,d}{g,u}
5261         chmod g+s $DIR/${tfile}-{f,d}g
5262         chmod u+s $DIR/${tfile}-{f,d}u
5263         for perm in 777 2777 4777; do
5264                 $RUNAS chmod $perm $DIR/${tfile}-fg && error "S/gid file allowed improper chmod to $perm"
5265                 $RUNAS chmod $perm $DIR/${tfile}-fu && error "S/uid file allowed improper chmod to $perm"
5266                 $RUNAS chmod $perm $DIR/${tfile}-dg && error "S/gid dir allowed improper chmod to $perm"
5267                 $RUNAS chmod $perm $DIR/${tfile}-du && error "S/uid dir allowed improper chmod to $perm"
5268         done
5269         true
5270 }
5271 run_test 72b "Test that we keep mode setting if without file data changed (bug 24226)"
5272
5273 # bug 3462 - multiple simultaneous MDC requests
5274 test_73() {
5275         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5276         test_mkdir $DIR/d73-1
5277         test_mkdir $DIR/d73-2
5278         multiop_bg_pause $DIR/d73-1/f73-1 O_c || return 1
5279         pid1=$!
5280
5281         lctl set_param fail_loc=0x80000129
5282         $MULTIOP $DIR/d73-1/f73-2 Oc &
5283         sleep 1
5284         lctl set_param fail_loc=0
5285
5286         $MULTIOP $DIR/d73-2/f73-3 Oc &
5287         pid3=$!
5288
5289         kill -USR1 $pid1
5290         wait $pid1 || return 1
5291
5292         sleep 25
5293
5294         $CHECKSTAT -t file $DIR/d73-1/f73-1 || return 4
5295         $CHECKSTAT -t file $DIR/d73-1/f73-2 || return 5
5296         $CHECKSTAT -t file $DIR/d73-2/f73-3 || return 6
5297
5298         rm -rf $DIR/d73-*
5299 }
5300 run_test 73 "multiple MDC requests (should not deadlock)"
5301
5302 test_74a() { # bug 6149, 6184
5303         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5304         #define OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT 0x30e
5305         #
5306         # very important to OR with OBD_FAIL_ONCE (0x80000000) -- otherwise it
5307         # will spin in a tight reconnection loop
5308         touch $DIR/f74a
5309         lctl set_param fail_loc=0x8000030e
5310         # get any lock that won't be difficult - lookup works.
5311         ls $DIR/f74a
5312         lctl set_param fail_loc=0
5313         true
5314         rm -f $DIR/f74a
5315 }
5316 run_test 74a "ldlm_enqueue freed-export error path, ls (shouldn't LBUG)"
5317
5318 test_74b() { # bug 13310
5319         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5320         #define OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT 0x30e
5321         #
5322         # very important to OR with OBD_FAIL_ONCE (0x80000000) -- otherwise it
5323         # will spin in a tight reconnection loop
5324         lctl set_param fail_loc=0x8000030e
5325         # get a "difficult" lock
5326         touch $DIR/f74b
5327         lctl set_param fail_loc=0
5328         true
5329         rm -f $DIR/f74b
5330 }
5331 run_test 74b "ldlm_enqueue freed-export error path, touch (shouldn't LBUG)"
5332
5333 test_74c() {
5334         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5335 #define OBD_FAIL_LDLM_NEW_LOCK
5336         lctl set_param fail_loc=0x80000319
5337         touch $DIR/$tfile && error "Touch successful"
5338         true
5339 }
5340 run_test 74c "ldlm_lock_create error path, (shouldn't LBUG)"
5341
5342 num_inodes() {
5343         awk '/lustre_inode_cache/ {print $2; exit}' /proc/slabinfo
5344 }
5345
5346 get_inode_slab_tunables() {
5347         awk '/lustre_inode_cache/ {print $9," ",$10," ",$11; exit}' /proc/slabinfo
5348 }
5349
5350 set_inode_slab_tunables() {
5351         echo "lustre_inode_cache $1" > /proc/slabinfo
5352 }
5353
5354 test_76() { # Now for bug 20433, added originally in bug 1443
5355         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5356         local SLAB_SETTINGS=`get_inode_slab_tunables`
5357         local CPUS=`getconf _NPROCESSORS_ONLN`
5358         # we cannot set limit below 1 which means 1 inode in each
5359         # per-cpu cache is still allowed
5360         set_inode_slab_tunables "1 1 0"
5361         cancel_lru_locks osc
5362         BEFORE_INODES=`num_inodes`
5363         echo "before inodes: $BEFORE_INODES"
5364         local COUNT=1000
5365         [ "$SLOW" = "no" ] && COUNT=100
5366         for i in `seq $COUNT`; do
5367                 touch $DIR/$tfile
5368                 rm -f $DIR/$tfile
5369         done
5370         cancel_lru_locks osc
5371         AFTER_INODES=`num_inodes`
5372         echo "after inodes: $AFTER_INODES"
5373         local wait=0
5374         while [ $((AFTER_INODES-1*CPUS)) -gt $BEFORE_INODES ]; do
5375                 sleep 2
5376                 AFTER_INODES=`num_inodes`
5377                 wait=$((wait+2))
5378                 echo "wait $wait seconds inodes: $AFTER_INODES"
5379                 if [ $wait -gt 30 ]; then
5380                         error "inode slab grew from $BEFORE_INODES to $AFTER_INODES"
5381                 fi
5382         done
5383         set_inode_slab_tunables "$SLAB_SETTINGS"
5384 }
5385 run_test 76 "confirm clients recycle inodes properly ===="
5386
5387
5388 export ORIG_CSUM=""
5389 set_checksums()
5390 {
5391         # Note: in sptlrpc modes which enable its own bulk checksum, the
5392         # original crc32_le bulk checksum will be automatically disabled,
5393         # and the OBD_FAIL_OSC_CHECKSUM_SEND/OBD_FAIL_OSC_CHECKSUM_RECEIVE
5394         # will be checked by sptlrpc code against sptlrpc bulk checksum.
5395         # In this case set_checksums() will not be no-op, because sptlrpc
5396         # bulk checksum will be enabled all through the test.
5397
5398         [ "$ORIG_CSUM" ] || ORIG_CSUM=`lctl get_param -n osc.*.checksums | head -n1`
5399         lctl set_param -n osc.*.checksums $1
5400         return 0
5401 }
5402
5403 export ORIG_CSUM_TYPE="`lctl get_param -n osc.*osc-[^mM]*.checksum_type |
5404                         sed 's/.*\[\(.*\)\].*/\1/g' | head -n1`"
5405 CKSUM_TYPES=${CKSUM_TYPES:-"crc32 adler"}
5406 [ "$ORIG_CSUM_TYPE" = "crc32c" ] && CKSUM_TYPES="$CKSUM_TYPES crc32c"
5407 set_checksum_type()
5408 {
5409         lctl set_param -n osc.*osc-[^mM]*.checksum_type $1
5410         log "set checksum type to $1"
5411         return 0
5412 }
5413 F77_TMP=$TMP/f77-temp
5414 F77SZ=8
5415 setup_f77() {
5416         dd if=/dev/urandom of=$F77_TMP bs=1M count=$F77SZ || \
5417                 error "error writing to $F77_TMP"
5418 }
5419
5420 test_77a() { # bug 10889
5421         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5422         $GSS && skip "could not run with gss" && return
5423         [ ! -f $F77_TMP ] && setup_f77
5424         set_checksums 1
5425         dd if=$F77_TMP of=$DIR/$tfile bs=1M count=$F77SZ || error "dd error"
5426         set_checksums 0
5427         rm -f $DIR/$tfile
5428 }
5429 run_test 77a "normal checksum read/write operation"
5430
5431 test_77b() { # bug 10889
5432         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5433         $GSS && skip "could not run with gss" && return
5434         [ ! -f $F77_TMP ] && setup_f77
5435         #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
5436         $LCTL set_param fail_loc=0x80000409
5437         set_checksums 1
5438
5439         dd if=$F77_TMP of=$DIR/$tfile bs=1M count=$F77SZ conv=sync ||
5440                 error "dd error: $?"
5441         $LCTL set_param fail_loc=0
5442
5443         for algo in $CKSUM_TYPES; do
5444                 cancel_lru_locks osc
5445                 set_checksum_type $algo
5446                 #define OBD_FAIL_OSC_CHECKSUM_RECEIVE    0x408
5447                 $LCTL set_param fail_loc=0x80000408
5448                 cmp $F77_TMP $DIR/$tfile || error "file compare failed"
5449                 $LCTL set_param fail_loc=0
5450         done
5451         set_checksums 0
5452         set_checksum_type $ORIG_CSUM_TYPE
5453         rm -f $DIR/$tfile
5454 }
5455 run_test 77b "checksum error on client write, read"
5456
5457 test_77d() { # bug 10889
5458         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5459         $GSS && skip "could not run with gss" && return
5460         #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
5461         $LCTL set_param fail_loc=0x80000409
5462         set_checksums 1
5463         $DIRECTIO write $DIR/$tfile 0 $F77SZ $((1024 * 1024)) ||
5464                 error "direct write: rc=$?"
5465         $LCTL set_param fail_loc=0
5466         set_checksums 0
5467
5468         #define OBD_FAIL_OSC_CHECKSUM_RECEIVE    0x408
5469         $LCTL set_param fail_loc=0x80000408
5470         set_checksums 1
5471         cancel_lru_locks osc
5472         $DIRECTIO read $DIR/$tfile 0 $F77SZ $((1024 * 1024)) ||
5473                 error "direct read: rc=$?"
5474         $LCTL set_param fail_loc=0
5475         set_checksums 0
5476 }
5477 run_test 77d "checksum error on OST direct write, read"
5478
5479 test_77f() { # bug 10889
5480         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5481         $GSS && skip "could not run with gss" && return
5482         set_checksums 1
5483         for algo in $CKSUM_TYPES; do
5484                 cancel_lru_locks osc
5485                 set_checksum_type $algo
5486                 #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
5487                 $LCTL set_param fail_loc=0x409
5488                 $DIRECTIO write $DIR/$tfile 0 $F77SZ $((1024 * 1024)) &&
5489                         error "direct write succeeded"
5490                 $LCTL set_param fail_loc=0
5491         done
5492         set_checksum_type $ORIG_CSUM_TYPE
5493         set_checksums 0
5494 }
5495 run_test 77f "repeat checksum error on write (expect error)"
5496
5497 test_77g() { # bug 10889
5498         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5499         $GSS && skip "could not run with gss" && return
5500         remote_ost_nodsh && skip "remote OST with nodsh" && return
5501
5502         [ ! -f $F77_TMP ] && setup_f77
5503
5504         $SETSTRIPE -c 1 -i 0 $DIR/$tfile
5505         #define OBD_FAIL_OST_CHECKSUM_RECEIVE       0x21a
5506         do_facet ost1 lctl set_param fail_loc=0x8000021a
5507         set_checksums 1
5508         dd if=$F77_TMP of=$DIR/$tfile bs=1M count=$F77SZ ||
5509                 error "write error: rc=$?"
5510         do_facet ost1 lctl set_param fail_loc=0
5511         set_checksums 0
5512
5513         cancel_lru_locks osc
5514         #define OBD_FAIL_OST_CHECKSUM_SEND          0x21b
5515         do_facet ost1 lctl set_param fail_loc=0x8000021b
5516         set_checksums 1
5517         cmp $F77_TMP $DIR/$tfile || error "file compare failed"
5518         do_facet ost1 lctl set_param fail_loc=0
5519         set_checksums 0
5520 }
5521 run_test 77g "checksum error on OST write, read"
5522
5523 test_77i() { # bug 13805
5524         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5525         $GSS && skip "could not run with gss" && return
5526         #define OBD_FAIL_OSC_CONNECT_CKSUM       0x40b
5527         lctl set_param fail_loc=0x40b
5528         remount_client $MOUNT
5529         lctl set_param fail_loc=0
5530         for VALUE in `lctl get_param osc.*osc-[^mM]*.checksum_type`; do
5531                 PARAM=`echo ${VALUE[0]} | cut -d "=" -f1`
5532                 algo=`lctl get_param -n $PARAM | sed 's/.*\[\(.*\)\].*/\1/g'`
5533                 [ "$algo" = "adler" ] || error "algo set to $algo instead of adler"
5534         done
5535         remount_client $MOUNT
5536 }
5537 run_test 77i "client not supporting OSD_CONNECT_CKSUM"
5538
5539 test_77j() { # bug 13805
5540         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5541         $GSS && skip "could not run with gss" && return
5542         #define OBD_FAIL_OSC_CKSUM_ADLER_ONLY    0x40c
5543         lctl set_param fail_loc=0x40c
5544         remount_client $MOUNT
5545         lctl set_param fail_loc=0
5546         sleep 2 # wait async osc connect to finish
5547         for VALUE in `lctl get_param osc.*osc-[^mM]*.checksum_type`; do
5548                 PARAM=`echo ${VALUE[0]} | cut -d "=" -f1`
5549                 algo=`lctl get_param -n $PARAM | sed 's/.*\[\(.*\)\].*/\1/g'`
5550                 [ "$algo" = "adler" ] || error "algo set to $algo instead of adler"
5551         done
5552         remount_client $MOUNT
5553 }
5554 run_test 77j "client only supporting ADLER32"
5555
5556 [ "$ORIG_CSUM" ] && set_checksums $ORIG_CSUM || true
5557 rm -f $F77_TMP
5558 unset F77_TMP
5559
5560 test_78() { # bug 10901
5561         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5562         remote_ost || { skip_env "local OST" && return; }
5563
5564         NSEQ=5
5565         F78SIZE=$(($(awk '/MemFree:/ { print $2 }' /proc/meminfo) / 1024))
5566         echo "MemFree: $F78SIZE, Max file size: $MAXFREE"
5567         MEMTOTAL=$(($(awk '/MemTotal:/ { print $2 }' /proc/meminfo) / 1024))
5568         echo "MemTotal: $MEMTOTAL"
5569 # reserve 256MB of memory for the kernel and other running processes,
5570 # and then take 1/2 of the remaining memory for the read/write buffers.
5571     if [ $MEMTOTAL -gt 512 ] ;then
5572         MEMTOTAL=$(((MEMTOTAL - 256 ) / 2))
5573     else
5574         # for those poor memory-starved high-end clusters...
5575         MEMTOTAL=$((MEMTOTAL / 2))
5576     fi
5577         echo "Mem to use for directio: $MEMTOTAL"
5578         [ $F78SIZE -gt $MEMTOTAL ] && F78SIZE=$MEMTOTAL
5579         [ $F78SIZE -gt 512 ] && F78SIZE=512
5580         [ $F78SIZE -gt $((MAXFREE / 1024)) ] && F78SIZE=$((MAXFREE / 1024))
5581         SMALLESTOST=`lfs df $DIR |grep OST | awk '{print $4}' |sort -n |head -1`
5582         echo "Smallest OST: $SMALLESTOST"
5583         [ $SMALLESTOST -lt 10240 ] && \
5584                 skip "too small OSTSIZE, useless to run large O_DIRECT test" && return 0
5585
5586         [ $F78SIZE -gt $((SMALLESTOST * $OSTCOUNT / 1024 - 80)) ] && \
5587                 F78SIZE=$((SMALLESTOST * $OSTCOUNT / 1024 - 80))
5588
5589         [ "$SLOW" = "no" ] && NSEQ=1 && [ $F78SIZE -gt 32 ] && F78SIZE=32
5590         echo "File size: $F78SIZE"
5591         $SETSTRIPE -c $OSTCOUNT $DIR/$tfile || error "setstripe failed"
5592         for i in `seq 1 $NSEQ`
5593         do
5594                 FSIZE=$(($F78SIZE / ($NSEQ - $i + 1)))
5595                 echo directIO rdwr round $i of $NSEQ
5596                 $DIRECTIO rdwr $DIR/$tfile 0 $FSIZE 1048576||error "rdwr failed"
5597         done
5598
5599         rm -f $DIR/$tfile
5600 }
5601 run_test 78 "handle large O_DIRECT writes correctly ============"
5602
5603 test_79() { # bug 12743
5604         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5605         wait_delete_completed
5606
5607         BKTOTAL=$(calc_osc_kbytes kbytestotal)
5608         BKFREE=$(calc_osc_kbytes kbytesfree)
5609         BKAVAIL=$(calc_osc_kbytes kbytesavail)
5610
5611         STRING=`df -P $MOUNT | tail -n 1 | awk '{print $2","$3","$4}'`
5612         DFTOTAL=`echo $STRING | cut -d, -f1`
5613         DFUSED=`echo $STRING  | cut -d, -f2`
5614         DFAVAIL=`echo $STRING | cut -d, -f3`
5615         DFFREE=$(($DFTOTAL - $DFUSED))
5616
5617         ALLOWANCE=$((64 * $OSTCOUNT))
5618
5619         if [ $DFTOTAL -lt $(($BKTOTAL - $ALLOWANCE)) ] ||
5620            [ $DFTOTAL -gt $(($BKTOTAL + $ALLOWANCE)) ] ; then
5621                 error "df total($DFTOTAL) mismatch OST total($BKTOTAL)"
5622         fi
5623         if [ $DFFREE -lt $(($BKFREE - $ALLOWANCE)) ] ||
5624            [ $DFFREE -gt $(($BKFREE + $ALLOWANCE)) ] ; then
5625                 error "df free($DFFREE) mismatch OST free($BKFREE)"
5626         fi
5627         if [ $DFAVAIL -lt $(($BKAVAIL - $ALLOWANCE)) ] ||
5628            [ $DFAVAIL -gt $(($BKAVAIL + $ALLOWANCE)) ] ; then
5629                 error "df avail($DFAVAIL) mismatch OST avail($BKAVAIL)"
5630         fi
5631 }
5632 run_test 79 "df report consistency check ======================="
5633
5634 test_80() { # bug 10718
5635         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5636         # relax strong synchronous semantics for slow backends like ZFS
5637         local soc="obdfilter.*.sync_on_lock_cancel"
5638         local soc_old=$(do_facet ost1 lctl get_param -n $soc | head -n1)
5639         local hosts=
5640         if [ "$soc_old" != "never" -a "$(facet_fstype ost1)" != "ldiskfs" ]; then
5641                 hosts=$(for host in $(seq -f "ost%g" 1 $OSTCOUNT); do
5642                           facet_active_host $host; done | sort -u)
5643                 do_nodes $hosts lctl set_param $soc=never
5644         fi
5645
5646         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1M
5647         sync; sleep 1; sync
5648         local BEFORE=`date +%s`
5649         cancel_lru_locks osc
5650         local AFTER=`date +%s`
5651         local DIFF=$((AFTER-BEFORE))
5652         if [ $DIFF -gt 1 ] ; then
5653                 error "elapsed for 1M@1T = $DIFF"
5654         fi
5655
5656         [ -n "$hosts" ] && do_nodes $hosts lctl set_param $soc=$soc_old
5657
5658         rm -f $DIR/$tfile
5659 }
5660 run_test 80 "Page eviction is equally fast at high offsets too  ===="
5661
5662 test_81a() { # LU-456
5663         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5664         remote_ost_nodsh && skip "remote OST with nodsh" && return
5665         # define OBD_FAIL_OST_MAPBLK_ENOSPC    0x228
5666         # MUST OR with the OBD_FAIL_ONCE (0x80000000)
5667         do_facet ost1 lctl set_param fail_loc=0x80000228
5668
5669         # write should trigger a retry and success
5670         $SETSTRIPE -i 0 -c 1 $DIR/$tfile
5671         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
5672         RC=$?
5673         if [ $RC -ne 0 ] ; then
5674                 error "write should success, but failed for $RC"
5675         fi
5676 }
5677 run_test 81a "OST should retry write when get -ENOSPC ==============="
5678
5679 test_81b() { # LU-456
5680         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5681         remote_ost_nodsh && skip "remote OST with nodsh" && return
5682         # define OBD_FAIL_OST_MAPBLK_ENOSPC    0x228
5683         # Don't OR with the OBD_FAIL_ONCE (0x80000000)
5684         do_facet ost1 lctl set_param fail_loc=0x228
5685
5686         # write should retry several times and return -ENOSPC finally
5687         $SETSTRIPE -i 0 -c 1 $DIR/$tfile
5688         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
5689         RC=$?
5690         ENOSPC=28
5691         if [ $RC -ne $ENOSPC ] ; then
5692                 error "dd should fail for -ENOSPC, but succeed."
5693         fi
5694 }
5695 run_test 81b "OST should return -ENOSPC when retry still fails ======="
5696
5697 test_82() { # LU-1031
5698         dd if=/dev/zero of=$DIR/$tfile bs=1M count=10
5699         local gid1=14091995
5700         local gid2=16022000
5701
5702         multiop_bg_pause $DIR/$tfile OG${gid1}_g${gid1}c || return 1
5703         local MULTIPID1=$!
5704         multiop_bg_pause $DIR/$tfile O_G${gid2}r10g${gid2}c || return 2
5705         local MULTIPID2=$!
5706         kill -USR1 $MULTIPID2
5707         sleep 2
5708         if [[ `ps h -o comm -p $MULTIPID2` == "" ]]; then
5709                 error "First grouplock does not block second one"
5710         else
5711                 echo "Second grouplock blocks first one"
5712         fi
5713         kill -USR1 $MULTIPID1
5714         wait $MULTIPID1
5715         wait $MULTIPID2
5716 }
5717 run_test 82 "Basic grouplock test ==============================="
5718
5719 test_99a() {
5720         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" &&
5721                 return
5722         test_mkdir -p $DIR/d99cvsroot
5723         chown $RUNAS_ID $DIR/d99cvsroot
5724         local oldPWD=$PWD       # bug 13584, use $TMP as working dir
5725         cd $TMP
5726
5727         $RUNAS cvs -d $DIR/d99cvsroot init || error "cvs init failed"
5728         cd $oldPWD
5729 }
5730 run_test 99a "cvs init ========================================="
5731
5732 test_99b() {
5733         [ -z "$(which cvs 2>/dev/null)" ] &&
5734                 skip_env "could not find cvs" && return
5735         [ ! -d $DIR/d99cvsroot ] && test_99a
5736         cd /etc/init.d
5737         # some versions of cvs import exit(1) when asked to import links or
5738         # files they can't read.  ignore those files.
5739         TOIGNORE=$(find . -type l -printf '-I %f\n' -o \
5740                         ! -perm +4 -printf '-I %f\n')
5741         $RUNAS cvs -d $DIR/d99cvsroot import -m "nomesg" $TOIGNORE \
5742                 d99reposname vtag rtag
5743 }
5744 run_test 99b "cvs import ======================================="
5745
5746 test_99c() {
5747         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
5748         [ ! -d $DIR/d99cvsroot ] && test_99b
5749         cd $DIR
5750         test_mkdir -p $DIR/d99reposname
5751         chown $RUNAS_ID $DIR/d99reposname
5752         $RUNAS cvs -d $DIR/d99cvsroot co d99reposname
5753 }
5754 run_test 99c "cvs checkout ====================================="
5755
5756 test_99d() {
5757         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
5758         [ ! -d $DIR/d99cvsroot ] && test_99c
5759         cd $DIR/d99reposname
5760         $RUNAS touch foo99
5761         $RUNAS cvs add -m 'addmsg' foo99
5762 }
5763 run_test 99d "cvs add =========================================="
5764
5765 test_99e() {
5766         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
5767         [ ! -d $DIR/d99cvsroot ] && test_99c
5768         cd $DIR/d99reposname
5769         $RUNAS cvs update
5770 }
5771 run_test 99e "cvs update ======================================="
5772
5773 test_99f() {
5774         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
5775         [ ! -d $DIR/d99cvsroot ] && test_99d
5776         cd $DIR/d99reposname
5777         $RUNAS cvs commit -m 'nomsg' foo99
5778     rm -fr $DIR/d99cvsroot
5779 }
5780 run_test 99f "cvs commit ======================================="
5781
5782 test_100() {
5783         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5784         [ "$NETTYPE" = tcp ] || \
5785                 { skip "TCP secure port test, not useful for NETTYPE=$NETTYPE" && \
5786                         return ; }
5787
5788         remote_ost_nodsh && skip "remote OST with nodsh" && return
5789         remote_mds_nodsh && skip "remote MDS with nodsh" && return
5790         remote_servers || \
5791                 { skip "useless for local single node setup" && return; }
5792
5793         netstat -tna | ( rc=1; while read PROT SND RCV LOCAL REMOTE STAT; do
5794                 [ "$PROT" != "tcp" ] && continue
5795                 RPORT=$(echo $REMOTE | cut -d: -f2)
5796                 [ "$RPORT" != "$ACCEPTOR_PORT" ] && continue
5797
5798                 rc=0
5799                 LPORT=`echo $LOCAL | cut -d: -f2`
5800                 if [ $LPORT -ge 1024 ]; then
5801                         echo "bad: $PROT $SND $RCV $LOCAL $REMOTE $STAT"
5802                         netstat -tna
5803                         error_exit "local: $LPORT > 1024, remote: $RPORT"
5804                 fi
5805         done
5806         [ "$rc" = 0 ] || error_exit "privileged port not found" )
5807 }
5808 run_test 100 "check local port using privileged port ==========="
5809
5810 function get_named_value()
5811 {
5812     local tag
5813
5814     tag=$1
5815     while read ;do
5816         line=$REPLY
5817         case $line in
5818         $tag*)
5819             echo $line | sed "s/^$tag[ ]*//"
5820             break
5821             ;;
5822         esac
5823     done
5824 }
5825
5826 export CACHE_MAX=$($LCTL get_param -n llite.*.max_cached_mb |
5827                    awk '/^max_cached_mb/ { print $2 }')
5828
5829 cleanup_101a() {
5830         $LCTL set_param -n llite.*.max_cached_mb $CACHE_MAX
5831         trap 0
5832 }
5833
5834 test_101a() {
5835         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5836         [ $MDSCOUNT -ge 2 ] && skip "skip now for >= 2 MDTs" && return #LU-4322
5837         local s
5838         local discard
5839         local nreads=10000
5840         local cache_limit=32
5841
5842         $LCTL set_param -n osc.*-osc*.rpc_stats 0
5843         trap cleanup_101a EXIT
5844         $LCTL set_param -n llite.*.read_ahead_stats 0
5845         $LCTL set_param -n llite.*.max_cached_mb $cache_limit
5846
5847         #
5848         # randomly read 10000 of 64K chunks from file 3x 32MB in size
5849         #
5850         echo "nreads: $nreads file size: $((cache_limit * 3))MB"
5851         $READS -f $DIR/$tfile -s$((cache_limit * 3192 * 1024)) -b65536 -C -n$nreads -t 180
5852
5853         discard=0
5854         for s in `$LCTL get_param -n llite.*.read_ahead_stats | \
5855                 get_named_value 'read but discarded' | cut -d" " -f1`; do
5856                         discard=$(($discard + $s))
5857         done
5858         cleanup_101a
5859
5860         if [ $(($discard * 10)) -gt $nreads ] ;then
5861                 $LCTL get_param osc.*-osc*.rpc_stats
5862                 $LCTL get_param llite.*.read_ahead_stats
5863                 error "too many ($discard) discarded pages"
5864         fi
5865         rm -f $DIR/$tfile || true
5866 }
5867 run_test 101a "check read-ahead for random reads ================"
5868
5869 setup_test101bc() {
5870         test_mkdir -p $DIR/$tdir
5871         STRIPE_SIZE=1048576
5872         STRIPE_COUNT=$OSTCOUNT
5873         STRIPE_OFFSET=0
5874
5875         local list=$(comma_list $(osts_nodes))
5876         set_osd_param $list '' read_cache_enable 0
5877         set_osd_param $list '' writethrough_cache_enable 0
5878
5879         trap cleanup_test101bc EXIT
5880         # prepare the read-ahead file
5881         $SETSTRIPE -S $STRIPE_SIZE -i $STRIPE_OFFSET -c $OSTCOUNT $DIR/$tfile
5882
5883         dd if=/dev/zero of=$DIR/$tfile bs=1024k count=100 2> /dev/null
5884 }
5885
5886 cleanup_test101bc() {
5887         trap 0
5888         rm -rf $DIR/$tdir
5889         rm -f $DIR/$tfile
5890
5891         local list=$(comma_list $(osts_nodes))
5892         set_osd_param $list '' read_cache_enable 1
5893         set_osd_param $list '' writethrough_cache_enable 1
5894 }
5895
5896 calc_total() {
5897         awk 'BEGIN{total=0}; {total+=$1}; END{print total}'
5898 }
5899
5900 ra_check_101() {
5901         local READ_SIZE=$1
5902         local STRIPE_SIZE=1048576
5903         local RA_INC=1048576
5904         local STRIDE_LENGTH=$((STRIPE_SIZE/READ_SIZE))
5905         local FILE_LENGTH=$((64*100))
5906         local discard_limit=$((((STRIDE_LENGTH - 1)*3/(STRIDE_LENGTH*OSTCOUNT))* \
5907                              (STRIDE_LENGTH*OSTCOUNT - STRIDE_LENGTH)))
5908         DISCARD=`$LCTL get_param -n llite.*.read_ahead_stats | \
5909                         get_named_value 'read but discarded' | \
5910                         cut -d" " -f1 | calc_total`
5911         if [ $DISCARD -gt $discard_limit ]; then
5912                 $LCTL get_param llite.*.read_ahead_stats
5913                 error "Too many ($DISCARD) discarded pages with size (${READ_SIZE})"
5914         else
5915                 echo "Read-ahead success for size ${READ_SIZE}"
5916         fi
5917 }
5918
5919 test_101b() {
5920         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5921         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping stride IO stride-ahead test" && return
5922         local STRIPE_SIZE=1048576
5923         local STRIDE_SIZE=$((STRIPE_SIZE*OSTCOUNT))
5924         local FILE_LENGTH=$((STRIPE_SIZE*100))
5925         local ITERATION=$((FILE_LENGTH/STRIDE_SIZE))
5926         # prepare the read-ahead file
5927         setup_test101bc
5928         cancel_lru_locks osc
5929         for BIDX in 2 4 8 16 32 64 128 256
5930         do
5931                 local BSIZE=$((BIDX*4096))
5932                 local READ_COUNT=$((STRIPE_SIZE/BSIZE))
5933                 local STRIDE_LENGTH=$((STRIDE_SIZE/BSIZE))
5934                 local OFFSET=$((STRIPE_SIZE/BSIZE*(OSTCOUNT - 1)))
5935                 $LCTL set_param -n llite.*.read_ahead_stats 0
5936                 $READS -f $DIR/$tfile  -l $STRIDE_LENGTH -o $OFFSET \
5937                               -s $FILE_LENGTH -b $STRIPE_SIZE -a $READ_COUNT -n $ITERATION
5938                 cancel_lru_locks osc
5939                 ra_check_101 $BSIZE
5940         done
5941         cleanup_test101bc
5942         true
5943 }
5944 run_test 101b "check stride-io mode read-ahead ================="
5945
5946 test_101c() {
5947         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5948         local STRIPE_SIZE=1048576
5949         local FILE_LENGTH=$((STRIPE_SIZE*100))
5950         local nreads=10000
5951         local osc_rpc_stats
5952
5953         setup_test101bc
5954
5955         cancel_lru_locks osc
5956         $LCTL set_param osc.*.rpc_stats 0
5957         $READS -f $DIR/$tfile -s$FILE_LENGTH -b65536 -n$nreads -t 180
5958         for osc_rpc_stats in $($LCTL get_param -N osc.*.rpc_stats); do
5959                 local stats=$($LCTL get_param -n $osc_rpc_stats)
5960                 local lines=$(echo "$stats" | awk 'END {print NR;}')
5961                 local size
5962
5963                 if [ $lines -le 20 ]; then
5964                         continue
5965                 fi
5966                 for size in 1 2 4 8; do
5967                         local rpc=$(echo "$stats" |
5968                                     awk '($1 == "'$size':") {print $2; exit; }')
5969                         [ $rpc != 0 ] &&
5970                                 error "Small $((size*4))k read IO $rpc !"
5971                 done
5972                 echo "$osc_rpc_stats check passed!"
5973         done
5974         cleanup_test101bc
5975         true
5976 }
5977 run_test 101c "check stripe_size aligned read-ahead ================="
5978
5979 set_read_ahead() {
5980         $LCTL get_param -n llite.*.max_read_ahead_mb | head -n 1
5981         $LCTL set_param -n llite.*.max_read_ahead_mb $1 > /dev/null 2>&1
5982 }
5983
5984 test_101d() {
5985         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5986         local file=$DIR/$tfile
5987         local sz_MB=${FILESIZE_101d:-500}
5988         local ra_MB=${READAHEAD_MB:-40}
5989
5990         local free_MB=$(($(df -P $DIR | tail -n 1 | awk '{ print $4 }') / 1024))
5991         [ $free_MB -lt $sz_MB ] &&
5992                 skip "Need free space ${sz_MB}M, have ${free_MB}M" && return
5993
5994         echo "Create test file $file size ${sz_MB}M, ${free_MB}M free"
5995         $SETSTRIPE -c -1 $file || error "setstripe failed"
5996
5997         dd if=/dev/zero of=$file bs=1M count=$sz_MB || error "dd failed"
5998         echo Cancel LRU locks on lustre client to flush the client cache
5999         cancel_lru_locks osc
6000
6001         echo Disable read-ahead
6002         local old_READAHEAD=$(set_read_ahead 0)
6003
6004         echo Reading the test file $file with read-ahead disabled
6005         local raOFF=$(do_and_time "dd if=$file of=/dev/null bs=1M count=$sz_MB")
6006
6007         echo Cancel LRU locks on lustre client to flush the client cache
6008         cancel_lru_locks osc
6009         echo Enable read-ahead with ${ra_MB}MB
6010         set_read_ahead $ra_MB
6011
6012         echo Reading the test file $file with read-ahead enabled
6013         local raON=$(do_and_time "dd if=$file of=/dev/null bs=1M count=$sz_MB")
6014
6015         echo "read-ahead disabled time read $raOFF"
6016         echo "read-ahead enabled  time read $raON"
6017
6018         set_read_ahead $old_READAHEAD
6019         rm -f $file
6020         wait_delete_completed
6021
6022         [ $raOFF -le 1 -o $raON -lt $raOFF ] ||
6023                 error "readahead ${raON}s > no-readahead ${raOFF}s ${sz_MB}M"
6024 }
6025 run_test 101d "file read with and without read-ahead enabled"
6026
6027 test_101e() {
6028         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6029         local file=$DIR/$tfile
6030         local size_KB=500  #KB
6031         local count=100
6032         local bsize=1024
6033
6034         local free_KB=$(df -P $DIR | tail -n 1 | awk '{ print $4 }')
6035         local need_KB=$((count * size_KB))
6036         [ $free_KB -le $need_KB ] &&
6037                 skip_env "Need free space $need_KB, have $free_KB" && return
6038
6039         echo "Creating $count ${size_KB}K test files"
6040         for ((i = 0; i < $count; i++)); do
6041                 dd if=/dev/zero of=$file.$i bs=$bsize count=$size_KB 2>/dev/null
6042         done
6043
6044         echo "Cancel LRU locks on lustre client to flush the client cache"
6045         cancel_lru_locks osc
6046
6047         echo "Reset readahead stats"
6048         $LCTL set_param -n llite.*.read_ahead_stats 0
6049
6050         for ((i = 0; i < $count; i++)); do
6051                 dd if=$file.$i of=/dev/null bs=$bsize count=$size_KB 2>/dev/null
6052         done
6053
6054         local miss=$($LCTL get_param -n llite.*.read_ahead_stats |
6055                      get_named_value 'misses' | cut -d" " -f1 | calc_total)
6056
6057         for ((i = 0; i < $count; i++)); do
6058                 rm -rf $file.$i 2>/dev/null
6059         done
6060
6061         #10000 means 20% reads are missing in readahead
6062         [ $miss -lt 10000 ] ||  error "misses too much for small reads"
6063 }
6064 run_test 101e "check read-ahead for small read(1k) for small files(500k)"
6065
6066 cleanup_test101f() {
6067     trap 0
6068     $LCTL set_param -n llite.*.max_read_ahead_whole_mb $MAX_WHOLE_MB
6069     rm -rf $DIR/$tfile 2>/dev/null
6070 }
6071
6072 test_101f() {
6073         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6074     local file=$DIR/$tfile
6075     local nreads=1000
6076
6077     MAX_WHOLE_MB=$($LCTL get_param -n llite.*.max_read_ahead_whole_mb)
6078     $LCTL set_param -n llite.*.max_read_ahead_whole_mb 2
6079     dd if=/dev/zero of=${file} bs=2097152 count=1 2>/dev/null
6080     trap cleanup_test101f EXIT
6081
6082     echo Cancel LRU locks on lustre client to flush the client cache
6083     cancel_lru_locks osc
6084
6085     echo Reset readahead stats
6086     $LCTL set_param -n llite.*.read_ahead_stats 0
6087     # Random read in a 2M file, because max_read_ahead_whole_mb = 2M,
6088     # readahead should read in 2M file on second read, so only miss
6089     # 2 pages.
6090     echo Random 4K reads on 2M file for 1000 times
6091     $READS -f $file -s 2097152 -b 4096 -n $nreads
6092
6093     echo checking missing pages
6094     local miss=$($LCTL get_param -n llite.*.read_ahead_stats |
6095           get_named_value 'misses' | cut -d" " -f1 | calc_total)
6096
6097     [ $miss -lt 3 ] || error "misses too much pages!"
6098     cleanup_test101f
6099 }
6100 run_test 101f "check read-ahead for max_read_ahead_whole_mb"
6101
6102 setup_test102() {
6103         test_mkdir -p $DIR/$tdir
6104         chown $RUNAS_ID $DIR/$tdir
6105         STRIPE_SIZE=65536
6106         STRIPE_OFFSET=1
6107         STRIPE_COUNT=$OSTCOUNT
6108         [ $OSTCOUNT -gt 4 ] && STRIPE_COUNT=4
6109
6110         trap cleanup_test102 EXIT
6111         cd $DIR
6112         $1 $SETSTRIPE -S $STRIPE_SIZE -i $STRIPE_OFFSET -c $STRIPE_COUNT $tdir
6113         cd $DIR/$tdir
6114         for num in 1 2 3 4; do
6115                 for count in $(seq 1 $STRIPE_COUNT); do
6116                         for idx in $(seq 0 $[$STRIPE_COUNT - 1]); do
6117                                 local size=`expr $STRIPE_SIZE \* $num`
6118                                 local file=file"$num-$idx-$count"
6119                                 $1 $SETSTRIPE -S $size -i $idx -c $count $file
6120                         done
6121                 done
6122         done
6123
6124         cd $DIR
6125         $1 $TAR cf $TMP/f102.tar $tdir --xattrs
6126 }
6127
6128 cleanup_test102() {
6129         trap 0
6130         rm -f $TMP/f102.tar
6131         rm -rf $DIR/d0.sanity/d102
6132 }
6133
6134 test_102a() {
6135         local testfile=$DIR/xattr_testfile
6136
6137         touch $testfile
6138
6139         [ "$UID" != 0 ] && skip_env "must run as root" && return
6140         [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep xattr)" ] &&
6141                 skip_env "must have user_xattr" && return
6142
6143         [ -z "$(which setfattr 2>/dev/null)" ] &&
6144                 skip_env "could not find setfattr" && return
6145
6146         echo "set/get xattr..."
6147         setfattr -n trusted.name1 -v value1 $testfile ||
6148                 error "setfattr -n trusted.name1=value1 $testfile failed"
6149         getfattr -n trusted.name1 $testfile 2> /dev/null |
6150           grep "trusted.name1=.value1" ||
6151                 error "$testfile missing trusted.name1=value1"
6152
6153         setfattr -n user.author1 -v author1 $testfile ||
6154                 error "setfattr -n user.author1=author1 $testfile failed"
6155         getfattr -n user.author1 $testfile 2> /dev/null |
6156           grep "user.author1=.author1" ||
6157                 error "$testfile missing trusted.author1=author1"
6158
6159         echo "listxattr..."
6160         setfattr -n trusted.name2 -v value2 $testfile ||
6161                 error "$testfile unable to set trusted.name2"
6162         setfattr -n trusted.name3 -v value3 $testfile ||
6163                 error "$testfile unable to set trusted.name3"
6164         [ $(getfattr -d -m "^trusted" $testfile 2> /dev/null |
6165             grep "trusted.name" | wc -l) -eq 3 ] ||
6166                 error "$testfile missing 3 trusted.name xattrs"
6167
6168         setfattr -n user.author2 -v author2 $testfile ||
6169                 error "$testfile unable to set user.author2"
6170         setfattr -n user.author3 -v author3 $testfile ||
6171                 error "$testfile unable to set user.author3"
6172         [ $(getfattr -d -m "^user" $testfile 2> /dev/null |
6173             grep "user.author" | wc -l) -eq 3 ] ||
6174                 error "$testfile missing 3 user.author xattrs"
6175
6176         echo "remove xattr..."
6177         setfattr -x trusted.name1 $testfile ||
6178                 error "$testfile error deleting trusted.name1"
6179         getfattr -d -m trusted $testfile 2> /dev/null | grep "trusted.name1" &&
6180                 error "$testfile did not delete trusted.name1 xattr"
6181
6182         setfattr -x user.author1 $testfile ||
6183                 error "$testfile error deleting user.author1"
6184         getfattr -d -m user $testfile 2> /dev/null | grep "user.author1" &&
6185                 error "$testfile did not delete trusted.name1 xattr"
6186
6187         # b10667: setting lustre special xattr be silently discarded
6188         echo "set lustre special xattr ..."
6189         setfattr -n "trusted.lov" -v "invalid value" $testfile ||
6190                 error "$testfile allowed setting trusted.lov"
6191 }
6192 run_test 102a "user xattr test =================================="
6193
6194 test_102b() {
6195         # b10930: get/set/list trusted.lov xattr
6196         echo "get/set/list trusted.lov xattr ..."
6197         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
6198         local testfile=$DIR/$tfile
6199         $SETSTRIPE -S 65536 -i 1 -c $OSTCOUNT $testfile ||
6200                 error "setstripe failed"
6201         local STRIPECOUNT=$($GETSTRIPE -c $testfile) ||
6202                 error "getstripe failed"
6203         getfattr -d -m "^trusted" $testfile 2> /dev/null | \
6204         grep "trusted.lov" || error "can't get trusted.lov from $testfile"
6205
6206         local testfile2=${testfile}2
6207         local value=`getfattr -n trusted.lov $testfile 2> /dev/null | \
6208                      grep "trusted.lov" |sed -e 's/[^=]\+=//'`
6209
6210         $MCREATE $testfile2
6211         setfattr -n trusted.lov -v $value $testfile2
6212         local stripe_size=$($GETSTRIPE -S $testfile2)
6213         local stripe_count=$($GETSTRIPE -c $testfile2)
6214         [ $stripe_size -eq 65536 ] || error "stripe size $stripe_size != 65536"
6215         [ $stripe_count -eq $STRIPECOUNT ] ||
6216                 error "stripe count $stripe_count != $STRIPECOUNT"
6217         rm -f $DIR/$tfile
6218 }
6219 run_test 102b "getfattr/setfattr for trusted.lov EAs ============"
6220
6221 test_102c() {
6222         # b10930: get/set/list lustre.lov xattr
6223         echo "get/set/list lustre.lov xattr ..."
6224         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
6225         test_mkdir -p $DIR/$tdir
6226         chown $RUNAS_ID $DIR/$tdir
6227         local testfile=$DIR/$tdir/$tfile
6228         $RUNAS $SETSTRIPE -S 65536 -i 1 -c $OSTCOUNT $testfile ||
6229                 error "setstripe failed"
6230         local STRIPECOUNT=$($RUNAS $GETSTRIPE -c $testfile) ||
6231                 error "getstripe failed"
6232         $RUNAS getfattr -d -m "^lustre" $testfile 2> /dev/null | \
6233         grep "lustre.lov" || error "can't get lustre.lov from $testfile"
6234
6235         local testfile2=${testfile}2
6236         local value=`getfattr -n lustre.lov $testfile 2> /dev/null | \
6237                      grep "lustre.lov" |sed -e 's/[^=]\+=//'  `
6238
6239         $RUNAS $MCREATE $testfile2
6240         $RUNAS setfattr -n lustre.lov -v $value $testfile2
6241         local stripe_size=$($RUNAS $GETSTRIPE -S $testfile2)
6242         local stripe_count=$($RUNAS $GETSTRIPE -c $testfile2)
6243         [ $stripe_size -eq 65536 ] || error "stripe size $stripe_size != 65536"
6244         [ $stripe_count -eq $STRIPECOUNT ] ||
6245                 error "stripe count $stripe_count != $STRIPECOUNT"
6246 }
6247 run_test 102c "non-root getfattr/setfattr for lustre.lov EAs ==========="
6248
6249 compare_stripe_info1() {
6250         local stripe_index_all_zero=true
6251
6252         for num in 1 2 3 4; do
6253                 for count in $(seq 1 $STRIPE_COUNT); do
6254                         for offset in $(seq 0 $[$STRIPE_COUNT - 1]); do
6255                                 local size=$((STRIPE_SIZE * num))
6256                                 local file=file"$num-$offset-$count"
6257                                 stripe_size=$(lfs getstripe -S $PWD/$file)
6258                                 [ $stripe_size -ne $size ] &&
6259                                     error "$file: size $stripe_size != $size"
6260                                 stripe_count=$(lfs getstripe -c $PWD/$file)
6261                                 # allow fewer stripes to be created, ORI-601
6262                                 [ $stripe_count -lt $(((3 * count + 3) / 4)) ]&&
6263                                     error "$file: count $stripe_count != $count"
6264                                 stripe_index=$(lfs getstripe -i $PWD/$file)
6265                                 [ $stripe_index -ne 0 ] &&
6266                                         stripe_index_all_zero=false
6267                         done
6268                 done
6269         done
6270         $stripe_index_all_zero &&
6271                 error "all files are being extracted starting from OST index 0"
6272         return 0
6273 }
6274
6275 find_lustre_tar() {
6276         [ -n "$(which tar 2>/dev/null)" ] &&
6277                 strings $(which tar) | grep -q "lustre" && echo tar
6278 }
6279
6280 test_102d() {
6281         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6282         # b10930: tar test for trusted.lov xattr
6283         TAR=$(find_lustre_tar)
6284         [ -z "$TAR" ] && skip_env "lustre-aware tar is not installed" && return
6285         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping N-stripe test" && return
6286         setup_test102
6287         test_mkdir -p $DIR/d102d
6288         $TAR xf $TMP/f102.tar -C $DIR/d102d --xattrs
6289         cd $DIR/d102d/$tdir
6290         compare_stripe_info1
6291 }
6292 run_test 102d "tar restore stripe info from tarfile,not keep osts ==========="
6293
6294 test_102f() {
6295         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6296         # b10930: tar test for trusted.lov xattr
6297         TAR=$(find_lustre_tar)
6298         [ -z "$TAR" ] && skip_env "lustre-aware tar is not installed" && return
6299         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping N-stripe test" && return
6300         setup_test102
6301         test_mkdir -p $DIR/d102f
6302         cd $DIR
6303         $TAR cf - --xattrs $tdir | $TAR xf - --xattrs -C $DIR/d102f
6304         cd $DIR/d102f/$tdir
6305         compare_stripe_info1
6306 }
6307 run_test 102f "tar copy files, not keep osts ==========="
6308
6309 grow_xattr() {
6310         local xsize=${1:-1024}  # in bytes
6311         local file=$DIR/$tfile
6312
6313         [ -z $(lctl get_param -n mdc.*.connect_flags | grep xattr) ] &&
6314                 skip "must have user_xattr" && return 0
6315         [ -z "$(which setfattr 2>/dev/null)" ] &&
6316                 skip_env "could not find setfattr" && return 0
6317         [ -z "$(which getfattr 2>/dev/null)" ] &&
6318                 skip_env "could not find getfattr" && return 0
6319
6320         touch $file
6321
6322         local value="$(generate_string $xsize)"
6323
6324         local xbig=trusted.big
6325         log "save $xbig on $file"
6326         setfattr -n $xbig -v $value $file ||
6327                 error "saving $xbig on $file failed"
6328
6329         local orig=$(get_xattr_value $xbig $file)
6330         [[ "$orig" != "$value" ]] && error "$xbig different after saving $xbig"
6331
6332         local xsml=trusted.sml
6333         log "save $xsml on $file"
6334         setfattr -n $xsml -v val $file || error "saving $xsml on $file failed"
6335
6336         local new=$(get_xattr_value $xbig $file)
6337         [[ "$new" != "$orig" ]] && error "$xbig different after saving $xsml"
6338
6339         log "grow $xsml on $file"
6340         setfattr -n $xsml -v "$value" $file ||
6341                 error "growing $xsml on $file failed"
6342
6343         new=$(get_xattr_value $xbig $file)
6344         [[ "$new" != "$orig" ]] && error "$xbig different after growing $xsml"
6345         log "$xbig still valid after growing $xsml"
6346
6347         rm -f $file
6348 }
6349
6350 test_102h() { # bug 15777
6351         grow_xattr 1024
6352 }
6353 run_test 102h "grow xattr from inside inode to external block"
6354
6355 test_102ha() {
6356         large_xattr_enabled || { skip "large_xattr disabled" && return; }
6357         grow_xattr $(max_xattr_size)
6358 }
6359 run_test 102ha "grow xattr from inside inode to external inode"
6360
6361 test_102i() { # bug 17038
6362         touch $DIR/$tfile
6363         ln -s $DIR/$tfile $DIR/${tfile}link
6364         getfattr -n trusted.lov $DIR/$tfile || error "lgetxattr on $DIR/$tfile failed"
6365         getfattr -h -n trusted.lov $DIR/${tfile}link 2>&1 | grep -i "no such attr" || error "error for lgetxattr on $DIR/${tfile}link is not ENODATA"
6366         rm -f $DIR/$tfile $DIR/${tfile}link
6367 }
6368 run_test 102i "lgetxattr test on symbolic link ============"
6369
6370 test_102j() {
6371         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6372         TAR=$(find_lustre_tar)
6373         [ -z "$TAR" ] && skip_env "lustre-aware tar is not installed" && return
6374         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping N-stripe test" && return
6375         setup_test102 "$RUNAS"
6376         test_mkdir -p $DIR/d102j
6377         chown $RUNAS_ID $DIR/d102j
6378         $RUNAS $TAR xf $TMP/f102.tar -C $DIR/d102j --xattrs
6379         cd $DIR/d102j/$tdir
6380         compare_stripe_info1 "$RUNAS"
6381 }
6382 run_test 102j "non-root tar restore stripe info from tarfile, not keep osts ==="
6383
6384 test_102k() {
6385         touch $DIR/$tfile
6386         # b22187 just check that does not crash for regular file.
6387         setfattr -n trusted.lov $DIR/$tfile
6388         # b22187 'setfattr -n trusted.lov' should work as remove LOV EA for directories
6389         local test_kdir=$DIR/d102k
6390         test_mkdir $test_kdir
6391         local default_size=`$GETSTRIPE -S $test_kdir`
6392         local default_count=`$GETSTRIPE -c $test_kdir`
6393         local default_offset=`$GETSTRIPE -i $test_kdir`
6394         $SETSTRIPE -S 65536 -i 0 -c $OSTCOUNT $test_kdir ||
6395                 error 'dir setstripe failed'
6396         setfattr -n trusted.lov $test_kdir
6397         local stripe_size=`$GETSTRIPE -S $test_kdir`
6398         local stripe_count=`$GETSTRIPE -c $test_kdir`
6399         local stripe_offset=`$GETSTRIPE -i $test_kdir`
6400         [ $stripe_size -eq $default_size ] ||
6401                 error "stripe size $stripe_size != $default_size"
6402         [ $stripe_count -eq $default_count ] ||
6403                 error "stripe count $stripe_count != $default_count"
6404         [ $stripe_offset -eq $default_offset ] ||
6405                 error "stripe offset $stripe_offset != $default_offset"
6406         rm -rf $DIR/$tfile $test_kdir
6407 }
6408 run_test 102k "setfattr without parameter of value shouldn't cause a crash"
6409
6410 test_102l() {
6411         # LU-532 trusted. xattr is invisible to non-root
6412         local testfile=$DIR/$tfile
6413
6414         touch $testfile
6415
6416         echo "listxattr as user..."
6417         chown $RUNAS_ID $testfile
6418         $RUNAS getfattr -d -m '.*' $testfile 2>&1 |
6419             grep -q "trusted" &&
6420                 error "$testfile trusted xattrs are user visible"
6421
6422         return 0;
6423 }
6424 run_test 102l "listxattr size test =================================="
6425
6426 test_102m() { # LU-3403 llite: error of listxattr when buffer is small
6427         local path=$DIR/$tfile
6428         touch $path
6429
6430         listxattr_size_check $path || error "listattr_size_check $path failed"
6431 }
6432 run_test 102m "Ensure listxattr fails on small bufffer ========"
6433
6434 cleanup_test102
6435
6436 getxattr() { # getxattr path name
6437         # Return the base64 encoding of the value of xattr name on path.
6438         local path=$1
6439         local name=$2
6440
6441         # # getfattr --absolute-names --encoding=base64 --name=trusted.lov $path
6442         # file: $path
6443         # trusted.lov=0s0AvRCwEAAAAGAAAAAAAAAAAEAAACAAAAAAAQAAEAA...AAAAAAAAA=
6444         #
6445         # We print just 0s0AvRCwEAAAAGAAAAAAAAAAAEAAACAAAAAAAQAAEAA...AAAAAAAAA=
6446
6447         getfattr --absolute-names --encoding=base64 --name=$name $path |
6448                 awk -F= -v name=$name '$1 == name {
6449                         print substr($0, index($0, "=") + 1);
6450         }'
6451 }
6452
6453 test_102n() { # LU-4101 mdt: protect internal xattrs
6454         local file0=$DIR/$tfile.0
6455         local file1=$DIR/$tfile.1
6456         local xattr0=$TMP/$tfile.0
6457         local xattr1=$TMP/$tfile.1
6458         local name
6459         local value
6460
6461         if [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.5.50) ]
6462         then
6463                 skip "MDT < 2.5.50 allows setxattr on internal trusted xattrs"
6464                 return
6465         fi
6466
6467         rm -rf $file0 $file1 $xattr0 $xattr1
6468         touch $file0 $file1
6469
6470         # Get 'before' xattrs of $file1.
6471         getfattr --absolute-names --dump --match=- $file1 > $xattr0
6472
6473         for name in lov lma lmv link fid version som hsm lfsck_namespace; do
6474                 # Try to copy xattr from $file0 to $file1.
6475                 value=$(getxattr $file0 trusted.$name 2> /dev/null)
6476
6477                 setfattr --name=trusted.$name --value="$value" $file1 ||
6478                         error "setxattr 'trusted.$name' failed"
6479
6480                 # Try to set a garbage xattr.
6481                 value=0sVGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIGl0c2VsZi4=
6482
6483                 setfattr --name=trusted.$name --value="$value" $file1 ||
6484                         error "setxattr 'trusted.$name' failed"
6485
6486                 # Try to remove the xattr from $file1. We don't care if this
6487                 # appears to succeed or fail, we just don't want there to be
6488                 # any changes or crashes.
6489                 setfattr --remove=$trusted.$name $file1 2> /dev/null
6490         done
6491
6492         # Get 'after' xattrs of file1.
6493         getfattr --absolute-names --dump --match=- $file1 > $xattr1
6494
6495         if ! diff $xattr0 $xattr1; then
6496                 error "before and after xattrs of '$file1' differ"
6497         fi
6498
6499         rm -rf $file0 $file1 $xattr0 $xattr1
6500
6501         return 0
6502 }
6503 run_test 102n "silently ignore setxattr on internal trusted xattrs"
6504
6505 run_acl_subtest()
6506 {
6507     $LUSTRE/tests/acl/run $LUSTRE/tests/acl/$1.test
6508     return $?
6509 }
6510
6511 test_103 () {
6512         [ "$UID" != 0 ] && skip_env "must run as root" && return
6513         [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep acl)" ] &&
6514                 skip "must have acl enabled" && return
6515         [ -z "$(which setfacl 2>/dev/null)" ] &&
6516                 skip_env "could not find setfacl" && return
6517         $GSS && skip "could not run under gss" && return
6518
6519         declare -a identity_old
6520
6521         for num in $(seq $MDSCOUNT); do
6522                 switch_identity $num true || identity_old[$num]=$?
6523         done
6524
6525         SAVE_UMASK=$(umask)
6526         umask 0022
6527         cd $DIR
6528
6529         echo "performing cp ..."
6530         run_acl_subtest cp || error "run_acl_subtest cp failed"
6531         echo "performing getfacl-noacl..."
6532         run_acl_subtest getfacl-noacl || error "getfacl-noacl test failed"
6533         echo "performing misc..."
6534         run_acl_subtest misc || error  "misc test failed"
6535         echo "performing permissions..."
6536         run_acl_subtest permissions || error "permissions failed"
6537         echo "performing setfacl..."
6538         run_acl_subtest setfacl || error  "setfacl test failed"
6539
6540         # inheritance test got from HP
6541         echo "performing inheritance..."
6542         cp $LUSTRE/tests/acl/make-tree . || error "cannot copy make-tree"
6543         chmod +x make-tree || error "chmod +x failed"
6544         run_acl_subtest inheritance || error "inheritance test failed"
6545         rm -f make-tree
6546
6547         echo "LU-974 ignore umask when acl is enabled..."
6548         run_acl_subtest 974 || error "LU-974 umask test failed"
6549         if [ $MDSCOUNT -ge 2 ]; then
6550                 run_acl_subtest 974_remote ||
6551                         error "LU-974 umask test failed under remote dir"
6552         fi
6553
6554         echo "LU-2561 newly created file is same size as directory..."
6555         run_acl_subtest 2561 || error "LU-2561 test failed"
6556
6557         cd $SAVE_PWD
6558         umask $SAVE_UMASK
6559
6560         for num in $(seq $MDSCOUNT); do
6561                 if [ "${identity_old[$num]}" = 1 ]; then
6562                         switch_identity $num false || identity_old[$num]=$?
6563                 fi
6564         done
6565 }
6566 run_test 103 "acl test ========================================="
6567
6568 test_104a() {
6569         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6570         touch $DIR/$tfile
6571         lfs df || error "lfs df failed"
6572         lfs df -ih || error "lfs df -ih failed"
6573         lfs df -h $DIR || error "lfs df -h $DIR failed"
6574         lfs df -i $DIR || error "lfs df -i $DIR failed"
6575         lfs df $DIR/$tfile || error "lfs df $DIR/$tfile failed"
6576         lfs df -ih $DIR/$tfile || error "lfs df -ih $DIR/$tfile failed"
6577
6578         local OSC=$(lctl dl | grep OST0000-osc-[^M] | awk '{ print $4 }')
6579         lctl --device %$OSC deactivate
6580         lfs df || error "lfs df with deactivated OSC failed"
6581         lctl --device %$OSC activate
6582         # wait the osc back to normal
6583         wait_osc_import_state client ost FULL
6584
6585         lfs df || error "lfs df with reactivated OSC failed"
6586         rm -f $DIR/$tfile
6587 }
6588 run_test 104a "lfs df [-ih] [path] test ========================="
6589
6590 test_104b() {
6591         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6592         [ $RUNAS_ID -eq $UID ] &&
6593                 skip_env "RUNAS_ID = UID = $UID -- skipping" && return
6594         chmod 666 /dev/obd
6595         denied_cnt=$(($($RUNAS $LFS check servers 2>&1 |
6596                         grep "Permission denied" | wc -l)))
6597         if [ $denied_cnt -ne 0 ]; then
6598                 error "lfs check servers test failed"
6599         fi
6600 }
6601 run_test 104b "$RUNAS lfs check servers test ===================="
6602
6603 test_105a() {
6604         # doesn't work on 2.4 kernels
6605         touch $DIR/$tfile
6606         if [ -n "$(mount | grep "$MOUNT.*flock" | grep -v noflock)" ]; then
6607                 flocks_test 1 on -f $DIR/$tfile || error "fail flock on"
6608         else
6609                 flocks_test 1 off -f $DIR/$tfile || error "fail flock off"
6610         fi
6611         rm -f $DIR/$tfile
6612 }
6613 run_test 105a "flock when mounted without -o flock test ========"
6614
6615 test_105b() {
6616         touch $DIR/$tfile
6617         if [ -n "$(mount | grep "$MOUNT.*flock" | grep -v noflock)" ]; then
6618                 flocks_test 1 on -c $DIR/$tfile || error "fail flock on"
6619         else
6620                 flocks_test 1 off -c $DIR/$tfile || error "fail flock off"
6621         fi
6622         rm -f $DIR/$tfile
6623 }
6624 run_test 105b "fcntl when mounted without -o flock test ========"
6625
6626 test_105c() {
6627         touch $DIR/$tfile
6628         if [ -n "$(mount | grep "$MOUNT.*flock" | grep -v noflock)" ]; then
6629                 flocks_test 1 on -l $DIR/$tfile || error "fail flock on"
6630         else
6631                 flocks_test 1 off -l $DIR/$tfile || error "fail flock off"
6632         fi
6633         rm -f $DIR/$tfile
6634 }
6635 run_test 105c "lockf when mounted without -o flock test ========"
6636
6637 test_105d() { # bug 15924
6638         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6639         test_mkdir -p $DIR/$tdir
6640         [ -z "$(mount | grep "$MOUNT.*flock" | grep -v noflock)" ] &&
6641                 skip "mount w/o flock enabled" && return
6642         #define OBD_FAIL_LDLM_CP_CB_WAIT  0x315
6643         $LCTL set_param fail_loc=0x80000315
6644         flocks_test 2 $DIR/$tdir
6645 }
6646 run_test 105d "flock race (should not freeze) ========"
6647
6648 test_105e() { # bug 22660 && 22040
6649         [ -z "$(mount | grep "$MOUNT.*flock" | grep -v noflock)" ] &&
6650                 skip "mount w/o flock enabled" && return
6651         touch $DIR/$tfile
6652         flocks_test 3 $DIR/$tfile
6653 }
6654 run_test 105e "Two conflicting flocks from same process ======="
6655
6656 test_106() { #bug 10921
6657         test_mkdir -p $DIR/$tdir
6658         $DIR/$tdir && error "exec $DIR/$tdir succeeded"
6659         chmod 777 $DIR/$tdir || error "chmod $DIR/$tdir failed"
6660 }
6661 run_test 106 "attempt exec of dir followed by chown of that dir"
6662
6663 test_107() {
6664         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6665         CDIR=`pwd`
6666         cd $DIR
6667
6668         local file=core
6669         rm -f $file
6670
6671         local save_pattern=$(sysctl -n kernel.core_pattern)
6672         local save_uses_pid=$(sysctl -n kernel.core_uses_pid)
6673         sysctl -w kernel.core_pattern=$file
6674         sysctl -w kernel.core_uses_pid=0
6675
6676         ulimit -c unlimited
6677         sleep 60 &
6678         SLEEPPID=$!
6679
6680         sleep 1
6681
6682         kill -s 11 $SLEEPPID
6683         wait $SLEEPPID
6684         if [ -e $file ]; then
6685                 size=`stat -c%s $file`
6686                 [ $size -eq 0 ] && error "Fail to create core file $file"
6687         else
6688                 error "Fail to create core file $file"
6689         fi
6690         rm -f $file
6691         sysctl -w kernel.core_pattern=$save_pattern
6692         sysctl -w kernel.core_uses_pid=$save_uses_pid
6693         cd $CDIR
6694 }
6695 run_test 107 "Coredump on SIG"
6696
6697 test_110() {
6698         test_mkdir -p $DIR/$tdir
6699         test_mkdir $DIR/$tdir/$(str_repeat 'a' 255) ||
6700                 error "mkdir with 255 char failed"
6701         test_mkdir $DIR/$tdir/$(str_repeat 'b' 256) &&
6702                 error "mkdir with 256 char should fail, but did not"
6703         touch $DIR/$tdir/$(str_repeat 'x' 255) ||
6704                 error "create with 255 char failed"
6705         touch $DIR/$tdir/$(str_repeat 'y' 256) &&
6706                 error "create with 256 char should fail, but did not"
6707
6708         ls -l $DIR/$tdir
6709         rm -rf $DIR/$tdir
6710 }
6711 run_test 110 "filename length checking"
6712
6713 test_115() {
6714         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6715         OSTIO_pre=$(ps -e|grep ll_ost_io|awk '{print $4}'|sort -n|tail -1|\
6716             cut -c11-20)
6717         [ -z "$OSTIO_pre" ] && skip "no OSS threads" && \
6718             return
6719         echo "Starting with $OSTIO_pre threads"
6720
6721         NUMTEST=20000
6722         NUMFREE=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
6723         [ $NUMFREE -lt $NUMTEST ] && NUMTEST=$(($NUMFREE - 1000))
6724         echo "$NUMTEST creates/unlinks"
6725         test_mkdir -p $DIR/$tdir
6726         createmany -o $DIR/$tdir/$tfile $NUMTEST
6727         unlinkmany $DIR/$tdir/$tfile $NUMTEST
6728
6729         OSTIO_post=$(ps -e|grep ll_ost_io|awk '{print $4}'|sort -n|tail -1|\
6730             cut -c11-20)
6731
6732         # don't return an error
6733         [ $OSTIO_post == $OSTIO_pre ] && echo \
6734             "WARNING: No new ll_ost_io threads were created ($OSTIO_pre)" &&
6735             echo "This may be fine, depending on what ran before this test" &&
6736             echo "and how fast this system is." && return
6737
6738         echo "Started with $OSTIO_pre threads, ended with $OSTIO_post"
6739 }
6740 run_test 115 "verify dynamic thread creation===================="
6741
6742 free_min_max () {
6743         wait_delete_completed
6744         AVAIL=($(lctl get_param -n osc.*[oO][sS][cC]-[^M]*.kbytesavail))
6745         echo OST kbytes available: ${AVAIL[@]}
6746         MAXI=0; MAXV=${AVAIL[0]}
6747         MINI=0; MINV=${AVAIL[0]}
6748         for ((i = 0; i < ${#AVAIL[@]}; i++)); do
6749             #echo OST $i: ${AVAIL[i]}kb
6750             if [ ${AVAIL[i]} -gt $MAXV ]; then
6751                 MAXV=${AVAIL[i]}; MAXI=$i
6752             fi
6753             if [ ${AVAIL[i]} -lt $MINV ]; then
6754                 MINV=${AVAIL[i]}; MINI=$i
6755             fi
6756         done
6757         echo Min free space: OST $MINI: $MINV
6758         echo Max free space: OST $MAXI: $MAXV
6759 }
6760
6761 test_116a() { # was previously test_116()
6762         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6763         [ "$OSTCOUNT" -lt "2" ] && skip_env "$OSTCOUNT < 2 OSTs" && return
6764
6765         echo -n "Free space priority "
6766         do_facet $SINGLEMDS lctl get_param -n lo*.*-mdtlov.qos_prio_free |
6767                 head -1
6768         declare -a AVAIL
6769         free_min_max
6770
6771         [ $MINV -eq 0 ] && skip "no free space in OST$MINI, skip" && return
6772         trap simple_cleanup_common EXIT
6773
6774         # Check if we need to generate uneven OSTs
6775         test_mkdir -p $DIR/$tdir/OST${MINI}
6776         local FILL=$(($MINV / 4))
6777         local DIFF=$(($MAXV - $MINV))
6778         local DIFF2=$(($DIFF * 100 / $MINV))
6779
6780         local threshold=$(do_facet $SINGLEMDS \
6781                 lctl get_param -n *.*MDT0000-mdtlov.qos_threshold_rr | head -1)
6782         threshold=${threshold%%%}
6783         echo -n "Check for uneven OSTs: "
6784         echo -n "diff=${DIFF}KB (${DIFF2}%) must be > ${threshold}% ..."
6785
6786         if [ $DIFF2 -gt $threshold ]; then
6787                 echo "ok"
6788                 echo "Don't need to fill OST$MINI"
6789         else
6790                 # generate uneven OSTs. Write 2% over the QOS threshold value
6791                 echo "no"
6792                 DIFF=$(($threshold - $DIFF2 + 2))
6793                 DIFF2=$(( ($MINV * $DIFF)/100 ))
6794                 echo "Fill ${DIFF}% remaining space in OST${MINI} with ${DIFF2}KB"
6795                 $SETSTRIPE -i $MINI -c 1 $DIR/$tdir/OST${MINI} ||
6796                         error "setstripe failed"
6797                 DIFF=$(($DIFF2 / 2048))
6798                 i=0
6799                 while [ $i -lt $DIFF ]; do
6800                         i=$(($i + 1))
6801                         dd if=/dev/zero of=$DIR/$tdir/OST${MINI}/$tfile-$i \
6802                                 bs=2M count=1 2>/dev/null
6803                         echo -n .
6804                 done
6805                 echo .
6806                 sync
6807                 sleep_maxage
6808                 free_min_max
6809         fi
6810
6811         DIFF=$(($MAXV - $MINV))
6812         DIFF2=$(($DIFF * 100 / $MINV))
6813         echo -n "diff=${DIFF}=${DIFF2}% must be > ${threshold}% for QOS mode..."
6814         if [ $DIFF2 -gt $threshold ]; then
6815                 echo "ok"
6816         else
6817                 echo "failed - QOS mode won't be used"
6818                 skip "QOS imbalance criteria not met"
6819                 simple_cleanup_common
6820                 return
6821         fi
6822
6823         MINI1=$MINI; MINV1=$MINV
6824         MAXI1=$MAXI; MAXV1=$MAXV
6825
6826         # now fill using QOS
6827         $SETSTRIPE -c 1 $DIR/$tdir
6828         FILL=$(($FILL / 200))
6829         if [ $FILL -gt 600 ]; then
6830                 FILL=600
6831         fi
6832         echo "writing $FILL files to QOS-assigned OSTs"
6833         i=0
6834         while [ $i -lt $FILL ]; do
6835                 i=$(($i + 1))
6836                 dd if=/dev/zero of=$DIR/$tdir/$tfile-$i bs=200k \
6837                         count=1 2>/dev/null
6838                 echo -n .
6839         done
6840         echo "wrote $i 200k files"
6841         sync
6842         sleep_maxage
6843
6844         echo "Note: free space may not be updated, so measurements might be off"
6845         free_min_max
6846         DIFF2=$(($MAXV - $MINV))
6847         echo "free space delta: orig $DIFF final $DIFF2"
6848         [ $DIFF2 -gt $DIFF ] && echo "delta got worse!"
6849         DIFF=$(($MINV1 - ${AVAIL[$MINI1]}))
6850         echo "Wrote ${DIFF}KB to smaller OST $MINI1"
6851         DIFF2=$(($MAXV1 - ${AVAIL[$MAXI1]}))
6852         echo "Wrote ${DIFF2}KB to larger OST $MAXI1"
6853         FILL=$(($DIFF2 * 100 / $DIFF - 100))
6854         [ $DIFF -gt 0 ] &&
6855                 echo "Wrote ${FILL}% more data to larger OST $MAXI1"
6856
6857         # Figure out which files were written where
6858         UUID=$(lctl get_param -n lov.${FSNAME}-clilov-*.target_obd |
6859                   awk '/'$MINI1': / {print $2; exit}')
6860         echo $UUID
6861         MINC=$($GETSTRIPE --ost $UUID $DIR/$tdir | grep $DIR | wc -l)
6862         echo "$MINC files created on smaller OST $MINI1"
6863         UUID=$(lctl get_param -n lov.${FSNAME}-clilov-*.target_obd |
6864                   awk '/'$MAXI1': / {print $2; exit}')
6865         echo $UUID
6866         MAXC=$($GETSTRIPE --ost $UUID $DIR/$tdir | grep $DIR | wc -l)
6867         echo "$MAXC files created on larger OST $MAXI1"
6868         FILL=$(($MAXC * 100 / $MINC - 100))
6869         [ $MINC -gt 0 ] &&
6870                 echo "Wrote ${FILL}% more files to larger OST $MAXI1"
6871         [ $MAXC -gt $MINC ] ||
6872                 error_ignore LU-9 "stripe QOS didn't balance free space"
6873         simple_cleanup_common
6874 }
6875 run_test 116a "stripe QOS: free space balance ==================="
6876
6877 test_116b() { # LU-2093
6878         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6879 #define OBD_FAIL_MDS_OSC_CREATE_FAIL     0x147
6880         local old_rr
6881         old_rr=$(do_facet $SINGLEMDS lctl get_param -n lov.*mdtlov*.qos_threshold_rr)
6882         do_facet $SINGLEMDS lctl set_param lov.*mdtlov*.qos_threshold_rr 0
6883         mkdir -p $DIR/$tdir
6884         do_facet $SINGLEMDS lctl set_param fail_loc=0x147
6885         createmany -o $DIR/$tdir/f- 20 || error "can't create"
6886         do_facet $SINGLEMDS lctl set_param fail_loc=0
6887         rm -rf $DIR/$tdir
6888         do_facet $SINGLEMDS lctl set_param lov.*mdtlov*.qos_threshold_rr $old_rr
6889 }
6890 run_test 116b "QoS shouldn't LBUG if not enough OSTs found on the 2nd pass"
6891
6892 test_117() # bug 10891
6893 {
6894         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6895         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1
6896         #define OBD_FAIL_OST_SETATTR_CREDITS 0x21e
6897         lctl set_param fail_loc=0x21e
6898         > $DIR/$tfile || error "truncate failed"
6899         lctl set_param fail_loc=0
6900         echo "Truncate succeeded."
6901         rm -f $DIR/$tfile
6902 }
6903 run_test 117 "verify osd extend =========="
6904
6905 NO_SLOW_RESENDCOUNT=4
6906 export OLD_RESENDCOUNT=""
6907 set_resend_count () {
6908         local PROC_RESENDCOUNT="osc.${FSNAME}-OST*-osc-*.resend_count"
6909         OLD_RESENDCOUNT=$(lctl get_param -n $PROC_RESENDCOUNT | head -1)
6910         lctl set_param -n $PROC_RESENDCOUNT $1
6911         echo resend_count is set to $(lctl get_param -n $PROC_RESENDCOUNT)
6912 }
6913
6914 # for reduce test_118* time (b=14842)
6915 [ "$SLOW" = "no" ] && set_resend_count $NO_SLOW_RESENDCOUNT
6916
6917 # Reset async IO behavior after error case
6918 reset_async() {
6919         FILE=$DIR/reset_async
6920
6921         # Ensure all OSCs are cleared
6922         $SETSTRIPE -c -1 $FILE
6923         dd if=/dev/zero of=$FILE bs=64k count=$OSTCOUNT
6924         sync
6925         rm $FILE
6926 }
6927
6928 test_118a() #bug 11710
6929 {
6930         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6931         reset_async
6932
6933         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
6934         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
6935         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
6936
6937         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
6938                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
6939                 return 1;
6940         fi
6941         rm -f $DIR/$tfile
6942 }
6943 run_test 118a "verify O_SYNC works =========="
6944
6945 test_118b()
6946 {
6947         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6948         remote_ost_nodsh && skip "remote OST with nodsh" && return
6949
6950         reset_async
6951
6952         #define OBD_FAIL_OST_ENOENT 0x217
6953         set_nodes_failloc "$(osts_nodes)" 0x217
6954         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
6955         RC=$?
6956         set_nodes_failloc "$(osts_nodes)" 0
6957         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
6958         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
6959                     grep -c writeback)
6960
6961         if [[ $RC -eq 0 ]]; then
6962                 error "Must return error due to dropped pages, rc=$RC"
6963                 return 1;
6964         fi
6965
6966         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
6967                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
6968                 return 1;
6969         fi
6970
6971         echo "Dirty pages not leaked on ENOENT"
6972
6973         # Due to the above error the OSC will issue all RPCs syncronously
6974         # until a subsequent RPC completes successfully without error.
6975         $MULTIOP $DIR/$tfile Ow4096yc
6976         rm -f $DIR/$tfile
6977
6978         return 0
6979 }
6980 run_test 118b "Reclaim dirty pages on fatal error =========="
6981
6982 test_118c()
6983 {
6984         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6985
6986         # for 118c, restore the original resend count, LU-1940
6987         [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] &&
6988                                 set_resend_count $OLD_RESENDCOUNT
6989         remote_ost_nodsh && skip "remote OST with nodsh" && return
6990
6991         reset_async
6992
6993         #define OBD_FAIL_OST_EROFS               0x216
6994         set_nodes_failloc "$(osts_nodes)" 0x216
6995
6996         # multiop should block due to fsync until pages are written
6997         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
6998         MULTIPID=$!
6999         sleep 1
7000
7001         if [[ `ps h -o comm -p $MULTIPID` != "multiop" ]]; then
7002                 error "Multiop failed to block on fsync, pid=$MULTIPID"
7003         fi
7004
7005         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
7006                     grep -c writeback)
7007         if [[ $WRITEBACK -eq 0 ]]; then
7008                 error "No page in writeback, writeback=$WRITEBACK"
7009         fi
7010
7011         set_nodes_failloc "$(osts_nodes)" 0
7012         wait $MULTIPID
7013         RC=$?
7014         if [[ $RC -ne 0 ]]; then
7015                 error "Multiop fsync failed, rc=$RC"
7016         fi
7017
7018         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
7019         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
7020                     grep -c writeback)
7021         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
7022                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
7023         fi
7024
7025         rm -f $DIR/$tfile
7026         echo "Dirty pages flushed via fsync on EROFS"
7027         return 0
7028 }
7029 run_test 118c "Fsync blocks on EROFS until dirty pages are flushed =========="
7030
7031 # continue to use small resend count to reduce test_118* time (b=14842)
7032 [ "$SLOW" = "no" ] && set_resend_count $NO_SLOW_RESENDCOUNT
7033
7034 test_118d()
7035 {
7036         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7037         remote_ost_nodsh && skip "remote OST with nodsh" && return
7038
7039         reset_async
7040
7041         #define OBD_FAIL_OST_BRW_PAUSE_BULK
7042         set_nodes_failloc "$(osts_nodes)" 0x214
7043         # multiop should block due to fsync until pages are written
7044         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
7045         MULTIPID=$!
7046         sleep 1
7047
7048         if [[ `ps h -o comm -p $MULTIPID` != "multiop" ]]; then
7049                 error "Multiop failed to block on fsync, pid=$MULTIPID"
7050         fi
7051
7052         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
7053                     grep -c writeback)
7054         if [[ $WRITEBACK -eq 0 ]]; then
7055                 error "No page in writeback, writeback=$WRITEBACK"
7056         fi
7057
7058         wait $MULTIPID || error "Multiop fsync failed, rc=$?"
7059         set_nodes_failloc "$(osts_nodes)" 0
7060
7061         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
7062         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
7063                     grep -c writeback)
7064         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
7065                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
7066         fi
7067
7068         rm -f $DIR/$tfile
7069         echo "Dirty pages gaurenteed flushed via fsync"
7070         return 0
7071 }
7072 run_test 118d "Fsync validation inject a delay of the bulk =========="
7073
7074 test_118f() {
7075         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7076         reset_async
7077
7078         #define OBD_FAIL_OSC_BRW_PREP_REQ2        0x40a
7079         lctl set_param fail_loc=0x8000040a
7080
7081         # Should simulate EINVAL error which is fatal
7082         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
7083         RC=$?
7084         if [[ $RC -eq 0 ]]; then
7085                 error "Must return error due to dropped pages, rc=$RC"
7086         fi
7087
7088         lctl set_param fail_loc=0x0
7089
7090         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
7091         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
7092         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
7093                     grep -c writeback)
7094         if [[ $LOCKED -ne 0 ]]; then
7095                 error "Locked pages remain in cache, locked=$LOCKED"
7096         fi
7097
7098         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
7099                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
7100         fi
7101
7102         rm -f $DIR/$tfile
7103         echo "No pages locked after fsync"
7104
7105         reset_async
7106         return 0
7107 }
7108 run_test 118f "Simulate unrecoverable OSC side error =========="
7109
7110 test_118g() {
7111         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7112         reset_async
7113
7114         #define OBD_FAIL_OSC_BRW_PREP_REQ        0x406
7115         lctl set_param fail_loc=0x406
7116
7117         # simulate local -ENOMEM
7118         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
7119         RC=$?
7120
7121         lctl set_param fail_loc=0
7122         if [[ $RC -eq 0 ]]; then
7123                 error "Must return error due to dropped pages, rc=$RC"
7124         fi
7125
7126         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
7127         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
7128         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
7129                         grep -c writeback)
7130         if [[ $LOCKED -ne 0 ]]; then
7131                 error "Locked pages remain in cache, locked=$LOCKED"
7132         fi
7133
7134         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
7135                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
7136         fi
7137
7138         rm -f $DIR/$tfile
7139         echo "No pages locked after fsync"
7140
7141         reset_async
7142         return 0
7143 }
7144 run_test 118g "Don't stay in wait if we got local -ENOMEM  =========="
7145
7146 test_118h() {
7147         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7148         remote_ost_nodsh && skip "remote OST with nodsh" && return
7149
7150         reset_async
7151
7152         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
7153         set_nodes_failloc "$(osts_nodes)" 0x20e
7154         # Should simulate ENOMEM error which is recoverable and should be handled by timeout
7155         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
7156         RC=$?
7157
7158         set_nodes_failloc "$(osts_nodes)" 0
7159         if [[ $RC -eq 0 ]]; then
7160                 error "Must return error due to dropped pages, rc=$RC"
7161         fi
7162
7163         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
7164         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
7165         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
7166                     grep -c writeback)
7167         if [[ $LOCKED -ne 0 ]]; then
7168                 error "Locked pages remain in cache, locked=$LOCKED"
7169         fi
7170
7171         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
7172                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
7173         fi
7174
7175         rm -f $DIR/$tfile
7176         echo "No pages locked after fsync"
7177
7178         return 0
7179 }
7180 run_test 118h "Verify timeout in handling recoverables errors  =========="
7181
7182 [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] && set_resend_count $OLD_RESENDCOUNT
7183
7184 test_118i() {
7185         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7186         remote_ost_nodsh && skip "remote OST with nodsh" && return
7187
7188         reset_async
7189
7190         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
7191         set_nodes_failloc "$(osts_nodes)" 0x20e
7192
7193         # Should simulate ENOMEM error which is recoverable and should be handled by timeout
7194         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
7195         PID=$!
7196         sleep 5
7197         set_nodes_failloc "$(osts_nodes)" 0
7198
7199         wait $PID
7200         RC=$?
7201         if [[ $RC -ne 0 ]]; then
7202                 error "got error, but should be not, rc=$RC"
7203         fi
7204
7205         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
7206         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
7207         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
7208         if [[ $LOCKED -ne 0 ]]; then
7209                 error "Locked pages remain in cache, locked=$LOCKED"
7210         fi
7211
7212         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
7213                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
7214         fi
7215
7216         rm -f $DIR/$tfile
7217         echo "No pages locked after fsync"
7218
7219         return 0
7220 }
7221 run_test 118i "Fix error before timeout in recoverable error  =========="
7222
7223 [ "$SLOW" = "no" ] && set_resend_count 4
7224
7225 test_118j() {
7226         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7227         remote_ost_nodsh && skip "remote OST with nodsh" && return
7228
7229         reset_async
7230
7231         #define OBD_FAIL_OST_BRW_WRITE_BULK2     0x220
7232         set_nodes_failloc "$(osts_nodes)" 0x220
7233
7234         # return -EIO from OST
7235         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
7236         RC=$?
7237         set_nodes_failloc "$(osts_nodes)" 0x0
7238         if [[ $RC -eq 0 ]]; then
7239                 error "Must return error due to dropped pages, rc=$RC"
7240         fi
7241
7242         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
7243         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
7244         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
7245         if [[ $LOCKED -ne 0 ]]; then
7246                 error "Locked pages remain in cache, locked=$LOCKED"
7247         fi
7248
7249         # in recoverable error on OST we want resend and stay until it finished
7250         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
7251                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
7252         fi
7253
7254         rm -f $DIR/$tfile
7255         echo "No pages locked after fsync"
7256
7257         return 0
7258 }
7259 run_test 118j "Simulate unrecoverable OST side error =========="
7260
7261 test_118k()
7262 {
7263         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7264         remote_ost_nodsh && skip "remote OSTs with nodsh" && return
7265
7266         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
7267         set_nodes_failloc "$(osts_nodes)" 0x20e
7268         test_mkdir -p $DIR/$tdir
7269
7270         for ((i=0;i<10;i++)); do
7271                 (dd if=/dev/zero of=$DIR/$tdir/$tfile-$i bs=1M count=10 || \
7272                         error "dd to $DIR/$tdir/$tfile-$i failed" )&
7273                 SLEEPPID=$!
7274                 sleep 0.500s
7275                 kill $SLEEPPID
7276                 wait $SLEEPPID
7277         done
7278
7279         set_nodes_failloc "$(osts_nodes)" 0
7280         rm -rf $DIR/$tdir
7281 }
7282 run_test 118k "bio alloc -ENOMEM and IO TERM handling ========="
7283
7284 test_118l()
7285 {
7286         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7287         # LU-646
7288         test_mkdir -p $DIR/$tdir
7289         $MULTIOP $DIR/$tdir Dy || error "fsync dir failed"
7290         rm -rf $DIR/$tdir
7291 }
7292 run_test 118l "fsync dir ========="
7293
7294 test_118m() # LU-3066
7295 {
7296         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7297         test_mkdir -p $DIR/$tdir
7298         $MULTIOP $DIR/$tdir DY || error "fdatasync dir failed"
7299         rm -rf $DIR/$tdir
7300 }
7301 run_test 118m "fdatasync dir ========="
7302
7303 [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] && set_resend_count $OLD_RESENDCOUNT
7304
7305 test_119a() # bug 11737
7306 {
7307         BSIZE=$((512 * 1024))
7308         directio write $DIR/$tfile 0 1 $BSIZE
7309         # We ask to read two blocks, which is more than a file size.
7310         # directio will indicate an error when requested and actual
7311         # sizes aren't equeal (a normal situation in this case) and
7312         # print actual read amount.
7313         NOB=`directio read $DIR/$tfile 0 2 $BSIZE | awk '/error/ {print $6}'`
7314         if [ "$NOB" != "$BSIZE" ]; then
7315                 error "read $NOB bytes instead of $BSIZE"
7316         fi
7317         rm -f $DIR/$tfile
7318 }
7319 run_test 119a "Short directIO read must return actual read amount"
7320
7321 test_119b() # bug 11737
7322 {
7323         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
7324
7325         $SETSTRIPE -c 2 $DIR/$tfile || error "setstripe failed"
7326         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1 || error "dd failed"
7327         sync
7328         $MULTIOP $DIR/$tfile oO_RDONLY:O_DIRECT:r$((2048 * 1024)) || \
7329                 error "direct read failed"
7330         rm -f $DIR/$tfile
7331 }
7332 run_test 119b "Sparse directIO read must return actual read amount"
7333
7334 test_119c() # bug 13099
7335 {
7336         BSIZE=1048576
7337         directio write $DIR/$tfile 3 1 $BSIZE || error "direct write failed"
7338         directio readhole $DIR/$tfile 0 2 $BSIZE || error "reading hole failed"
7339         rm -f $DIR/$tfile
7340 }
7341 run_test 119c "Testing for direct read hitting hole"
7342
7343 test_119d() # bug 15950
7344 {
7345         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7346         MAX_RPCS_IN_FLIGHT=`$LCTL get_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight`
7347         $LCTL set_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight 1
7348         BSIZE=1048576
7349         $SETSTRIPE $DIR/$tfile -i 0 -c 1 || error "setstripe failed"
7350         $DIRECTIO write $DIR/$tfile 0 1 $BSIZE || error "first directio failed"
7351         #define OBD_FAIL_OSC_DIO_PAUSE           0x40d
7352         lctl set_param fail_loc=0x40d
7353         $DIRECTIO write $DIR/$tfile 1 4 $BSIZE &
7354         pid_dio=$!
7355         sleep 1
7356         cat $DIR/$tfile > /dev/null &
7357         lctl set_param fail_loc=0
7358         pid_reads=$!
7359         wait $pid_dio
7360         log "the DIO writes have completed, now wait for the reads (should not block very long)"
7361         sleep 2
7362         [ -n "`ps h -p $pid_reads -o comm`" ] && \
7363         error "the read rpcs have not completed in 2s"
7364         rm -f $DIR/$tfile
7365         $LCTL set_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight $MAX_RPCS_IN_FLIGHT
7366 }
7367 run_test 119d "The DIO path should try to send a new rpc once one is completed"
7368
7369 test_120a() {
7370         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7371         test_mkdir -p $DIR/$tdir
7372         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7373                skip "no early lock cancel on server" && return 0
7374
7375         lru_resize_disable mdc
7376         lru_resize_disable osc
7377         cancel_lru_locks mdc
7378         # asynchronous object destroy at MDT could cause bl ast to client
7379         cancel_lru_locks osc
7380
7381         stat $DIR/$tdir > /dev/null
7382         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7383         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7384         test_mkdir $DIR/$tdir/d1
7385         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7386         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7387         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
7388         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
7389         lru_resize_enable mdc
7390         lru_resize_enable osc
7391 }
7392 run_test 120a "Early Lock Cancel: mkdir test"
7393
7394 test_120b() {
7395         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7396         test_mkdir -p $DIR/$tdir
7397         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7398                skip "no early lock cancel on server" && return 0
7399         lru_resize_disable mdc
7400         lru_resize_disable osc
7401         cancel_lru_locks mdc
7402         stat $DIR/$tdir > /dev/null
7403         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7404         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7405         touch $DIR/$tdir/f1
7406         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7407         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7408         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
7409         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
7410         lru_resize_enable mdc
7411         lru_resize_enable osc
7412 }
7413 run_test 120b "Early Lock Cancel: create test"
7414
7415 test_120c() {
7416         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7417         test_mkdir -p $DIR/$tdir
7418         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7419                skip "no early lock cancel on server" && return 0
7420         lru_resize_disable mdc
7421         lru_resize_disable osc
7422         test_mkdir -p $DIR/$tdir/d1
7423         test_mkdir -p $DIR/$tdir/d2
7424         touch $DIR/$tdir/d1/f1
7425         cancel_lru_locks mdc
7426         stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 > /dev/null
7427         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7428         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7429         ln $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2
7430         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7431         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7432         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
7433         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
7434         lru_resize_enable mdc
7435         lru_resize_enable osc
7436 }
7437 run_test 120c "Early Lock Cancel: link test"
7438
7439 test_120d() {
7440         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7441         test_mkdir -p $DIR/$tdir
7442         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7443                skip "no early lock cancel on server" && return 0
7444         lru_resize_disable mdc
7445         lru_resize_disable osc
7446         touch $DIR/$tdir
7447         cancel_lru_locks mdc
7448         stat $DIR/$tdir > /dev/null
7449         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7450         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7451         chmod a+x $DIR/$tdir
7452         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7453         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7454         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
7455         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
7456         lru_resize_enable mdc
7457         lru_resize_enable osc
7458 }
7459 run_test 120d "Early Lock Cancel: setattr test"
7460
7461 test_120e() {
7462         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7463         test_mkdir -p $DIR/$tdir
7464         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7465                skip "no early lock cancel on server" && return 0
7466         lru_resize_disable mdc
7467         lru_resize_disable osc
7468         dd if=/dev/zero of=$DIR/$tdir/f1 count=1
7469         cancel_lru_locks mdc
7470         cancel_lru_locks osc
7471         dd if=$DIR/$tdir/f1 of=/dev/null
7472         stat $DIR/$tdir $DIR/$tdir/f1 > /dev/null
7473         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7474               awk '/ldlm_cancel/ {print $2}'`
7475         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7476               awk '/ldlm_bl_callback/ {print $2}'`
7477         unlink $DIR/$tdir/f1
7478         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7479               awk '/ldlm_cancel/ {print $2}'`
7480         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7481               awk '/ldlm_bl_callback/ {print $2}'`
7482         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
7483         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
7484         lru_resize_enable mdc
7485         lru_resize_enable osc
7486 }
7487 run_test 120e "Early Lock Cancel: unlink test"
7488
7489 test_120f() {
7490         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7491         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7492                skip "no early lock cancel on server" && return 0
7493         test_mkdir -p $DIR/$tdir
7494         lru_resize_disable mdc
7495         lru_resize_disable osc
7496         test_mkdir -p $DIR/$tdir/d1
7497         test_mkdir -p $DIR/$tdir/d2
7498         dd if=/dev/zero of=$DIR/$tdir/d1/f1 count=1
7499         dd if=/dev/zero of=$DIR/$tdir/d2/f2 count=1
7500         cancel_lru_locks mdc
7501         cancel_lru_locks osc
7502         dd if=$DIR/$tdir/d1/f1 of=/dev/null
7503         dd if=$DIR/$tdir/d2/f2 of=/dev/null
7504         stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2 > /dev/null
7505         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7506               awk '/ldlm_cancel/ {print $2}'`
7507         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7508               awk '/ldlm_bl_callback/ {print $2}'`
7509         mv $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2
7510         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7511               awk '/ldlm_cancel/ {print $2}'`
7512         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7513               awk '/ldlm_bl_callback/ {print $2}'`
7514         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
7515         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
7516         lru_resize_enable mdc
7517         lru_resize_enable osc
7518 }
7519 run_test 120f "Early Lock Cancel: rename test"
7520
7521 test_120g() {
7522         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7523         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7524                skip "no early lock cancel on server" && return 0
7525         lru_resize_disable mdc
7526         lru_resize_disable osc
7527         count=10000
7528         echo create $count files
7529         test_mkdir -p $DIR/$tdir
7530         cancel_lru_locks mdc
7531         cancel_lru_locks osc
7532         t0=`date +%s`
7533
7534         can0=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7535               awk '/ldlm_cancel/ {print $2}'`
7536         blk0=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7537               awk '/ldlm_bl_callback/ {print $2}'`
7538         createmany -o $DIR/$tdir/f $count
7539         sync
7540         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7541               awk '/ldlm_cancel/ {print $2}'`
7542         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7543               awk '/ldlm_bl_callback/ {print $2}'`
7544         t1=`date +%s`
7545         echo total: $((can1-can0)) cancels, $((blk1-blk0)) blockings
7546         echo rm $count files
7547         rm -r $DIR/$tdir
7548         sync
7549         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7550               awk '/ldlm_cancel/ {print $2}'`
7551         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7552               awk '/ldlm_bl_callback/ {print $2}'`
7553         t2=`date +%s`
7554         echo total: $count removes in $((t2-t1))
7555         echo total: $((can2-can1)) cancels, $((blk2-blk1)) blockings
7556         sleep 2
7557         # wait for commitment of removal
7558         lru_resize_enable mdc
7559         lru_resize_enable osc
7560 }
7561 run_test 120g "Early Lock Cancel: performance test"
7562
7563 test_121() { #bug #10589
7564         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7565         rm -rf $DIR/$tfile
7566         writes=$(LANG=C dd if=/dev/zero of=$DIR/$tfile count=1 2>&1 | awk -F '+' '/out$/ {print $1}')
7567 #define OBD_FAIL_LDLM_CANCEL_RACE        0x310
7568         lctl set_param fail_loc=0x310
7569         cancel_lru_locks osc > /dev/null
7570         reads=$(LANG=C dd if=$DIR/$tfile of=/dev/null 2>&1 | awk -F '+' '/in$/ {print $1}')
7571         lctl set_param fail_loc=0
7572         [ "$reads" -eq "$writes" ] || error "read" $reads "blocks, must be" $writes
7573 }
7574 run_test 121 "read cancel race ========="
7575
7576 test_123a() { # was test 123, statahead(bug 11401)
7577         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7578         SLOWOK=0
7579         if [ -z "$(grep "processor.*: 1" /proc/cpuinfo)" ]; then
7580             log "testing on UP system. Performance may be not as good as expected."
7581                         SLOWOK=1
7582         fi
7583
7584         rm -rf $DIR/$tdir
7585         test_mkdir -p $DIR/$tdir
7586         NUMFREE=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
7587         [ $NUMFREE -gt 100000 ] && NUMFREE=100000 || NUMFREE=$((NUMFREE-1000))
7588         MULT=10
7589         for ((i=100, j=0; i<=$NUMFREE; j=$i, i=$((i * MULT)) )); do
7590                 createmany -o $DIR/$tdir/$tfile $j $((i - j))
7591
7592                 max=`lctl get_param -n llite.*.statahead_max | head -n 1`
7593                 lctl set_param -n llite.*.statahead_max 0
7594                 lctl get_param llite.*.statahead_max
7595                 cancel_lru_locks mdc
7596                 cancel_lru_locks osc
7597                 stime=`date +%s`
7598                 time ls -l $DIR/$tdir | wc -l
7599                 etime=`date +%s`
7600                 delta=$((etime - stime))
7601                 log "ls $i files without statahead: $delta sec"
7602                 lctl set_param llite.*.statahead_max=$max
7603
7604                 swrong=`lctl get_param -n llite.*.statahead_stats | grep "statahead wrong:" | awk '{print $3}'`
7605                 lctl get_param -n llite.*.statahead_max | grep '[0-9]'
7606                 cancel_lru_locks mdc
7607                 cancel_lru_locks osc
7608                 stime=`date +%s`
7609                 time ls -l $DIR/$tdir | wc -l
7610                 etime=`date +%s`
7611                 delta_sa=$((etime - stime))
7612                 log "ls $i files with statahead: $delta_sa sec"
7613                 lctl get_param -n llite.*.statahead_stats
7614                 ewrong=`lctl get_param -n llite.*.statahead_stats | grep "statahead wrong:" | awk '{print $3}'`
7615
7616                 [ $swrong -lt $ewrong ] && log "statahead was stopped, maybe too many locks held!"
7617                 [ $delta -eq 0 -o $delta_sa -eq 0 ] && continue
7618
7619                 if [ $((delta_sa * 100)) -gt $((delta * 105)) -a $delta_sa -gt $((delta + 2)) ]; then
7620                     max=`lctl get_param -n llite.*.statahead_max | head -n 1`
7621                     lctl set_param -n llite.*.statahead_max 0
7622                     lctl get_param llite.*.statahead_max
7623                     cancel_lru_locks mdc
7624                     cancel_lru_locks osc
7625                     stime=`date +%s`
7626                     time ls -l $DIR/$tdir | wc -l
7627                     etime=`date +%s`
7628                     delta=$((etime - stime))
7629                     log "ls $i files again without statahead: $delta sec"
7630                     lctl set_param llite.*.statahead_max=$max
7631                     if [ $((delta_sa * 100)) -gt $((delta * 105)) -a $delta_sa -gt $((delta + 2)) ]; then
7632                         if [  $SLOWOK -eq 0 ]; then
7633                                 error "ls $i files is slower with statahead!"
7634                         else
7635                                 log "ls $i files is slower with statahead!"
7636                         fi
7637                         break
7638                     fi
7639                 fi
7640
7641                 [ $delta -gt 20 ] && break
7642                 [ $delta -gt 8 ] && MULT=$((50 / delta))
7643                 [ "$SLOW" = "no" -a $delta -gt 5 ] && break
7644         done
7645         log "ls done"
7646
7647         stime=`date +%s`
7648         rm -r $DIR/$tdir
7649         sync
7650         etime=`date +%s`
7651         delta=$((etime - stime))
7652         log "rm -r $DIR/$tdir/: $delta seconds"
7653         log "rm done"
7654         lctl get_param -n llite.*.statahead_stats
7655 }
7656 run_test 123a "verify statahead work"
7657
7658 test_123b () { # statahead(bug 15027)
7659         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7660         test_mkdir -p $DIR/$tdir
7661         createmany -o $DIR/$tdir/$tfile-%d 1000
7662
7663         cancel_lru_locks mdc
7664         cancel_lru_locks osc
7665
7666 #define OBD_FAIL_MDC_GETATTR_ENQUEUE     0x803
7667         lctl set_param fail_loc=0x80000803
7668         ls -lR $DIR/$tdir > /dev/null
7669         log "ls done"
7670         lctl set_param fail_loc=0x0
7671         lctl get_param -n llite.*.statahead_stats
7672         rm -r $DIR/$tdir
7673         sync
7674
7675 }
7676 run_test 123b "not panic with network error in statahead enqueue (bug 15027)"
7677
7678 test_124a() {
7679         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7680         [ -z "`lctl get_param -n mdc.*.connect_flags | grep lru_resize`" ] && \
7681                skip "no lru resize on server" && return 0
7682         local NR=2000
7683         test_mkdir -p $DIR/$tdir || error "failed to create $DIR/$tdir"
7684
7685         log "create $NR files at $DIR/$tdir"
7686         createmany -o $DIR/$tdir/f $NR ||
7687                 error "failed to create $NR files in $DIR/$tdir"
7688
7689         cancel_lru_locks mdc
7690         ls -l $DIR/$tdir > /dev/null
7691
7692         local NSDIR=""
7693         local LRU_SIZE=0
7694         for VALUE in `lctl get_param ldlm.namespaces.*mdc-*.lru_size`; do
7695                 local PARAM=`echo ${VALUE[0]} | cut -d "=" -f1`
7696                 LRU_SIZE=$(lctl get_param -n $PARAM)
7697                 if [ $LRU_SIZE -gt $(default_lru_size) ]; then
7698                         NSDIR=$(echo $PARAM | cut -d "." -f1-3)
7699                                                 log "NSDIR=$NSDIR"
7700                         log "NS=$(basename $NSDIR)"
7701                         break
7702                 fi
7703         done
7704
7705         if [ -z "$NSDIR" -o $LRU_SIZE -lt $(default_lru_size) ]; then
7706                 skip "Not enough cached locks created!"
7707                 return 0
7708         fi
7709         log "LRU=$LRU_SIZE"
7710
7711         local SLEEP=30
7712
7713         # We know that lru resize allows one client to hold $LIMIT locks
7714         # for 10h. After that locks begin to be killed by client.
7715         local MAX_HRS=10
7716         local LIMIT=`lctl get_param -n $NSDIR.pool.limit`
7717                 log "LIMIT=$LIMIT"
7718
7719         # Make LVF so higher that sleeping for $SLEEP is enough to _start_
7720         # killing locks. Some time was spent for creating locks. This means
7721         # that up to the moment of sleep finish we must have killed some of
7722         # them (10-100 locks). This depends on how fast ther were created.
7723         # Many of them were touched in almost the same moment and thus will
7724         # be killed in groups.
7725         local LVF=$(($MAX_HRS * 60 * 60 / $SLEEP * $LIMIT / $LRU_SIZE))
7726
7727         # Use $LRU_SIZE_B here to take into account real number of locks
7728         # created in the case of CMD, LRU_SIZE_B != $NR in most of cases
7729         local LRU_SIZE_B=$LRU_SIZE
7730         log "LVF=$LVF"
7731         local OLD_LVF=`lctl get_param -n $NSDIR.pool.lock_volume_factor`
7732                 log "OLD_LVF=$OLD_LVF"
7733         lctl set_param -n $NSDIR.pool.lock_volume_factor $LVF
7734
7735         # Let's make sure that we really have some margin. Client checks
7736         # cached locks every 10 sec.
7737         SLEEP=$((SLEEP+20))
7738         log "Sleep ${SLEEP} sec"
7739         local SEC=0
7740         while ((SEC<$SLEEP)); do
7741                 echo -n "..."
7742                 sleep 5
7743                 SEC=$((SEC+5))
7744                 LRU_SIZE=`lctl get_param -n $NSDIR/lru_size`
7745                 echo -n "$LRU_SIZE"
7746         done
7747         echo ""
7748         lctl set_param -n $NSDIR.pool.lock_volume_factor $OLD_LVF
7749         local LRU_SIZE_A=`lctl get_param -n $NSDIR.lru_size`
7750
7751         [ $LRU_SIZE_B -gt $LRU_SIZE_A ] || {
7752                 error "No locks dropped in ${SLEEP}s. LRU size: $LRU_SIZE_A"
7753                 unlinkmany $DIR/$tdir/f $NR
7754                 return
7755         }
7756
7757         log "Dropped "$((LRU_SIZE_B-LRU_SIZE_A))" locks in ${SLEEP}s"
7758         log "unlink $NR files at $DIR/$tdir"
7759         unlinkmany $DIR/$tdir/f $NR
7760 }
7761 run_test 124a "lru resize ======================================="
7762
7763 get_max_pool_limit()
7764 {
7765         local limit=`lctl get_param -n ldlm.namespaces.*-MDT0000-mdc-*.pool.limit`
7766         local max=0
7767         for l in $limit; do
7768                 if test $l -gt $max; then
7769                         max=$l
7770                 fi
7771         done
7772         echo $max
7773 }
7774
7775 test_124b() {
7776         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7777         [ -z "`lctl get_param -n mdc.*.connect_flags | grep lru_resize`" ] && \
7778                skip "no lru resize on server" && return 0
7779
7780         LIMIT=`get_max_pool_limit`
7781
7782         NR=$(($(default_lru_size)*20))
7783         if [ $NR -gt $LIMIT ]; then
7784                 log "Limit lock number by $LIMIT locks"
7785                 NR=$LIMIT
7786         fi
7787         lru_resize_disable mdc
7788         test_mkdir -p $DIR/$tdir/disable_lru_resize ||
7789                 error "failed to create $DIR/$tdir/disable_lru_resize"
7790
7791         createmany -o $DIR/$tdir/disable_lru_resize/f $NR
7792         log "doing ls -la $DIR/$tdir/disable_lru_resize 3 times"
7793         cancel_lru_locks mdc
7794         stime=`date +%s`
7795         PID=""
7796         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
7797         PID="$PID $!"
7798         sleep 2
7799         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
7800         PID="$PID $!"
7801         sleep 2
7802         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
7803         PID="$PID $!"
7804         wait $PID
7805         etime=`date +%s`
7806         nolruresize_delta=$((etime-stime))
7807         log "ls -la time: $nolruresize_delta seconds"
7808         log "lru_size = $(lctl get_param -n ldlm.namespaces.*mdc*.lru_size)"
7809         unlinkmany $DIR/$tdir/disable_lru_resize/f $NR
7810
7811         lru_resize_enable mdc
7812         test_mkdir -p $DIR/$tdir/enable_lru_resize ||
7813                 error "failed to create $DIR/$tdir/enable_lru_resize"
7814
7815         createmany -o $DIR/$tdir/enable_lru_resize/f $NR
7816         log "doing ls -la $DIR/$tdir/enable_lru_resize 3 times"
7817         cancel_lru_locks mdc
7818         stime=`date +%s`
7819         PID=""
7820         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
7821         PID="$PID $!"
7822         sleep 2
7823         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
7824         PID="$PID $!"
7825         sleep 2
7826         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
7827         PID="$PID $!"
7828         wait $PID
7829         etime=`date +%s`
7830         lruresize_delta=$((etime-stime))
7831         log "ls -la time: $lruresize_delta seconds"
7832         log "lru_size = $(lctl get_param -n ldlm.namespaces.*mdc*.lru_size)"
7833
7834         if [ $lruresize_delta -gt $nolruresize_delta ]; then
7835                 log "ls -la is $(((lruresize_delta - $nolruresize_delta) * 100 / $nolruresize_delta))% slower with lru resize enabled"
7836         elif [ $nolruresize_delta -gt $lruresize_delta ]; then
7837                 log "ls -la is $(((nolruresize_delta - $lruresize_delta) * 100 / $nolruresize_delta))% faster with lru resize enabled"
7838         else
7839                 log "lru resize performs the same with no lru resize"
7840         fi
7841         unlinkmany $DIR/$tdir/enable_lru_resize/f $NR
7842 }
7843 run_test 124b "lru resize (performance test) ======================="
7844
7845 test_125() { # 13358
7846         [ -z "$(lctl get_param -n llite.*.client_type | grep local)" ] && skip "must run as local client" && return
7847         [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep acl)" ] && skip "must have acl enabled" && return
7848         test_mkdir -p $DIR/d125 || error "mkdir failed"
7849         $SETSTRIPE -S 65536 -c -1 $DIR/d125 || error "setstripe failed"
7850         setfacl -R -m u:bin:rwx $DIR/d125 || error "setfacl $DIR/d125 failed"
7851         ls -ld $DIR/d125 || error "cannot access $DIR/d125"
7852 }
7853 run_test 125 "don't return EPROTO when a dir has a non-default striping and ACLs"
7854
7855 test_126() { # bug 12829/13455
7856         [ -z "$(lctl get_param -n llite.*.client_type | grep local)" ] && skip "must run as local client" && return
7857         [ "$UID" != 0 ] && skip_env "skipping $TESTNAME (must run as root)" && return
7858         $GSS && skip "must run as gss disabled" && return
7859
7860         $RUNAS -u 0 -g 1 touch $DIR/$tfile || error "touch failed"
7861         gid=`ls -n $DIR/$tfile | awk '{print $4}'`
7862         rm -f $DIR/$tfile
7863         [ $gid -eq "1" ] || error "gid is set to" $gid "instead of 1"
7864 }
7865 run_test 126 "check that the fsgid provided by the client is taken into account"
7866
7867 test_127a() { # bug 15521
7868         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7869         $SETSTRIPE -i 0 -c 1 $DIR/$tfile || error "setstripe failed"
7870         $LCTL set_param osc.*.stats=0
7871         FSIZE=$((2048 * 1024))
7872         dd if=/dev/zero of=$DIR/$tfile bs=$FSIZE count=1
7873         cancel_lru_locks osc
7874         dd if=$DIR/$tfile of=/dev/null bs=$FSIZE
7875
7876         $LCTL get_param osc.*0000-osc-*.stats | grep samples > $DIR/${tfile}.tmp
7877         while read NAME COUNT SAMP UNIT MIN MAX SUM SUMSQ; do
7878                 echo "got $COUNT $NAME"
7879                 [ ! $MIN ] && error "Missing min value for $NAME proc entry"
7880                 eval $NAME=$COUNT || error "Wrong proc format"
7881
7882                 case $NAME in
7883                         read_bytes|write_bytes)
7884                         [ $MIN -lt 4096 ] && error "min is too small: $MIN"
7885                         [ $MIN -gt $FSIZE ] && error "min is too big: $MIN"
7886                         [ $MAX -lt 4096 ] && error "max is too small: $MAX"
7887                         [ $MAX -gt $FSIZE ] && error "max is too big: $MAX"
7888                         [ $SUM -ne $FSIZE ] && error "sum is wrong: $SUM"
7889                         [ $SUMSQ -lt $(((FSIZE /4096) * (4096 * 4096))) ] &&
7890                                 error "sumsquare is too small: $SUMSQ"
7891                         [ $SUMSQ -gt $((FSIZE * FSIZE)) ] &&
7892                                 error "sumsquare is too big: $SUMSQ"
7893                         ;;
7894                         *) ;;
7895                 esac
7896         done < $DIR/${tfile}.tmp
7897
7898         #check that we actually got some stats
7899         [ "$read_bytes" ] || error "Missing read_bytes stats"
7900         [ "$write_bytes" ] || error "Missing write_bytes stats"
7901         [ "$read_bytes" != 0 ] || error "no read done"
7902         [ "$write_bytes" != 0 ] || error "no write done"
7903 }
7904 run_test 127a "verify the client stats are sane"
7905
7906 test_127b() { # bug LU-333
7907         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7908         $LCTL set_param llite.*.stats=0
7909         FSIZE=65536 # sized fixed to match PAGE_SIZE for most clients
7910         # perform 2 reads and writes so MAX is different from SUM.
7911         dd if=/dev/zero of=$DIR/$tfile bs=$FSIZE count=1
7912         dd if=/dev/zero of=$DIR/$tfile bs=$FSIZE count=1
7913         cancel_lru_locks osc
7914         dd if=$DIR/$tfile of=/dev/null bs=$FSIZE count=1
7915         dd if=$DIR/$tfile of=/dev/null bs=$FSIZE count=1
7916
7917         $LCTL get_param llite.*.stats | grep samples > $TMP/${tfile}.tmp
7918         while read NAME COUNT SAMP UNIT MIN MAX SUM SUMSQ; do
7919                 echo "got $COUNT $NAME"
7920                 eval $NAME=$COUNT || error "Wrong proc format"
7921
7922         case $NAME in
7923                 read_bytes)
7924                         [ $COUNT -ne 2 ] && error "count is not 2: $COUNT"
7925                         [ $MIN -ne $FSIZE ] && error "min is not $FSIZE: $MIN"
7926                         [ $MAX -ne $FSIZE ] && error "max is incorrect: $MAX"
7927                         [ $SUM -ne $((FSIZE * 2)) ] && error "sum is wrong: $SUM"
7928                         ;;
7929                 write_bytes)
7930                         [ $COUNT -ne 2 ] && error "count is not 2: $COUNT"
7931                         [ $MIN -ne $FSIZE ] && error "min is not $FSIZE: $MIN"
7932                         [ $MAX -ne $FSIZE ] && error "max is incorrect: $MAX"
7933                         [ $SUM -ne $((FSIZE * 2)) ] && error "sum is wrong: $SUM"
7934                         ;;
7935                         *) ;;
7936                 esac
7937         done < $TMP/${tfile}.tmp
7938
7939         #check that we actually got some stats
7940         [ "$read_bytes" ] || error "Missing read_bytes stats"
7941         [ "$write_bytes" ] || error "Missing write_bytes stats"
7942         [ "$read_bytes" != 0 ] || error "no read done"
7943         [ "$write_bytes" != 0 ] || error "no write done"
7944 }
7945 run_test 127b "verify the llite client stats are sane"
7946
7947 test_128() { # bug 15212
7948         touch $DIR/$tfile
7949         $LFS 2>&1 <<-EOF | tee $TMP/$tfile.log
7950                 find $DIR/$tfile
7951                 find $DIR/$tfile
7952         EOF
7953
7954         result=$(grep error $TMP/$tfile.log)
7955         rm -f $DIR/$tfile
7956         [ -z "$result" ] || error "consecutive find's under interactive lfs failed"
7957 }
7958 run_test 128 "interactive lfs for 2 consecutive find's"
7959
7960 set_dir_limits () {
7961         local mntdev
7962         local canondev
7963         local node
7964
7965         local LDPROC=/proc/fs/ldiskfs
7966         local facets=$(get_facets MDS)
7967
7968         for facet in ${facets//,/ }; do
7969                 canondev=$(ldiskfs_canon \
7970                            *.$(convert_facet2label $facet).mntdev $facet)
7971                 do_facet $facet "test -e $LDPROC/$canondev/max_dir_size" ||
7972                                                 LDPROC=/sys/fs/ldiskfs
7973                 do_facet $facet "echo $1 >$LDPROC/$canondev/max_dir_size"
7974         done
7975 }
7976
7977 test_129() {
7978         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7979         if [ "$(facet_fstype $SINGLEMDS)" != ldiskfs ]; then
7980                 skip "Only applicable to ldiskfs-based MDTs"
7981                 return
7982         fi
7983         remote_mds_nodsh && skip "remote MDS with nodsh" && return
7984
7985         ENOSPC=28
7986         EFBIG=27
7987
7988         rm -rf $DIR/$tdir
7989         test_mkdir -p $DIR/$tdir
7990
7991         # block size of mds1
7992         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
7993         local MDSBLOCKSIZE=$($LCTL get_param -n mdc.*MDT0000*.blocksize)
7994         local MAX=$((MDSBLOCKSIZE * 3))
7995         set_dir_limits $MAX
7996         local I=$(stat -c%s "$DIR/$tdir")
7997         local J=0
7998         while [ ! $I -gt $MAX ]; do
7999                 $MULTIOP $DIR/$tdir/$J Oc
8000                 rc=$?
8001                 #check two errors ENOSPC for new version of ext4 max_dir_size patch
8002                 #mainline kernel commit df981d03eeff7971ac7e6ff37000bfa702327ef1
8003                 #and EFBIG for previous versions
8004                 if [ $rc -eq $EFBIG -o $rc -eq $ENOSPC ]; then
8005                         set_dir_limits 0
8006                         echo "return code $rc received as expected"
8007                         multiop $DIR/$tdir/$J Oc ||
8008                                 error_exit "multiop failed w/o dir size limit"
8009
8010                         I=$(stat -c%s "$DIR/$tdir")
8011
8012                         if [ $(lustre_version_code $SINGLEMDS) -lt \
8013                                         $(version_code 2.4.51) ]
8014                         then
8015                                 [ $I -eq $MAX ] && return 0
8016                         else
8017                                 [ $I -gt $MAX ] && return 0
8018                         fi
8019                         error_exit "current dir size $I, previous limit $MAX"
8020                 elif [ $rc -ne 0 ]; then
8021                         set_dir_limits 0
8022                         error_exit "return code $rc received instead of expected " \
8023                                    "$EFBIG or $ENOSPC, files in dir $I"
8024                 fi
8025                 J=$((J+1))
8026                 I=$(stat -c%s "$DIR/$tdir")
8027         done
8028
8029         set_dir_limits 0
8030         error "exceeded dir size limit $MAX x $MDSCOUNT $MAX : $I bytes"
8031 }
8032 run_test 129 "test directory size limit ========================"
8033
8034 OLDIFS="$IFS"
8035 cleanup_130() {
8036         trap 0
8037         IFS="$OLDIFS"
8038 }
8039
8040 test_130a() {
8041         local filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
8042         [ -n "$filefrag_op" ] && skip_env "filefrag does not support FIEMAP" &&
8043                 return
8044
8045         trap cleanup_130 EXIT RETURN
8046
8047         local fm_file=$DIR/$tfile
8048         $SETSTRIPE -S 65536 -c 1 $fm_file || error "setstripe on $fm_file"
8049         dd if=/dev/zero of=$fm_file bs=65536 count=1 ||
8050                 error "dd failed for $fm_file"
8051
8052         # LU-1795: test filefrag/FIEMAP once, even if unsupported
8053         filefrag -ves $fm_file
8054         RC=$?
8055         [ "$(facet_fstype ost$(($($GETSTRIPE -i $fm_file) + 1)))" = "zfs" ] &&
8056                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS" && return
8057         [ $RC != 0 ] && error "filefrag $fm_file failed"
8058
8059         filefrag_op=$(filefrag -ve $fm_file | grep -A 100 "ext:" |
8060                       grep -v "ext:" | grep -v "found")
8061         lun=$($GETSTRIPE -i $fm_file)
8062
8063         start_blk=`echo $filefrag_op | cut -d: -f2 | cut -d. -f1`
8064         IFS=$'\n'
8065         tot_len=0
8066         for line in $filefrag_op
8067         do
8068                 frag_lun=`echo $line | cut -d: -f5`
8069                 ext_len=`echo $line | cut -d: -f4`
8070                 if (( $frag_lun != $lun )); then
8071                         cleanup_130
8072                         error "FIEMAP on 1-stripe file($fm_file) failed"
8073                         return
8074                 fi
8075                 (( tot_len += ext_len ))
8076         done
8077
8078         if (( lun != frag_lun || start_blk != 0 || tot_len != 64 )); then
8079                 cleanup_130
8080                 error "FIEMAP on 1-stripe file($fm_file) failed;"
8081                 return
8082         fi
8083
8084         cleanup_130
8085
8086         echo "FIEMAP on single striped file succeeded"
8087 }
8088 run_test 130a "FIEMAP (1-stripe file)"
8089
8090 test_130b() {
8091         [ "$OSTCOUNT" -lt "2" ] &&
8092                 skip_env "skipping FIEMAP on 2-stripe file test" && return
8093
8094         [ "$OSTCOUNT" -ge "10" ] &&
8095                 skip_env "skipping FIEMAP with >= 10 OSTs" && return
8096
8097         local filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
8098         [ -n "$filefrag_op" ] && skip_env "filefrag does not support FIEMAP" &&
8099                 return
8100
8101         trap cleanup_130 EXIT RETURN
8102
8103         local fm_file=$DIR/$tfile
8104         $SETSTRIPE -S 65536 -c 2 $fm_file || error "setstripe on $fm_file"
8105         [ "$(facet_fstype ost$(($($GETSTRIPE -i $fm_file) + 1)))" = "zfs" ] &&
8106                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS" && return
8107
8108         dd if=/dev/zero of=$fm_file bs=1M count=2 ||
8109                 error "dd failed on $fm_file"
8110
8111         filefrag -ves $fm_file || error "filefrag $fm_file failed"
8112         filefrag_op=$(filefrag -ve $fm_file | grep -A 100 "ext:" |
8113                       grep -v "ext:" | grep -v "found")
8114
8115         last_lun=$(echo $filefrag_op | cut -d: -f5)
8116
8117         IFS=$'\n'
8118         tot_len=0
8119         num_luns=1
8120         for line in $filefrag_op
8121         do
8122                 frag_lun=`echo $line | cut -d: -f5`
8123                 ext_len=`echo $line | cut -d: -f4`
8124                 if (( $frag_lun != $last_lun )); then
8125                         if (( tot_len != 1024 )); then
8126                                 cleanup_130
8127                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of 256"
8128                                 return
8129                         else
8130                                 (( num_luns += 1 ))
8131                                 tot_len=0
8132                         fi
8133                 fi
8134                 (( tot_len += ext_len ))
8135                 last_lun=$frag_lun
8136         done
8137         if (( num_luns != 2 || tot_len != 1024 )); then
8138                 cleanup_130
8139                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
8140                 return
8141         fi
8142
8143         cleanup_130
8144
8145         echo "FIEMAP on 2-stripe file succeeded"
8146 }
8147 run_test 130b "FIEMAP (2-stripe file)"
8148
8149 test_130c() {
8150         [ "$OSTCOUNT" -lt "2" ] &&
8151                 skip_env "skipping FIEMAP on 2-stripe file" && return
8152
8153         [ "$OSTCOUNT" -ge "10" ] &&
8154                 skip_env "skipping FIEMAP with >= 10 OSTs" && return
8155
8156         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
8157         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" &&
8158                 return
8159
8160         trap cleanup_130 EXIT RETURN
8161
8162         local fm_file=$DIR/$tfile
8163         $SETSTRIPE -S 65536 -c 2 $fm_file || error "setstripe on $fm_file"
8164         [ "$(facet_fstype ost$(($($GETSTRIPE -i $fm_file) + 1)))" = "zfs" ] &&
8165                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS" && return
8166
8167         dd if=/dev/zero of=$fm_file seek=1 bs=1M count=1 || error "dd failed on $fm_file"
8168
8169         filefrag -ves $fm_file || error "filefrag $fm_file failed"
8170         filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" | grep -v "ext:" | grep -v "found"`
8171
8172         last_lun=`echo $filefrag_op | cut -d: -f5`
8173
8174         IFS=$'\n'
8175         tot_len=0
8176         num_luns=1
8177         for line in $filefrag_op
8178         do
8179                 frag_lun=`echo $line | cut -d: -f5`
8180                 ext_len=`echo $line | cut -d: -f4`
8181                 if (( $frag_lun != $last_lun )); then
8182                         logical=`echo $line | cut -d: -f2 | cut -d. -f1`
8183                         if (( logical != 512 )); then
8184                                 cleanup_130
8185                                 error "FIEMAP on $fm_file failed; returned logical start for lun $logical instead of 512"
8186                                 return
8187                         fi
8188                         if (( tot_len != 512 )); then
8189                                 cleanup_130
8190                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of 1024"
8191                                 return
8192                         else
8193                                 (( num_luns += 1 ))
8194                                 tot_len=0
8195                         fi
8196                 fi
8197                 (( tot_len += ext_len ))
8198                 last_lun=$frag_lun
8199         done
8200         if (( num_luns != 2 || tot_len != 512 )); then
8201                 cleanup_130
8202                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
8203                 return
8204         fi
8205
8206         cleanup_130
8207
8208         echo "FIEMAP on 2-stripe file with hole succeeded"
8209 }
8210 run_test 130c "FIEMAP (2-stripe file with hole)"
8211
8212 test_130d() {
8213         [ "$OSTCOUNT" -lt "3" ] && skip_env "skipping FIEMAP on N-stripe file test" && return
8214
8215         [ "$OSTCOUNT" -ge "10" ] &&
8216                 skip_env "skipping FIEMAP with >= 10 OSTs" && return
8217
8218         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
8219         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
8220
8221         trap cleanup_130 EXIT RETURN
8222
8223         local fm_file=$DIR/$tfile
8224         $SETSTRIPE -S 65536 -c $OSTCOUNT $fm_file||error "setstripe on $fm_file"
8225         [ "$(facet_fstype ost$(($($GETSTRIPE -i $fm_file) + 1)))" = "zfs" ] &&
8226                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS" && return
8227
8228         local actual_stripecnt=$($GETSTRIPE -c $fm_file)
8229         dd if=/dev/zero of=$fm_file bs=1M count=$actual_stripecnt ||
8230                 error "dd failed on $fm_file"
8231
8232         filefrag -ves $fm_file || error "filefrag $fm_file failed"
8233         filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" |
8234                 grep -v "ext:" | grep -v "found"`
8235
8236         last_lun=`echo $filefrag_op | cut -d: -f5`
8237
8238         IFS=$'\n'
8239         tot_len=0
8240         num_luns=1
8241         for line in $filefrag_op
8242         do
8243                 frag_lun=`echo $line | cut -d: -f5`
8244                 ext_len=`echo $line | cut -d: -f4`
8245                 if (( $frag_lun != $last_lun )); then
8246                         if (( tot_len != 1024 )); then
8247                                 cleanup_130
8248                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of 1024"
8249                                 return
8250                         else
8251                                 (( num_luns += 1 ))
8252                                 tot_len=0
8253                         fi
8254                 fi
8255                 (( tot_len += ext_len ))
8256                 last_lun=$frag_lun
8257         done
8258         if (( num_luns != actual_stripecnt || tot_len != 1024 )); then
8259                 cleanup_130
8260                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
8261                 return
8262         fi
8263
8264         cleanup_130
8265
8266         echo "FIEMAP on N-stripe file succeeded"
8267 }
8268 run_test 130d "FIEMAP (N-stripe file)"
8269
8270 test_130e() {
8271         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping continuation FIEMAP test" && return
8272
8273         [ "$OSTCOUNT" -ge "10" ] &&
8274                 skip_env "skipping FIEMAP with >= 10 OSTs" && return
8275
8276         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
8277         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
8278
8279         trap cleanup_130 EXIT RETURN
8280
8281         local fm_file=$DIR/$tfile
8282         $SETSTRIPE -S 131072 -c 2 $fm_file || error "setstripe on $fm_file"
8283         [ "$(facet_fstype ost$(($($GETSTRIPE -i $fm_file) + 1)))" = "zfs" ] &&
8284                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS" && return
8285
8286         NUM_BLKS=512
8287         EXPECTED_LEN=$(( (NUM_BLKS / 2) * 64 ))
8288         for ((i = 0; i < $NUM_BLKS; i++))
8289         do
8290                 dd if=/dev/zero of=$fm_file count=1 bs=64k seek=$((2*$i)) conv=notrunc > /dev/null 2>&1
8291         done
8292
8293         filefrag -ves $fm_file || error "filefrag $fm_file failed"
8294         filefrag_op=`filefrag -ve $fm_file | grep -A 12000 "ext:" | grep -v "ext:" | grep -v "found"`
8295
8296         last_lun=`echo $filefrag_op | cut -d: -f5`
8297
8298         IFS=$'\n'
8299         tot_len=0
8300         num_luns=1
8301         for line in $filefrag_op
8302         do
8303                 frag_lun=`echo $line | cut -d: -f5`
8304                 ext_len=`echo $line | cut -d: -f4`
8305                 if (( $frag_lun != $last_lun )); then
8306                         if (( tot_len != $EXPECTED_LEN )); then
8307                                 cleanup_130
8308                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of $EXPECTED_LEN"
8309                                 return
8310                         else
8311                                 (( num_luns += 1 ))
8312                                 tot_len=0
8313                         fi
8314                 fi
8315                 (( tot_len += ext_len ))
8316                 last_lun=$frag_lun
8317         done
8318         if (( num_luns != 2 || tot_len != $EXPECTED_LEN )); then
8319                 cleanup_130
8320                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
8321                 return
8322         fi
8323
8324         cleanup_130
8325
8326         echo "FIEMAP with continuation calls succeeded"
8327 }
8328 run_test 130e "FIEMAP (test continuation FIEMAP calls)"
8329
8330 # Test for writev/readv
8331 test_131a() {
8332         rwv -f $DIR/$tfile -w -n 3 524288 1048576 1572864 || \
8333         error "writev test failed"
8334         rwv -f $DIR/$tfile -r -v -n 2 1572864 1048576 || \
8335         error "readv failed"
8336         rm -f $DIR/$tfile
8337 }
8338 run_test 131a "test iov's crossing stripe boundary for writev/readv"
8339
8340 test_131b() {
8341         rwv -f $DIR/$tfile -w -a -n 3 524288 1048576 1572864 || \
8342         error "append writev test failed"
8343         rwv -f $DIR/$tfile -w -a -n 2 1572864 1048576 || \
8344         error "append writev test failed"
8345         rm -f $DIR/$tfile
8346 }
8347 run_test 131b "test append writev"
8348
8349 test_131c() {
8350         rwv -f $DIR/$tfile -w -d -n 1 1048576 || return 0
8351         error "NOT PASS"
8352 }
8353 run_test 131c "test read/write on file w/o objects"
8354
8355 test_131d() {
8356         rwv -f $DIR/$tfile -w -n 1 1572864
8357         NOB=`rwv -f $DIR/$tfile -r -n 3 524288 524288 1048576 | awk '/error/ {print $6}'`
8358         if [ "$NOB" != 1572864 ]; then
8359                 error "Short read filed: read $NOB bytes instead of 1572864"
8360         fi
8361         rm -f $DIR/$tfile
8362 }
8363 run_test 131d "test short read"
8364
8365 test_131e() {
8366         rwv -f $DIR/$tfile -w -s 1048576 -n 1 1048576
8367         rwv -f $DIR/$tfile -r -z -s 0 -n 1 524288 || \
8368         error "read hitting hole failed"
8369         rm -f $DIR/$tfile
8370 }
8371 run_test 131e "test read hitting hole"
8372
8373 get_ost_param() {
8374         local token=$1
8375         local gl_sum=0
8376         for node in $(osts_nodes); do
8377                 gl=$(do_node $node "$LCTL get_param -n ost.OSS.ost.stats" | awk '/'$token'/ {print $2}' | head -n 1)
8378                 [ x$gl = x"" ] && gl=0
8379                 gl_sum=$((gl_sum + gl))
8380         done
8381         echo $gl_sum
8382 }
8383
8384 som_mode_switch() {
8385         local som=$1
8386         local gl1=$2
8387         local gl2=$3
8388
8389         if [ x$som = x"enabled" ]; then
8390                 [ $((gl2 - gl1)) -gt 0 ] && error "no glimpse RPC is expected"
8391                 MOUNTOPT=`echo $MOUNTOPT | sed 's/som_preview//g'`
8392                 do_facet mgs "$LCTL conf_param $FSNAME.mdt.som=disabled"
8393         else
8394                 [ $((gl2 - gl1)) -gt 0 ] || error "some glimpse RPC is expected"
8395                 MOUNTOPT="$MOUNTOPT,som_preview"
8396                 do_facet mgs "$LCTL conf_param $FSNAME.mdt.som=enabled"
8397         fi
8398
8399         # do remount to make new mount-conf parameters actual
8400         echo remounting...
8401         sync
8402         stopall
8403         setupall
8404 }
8405
8406 test_132() { #1028, SOM
8407         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8408         remote_mds_nodsh && skip "remote MDS with nodsh" && return
8409         local num=$(get_mds_dir $DIR)
8410         local mymds=mds${num}
8411         local MOUNTOPT_SAVE=$MOUNTOPT
8412
8413         dd if=/dev/zero of=$DIR/$tfile count=1 2>/dev/null
8414         cancel_lru_locks osc
8415
8416         som1=$(do_facet $mymds "$LCTL get_param mdt.*.som" |  awk -F= ' {print $2}' | head -n 1)
8417
8418         gl1=$(get_ost_param "ldlm_glimpse_enqueue")
8419         stat $DIR/$tfile >/dev/null
8420         gl2=$(get_ost_param "ldlm_glimpse_enqueue")
8421         echo "====> SOM is "$som1", "$((gl2 - gl1))" glimpse RPC occured"
8422         rm $DIR/$tfile
8423         som_mode_switch $som1 $gl1 $gl2
8424
8425         dd if=/dev/zero of=$DIR/$tfile count=1 2>/dev/null
8426         cancel_lru_locks osc
8427
8428         som2=$(do_facet $mymds "$LCTL get_param mdt.*.som" |  awk -F= ' {print $2}' | head -n 1)
8429         if [ $som1 == $som2 ]; then
8430             error "som is still "$som2
8431             if [ x$som2 = x"enabled" ]; then
8432                 som2="disabled"
8433             else
8434                 som2="enabled"
8435             fi
8436         fi
8437
8438         gl1=$(get_ost_param "ldlm_glimpse_enqueue")
8439         stat $DIR/$tfile >/dev/null
8440         gl2=$(get_ost_param "ldlm_glimpse_enqueue")
8441         echo "====> SOM is "$som2", "$((gl2 - gl1))" glimpse RPC occured"
8442         som_mode_switch $som2 $gl1 $gl2
8443         MOUNTOPT=$MOUNTOPT_SAVE
8444 }
8445 run_test 132 "som avoids glimpse rpc"
8446
8447 check_stats() {
8448         local res
8449         local count
8450         case $1 in
8451         $SINGLEMDS) res=`do_facet $SINGLEMDS $LCTL get_param mdt.$FSNAME-MDT0000.md_stats | grep "$2"`
8452                  ;;
8453         ost) res=`do_facet ost1 $LCTL get_param obdfilter.$FSNAME-OST0000.stats | grep "$2"`
8454                  ;;
8455         *) error "Wrong argument $1" ;;
8456         esac
8457         echo $res
8458         count=`echo $res | awk '{print $2}'`
8459         [ -z "$res" ] && error "The counter for $2 on $1 was not incremented"
8460         # if the argument $3 is zero, it means any stat increment is ok.
8461         if [ $3 -gt 0 ] ; then
8462                 [ $count -ne $3 ] && error "The $2 counter on $1 is wrong - expected $3"
8463         fi
8464 }
8465
8466 test_133a() {
8467         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8468         remote_ost_nodsh && skip "remote OST with nodsh" && return
8469         remote_mds_nodsh && skip "remote MDS with nodsh" && return
8470
8471         do_facet $SINGLEMDS $LCTL list_param mdt.*.rename_stats ||
8472                 { skip "MDS doesn't support rename stats"; return; }
8473         local testdir=$DIR/${tdir}/stats_testdir
8474         mkdir -p $DIR/${tdir}
8475
8476         # clear stats.
8477         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
8478         do_facet ost1 $LCTL set_param obdfilter.*.stats=clear
8479
8480         # verify mdt stats first.
8481         mkdir ${testdir} || error "mkdir failed"
8482         check_stats $SINGLEMDS "mkdir" 1
8483         touch ${testdir}/${tfile} || "touch failed"
8484         check_stats $SINGLEMDS "open" 1
8485         check_stats $SINGLEMDS "close" 1
8486         mknod ${testdir}/${tfile}-pipe p || "mknod failed"
8487         check_stats $SINGLEMDS "mknod" 1
8488         rm -f ${testdir}/${tfile}-pipe || "pipe remove failed"
8489         check_stats $SINGLEMDS "unlink" 1
8490         rm -f ${testdir}/${tfile} || error "file remove failed"
8491         check_stats $SINGLEMDS "unlink" 2
8492
8493         # remove working dir and check mdt stats again.
8494         rmdir ${testdir} || error "rmdir failed"
8495         check_stats $SINGLEMDS "rmdir" 1
8496
8497         local testdir1=$DIR/${tdir}/stats_testdir1
8498         mkdir -p ${testdir}
8499         mkdir -p ${testdir1}
8500         touch ${testdir1}/test1
8501         mv ${testdir1}/test1 ${testdir} || error "file crossdir rename"
8502         check_stats $SINGLEMDS "crossdir_rename" 1
8503
8504         mv ${testdir}/test1 ${testdir}/test0 || error "file samedir rename"
8505         check_stats $SINGLEMDS "samedir_rename" 1
8506
8507         rm -rf $DIR/${tdir}
8508 }
8509 run_test 133a "Verifying MDT stats ========================================"
8510
8511 test_133b() {
8512         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8513         remote_ost_nodsh && skip "remote OST with nodsh" && return
8514         remote_mds_nodsh && skip "remote MDS with nodsh" && return
8515         local testdir=$DIR/${tdir}/stats_testdir
8516         mkdir -p ${testdir} || error "mkdir failed"
8517         touch ${testdir}/${tfile} || "touch failed"
8518         cancel_lru_locks mdc
8519
8520         # clear stats.
8521         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
8522         do_facet ost1 $LCTL set_param obdfilter.*.stats=clear
8523
8524         # extra mdt stats verification.
8525         chmod 444 ${testdir}/${tfile} || error "chmod failed"
8526         check_stats $SINGLEMDS "setattr" 1
8527         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
8528         if [ $(lustre_version_code $SINGLEMDS) -ne $(version_code 2.2.0) ]
8529         then            # LU-1740
8530                 ls -l ${testdir}/${tfile} > /dev/null|| error "ls failed"
8531                 check_stats $SINGLEMDS "getattr" 1
8532         fi
8533         $LFS df || error "lfs failed"
8534         check_stats $SINGLEMDS "statfs" 1
8535
8536         rm -rf $DIR/${tdir}
8537 }
8538 run_test 133b "Verifying extra MDT stats =================================="
8539
8540 test_133c() {
8541         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8542         remote_ost_nodsh && skip "remote OST with nodsh" && return
8543         remote_mds_nodsh && skip "remote MDS with nodsh" && return
8544         local testdir=$DIR/${tdir}/stats_testdir
8545         test_mkdir -p ${testdir} || error "mkdir failed"
8546
8547         # verify obdfilter stats.
8548         $SETSTRIPE -c 1 -i 0 ${testdir}/${tfile}
8549         sync
8550         cancel_lru_locks osc
8551         wait_delete_completed
8552
8553         # clear stats.
8554         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
8555         do_facet ost1 $LCTL set_param obdfilter.*.stats=clear
8556
8557         dd if=/dev/zero of=${testdir}/${tfile} conv=notrunc bs=512k count=1 || error "dd failed"
8558         sync
8559         cancel_lru_locks osc
8560         check_stats ost "write" 1
8561
8562         dd if=${testdir}/${tfile} of=/dev/null bs=1k count=1 || error "dd failed"
8563         check_stats ost "read" 1
8564
8565         > ${testdir}/${tfile} || error "truncate failed"
8566         check_stats ost "punch" 1
8567
8568         rm -f ${testdir}/${tfile} || error "file remove failed"
8569         wait_delete_completed
8570         check_stats ost "destroy" 1
8571
8572         rm -rf $DIR/${tdir}
8573 }
8574 run_test 133c "Verifying OST stats ========================================"
8575
8576 order_2() {
8577     local value=$1
8578     local orig=$value
8579     local order=1
8580
8581     while [ $value -ge 2 ]; do
8582         order=$((order*2))
8583         value=$((value/2))
8584     done
8585
8586     if [ $orig -gt $order ]; then
8587         order=$((order*2))
8588     fi
8589     echo $order
8590 }
8591
8592 size_in_KMGT() {
8593     local value=$1
8594     local size=('K' 'M' 'G' 'T');
8595     local i=0
8596     local size_string=$value
8597
8598     while [ $value -ge 1024 ]; do
8599         if [ $i -gt 3 ]; then
8600             #T is the biggest unit we get here, if that is bigger,
8601             #just return XXXT
8602             size_string=${value}T
8603             break
8604         fi
8605         value=$((value >> 10))
8606         if [ $value -lt 1024 ]; then
8607             size_string=${value}${size[$i]}
8608             break
8609         fi
8610         i=$((i + 1))
8611     done
8612
8613     echo $size_string
8614 }
8615
8616 get_rename_size() {
8617     local size=$1
8618     local context=${2:-.}
8619     local sample=$(do_facet $SINGLEMDS $LCTL get_param mdt.*.rename_stats |
8620                 grep -A1 $context |
8621                 awk '/ '${size}'/ {print $4}' | sed -e "s/,//g")
8622     echo $sample
8623 }
8624
8625 test_133d() {
8626         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8627         remote_ost_nodsh && skip "remote OST with nodsh" && return
8628         remote_mds_nodsh && skip "remote MDS with nodsh" && return
8629         do_facet $SINGLEMDS $LCTL list_param mdt.*.rename_stats ||
8630         { skip "MDS doesn't support rename stats"; return; }
8631
8632         local testdir1=$DIR/${tdir}/stats_testdir1
8633         local testdir2=$DIR/${tdir}/stats_testdir2
8634
8635         do_facet $SINGLEMDS $LCTL set_param mdt.*.rename_stats=clear
8636
8637         mkdir -p ${testdir1} || error "mkdir failed"
8638         mkdir -p ${testdir2} || error "mkdir failed"
8639
8640         createmany -o $testdir1/test 512 || error "createmany failed"
8641
8642         # check samedir rename size
8643         mv ${testdir1}/test0 ${testdir1}/test_0
8644
8645         local testdir1_size=$(ls -l $DIR/${tdir} |
8646                 awk '/stats_testdir1/ {print $5}')
8647         local testdir2_size=$(ls -l $DIR/${tdir} |
8648                 awk '/stats_testdir2/ {print $5}')
8649
8650         testdir1_size=$(order_2 $testdir1_size)
8651         testdir2_size=$(order_2 $testdir2_size)
8652
8653         testdir1_size=$(size_in_KMGT $testdir1_size)
8654         testdir2_size=$(size_in_KMGT $testdir2_size)
8655
8656         echo "source rename dir size: ${testdir1_size}"
8657         echo "target rename dir size: ${testdir2_size}"
8658
8659         local cmd="do_facet $SINGLEMDS $LCTL get_param mdt.*.rename_stats"
8660         eval $cmd || error "$cmd failed"
8661         local samedir=$($cmd | grep 'same_dir')
8662         local same_sample=$(get_rename_size $testdir1_size)
8663         [ -z "$samedir" ] && error "samedir_rename_size count error"
8664         [ "$same_sample" -eq 1 ] || error "samedir_rename_size error $same_sample"
8665         echo "Check same dir rename stats success"
8666
8667         do_facet $SINGLEMDS $LCTL set_param mdt.*.rename_stats=clear
8668
8669         # check crossdir rename size
8670         mv ${testdir1}/test_0 ${testdir2}/test_0
8671
8672         testdir1_size=$(ls -l $DIR/${tdir} |
8673                 awk '/stats_testdir1/ {print $5}')
8674         testdir2_size=$(ls -l $DIR/${tdir} |
8675                 awk '/stats_testdir2/ {print $5}')
8676
8677         testdir1_size=$(order_2 $testdir1_size)
8678         testdir2_size=$(order_2 $testdir2_size)
8679
8680         testdir1_size=$(size_in_KMGT $testdir1_size)
8681         testdir2_size=$(size_in_KMGT $testdir2_size)
8682
8683         echo "source rename dir size: ${testdir1_size}"
8684         echo "target rename dir size: ${testdir2_size}"
8685
8686         eval $cmd || error "$cmd failed"
8687         local crossdir=$($cmd | grep 'crossdir')
8688         local src_sample=$(get_rename_size $testdir1_size crossdir_src)
8689         local tgt_sample=$(get_rename_size $testdir2_size crossdir_tgt)
8690         [ -z "$crossdir" ] && error "crossdir_rename_size count error"
8691         [ "$src_sample" -eq 1 ] || error "crossdir_rename_size error $src_sample"
8692         [ "$tgt_sample" -eq 1 ] || error "crossdir_rename_size error $tgt_sample"
8693         echo "Check cross dir rename stats success"
8694         rm -rf $DIR/${tdir}
8695 }
8696 run_test 133d "Verifying rename_stats ========================================"
8697
8698 test_133e() {
8699         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8700         local testdir=$DIR/${tdir}/stats_testdir
8701         local ctr f0 f1 bs=32768 count=42 sum
8702
8703         remote_ost_nodsh && skip "remote OST with nodsh" && return
8704         mkdir -p ${testdir} || error "mkdir failed"
8705
8706         $SETSTRIPE -c 1 -i 0 ${testdir}/${tfile}
8707
8708         for ctr in {write,read}_bytes; do
8709                 sync
8710                 cancel_lru_locks osc
8711
8712                 do_facet ost1 $LCTL set_param -n \
8713                         "obdfilter.*.exports.clear=clear"
8714
8715                 if [ $ctr = write_bytes ]; then
8716                         f0=/dev/zero
8717                         f1=${testdir}/${tfile}
8718                 else
8719                         f0=${testdir}/${tfile}
8720                         f1=/dev/null
8721                 fi
8722
8723                 dd if=$f0 of=$f1 conv=notrunc bs=$bs count=$count || \
8724                         error "dd failed"
8725                 sync
8726                 cancel_lru_locks osc
8727
8728                 sum=$(do_facet ost1 $LCTL get_param \
8729                                 "obdfilter.*.exports.*.stats" | \
8730                           awk -v ctr=$ctr '\
8731                                 BEGIN { sum = 0 }
8732                                 $1 == ctr { sum += $7 }
8733                                 END { print sum }')
8734
8735                 if ((sum != bs * count)); then
8736                         error "Bad $ctr sum, expected $((bs * count)), got $sum"
8737                 fi
8738         done
8739
8740         rm -rf $DIR/${tdir}
8741 }
8742 run_test 133e "Verifying OST {read,write}_bytes nid stats ================="
8743
8744 test_133f() {
8745         local proc_dirs="/proc/fs/lustre/ /proc/sys/lnet/ /proc/sys/lustre/"
8746         local facet
8747
8748         # First without trusting modes.
8749         find $proc_dirs \
8750                 -exec cat '{}' \; &> /dev/null
8751
8752         # Second verifying readability.
8753         find $proc_dirs \
8754                 -type f \
8755                 -readable \
8756                 -exec cat '{}' \; > /dev/null ||
8757                         error "proc file read failed"
8758
8759         for facet in $SINGLEMDS ost1; do
8760                 do_facet $facet find $proc_dirs \
8761                         -not -name req_history \
8762                         -exec cat '{}' \\\; &> /dev/null
8763
8764             do_facet $facet     find $proc_dirs \
8765                         -not -name req_history \
8766                         -type f \
8767                         -readable \
8768                         -exec cat '{}' \\\; > /dev/null ||
8769                                 error "proc file read failed"
8770         done
8771 }
8772 run_test 133f "Check for LBUGs/Oopses/unreadable files in /proc"
8773
8774 test_140() { #bug-17379
8775         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8776         test_mkdir -p $DIR/$tdir || error "Creating dir $DIR/$tdir"
8777         cd $DIR/$tdir || error "Changing to $DIR/$tdir"
8778         cp /usr/bin/stat . || error "Copying stat to $DIR/$tdir"
8779
8780         # VFS limits max symlink depth to 5(4KSTACK) or 7(8KSTACK) or 8
8781         # For kernel > 3.5, bellow only tests consecutive symlink (MAX 40)
8782         local i=0
8783         while i=`expr $i + 1`; do
8784                 test_mkdir -p $i || error "Creating dir $i"
8785                 cd $i || error "Changing to $i"
8786                 ln -s ../stat stat || error "Creating stat symlink"
8787                 # Read the symlink until ELOOP present,
8788                 # not LBUGing the system is considered success,
8789                 # we didn't overrun the stack.
8790                 $OPENFILE -f O_RDONLY stat >/dev/null 2>&1; ret=$?
8791                 [ $ret -ne 0 ] && {
8792                         if [ $ret -eq 40 ]; then
8793                                 break  # -ELOOP
8794                         else
8795                                 error "Open stat symlink"
8796                                 return
8797                         fi
8798                 }
8799         done
8800         i=`expr $i - 1`
8801         echo "The symlink depth = $i"
8802         [ $i -eq 5 -o $i -eq 7 -o $i -eq 8 -o $i -eq 40 ] ||
8803                                         error "Invalid symlink depth"
8804
8805         # Test recursive symlink
8806         ln -s symlink_self symlink_self
8807         $OPENFILE -f O_RDONLY symlink_self >/dev/null 2>&1; ret=$?
8808         echo "open symlink_self returns $ret"
8809         [ $ret -eq 40 ] || error "recursive symlink doesn't return -ELOOP"
8810 }
8811 run_test 140 "Check reasonable stack depth (shouldn't LBUG) ===="
8812
8813 test_150() {
8814         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8815         local TF="$TMP/$tfile"
8816
8817         dd if=/dev/urandom of=$TF bs=6096 count=1 || error "dd failed"
8818         cp $TF $DIR/$tfile
8819         cancel_lru_locks osc
8820         cmp $TF $DIR/$tfile || error "$TMP/$tfile $DIR/$tfile differ"
8821         remount_client $MOUNT
8822         df -P $MOUNT
8823         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (remount)"
8824
8825         $TRUNCATE $TF 6000
8826         $TRUNCATE $DIR/$tfile 6000
8827         cancel_lru_locks osc
8828         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (truncate1)"
8829
8830         echo "12345" >>$TF
8831         echo "12345" >>$DIR/$tfile
8832         cancel_lru_locks osc
8833         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (append1)"
8834
8835         echo "12345" >>$TF
8836         echo "12345" >>$DIR/$tfile
8837         cancel_lru_locks osc
8838         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (append2)"
8839
8840         rm -f $TF
8841         true
8842 }
8843 run_test 150 "truncate/append tests"
8844
8845 #LU-2902 roc_hit was not able to read all values from lproc
8846 function roc_hit_init() {
8847         local list=$(comma_list $(osts_nodes))
8848         local dir=$DIR/$tdir-check
8849         local file=$dir/file
8850         local BEFORE
8851         local AFTER
8852         local idx
8853
8854         test_mkdir -p $dir
8855         #use setstripe to do a write to every ost
8856         for i in $(seq 0 $((OSTCOUNT-1))); do
8857                 $SETSTRIPE -c 1 -i $i $dir || error "$SETSTRIPE $file failed"
8858                 dd if=/dev/urandom of=$file bs=4k count=4 2>&1 > /dev/null
8859                 idx=$(printf %04x $i)
8860                 BEFORE=$(get_osd_param $list *OST*$idx stats |
8861                     awk '$1 == "cache_access" {sum += $2} END { print sum }')
8862                 if [ -z "$BEFORE" ]; then
8863                         BEFORE=0
8864                 fi
8865
8866                 cancel_lru_locks osc
8867                 cat $file >/dev/null
8868
8869                 AFTER=$(get_osd_param $list *OST*$idx stats |
8870                     awk '$1 == "cache_access" {sum += $2} END { print sum }')
8871
8872                 echo BEFORE:$BEFORE AFTER:$AFTER
8873                 if ! let "AFTER - BEFORE == 4"; then
8874                         rm -rf $dir
8875                         error "roc_hit is not safe to use"
8876                 fi
8877                 rm $file
8878         done
8879
8880         rm -rf $dir
8881 }
8882
8883 function roc_hit() {
8884         local list=$(comma_list $(osts_nodes))
8885         echo $(get_osd_param $list '' stats |
8886                 awk '$1 == "cache_hit" {sum += $2} END { print sum }')
8887 }
8888
8889 function set_cache() {
8890         local on=1
8891
8892         if [ "$2" == "off" ]; then
8893                 on=0;
8894         fi
8895         local list=$(comma_list $(osts_nodes))
8896         set_osd_param $list '' $1_cache_enable $on
8897
8898         cancel_lru_locks osc
8899 }
8900
8901 test_151() {
8902         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8903         remote_ost_nodsh && skip "remote OST with nodsh" && return
8904
8905         local CPAGES=3
8906         local list=$(comma_list $(osts_nodes))
8907
8908         # check whether obdfilter is cache capable at all
8909         if ! get_osd_param $list '' read_cache_enable >/dev/null; then
8910                 echo "not cache-capable obdfilter"
8911                 return 0
8912         fi
8913
8914         # check cache is enabled on all obdfilters
8915         if get_osd_param $list '' read_cache_enable | grep 0; then
8916                 echo "oss cache is disabled"
8917                 return 0
8918         fi
8919
8920         set_osd_param $list '' writethrough_cache_enable 1
8921
8922         # check write cache is enabled on all obdfilters
8923         if get_osd_param $list '' writethrough_cache_enable | grep 0; then
8924                 echo "oss write cache is NOT enabled"
8925                 return 0
8926         fi
8927
8928         roc_hit_init
8929
8930         #define OBD_FAIL_OBD_NO_LRU  0x609
8931         do_nodes $list $LCTL set_param fail_loc=0x609
8932
8933         # pages should be in the case right after write
8934         dd if=/dev/urandom of=$DIR/$tfile bs=4k count=$CPAGES ||
8935                 error "dd failed"
8936
8937         local BEFORE=$(roc_hit)
8938         cancel_lru_locks osc
8939         cat $DIR/$tfile >/dev/null
8940         local AFTER=$(roc_hit)
8941
8942         do_nodes $list $LCTL set_param fail_loc=0
8943
8944         if ! let "AFTER - BEFORE == CPAGES"; then
8945                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
8946         fi
8947
8948         # the following read invalidates the cache
8949         cancel_lru_locks osc
8950         set_osd_param $list '' read_cache_enable 0
8951         cat $DIR/$tfile >/dev/null
8952
8953         # now data shouldn't be found in the cache
8954         BEFORE=$(roc_hit)
8955         cancel_lru_locks osc
8956         cat $DIR/$tfile >/dev/null
8957         AFTER=$(roc_hit)
8958         if let "AFTER - BEFORE != 0"; then
8959                 error "IN CACHE: before: $BEFORE, after: $AFTER"
8960         fi
8961
8962         set_osd_param $list '' read_cache_enable 1
8963         rm -f $DIR/$tfile
8964 }
8965 run_test 151 "test cache on oss and controls ==============================="
8966
8967 test_152() {
8968         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8969         local TF="$TMP/$tfile"
8970
8971         # simulate ENOMEM during write
8972 #define OBD_FAIL_OST_NOMEM      0x226
8973         lctl set_param fail_loc=0x80000226
8974         dd if=/dev/urandom of=$TF bs=6096 count=1 || error "dd failed"
8975         cp $TF $DIR/$tfile
8976         sync || error "sync failed"
8977         lctl set_param fail_loc=0
8978
8979         # discard client's cache
8980         cancel_lru_locks osc
8981
8982         # simulate ENOMEM during read
8983         lctl set_param fail_loc=0x80000226
8984         cmp $TF $DIR/$tfile || error "cmp failed"
8985         lctl set_param fail_loc=0
8986
8987         rm -f $TF
8988 }
8989 run_test 152 "test read/write with enomem ============================"
8990
8991 test_153() {
8992         $MULTIOP $DIR/$tfile Ow4096Ycu || error "multiop failed"
8993 }
8994 run_test 153 "test if fdatasync does not crash ======================="
8995
8996 dot_lustre_fid_permission_check() {
8997         local fid=$1
8998         local ffid=$MOUNT/.lustre/fid/$fid
8999         local test_dir=$2
9000
9001         echo "stat fid $fid"
9002         stat $ffid > /dev/null || error "stat $ffid failed."
9003         echo "touch fid $fid"
9004         touch $ffid || error "touch $ffid failed."
9005         echo "write to fid $fid"
9006         cat /etc/hosts > $ffid || error "write $ffid failed."
9007         echo "read fid $fid"
9008         diff /etc/hosts $ffid || error "read $ffid failed."
9009         echo "append write to fid $fid"
9010         cat /etc/hosts >> $ffid || error "append write $ffid failed."
9011         echo "rename fid $fid"
9012         mv $ffid $test_dir/$tfile.1 &&
9013                 error "rename $ffid to $tfile.1 should fail."
9014         touch $test_dir/$tfile.1
9015         mv $test_dir/$tfile.1 $ffid &&
9016                 error "rename $tfile.1 to $ffid should fail."
9017         rm -f $test_dir/$tfile.1
9018         echo "truncate fid $fid"
9019         $TRUNCATE $ffid 777 || error "truncate $ffid failed."
9020         echo "link fid $fid"
9021         ln -f $ffid $test_dir/tfile.lnk || error "link $ffid failed."
9022         if [ -n $(lctl get_param -n mdc.*-mdc-*.connect_flags | grep acl) ]; then
9023                 echo "setfacl fid $fid"
9024                 setfacl -R -m u:bin:rwx $ffid || error "setfacl $ffid failed."
9025                 echo "getfacl fid $fid"
9026                 getfacl $ffid >/dev/null || error "getfacl $ffid failed."
9027         fi
9028         echo "unlink fid $fid"
9029         unlink $MOUNT/.lustre/fid/$fid && error "unlink $ffid should fail."
9030         echo "mknod fid $fid"
9031         mknod $ffid c 1 3 && error "mknod $ffid should fail."
9032
9033         fid=[0xf00000400:0x1:0x0]
9034         ffid=$MOUNT/.lustre/fid/$fid
9035
9036         echo "stat non-exist fid $fid"
9037         stat $ffid > /dev/null && error "stat non-exist $ffid should fail."
9038         echo "write to non-exist fid $fid"
9039         cat /etc/hosts > $ffid && error "write non-exist $ffid should fail."
9040         echo "link new fid $fid"
9041         ln $test_dir/$tfile $ffid && error "link $ffid should fail."
9042
9043         mkdir -p $test_dir/$tdir
9044         touch $test_dir/$tdir/$tfile
9045         fid=$($LFS path2fid $test_dir/$tdir)
9046         rc=$?
9047         [ $rc -ne 0 ] &&
9048                 error "error: could not get fid for $test_dir/$dir/$tfile."
9049
9050         ffid=$MOUNT/.lustre/fid/$fid
9051
9052         echo "ls $fid"
9053         ls $ffid > /dev/null || error "ls $ffid failed."
9054         echo "touch $fid/$tfile.1"
9055         touch $ffid/$tfile.1 || error "touch $ffid/$tfile.1 failed."
9056
9057         echo "touch $MOUNT/.lustre/fid/$tfile"
9058         touch $MOUNT/.lustre/fid/$tfile && \
9059                 error "touch $MOUNT/.lustre/fid/$tfile should fail."
9060
9061         echo "setxattr to $MOUNT/.lustre/fid"
9062         setfattr -n trusted.name1 -v value1 $MOUNT/.lustre/fid
9063
9064         echo "listxattr for $MOUNT/.lustre/fid"
9065         getfattr -d -m "^trusted" $MOUNT/.lustre/fid
9066
9067         echo "delxattr from $MOUNT/.lustre/fid"
9068         setfattr -x trusted.name1 $MOUNT/.lustre/fid
9069
9070         echo "touch invalid fid: $MOUNT/.lustre/fid/[0x200000400:0x2:0x3]"
9071         touch $MOUNT/.lustre/fid/[0x200000400:0x2:0x3] &&
9072                 error "touch invalid fid should fail."
9073
9074         echo "touch non-normal fid: $MOUNT/.lustre/fid/[0x1:0x2:0x0]"
9075         touch $MOUNT/.lustre/fid/[0x1:0x2:0x0] &&
9076                 error "touch non-normal fid should fail."
9077
9078         echo "rename $tdir to $MOUNT/.lustre/fid"
9079         mrename $test_dir/$tdir $MOUNT/.lustre/fid &&
9080                 error "rename to $MOUNT/.lustre/fid should fail."
9081
9082         if [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.3.51) ]
9083         then            # LU-3547
9084                 local old_obf_mode=$(stat --format="%a" $DIR/.lustre/fid)
9085                 local new_obf_mode=777
9086
9087                 echo "change mode of $DIR/.lustre/fid to $new_obf_mode"
9088                 chmod $new_obf_mode $DIR/.lustre/fid ||
9089                         error "chmod $new_obf_mode $DIR/.lustre/fid failed"
9090
9091                 local obf_mode=$(stat --format=%a $DIR/.lustre/fid)
9092                 [ $obf_mode -eq $new_obf_mode ] ||
9093                         error "stat $DIR/.lustre/fid returned wrong mode $obf_mode"
9094
9095                 echo "restore mode of $DIR/.lustre/fid to $old_obf_mode"
9096                 chmod $old_obf_mode $DIR/.lustre/fid ||
9097                         error "chmod $old_obf_mode $DIR/.lustre/fid failed"
9098         fi
9099
9100         $OPENFILE -f O_LOV_DELAY_CREATE:O_CREAT $test_dir/$tfile-2
9101         fid=$($LFS path2fid $test_dir/$tfile-2)
9102         echo "cp /etc/passwd $MOUNT/.lustre/fid/$fid"
9103         cp /etc/passwd $MOUNT/.lustre/fid/$fid &&
9104                 error "create lov data thru .lustre should fail."
9105         echo "cp /etc/passwd $test_dir/$tfile-2"
9106         cp /etc/passwd $test_dir/$tfile-2 ||
9107                 error "copy to $test_dir/$tfile-2 failed."
9108         echo "diff /etc/passwd $MOUNT/.lustre/fid/$fid"
9109         diff /etc/passwd $MOUNT/.lustre/fid/$fid ||
9110                 error "diff /etc/passwd $MOUNT/.lustre/fid/$fid failed."
9111
9112         rm -rf $test_dir/tfile.lnk
9113         rm -rf $test_dir/$tfile-2
9114 }
9115
9116 test_154A() {
9117         [[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.4.1) ]] &&
9118                 skip "Need MDS version at least 2.4.1" && return
9119
9120         touch $DIR/$tfile
9121         local FID=$($LFS path2fid $DIR/$tfile)
9122         [ -z "$FID" ] && error "path2fid unable to get $DIR/$tfile FID"
9123
9124         # check that we get the same pathname back
9125         local FOUND=$($LFS fid2path $MOUNT $FID)
9126         [ -z "$FOUND" ] && error "fid2path unable to get $FID path"
9127         [ "$FOUND" != "$DIR/$tfile" ] &&
9128                 error "fid2path(path2fid($DIR/$tfile)) = $FOUND != $DIR/$tfile"
9129
9130         rm -rf $DIR/$tfile
9131 }
9132 run_test 154A "lfs path2fid and fid2path basic checks"
9133
9134 test_154a() {
9135         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9136         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.51) ]] ||
9137                 { skip "Need MDS version at least 2.2.51"; return 0; }
9138
9139         cp /etc/hosts $DIR/$tfile
9140
9141         fid=$($LFS path2fid $DIR/$tfile)
9142         rc=$?
9143         [ $rc -ne 0 ] && error "error: could not get fid for $DIR/$tfile."
9144
9145         dot_lustre_fid_permission_check "$fid" $DIR ||
9146                 error "dot lustre permission check $fid failed"
9147
9148         rm -rf $MOUNT/.lustre && error ".lustre is not allowed to be unlinked"
9149
9150         touch $MOUNT/.lustre/file &&
9151                 error "creation is not allowed under .lustre"
9152
9153         mkdir $MOUNT/.lustre/dir &&
9154                 error "mkdir is not allowed under .lustre"
9155
9156         rm -rf $DIR/$tfile
9157 }
9158 run_test 154a "Open-by-FID"
9159
9160 test_154b() {
9161         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9162         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.51) ]] ||
9163                 { skip "Need MDS version at least 2.2.51"; return 0; }
9164
9165         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
9166
9167         local remote_dir=$DIR/$tdir/remote_dir
9168         local MDTIDX=1
9169         local rc=0
9170
9171         mkdir -p $DIR/$tdir
9172         $LFS mkdir -i $MDTIDX $remote_dir ||
9173                 error "create remote directory failed"
9174
9175         cp /etc/hosts $remote_dir/$tfile
9176
9177         fid=$($LFS path2fid $remote_dir/$tfile)
9178         rc=$?
9179         [ $rc -ne 0 ] && error "error: could not get fid for $remote_dir/$tfile"
9180
9181         dot_lustre_fid_permission_check "$fid" $remote_dir ||
9182                 error "dot lustre permission check $fid failed"
9183         rm -rf $DIR/$tdir
9184 }
9185 run_test 154b "Open-by-FID for remote directory"
9186
9187 test_154c() {
9188         [[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.4.1) ]] &&
9189                 skip "Need MDS version at least 2.4.1" && return
9190
9191         touch $DIR/$tfile.1 $DIR/$tfile.2 $DIR/$tfile.3
9192         local FID1=$($LFS path2fid $DIR/$tfile.1)
9193         local FID2=$($LFS path2fid $DIR/$tfile.2)
9194         local FID3=$($LFS path2fid $DIR/$tfile.3)
9195
9196         local N=1
9197         $LFS path2fid $DIR/$tfile.[123] | while read PATHNAME FID; do
9198                 [ "$PATHNAME" = "$DIR/$tfile.$N:" ] ||
9199                         error "path2fid pathname $PATHNAME != $DIR/$tfile.$N:"
9200                 local want=FID$N
9201                 [ "$FID" = "${!want}" ] ||
9202                         error "path2fid $PATHNAME FID $FID != FID$N ${!want}"
9203                 N=$((N + 1))
9204         done
9205
9206         $LFS fid2path $MOUNT $FID1 $FID2 $FID3 | while read PATHNAME; do
9207                 [ "$PATHNAME" = "$DIR/$tfile.$N" ] ||
9208                         error "fid2path pathname $PATHNAME != $DIR/$tfile.$N:"
9209                 N=$((N + 1))
9210         done
9211 }
9212 run_test 154c "lfs path2fid and fid2path multiple arguments"
9213
9214 test_154d() {
9215         [[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.5.53) ]] &&
9216                 skip "Need MDS version at least 2.5.53" && return
9217
9218         if remote_mds; then
9219                 nid=$($LCTL list_nids | sed  "s/\./\\\./g")
9220         else
9221                 nid="0@lo"
9222         fi
9223         local proc_ofile="mdt.*.exports.'$nid'.open_files"
9224         local fd
9225         local cmd
9226
9227         rm -f $DIR/$tfile
9228         touch $DIR/$tfile
9229
9230         fid=$($LFS path2fid $DIR/$tfile)
9231         # Open the file
9232         fd=$(free_fd)
9233         cmd="exec $fd<$DIR/$tfile"
9234         eval $cmd
9235         fid_list=$(do_facet $SINGLEMDS $LCTL get_param $proc_ofile)
9236         echo $fid_list | grep $fid
9237         rc=$?
9238
9239         cmd="exec $fd>/dev/null"
9240         eval $cmd
9241         if [ $rc -ne 0 ]; then
9242                 error "FID $fid not found in open files list $fid_list"
9243         fi
9244 }
9245 run_test 154d "Verify open file fid"
9246
9247 test_155_small_load() {
9248     local temp=$TMP/$tfile
9249     local file=$DIR/$tfile
9250
9251     dd if=/dev/urandom of=$temp bs=6096 count=1 || \
9252         error "dd of=$temp bs=6096 count=1 failed"
9253     cp $temp $file
9254     cancel_lru_locks osc
9255     cmp $temp $file || error "$temp $file differ"
9256
9257     $TRUNCATE $temp 6000
9258     $TRUNCATE $file 6000
9259     cmp $temp $file || error "$temp $file differ (truncate1)"
9260
9261     echo "12345" >>$temp
9262     echo "12345" >>$file
9263     cmp $temp $file || error "$temp $file differ (append1)"
9264
9265     echo "12345" >>$temp
9266     echo "12345" >>$file
9267     cmp $temp $file || error "$temp $file differ (append2)"
9268
9269     rm -f $temp $file
9270     true
9271 }
9272
9273 test_155_big_load() {
9274     remote_ost_nodsh && skip "remote OST with nodsh" && return
9275     local temp=$TMP/$tfile
9276     local file=$DIR/$tfile
9277
9278     free_min_max
9279     local cache_size=$(do_facet ost$((MAXI+1)) \
9280         "awk '/cache/ {sum+=\\\$4} END {print sum}' /proc/cpuinfo")
9281     local large_file_size=$((cache_size * 2))
9282
9283     echo "OSS cache size: $cache_size KB"
9284     echo "Large file size: $large_file_size KB"
9285
9286     [ $MAXV -le $large_file_size ] && \
9287         skip_env "max available OST size needs > $large_file_size KB" && \
9288         return 0
9289
9290     $SETSTRIPE $file -c 1 -i $MAXI || error "$SETSTRIPE $file failed"
9291
9292     dd if=/dev/urandom of=$temp bs=$large_file_size count=1k || \
9293         error "dd of=$temp bs=$large_file_size count=1k failed"
9294     cp $temp $file
9295     ls -lh $temp $file
9296     cancel_lru_locks osc
9297     cmp $temp $file || error "$temp $file differ"
9298
9299     rm -f $temp $file
9300     true
9301 }
9302
9303 test_155a() {
9304         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9305         set_cache read on
9306         set_cache writethrough on
9307         test_155_small_load
9308 }
9309 run_test 155a "Verify small file correctness: read cache:on write_cache:on"
9310
9311 test_155b() {
9312         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9313         set_cache read on
9314         set_cache writethrough off
9315         test_155_small_load
9316 }
9317 run_test 155b "Verify small file correctness: read cache:on write_cache:off"
9318
9319 test_155c() {
9320         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9321         set_cache read off
9322         set_cache writethrough on
9323         test_155_small_load
9324 }
9325 run_test 155c "Verify small file correctness: read cache:off write_cache:on"
9326
9327 test_155d() {
9328         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9329         set_cache read off
9330         set_cache writethrough off
9331         test_155_small_load
9332 }
9333 run_test 155d "Verify small file correctness: read cache:off write_cache:off"
9334
9335 test_155e() {
9336         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9337         set_cache read on
9338         set_cache writethrough on
9339         test_155_big_load
9340 }
9341 run_test 155e "Verify big file correctness: read cache:on write_cache:on"
9342
9343 test_155f() {
9344         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9345         set_cache read on
9346         set_cache writethrough off
9347         test_155_big_load
9348 }
9349 run_test 155f "Verify big file correctness: read cache:on write_cache:off"
9350
9351 test_155g() {
9352         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9353         set_cache read off
9354         set_cache writethrough on
9355         test_155_big_load
9356 }
9357 run_test 155g "Verify big file correctness: read cache:off write_cache:on"
9358
9359 test_155h() {
9360         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9361         set_cache read off
9362         set_cache writethrough off
9363         test_155_big_load
9364 }
9365 run_test 155h "Verify big file correctness: read cache:off write_cache:off"
9366
9367 test_156() {
9368         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9369         local CPAGES=3
9370         local BEFORE
9371         local AFTER
9372         local file="$DIR/$tfile"
9373
9374         [ "$(facet_fstype ost1)" = "zfs" ] &&
9375                 skip "LU-1956/LU-2261: stats unimplemented on OSD ZFS" &&
9376                 return
9377
9378         roc_hit_init
9379
9380     log "Turn on read and write cache"
9381     set_cache read on
9382     set_cache writethrough on
9383
9384     log "Write data and read it back."
9385     log "Read should be satisfied from the cache."
9386     dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
9387     BEFORE=`roc_hit`
9388     cancel_lru_locks osc
9389     cat $file >/dev/null
9390     AFTER=`roc_hit`
9391     if ! let "AFTER - BEFORE == CPAGES"; then
9392         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
9393     else
9394         log "cache hits:: before: $BEFORE, after: $AFTER"
9395     fi
9396
9397     log "Read again; it should be satisfied from the cache."
9398     BEFORE=$AFTER
9399     cancel_lru_locks osc
9400     cat $file >/dev/null
9401     AFTER=`roc_hit`
9402     if ! let "AFTER - BEFORE == CPAGES"; then
9403         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
9404     else
9405         log "cache hits:: before: $BEFORE, after: $AFTER"
9406     fi
9407
9408
9409     log "Turn off the read cache and turn on the write cache"
9410     set_cache read off
9411     set_cache writethrough on
9412
9413     log "Read again; it should be satisfied from the cache."
9414     BEFORE=`roc_hit`
9415     cancel_lru_locks osc
9416     cat $file >/dev/null
9417     AFTER=`roc_hit`
9418     if ! let "AFTER - BEFORE == CPAGES"; then
9419         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
9420     else
9421         log "cache hits:: before: $BEFORE, after: $AFTER"
9422     fi
9423
9424     log "Read again; it should not be satisfied from the cache."
9425     BEFORE=$AFTER
9426     cancel_lru_locks osc
9427     cat $file >/dev/null
9428     AFTER=`roc_hit`
9429     if ! let "AFTER - BEFORE == 0"; then
9430         error "IN CACHE: before: $BEFORE, after: $AFTER"
9431     else
9432         log "cache hits:: before: $BEFORE, after: $AFTER"
9433     fi
9434
9435     log "Write data and read it back."
9436     log "Read should be satisfied from the cache."
9437     dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
9438     BEFORE=`roc_hit`
9439     cancel_lru_locks osc
9440     cat $file >/dev/null
9441     AFTER=`roc_hit`
9442     if ! let "AFTER - BEFORE == CPAGES"; then
9443         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
9444     else
9445         log "cache hits:: before: $BEFORE, after: $AFTER"
9446     fi
9447
9448     log "Read again; it should not be satisfied from the cache."
9449     BEFORE=$AFTER
9450     cancel_lru_locks osc
9451     cat $file >/dev/null
9452     AFTER=`roc_hit`
9453     if ! let "AFTER - BEFORE == 0"; then
9454         error "IN CACHE: before: $BEFORE, after: $AFTER"
9455     else
9456         log "cache hits:: before: $BEFORE, after: $AFTER"
9457     fi
9458
9459
9460     log "Turn off read and write cache"
9461     set_cache read off
9462     set_cache writethrough off
9463
9464     log "Write data and read it back"
9465     log "It should not be satisfied from the cache."
9466     rm -f $file
9467     dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
9468     cancel_lru_locks osc
9469     BEFORE=`roc_hit`
9470     cat $file >/dev/null
9471     AFTER=`roc_hit`
9472         if ! let "AFTER - BEFORE == 0"; then
9473                 error_ignore bz20762 "IN CACHE: before: $BEFORE, after: $AFTER"
9474         else
9475                 log "cache hits:: before: $BEFORE, after: $AFTER"
9476         fi
9477
9478     log "Turn on the read cache and turn off the write cache"
9479     set_cache read on
9480     set_cache writethrough off
9481
9482     log "Write data and read it back"
9483     log "It should not be satisfied from the cache."
9484     rm -f $file
9485     dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
9486     BEFORE=`roc_hit`
9487     cancel_lru_locks osc
9488     cat $file >/dev/null
9489     AFTER=`roc_hit`
9490         if ! let "AFTER - BEFORE == 0"; then
9491                 error_ignore bz20762 "IN CACHE: before: $BEFORE, after: $AFTER"
9492         else
9493                 log "cache hits:: before: $BEFORE, after: $AFTER"
9494         fi
9495
9496     log "Read again; it should be satisfied from the cache."
9497     BEFORE=`roc_hit`
9498     cancel_lru_locks osc
9499     cat $file >/dev/null
9500     AFTER=`roc_hit`
9501     if ! let "AFTER - BEFORE == CPAGES"; then
9502         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
9503     else
9504         log "cache hits:: before: $BEFORE, after: $AFTER"
9505     fi
9506
9507     rm -f $file
9508 }
9509 run_test 156 "Verification of tunables ============================"
9510
9511 #Changelogs
9512 err17935 () {
9513         if [ $MDSCOUNT -gt 1 ]; then
9514                 error_ignore bz17935 $*
9515         else
9516                 error $*
9517         fi
9518 }
9519
9520 changelog_chmask()
9521 {
9522         local CL_MASK_PARAM="mdd.$MDT0.changelog_mask"
9523
9524         MASK=$(do_facet $SINGLEMDS $LCTL get_param $CL_MASK_PARAM| grep -c "$1")
9525
9526         if [ $MASK -eq 1 ]; then
9527                 do_facet $SINGLEMDS $LCTL set_param $CL_MASK_PARAM="-$1"
9528         else
9529                 do_facet $SINGLEMDS $LCTL set_param $CL_MASK_PARAM="+$1"
9530         fi
9531 }
9532
9533 changelog_extract_field() {
9534         local mdt=$1
9535         local cltype=$2
9536         local file=$3
9537         local identifier=$4
9538
9539         $LFS changelog $mdt | gawk "/$cltype.*$file$/ {
9540                 print gensub(/^.* "$identifier'(\[[^\]]*\]).*$/,"\\1",1)}' |
9541                 tail -1
9542 }
9543
9544 test_160a() {
9545         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9546         remote_mds_nodsh && skip "remote MDS with nodsh" && return
9547         [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.0) ] ||
9548                 { skip "Need MDS version at least 2.2.0"; return; }
9549
9550         local CL_USERS="mdd.$MDT0.changelog_users"
9551         local GET_CL_USERS="do_facet $SINGLEMDS $LCTL get_param -n $CL_USERS"
9552         USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_register -n)
9553         echo "Registered as changelog user $USER"
9554         $GET_CL_USERS | grep -q $USER ||
9555                 error "User $USER not found in changelog_users"
9556
9557         # change something
9558         test_mkdir -p $DIR/$tdir/pics/2008/zachy
9559         touch $DIR/$tdir/pics/2008/zachy/timestamp
9560         cp /etc/hosts $DIR/$tdir/pics/2008/zachy/pic1.jpg
9561         mv $DIR/$tdir/pics/2008/zachy $DIR/$tdir/pics/zach
9562         ln $DIR/$tdir/pics/zach/pic1.jpg $DIR/$tdir/pics/2008/portland.jpg
9563         ln -s $DIR/$tdir/pics/2008/portland.jpg $DIR/$tdir/pics/desktop.jpg
9564         rm $DIR/$tdir/pics/desktop.jpg
9565
9566         $LFS changelog $MDT0 | tail -5
9567
9568         echo "verifying changelog mask"
9569         changelog_chmask "MKDIR"
9570         changelog_chmask "CLOSE"
9571
9572         test_mkdir -p $DIR/$tdir/pics/zach/sofia
9573         echo "zzzzzz" > $DIR/$tdir/pics/zach/file
9574
9575         changelog_chmask "MKDIR"
9576         changelog_chmask "CLOSE"
9577
9578         test_mkdir -p $DIR/$tdir/pics/2008/sofia
9579         echo "zzzzzz" > $DIR/$tdir/pics/zach/file
9580
9581         $LFS changelog $MDT0
9582         MKDIRS=$($LFS changelog $MDT0 | tail -5 | grep -c "MKDIR")
9583         CLOSES=$($LFS changelog $MDT0 | tail -5 | grep -c "CLOSE")
9584         [ $MKDIRS -eq 1 ] || err17935 "MKDIR changelog mask count $DIRS != 1"
9585         [ $CLOSES -eq 1 ] || err17935 "CLOSE changelog mask count $DIRS != 1"
9586
9587         # verify contents
9588         echo "verifying target fid"
9589         fidc=$(changelog_extract_field $MDT0 "CREAT" "timestamp" "t=")
9590         fidf=$($LFS path2fid $DIR/$tdir/pics/zach/timestamp)
9591         [ "$fidc" == "$fidf" ] ||
9592                 err17935 "fid in changelog $fidc != file fid $fidf"
9593         echo "verifying parent fid"
9594         fidc=$(changelog_extract_field $MDT0 "CREAT" "timestamp" "p=")
9595         fidf=$($LFS path2fid $DIR/$tdir/pics/zach)
9596         [ "$fidc" == "$fidf" ] ||
9597                 err17935 "pfid in changelog $fidc != dir fid $fidf"
9598
9599         USER_REC1=$($GET_CL_USERS | awk "\$1 == \"$USER\" {print \$2}")
9600         $LFS changelog_clear $MDT0 $USER $(($USER_REC1 + 5))
9601         USER_REC2=$($GET_CL_USERS | awk "\$1 == \"$USER\" {print \$2}")
9602         echo "verifying user clear: $(( $USER_REC1 + 5 )) == $USER_REC2"
9603         [ $USER_REC2 == $(($USER_REC1 + 5)) ] ||
9604                 err17935 "user index expected $(($USER_REC1 + 5)) is $USER_REC2"
9605
9606         MIN_REC=$($GET_CL_USERS |
9607                 awk 'min == "" || $2 < min {min = $2}; END {print min}')
9608         FIRST_REC=$($LFS changelog $MDT0 | head -1 | awk '{print $1}')
9609         echo "verifying min purge: $(( $MIN_REC + 1 )) == $FIRST_REC"
9610         [ $FIRST_REC == $(($MIN_REC + 1)) ] ||
9611                 err17935 "first index should be $(($MIN_REC + 1)) is $FIRST_REC"
9612
9613         # LU-3446 changelog index reset on MDT restart
9614         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
9615         CUR_REC1=$($GET_CL_USERS | head -1 | cut -f3 -d' ')
9616         $LFS changelog_clear $MDT0 $USER 0
9617         stop $SINGLEMDS || error "Fail to stop MDT."
9618         start $SINGLEMDS $MDT_DEV $MDS_MOUNT_OPTS || error "Fail to start MDT."
9619         CUR_REC2=$($GET_CL_USERS | head -1 | cut -f3 -d' ')
9620         echo "verifying index survives MDT restart: $CUR_REC1 == $CUR_REC2"
9621         [ $CUR_REC1 == $CUR_REC2 ] ||
9622                 err17935 "current index should be $CUR_REC1 is $CUR_REC2"
9623
9624         echo "verifying user deregister"
9625         do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister $USER
9626         $GET_CL_USERS | grep -q $USER &&
9627                 error "User $USER still in changelog_users"
9628
9629         USERS=$(( $($GET_CL_USERS | wc -l) - 2 ))
9630         if [ $USERS -eq 0 ]; then
9631                 LAST_REC1=$($GET_CL_USERS | head -1 | cut -f3 -d' ')
9632                 touch $DIR/$tdir/chloe
9633                 LAST_REC2=$($GET_CL_USERS | head -1 | cut -f3 -d' ')
9634                 echo "verify changelogs are off: $LAST_REC1 == $LAST_REC2"
9635                 [ $LAST_REC1 == $LAST_REC2 ] || error "changelogs not off"
9636         else
9637                 echo "$USERS other changelog users; can't verify off"
9638         fi
9639 }
9640 run_test 160a "changelog sanity"
9641
9642 test_160b() { # LU-3587
9643         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9644         remote_mds_nodsh && skip "remote MDS with nodsh" && return
9645         [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.0) ] ||
9646                 { skip "Need MDS version at least 2.2.0"; return; }
9647
9648         local CL_USERS="mdd.$MDT0.changelog_users"
9649         local GET_CL_USERS="do_facet $SINGLEMDS $LCTL get_param -n $CL_USERS"
9650         USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_register -n)
9651         echo "Registered as changelog user $USER"
9652         $GET_CL_USERS | grep -q $USER ||
9653                 error "User $USER not found in changelog_users"
9654
9655         local LONGNAME1=$(str_repeat a 255)
9656         local LONGNAME2=$(str_repeat b 255)
9657
9658         cd $DIR
9659         echo "creating very long named file"
9660         touch $LONGNAME1 || error "create of $LONGNAME1 failed"
9661         echo "moving very long named file"
9662         mv $LONGNAME1 $LONGNAME2
9663
9664         $LFS changelog $MDT0 | grep RENME
9665
9666         echo "deregistering $USER"
9667         do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister $USER
9668
9669         rm -f $LONGNAME2
9670 }
9671 run_test 160b "Verify that very long rename doesn't crash in changelog"
9672
9673 test_161a() {
9674         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9675     test_mkdir -p $DIR/$tdir
9676     cp /etc/hosts $DIR/$tdir/$tfile
9677     test_mkdir $DIR/$tdir/foo1
9678     test_mkdir $DIR/$tdir/foo2
9679     ln $DIR/$tdir/$tfile $DIR/$tdir/foo1/sofia
9680     ln $DIR/$tdir/$tfile $DIR/$tdir/foo2/zachary
9681     ln $DIR/$tdir/$tfile $DIR/$tdir/foo1/luna
9682     ln $DIR/$tdir/$tfile $DIR/$tdir/foo2/thor
9683         local FID=$($LFS path2fid $DIR/$tdir/$tfile | tr -d '[]')
9684         if [ "$($LFS fid2path $DIR $FID | wc -l)" != "5" ]; then
9685                 $LFS fid2path $DIR $FID
9686                 err17935 "bad link ea"
9687         fi
9688     # middle
9689     rm $DIR/$tdir/foo2/zachary
9690     # last
9691     rm $DIR/$tdir/foo2/thor
9692     # first
9693     rm $DIR/$tdir/$tfile
9694     # rename
9695     mv $DIR/$tdir/foo1/sofia $DIR/$tdir/foo2/maggie
9696     if [ "$($LFS fid2path $FSNAME --link 1 $FID)" != "$tdir/foo2/maggie" ]
9697         then
9698         $LFS fid2path $DIR $FID
9699         err17935 "bad link rename"
9700     fi
9701     rm $DIR/$tdir/foo2/maggie
9702
9703     # overflow the EA
9704     local longname=filename_avg_len_is_thirty_two_
9705     createmany -l$DIR/$tdir/foo1/luna $DIR/$tdir/foo2/$longname 1000 || \
9706         error "failed to hardlink many files"
9707     links=$($LFS fid2path $DIR $FID | wc -l)
9708     echo -n "${links}/1000 links in link EA"
9709     [ ${links} -gt 60 ] || err17935 "expected at least 60 links in link EA"
9710     unlinkmany $DIR/$tdir/foo2/$longname 1000 || \
9711         error "failed to unlink many hardlinks"
9712 }
9713 run_test 161a "link ea sanity"
9714
9715 test_161b() {
9716         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9717         [ $MDSCOUNT -lt 2 ] &&
9718                 skip "skipping remote directory test" && return
9719         local MDTIDX=1
9720         local remote_dir=$DIR/$tdir/remote_dir
9721
9722         mkdir -p $DIR/$tdir
9723         $LFS mkdir -i $MDTIDX $remote_dir ||
9724                 error "create remote directory failed"
9725
9726         cp /etc/hosts $remote_dir/$tfile
9727         mkdir -p $remote_dir/foo1
9728         mkdir -p $remote_dir/foo2
9729         ln $remote_dir/$tfile $remote_dir/foo1/sofia
9730         ln $remote_dir/$tfile $remote_dir/foo2/zachary
9731         ln $remote_dir/$tfile $remote_dir/foo1/luna
9732         ln $remote_dir/$tfile $remote_dir/foo2/thor
9733
9734         local FID=$($LFS path2fid $remote_dir/$tfile | tr -d '[' |
9735                      tr -d ']')
9736         if [ "$($LFS fid2path $DIR $FID | wc -l)" != "5" ]; then
9737                 $LFS fid2path $DIR $FID
9738                 err17935 "bad link ea"
9739         fi
9740         # middle
9741         rm $remote_dir/foo2/zachary
9742         # last
9743         rm $remote_dir/foo2/thor
9744         # first
9745         rm $remote_dir/$tfile
9746         # rename
9747         mv $remote_dir/foo1/sofia $remote_dir/foo2/maggie
9748         local link_path=$($LFS fid2path $FSNAME --link 1 $FID)
9749         if [ "$DIR/$link_path" != "$remote_dir/foo2/maggie" ]; then
9750                 $LFS fid2path $DIR $FID
9751                 err17935 "bad link rename"
9752         fi
9753         rm $remote_dir/foo2/maggie
9754
9755         # overflow the EA
9756         local longname=filename_avg_len_is_thirty_two_
9757         createmany -l$remote_dir/foo1/luna $remote_dir/foo2/$longname 1000 ||
9758                 error "failed to hardlink many files"
9759         links=$($LFS fid2path $DIR $FID | wc -l)
9760         echo -n "${links}/1000 links in link EA"
9761         [ ${links} -gt 60 ] || err17935 "expected at least 60 links in link EA"
9762         unlinkmany $remote_dir/foo2/$longname 1000 ||
9763         error "failed to unlink many hardlinks"
9764 }
9765 run_test 161b "link ea sanity under remote directory"
9766
9767 test_161c() {
9768         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9769         [[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.1.5) ]] &&
9770                 skip "Need MDS version at least 2.1.5" && return
9771
9772         # define CLF_RENAME_LAST 0x0001
9773         # rename overwrite a target having nlink = 1 (changelog flag 0x1)
9774         local USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0 \
9775                 changelog_register -n)
9776         rm -rf $DIR/$tdir
9777         mkdir -p $DIR/$tdir
9778         touch $DIR/$tdir/foo_161c
9779         touch $DIR/$tdir/bar_161c
9780         mv -f $DIR/$tdir/foo_161c $DIR/$tdir/bar_161c
9781         $LFS changelog $MDT0 | grep RENME
9782         local flags=$($LFS changelog $MDT0 | grep RENME | tail -1 | \
9783                 cut -f5 -d' ')
9784         $LFS changelog_clear $MDT0 $USER 0
9785         if [ x$flags != "x0x1" ]; then
9786                 do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister \
9787                         $USER
9788                 error "flag $flags is not 0x1"
9789         fi
9790         echo "rename overwrite a target having nlink = 1," \
9791                 "changelog record has flags of $flags"
9792
9793         # rename overwrite a target having nlink > 1 (changelog flag 0x0)
9794         touch $DIR/$tdir/foo_161c
9795         touch $DIR/$tdir/bar_161c
9796         ln $DIR/$tdir/bar_161c $DIR/$tdir/foobar_161c
9797         mv -f $DIR/$tdir/foo_161c $DIR/$tdir/bar_161c
9798         $LFS changelog $MDT0 | grep RENME
9799         flags=$($LFS changelog $MDT0 | grep RENME | tail -1 | cut -f5 -d' ')
9800         $LFS changelog_clear $MDT0 $USER 0
9801         if [ x$flags != "x0x0" ]; then
9802                 do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister \
9803                         $USER
9804                 error "flag $flags is not 0x0"
9805         fi
9806         echo "rename overwrite a target having nlink > 1," \
9807                 "changelog record has flags of $flags"
9808
9809         # rename doesn't overwrite a target (changelog flag 0x0)
9810         touch $DIR/$tdir/foo_161c
9811         mv -f $DIR/$tdir/foo_161c $DIR/$tdir/foo2_161c
9812         $LFS changelog $MDT0 | grep RENME
9813         flags=$($LFS changelog $MDT0 | grep RENME | tail -1 | cut -f5 -d' ')
9814         $LFS changelog_clear $MDT0 $USER 0
9815         if [ x$flags != "x0x0" ]; then
9816                 do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister \
9817                         $USER
9818                 error "flag $flags is not 0x0"
9819         fi
9820         echo "rename doesn't overwrite a target," \
9821                 "changelog record has flags of $flags"
9822
9823         # define CLF_UNLINK_LAST 0x0001
9824         # unlink a file having nlink = 1 (changelog flag 0x1)
9825         rm -f $DIR/$tdir/foo2_161c
9826         $LFS changelog $MDT0 | grep UNLNK
9827         flags=$($LFS changelog $MDT0 | grep UNLNK | tail -1 | cut -f5 -d' ')
9828         $LFS changelog_clear $MDT0 $USER 0
9829         if [ x$flags != "x0x1" ]; then
9830                 do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister \
9831                         $USER
9832                 error "flag $flags is not 0x1"
9833         fi
9834         echo "unlink a file having nlink = 1," \
9835                 "changelog record has flags of $flags"
9836
9837         # unlink a file having nlink > 1 (changelog flag 0x0)
9838         ln -f $DIR/$tdir/bar_161c $DIR/$tdir/foobar_161c
9839         rm -f $DIR/$tdir/foobar_161c
9840         $LFS changelog $MDT0 | grep UNLNK
9841         flags=$($LFS changelog $MDT0 | grep UNLNK | tail -1 | cut -f5 -d' ')
9842         $LFS changelog_clear $MDT0 $USER 0
9843         if [ x$flags != "x0x0" ]; then
9844                 do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister \
9845                         $USER
9846                 error "flag $flags is not 0x0"
9847         fi
9848         echo "unlink a file having nlink > 1," \
9849                 "changelog record has flags of $flags"
9850         do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister $USER
9851 }
9852 run_test 161c "check CL_RENME[UNLINK] changelog record flags"
9853
9854 check_path() {
9855     local expected=$1
9856     shift
9857     local fid=$2
9858
9859     local path=$(${LFS} fid2path $*)
9860     RC=$?
9861
9862     if [ $RC -ne 0 ]; then
9863         err17935 "path looked up of $expected failed. Error $RC"
9864         return $RC
9865     elif [ "${path}" != "${expected}" ]; then
9866         err17935 "path looked up \"${path}\" instead of \"${expected}\""
9867         return 2
9868     fi
9869     echo "fid $fid resolves to path $path (expected $expected)"
9870 }
9871
9872 test_162() {
9873         # Make changes to filesystem
9874         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9875         test_mkdir -p $DIR/$tdir/d2
9876         touch $DIR/$tdir/d2/$tfile
9877         touch $DIR/$tdir/d2/x1
9878         touch $DIR/$tdir/d2/x2
9879         test_mkdir -p $DIR/$tdir/d2/a/b/c
9880         test_mkdir -p $DIR/$tdir/d2/p/q/r
9881         # regular file
9882         FID=$($LFS path2fid $DIR/$tdir/d2/$tfile | tr -d '[]')
9883         check_path "$tdir/d2/$tfile" $FSNAME $FID --link 0
9884
9885         # softlink
9886         ln -s $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/p/q/r/slink
9887         FID=$($LFS path2fid $DIR/$tdir/d2/p/q/r/slink | tr -d '[]')
9888         check_path "$tdir/d2/p/q/r/slink" $FSNAME $FID --link 0
9889
9890         # softlink to wrong file
9891         ln -s /this/is/garbage $DIR/$tdir/d2/p/q/r/slink.wrong
9892         FID=$($LFS path2fid $DIR/$tdir/d2/p/q/r/slink.wrong | tr -d '[]')
9893         check_path "$tdir/d2/p/q/r/slink.wrong" $FSNAME $FID --link 0
9894
9895         # hardlink
9896         ln $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/p/q/r/hlink
9897         mv $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/a/b/c/new_file
9898         FID=$($LFS path2fid $DIR/$tdir/d2/a/b/c/new_file | tr -d '[]')
9899         # fid2path dir/fsname should both work
9900         check_path "$tdir/d2/a/b/c/new_file" $FSNAME $FID --link 1
9901         check_path "$DIR/$tdir/d2/p/q/r/hlink" $DIR $FID --link 0
9902
9903         # hardlink count: check that there are 2 links
9904         # Doesnt work with CMD yet: 17935
9905         ${LFS} fid2path $DIR $FID | wc -l | grep -q 2 || \
9906                 err17935 "expected 2 links"
9907
9908         # hardlink indexing: remove the first link
9909         rm $DIR/$tdir/d2/p/q/r/hlink
9910         check_path "$tdir/d2/a/b/c/new_file" $FSNAME $FID --link 0
9911
9912         return 0
9913 }
9914 run_test 162 "path lookup sanity"
9915
9916 test_169() {
9917         # do directio so as not to populate the page cache
9918         log "creating a 10 Mb file"
9919         $MULTIOP $DIR/$tfile oO_CREAT:O_DIRECT:O_RDWR:w$((10*1048576))c || error "multiop failed while creating a file"
9920         log "starting reads"
9921         dd if=$DIR/$tfile of=/dev/null bs=4096 &
9922         log "truncating the file"
9923         $MULTIOP $DIR/$tfile oO_TRUNC:c || error "multiop failed while truncating the file"
9924         log "killing dd"
9925         kill %+ || true # reads might have finished
9926         echo "wait until dd is finished"
9927         wait
9928         log "removing the temporary file"
9929         rm -rf $DIR/$tfile || error "tmp file removal failed"
9930 }
9931 run_test 169 "parallel read and truncate should not deadlock"
9932
9933 test_170() {
9934         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9935         $LCTL clear     # bug 18514
9936         $LCTL debug_daemon start $TMP/${tfile}_log_good
9937         touch $DIR/$tfile
9938         $LCTL debug_daemon stop
9939         sed -e "s/^...../a/g" $TMP/${tfile}_log_good > $TMP/${tfile}_log_bad ||
9940                error "sed failed to read log_good"
9941
9942         $LCTL debug_daemon start $TMP/${tfile}_log_good
9943         rm -rf $DIR/$tfile
9944         $LCTL debug_daemon stop
9945
9946         $LCTL df $TMP/${tfile}_log_bad > $TMP/${tfile}_log_bad.out 2>&1 ||
9947                error "lctl df log_bad failed"
9948
9949         local bad_line=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $9}')
9950         local good_line1=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $5}')
9951
9952         $LCTL df $TMP/${tfile}_log_good > $TMP/${tfile}_log_good.out 2>&1
9953         local good_line2=$(tail -n 1 $TMP/${tfile}_log_good.out | awk '{print $5}')
9954
9955         [ "$bad_line" ] && [ "$good_line1" ] && [ "$good_line2" ] ||
9956                 error "bad_line good_line1 good_line2 are empty"
9957
9958         cat $TMP/${tfile}_log_good >> $TMP/${tfile}_logs_corrupt
9959         cat $TMP/${tfile}_log_bad >> $TMP/${tfile}_logs_corrupt
9960         cat $TMP/${tfile}_log_good >> $TMP/${tfile}_logs_corrupt
9961
9962         $LCTL df $TMP/${tfile}_logs_corrupt > $TMP/${tfile}_log_bad.out 2>&1
9963         local bad_line_new=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $9}')
9964         local good_line_new=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $5}')
9965
9966         [ "$bad_line_new" ] && [ "$good_line_new" ] ||
9967                 error "bad_line_new good_line_new are empty"
9968
9969         local expected_good=$((good_line1 + good_line2*2))
9970
9971         rm -f $TMP/${tfile}*
9972         # LU-231, short malformed line may not be counted into bad lines
9973         if [ $bad_line -ne $bad_line_new ] &&
9974                    [ $bad_line -ne $((bad_line_new - 1)) ]; then
9975                 error "expected $bad_line bad lines, but got $bad_line_new"
9976                 return 1
9977         fi
9978
9979         if [ $expected_good -ne $good_line_new ]; then
9980                 error "expected $expected_good good lines, but got $good_line_new"
9981                 return 2
9982         fi
9983         true
9984 }
9985 run_test 170 "test lctl df to handle corrupted log ====================="
9986
9987 test_171() { # bug20592
9988         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9989 #define OBD_FAIL_PTLRPC_DUMP_LOG         0x50e
9990         $LCTL set_param fail_loc=0x50e
9991         $LCTL set_param fail_val=3000
9992         multiop_bg_pause $DIR/$tfile O_s || true
9993         local MULTIPID=$!
9994         kill -USR1 $MULTIPID
9995         # cause log dump
9996         sleep 3
9997         wait $MULTIPID
9998         if dmesg | grep "recursive fault"; then
9999                 error "caught a recursive fault"
10000         fi
10001         $LCTL set_param fail_loc=0
10002         true
10003 }
10004 run_test 171 "test libcfs_debug_dumplog_thread stuck in do_exit() ======"
10005
10006 # it would be good to share it with obdfilter-survey/libecho code
10007 setup_obdecho_osc () {
10008         local rc=0
10009         local ost_nid=$1
10010         local obdfilter_name=$2
10011         echo "Creating new osc for $obdfilter_name on $ost_nid"
10012         # make sure we can find loopback nid
10013         $LCTL add_uuid $ost_nid $ost_nid >/dev/null 2>&1
10014
10015         [ $rc -eq 0 ] && { $LCTL attach osc ${obdfilter_name}_osc     \
10016                            ${obdfilter_name}_osc_UUID || rc=2; }
10017         [ $rc -eq 0 ] && { $LCTL --device ${obdfilter_name}_osc setup \
10018                            ${obdfilter_name}_UUID  $ost_nid || rc=3; }
10019         return $rc
10020 }
10021
10022 cleanup_obdecho_osc () {
10023         local obdfilter_name=$1
10024         $LCTL --device ${obdfilter_name}_osc cleanup >/dev/null
10025         $LCTL --device ${obdfilter_name}_osc detach  >/dev/null
10026         return 0
10027 }
10028
10029 obdecho_test() {
10030         local OBD=$1
10031         local node=$2
10032         local pages=${3:-64}
10033         local rc=0
10034         local id
10035
10036         local count=10
10037         local obd_size=$(get_obd_size $node $OBD)
10038         local page_size=$(get_page_size $node)
10039         if [[ -n "$obd_size" ]]; then
10040                 local new_count=$((obd_size / (pages * page_size / 1024)))
10041                 [[ $new_count -ge $count ]] || count=$new_count
10042         fi
10043
10044         do_facet $node "$LCTL attach echo_client ec ec_uuid" || rc=1
10045         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec setup $OBD" ||
10046                            rc=2; }
10047         if [ $rc -eq 0 ]; then
10048             id=$(do_facet $node "$LCTL --device ec create 1"  | awk '/object id/ {print $6}')
10049             [ ${PIPESTATUS[0]} -eq 0 -a -n "$id" ] || rc=3
10050         fi
10051         echo "New object id is $id"
10052         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec getattr $id" ||
10053                            rc=4; }
10054         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec "                 \
10055                            "test_brw $count w v $pages $id" || rc=4; }
10056         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec destroy $id 1" ||
10057                            rc=4; }
10058         [ $rc -eq 0 -o $rc -gt 2 ] && { do_facet $node "$LCTL --device ec "    \
10059                                         "cleanup" || rc=5; }
10060         [ $rc -eq 0 -o $rc -gt 1 ] && { do_facet $node "$LCTL --device ec "    \
10061                                         "detach" || rc=6; }
10062         [ $rc -ne 0 ] && echo "obecho_create_test failed: $rc"
10063         return $rc
10064 }
10065
10066 test_180a() {
10067         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10068         remote_ost_nodsh && skip "remote OST with nodsh" && return
10069         local rc=0
10070         local rmmod_local=0
10071
10072         if ! module_loaded obdecho; then
10073             load_module obdecho/obdecho
10074             rmmod_local=1
10075         fi
10076
10077         local osc=$($LCTL dl | grep -v mdt | awk '$3 == "osc" {print $4; exit}')
10078         local host=$(lctl get_param -n osc.$osc.import |
10079                              awk '/current_connection:/ {print $2}' )
10080         local target=$(lctl get_param -n osc.$osc.import |
10081                              awk '/target:/ {print $2}' )
10082         target=${target%_UUID}
10083
10084         [[ -n $target ]]  && { setup_obdecho_osc $host $target || rc=1; } || rc=1
10085         [ $rc -eq 0 ] && { obdecho_test ${target}_osc client || rc=2; }
10086         [[ -n $target ]] && cleanup_obdecho_osc $target
10087         [ $rmmod_local -eq 1 ] && rmmod obdecho
10088         return $rc
10089 }
10090 run_test 180a "test obdecho on osc"
10091
10092 test_180b() {
10093         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10094         remote_ost_nodsh && skip "remote OST with nodsh" && return
10095         local rc=0
10096         local rmmod_remote=0
10097
10098         do_facet ost1 "lsmod | grep -q obdecho || "                      \
10099                       "{ insmod ${LUSTRE}/obdecho/obdecho.ko || "        \
10100                       "modprobe obdecho; }" && rmmod_remote=1
10101         target=$(do_facet ost1 $LCTL dl | awk '/obdfilter/ {print $4;exit}')
10102         [[ -n $target ]] && { obdecho_test $target ost1 || rc=1; }
10103         [ $rmmod_remote -eq 1 ] && do_facet ost1 "rmmod obdecho"
10104         return $rc
10105 }
10106 run_test 180b "test obdecho directly on obdfilter"
10107
10108 test_180c() { # LU-2598
10109         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10110         [[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.4.0) ]] &&
10111                 skip "Need MDS version at least 2.4.0" && return
10112
10113         local rc=0
10114         local rmmod_remote=false
10115         local pages=16384 # 64MB bulk I/O RPC size
10116         local target
10117
10118         do_rpc_nodes $(facet_active_host ost1) load_module obdecho/obdecho &&
10119                 rmmod_remote=true || error "failed to load module obdecho"
10120
10121         target=$(do_facet ost1 $LCTL dl | awk '/obdfilter/ {print $4}'|head -1)
10122         if [[ -n $target ]]; then
10123                 obdecho_test "$target" ost1 "$pages" ||
10124                         rc=${PIPESTATUS[0]}
10125         else
10126                 echo "there is no obdfilter target on ost1"
10127                 rc=2
10128         fi
10129         $rmmod_remote && do_facet ost1 "rmmod obdecho" || true
10130         return $rc
10131 }
10132 run_test 180c "test huge bulk I/O size on obdfilter, don't LASSERT"
10133
10134 test_181() { # bug 22177
10135         test_mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
10136         # create enough files to index the directory
10137         createmany -o $DIR/$tdir/foobar 4000
10138         # print attributes for debug purpose
10139         lsattr -d .
10140         # open dir
10141         multiop_bg_pause $DIR/$tdir D_Sc || return 1
10142         MULTIPID=$!
10143         # remove the files & current working dir
10144         unlinkmany $DIR/$tdir/foobar 4000
10145         rmdir $DIR/$tdir
10146         kill -USR1 $MULTIPID
10147         wait $MULTIPID
10148         stat $DIR/$tdir && error "open-unlinked dir was not removed!"
10149         return 0
10150 }
10151 run_test 181 "Test open-unlinked dir ========================"
10152
10153 test_182() {
10154         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10155         # disable MDC RPC lock wouldn't crash client
10156         local fcount=1000
10157         local tcount=4
10158
10159         mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
10160 #define OBD_FAIL_MDC_RPCS_SEM           0x804
10161         $LCTL set_param fail_loc=0x804
10162
10163         for (( i=0; i < $tcount; i++ )) ; do
10164                 mkdir $DIR/$tdir/$i
10165                 createmany -o $DIR/$tdir/$i/f- $fcount &
10166         done
10167         wait
10168
10169         for (( i=0; i < $tcount; i++ )) ; do
10170                 unlinkmany $DIR/$tdir/$i/f- $fcount &
10171         done
10172         wait
10173
10174         rm -rf $DIR/$tdir
10175
10176         $LCTL set_param fail_loc=0
10177 }
10178 run_test 182 "Disable MDC RPCs semaphore wouldn't crash client ================"
10179
10180 test_183() { # LU-2275
10181         [[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.3.56) ]] &&
10182                 skip "Need MDS version at least 2.3.56" && return
10183
10184         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10185         mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
10186         echo aaa > $DIR/$tdir/$tfile
10187
10188 #define OBD_FAIL_MDS_NEGATIVE_POSITIVE  0x148
10189         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x148
10190
10191         ls -l $DIR/$tdir && error "ls succeeded, should have failed"
10192         cat $DIR/$tdir/$tfile && error "cat succeeded, should have failed"
10193
10194         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
10195
10196         # Flush negative dentry cache
10197         touch $DIR/$tdir/$tfile
10198
10199         # We are not checking for any leaked references here, they'll
10200         # become evident next time we do cleanup with module unload.
10201         rm -rf $DIR/$tdir
10202 }
10203 run_test 183 "No crash or request leak in case of strange dispositions ========"
10204
10205 # test suite 184 is for LU-2016, LU-2017
10206 test_184a() {
10207         check_swap_layouts_support && return 0
10208
10209         dir0=$DIR/$tdir/$testnum
10210         test_mkdir -p $dir0 || error "creating dir $dir0"
10211         ref1=/etc/passwd
10212         ref2=/etc/group
10213         file1=$dir0/f1
10214         file2=$dir0/f2
10215         $SETSTRIPE -c1 $file1
10216         cp $ref1 $file1
10217         $SETSTRIPE -c2 $file2
10218         cp $ref2 $file2
10219         gen1=$($GETSTRIPE -g $file1)
10220         gen2=$($GETSTRIPE -g $file2)
10221
10222         $LFS swap_layouts $file1 $file2 || error "swap of file layout failed"
10223         gen=$($GETSTRIPE -g $file1)
10224         [[ $gen1 != $gen ]] ||
10225                 "Layout generation on $file1 does not change"
10226         gen=$($GETSTRIPE -g $file2)
10227         [[ $gen2 != $gen ]] ||
10228                 "Layout generation on $file2 does not change"
10229
10230         cmp $ref1 $file2 || error "content compare failed ($ref1 != $file2)"
10231         cmp $ref2 $file1 || error "content compare failed ($ref2 != $file1)"
10232 }
10233 run_test 184a "Basic layout swap"
10234
10235 test_184b() {
10236         check_swap_layouts_support && return 0
10237
10238         dir0=$DIR/$tdir/$testnum
10239         mkdir -p $dir0 || error "creating dir $dir0"
10240         file1=$dir0/f1
10241         file2=$dir0/f2
10242         file3=$dir0/f3
10243         dir1=$dir0/d1
10244         dir2=$dir0/d2
10245         mkdir $dir1 $dir2
10246         $SETSTRIPE -c1 $file1
10247         $SETSTRIPE -c2 $file2
10248         $SETSTRIPE -c1 $file3
10249         chown $RUNAS_ID $file3
10250         gen1=$($GETSTRIPE -g $file1)
10251         gen2=$($GETSTRIPE -g $file2)
10252
10253         $LFS swap_layouts $dir1 $dir2 &&
10254                 error "swap of directories layouts should fail"
10255         $LFS swap_layouts $dir1 $file1 &&
10256                 error "swap of directory and file layouts should fail"
10257         $RUNAS $LFS swap_layouts $file1 $file2 &&
10258                 error "swap of file we cannot write should fail"
10259         $LFS swap_layouts $file1 $file3 &&
10260                 error "swap of file with different owner should fail"
10261         /bin/true # to clear error code
10262 }
10263 run_test 184b "Forbidden layout swap (will generate errors)"
10264
10265 test_184c() {
10266         check_swap_layouts_support && return 0
10267
10268         local dir0=$DIR/$tdir/$testnum
10269         mkdir -p $dir0 || error "creating dir $dir0"
10270
10271         local ref1=$dir0/ref1
10272         local ref2=$dir0/ref2
10273         local file1=$dir0/file1
10274         local file2=$dir0/file2
10275         # create a file large enough for the concurent test
10276         dd if=/dev/urandom of=$ref1 bs=1M count=$((RANDOM % 50 + 20))
10277         dd if=/dev/urandom of=$ref2 bs=1M count=$((RANDOM % 50 + 20))
10278         echo "ref file size: ref1(`stat -c %s $ref1`), ref2(`stat -c %s $ref2`)"
10279
10280         cp $ref2 $file2
10281         dd if=$ref1 of=$file1 bs=16k &
10282         local DD_PID=$!
10283
10284         # Make sure dd starts to copy file
10285         while [ ! -f $file1 ]; do sleep 0.1; done
10286
10287         $LFS swap_layouts $file1 $file2
10288         local rc=$?
10289         wait $DD_PID
10290         [[ $? == 0 ]] || error "concurrent write on $file1 failed"
10291         [[ $rc == 0 ]] || error "swap of $file1 and $file2 failed"
10292
10293         # how many bytes copied before swapping layout
10294         local copied=`stat -c %s $file2`
10295         local remaining=`stat -c %s $ref1`
10296         remaining=$((remaining - copied))
10297         echo "Copied $copied bytes before swapping layout..."
10298
10299         cmp -n $copied $file1 $ref2 | grep differ &&
10300                 error "Content mismatch [0, $copied) of ref2 and file1"
10301         cmp -n $copied $file2 $ref1 ||
10302                 error "Content mismatch [0, $copied) of ref1 and file2"
10303         cmp -i $copied:$copied -n $remaining $file1 $ref1 ||
10304                 error "Content mismatch [$copied, EOF) of ref1 and file1"
10305
10306         # clean up
10307         rm -f $ref1 $ref2 $file1 $file2
10308 }
10309 run_test 184c "Concurrent write and layout swap"
10310
10311 test_184d() {
10312         check_swap_layouts_support && return 0
10313
10314         local file1=$DIR/$tdir/$tfile-1
10315         local file2=$DIR/$tdir/$tfile-2
10316         local file3=$DIR/$tdir/$tfile-3
10317         local lovea1
10318         local lovea2
10319
10320         mkdir -p $DIR/$tdir
10321         touch $file1 || error "create $file1 failed"
10322         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE $file2 ||
10323                 error "create $file2 failed"
10324         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE $file3 ||
10325                 error "create $file3 failed"
10326         lovea1=$($LFS getstripe $file1 | sed 1d)
10327
10328         $LFS swap_layouts $file2 $file3 ||
10329                 error "swap $file2 $file3 layouts failed"
10330         $LFS swap_layouts $file1 $file2 ||
10331                 error "swap $file1 $file2 layouts failed"
10332
10333         lovea2=$($LFS getstripe $file2 | sed 1d)
10334         [ "$lovea1" == "$lovea2" ] || error "lovea $lovea1 != $lovea2"
10335
10336         lovea1=$(getfattr -n trusted.lov $file1 | grep ^trusted)
10337         [ -z $lovea1 ] || error "$file1 shouldn't have lovea"
10338 }
10339 run_test 184d "allow stripeless layouts swap"
10340
10341
10342 test_185() { # LU-2441
10343         # LU-3553 - no volatile file support in old servers
10344         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.3.60) ]] ||
10345                 { skip "Need MDS version at least 2.3.60"; return 0; }
10346
10347         mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
10348         touch $DIR/$tdir/spoo
10349         local mtime1=$(stat -c "%Y" $DIR/$tdir)
10350         local fid=$($MULTIOP $DIR/$tdir VFw4096c) ||
10351                 error "cannot create/write a volatile file"
10352         $CHECKSTAT -t file $MOUNT/.lustre/fid/$fid 2>/dev/null &&
10353                 error "FID is still valid after close"
10354
10355         multiop_bg_pause $DIR/$tdir vVw4096_c
10356         local multi_pid=$!
10357
10358         local OLD_IFS=$IFS
10359         IFS=":"
10360         local fidv=($fid)
10361         IFS=$OLD_IFS
10362         # assume that the next FID for this client is sequential, since stdout
10363         # is unfortunately eaten by multiop_bg_pause
10364         local n=$((${fidv[1]} + 1))
10365         local next_fid="${fidv[0]}:$(printf "0x%x" $n):${fidv[2]}"
10366         $CHECKSTAT -t file $MOUNT/.lustre/fid/$next_fid ||
10367                 error "FID is missing before close"
10368         kill -USR1 $multi_pid
10369         # 1 second delay, so if mtime change we will see it
10370         sleep 1
10371         local mtime2=$(stat -c "%Y" $DIR/$tdir)
10372         [[ $mtime1 == $mtime2 ]] || error "mtime has changed"
10373 }
10374 run_test 185 "Volatile file support"
10375
10376 test_187a() {
10377         local dir0=$DIR/$tdir/$testnum
10378         mkdir -p $dir0 || error "creating dir $dir0"
10379
10380         local file=$dir0/file1
10381         dd if=/dev/urandom of=$file count=10 bs=1M conv=fsync
10382         local dv1=$($LFS data_version $file)
10383         dd if=/dev/urandom of=$file seek=10 count=1 bs=1M conv=fsync
10384         local dv2=$($LFS data_version $file)
10385         [[ $dv1 != $dv2 ]] ||
10386                 error "data version did not change on write $dv1 == $dv2"
10387
10388         # clean up
10389         rm -f $file1
10390 }
10391 run_test 187a "Test data version change"
10392
10393 test_187b() {
10394         local dir0=$DIR/$tdir/$testnum
10395         mkdir -p $dir0 || error "creating dir $dir0"
10396
10397         declare -a DV=$($MULTIOP $dir0 Vw1000xYw1000xY | cut -f3 -d" ")
10398         [[ ${DV[0]} != ${DV[1]} ]] ||
10399                 error "data version did not change on write"\
10400                       " ${DV[0]} == ${DV[1]}"
10401
10402         # clean up
10403         rm -f $file1
10404 }
10405 run_test 187b "Test data version change on volatile file"
10406
10407 # OST pools tests
10408 check_file_in_pool()
10409 {
10410         local file=$1
10411         local pool=$2
10412         local tlist="$3"
10413         local res=$($GETSTRIPE $file | grep 0x | cut -f2)
10414         for i in $res
10415         do
10416                 for t in $tlist ; do
10417                         [ "$i" -eq "$t" ] && continue 2
10418                 done
10419
10420                 echo "pool list: $tlist"
10421                 echo "striping: $res"
10422                 error_noexit "$file not allocated in $pool"
10423                 return 1
10424         done
10425         return 0
10426 }
10427
10428 pool_add() {
10429         echo "Creating new pool"
10430         local pool=$1
10431
10432         create_pool $FSNAME.$pool ||
10433                 { error_noexit "No pool created, result code $?"; return 1; }
10434         [ $($LFS pool_list $FSNAME | grep -c $pool) -eq 1 ] ||
10435                 { error_noexit "$pool not in lfs pool_list"; return 2; }
10436 }
10437
10438 pool_add_targets() {
10439         echo "Adding targets to pool"
10440         local pool=$1
10441         local first=$2
10442         local last=$3
10443         local step=${4:-1}
10444
10445         local list=$(seq $first $step $last)
10446
10447         local t=$(for i in $list; do printf "$FSNAME-OST%04x_UUID " $i; done)
10448         do_facet mgs $LCTL pool_add \
10449                         $FSNAME.$pool $FSNAME-OST[$first-$last/$step]
10450         wait_update $HOSTNAME "lctl get_param -n lov.$FSNAME-*.pools.$pool \
10451                         | sort -u | tr '\n' ' ' " "$t" || {
10452                 error_noexit "Add to pool failed"
10453                 return 1
10454         }
10455         local lfscount=$($LFS pool_list $FSNAME.$pool | grep -c "\-OST")
10456         local addcount=$(((last - first) / step + 1))
10457         [ $lfscount -eq $addcount ] || {
10458                 error_noexit "lfs pool_list bad ost count" \
10459                                                 "$lfscount != $addcount"
10460                 return 2
10461         }
10462 }
10463
10464 pool_set_dir() {
10465         local pool=$1
10466         local tdir=$2
10467         echo "Setting pool on directory $tdir"
10468
10469         $SETSTRIPE -c 2 -p $pool $tdir && return 0
10470
10471         error_noexit "Cannot set pool $pool to $tdir"
10472         return 1
10473 }
10474
10475 pool_check_dir() {
10476         local pool=$1
10477         local tdir=$2
10478         echo "Checking pool on directory $tdir"
10479
10480         local res=$($GETSTRIPE --pool $tdir | sed "s/\s*$//")
10481         [ "$res" = "$pool" ] && return 0
10482
10483         error_noexit "Pool on '$tdir' is '$res', not '$pool'"
10484         return 1
10485 }
10486
10487 pool_dir_rel_path() {
10488         echo "Testing relative path works well"
10489         local pool=$1
10490         local tdir=$2
10491         local root=$3
10492
10493         mkdir -p $root/$tdir/$tdir
10494         cd $root/$tdir
10495         pool_set_dir $pool $tdir          || return 1
10496         pool_set_dir $pool ./$tdir        || return 2
10497         pool_set_dir $pool ../$tdir       || return 3
10498         pool_set_dir $pool ../$tdir/$tdir || return 4
10499         rm -rf $tdir; cd - > /dev/null
10500 }
10501
10502 pool_alloc_files() {
10503         echo "Checking files allocation from directory pool"
10504         local pool=$1
10505         local tdir=$2
10506         local count=$3
10507         local tlist="$4"
10508
10509         local failed=0
10510         for i in $(seq -w 1 $count)
10511         do
10512                 local file=$tdir/file-$i
10513                 touch $file
10514                 check_file_in_pool $file $pool "$tlist" || \
10515                         failed=$((failed + 1))
10516         done
10517         [ "$failed" = 0 ] && return 0
10518
10519         error_noexit "$failed files not allocated in $pool"
10520         return 1
10521 }
10522
10523 pool_create_files() {
10524         echo "Creating files in pool"
10525         local pool=$1
10526         local tdir=$2
10527         local count=$3
10528         local tlist="$4"
10529
10530         mkdir -p $tdir
10531         local failed=0
10532         for i in $(seq -w 1 $count)
10533         do
10534                 local file=$tdir/spoo-$i
10535                 $SETSTRIPE -p $pool $file
10536                 check_file_in_pool $file $pool "$tlist" || \
10537                         failed=$((failed + 1))
10538         done
10539         [ "$failed" = 0 ] && return 0
10540
10541         error_noexit "$failed files not allocated in $pool"
10542         return 1
10543 }
10544
10545 pool_lfs_df() {
10546         echo "Checking 'lfs df' output"
10547         local pool=$1
10548
10549         local t=$($LCTL get_param -n lov.$FSNAME-clilov-*.pools.$pool |
10550                         tr '\n' ' ')
10551         local res=$($LFS df --pool $FSNAME.$pool |
10552                         awk '{print $1}' |
10553                         grep "$FSNAME-OST" |
10554                         tr '\n' ' ')
10555         [ "$res" = "$t" ] && return 0
10556
10557         error_noexit "Pools OSTs '$t' is not '$res' that lfs df reports"
10558         return 1
10559 }
10560
10561 pool_file_rel_path() {
10562         echo "Creating files in a pool with relative pathname"
10563         local pool=$1
10564         local tdir=$2
10565
10566         mkdir -p $tdir ||
10567                 { error_noexit "unable to create $tdir"; return 1 ; }
10568         local file="/..$tdir/$tfile-1"
10569         $SETSTRIPE -p $pool $file ||
10570                 { error_noexit "unable to create $file" ; return 2 ; }
10571
10572         cd $tdir
10573         $SETSTRIPE -p $pool $tfile-2 || {
10574                 error_noexit "unable to create $tfile-2 in $tdir"
10575                 return 3
10576         }
10577 }
10578
10579 pool_remove_first_target() {
10580         echo "Removing first target from a pool"
10581         local pool=$1
10582
10583         local pname="lov.$FSNAME-*.pools.$pool"
10584         local t=$($LCTL get_param -n $pname | head -1)
10585         do_facet mgs $LCTL pool_remove $FSNAME.$pool $t
10586         wait_update $HOSTNAME "lctl get_param -n $pname | grep $t" "" || {
10587                 error_noexit "$t not removed from $FSNAME.$pool"
10588                 return 1
10589         }
10590 }
10591
10592 pool_remove_all_targets() {
10593         echo "Removing all targets from pool"
10594         local pool=$1
10595         local file=$2
10596         local pname="lov.$FSNAME-*.pools.$pool"
10597         for t in $($LCTL get_param -n $pname | sort -u)
10598         do
10599                 do_facet mgs $LCTL pool_remove $FSNAME.$pool $t
10600         done
10601         wait_update $HOSTNAME "lctl get_param -n $pname" "" || {
10602                 error_noexit "Pool $FSNAME.$pool cannot be drained"
10603                 return 1
10604         }
10605         # striping on an empty/nonexistant pool should fall back
10606         # to "pool of everything"
10607         touch $file || {
10608                 error_noexit "failed to use fallback striping for empty pool"
10609                 return 2
10610         }
10611         # setstripe on an empty pool should fail
10612         $SETSTRIPE -p $pool $file 2>/dev/null && {
10613                 error_noexit "expected failure when creating file" \
10614                                                         "with empty pool"
10615                 return 3
10616         }
10617         return 0
10618 }
10619
10620 pool_remove() {
10621         echo "Destroying pool"
10622         local pool=$1
10623         local file=$2
10624
10625         do_facet mgs $LCTL pool_destroy $FSNAME.$pool
10626
10627         sleep 2
10628         # striping on an empty/nonexistant pool should fall back
10629         # to "pool of everything"
10630         touch $file || {
10631                 error_noexit "failed to use fallback striping for missing pool"
10632                 return 1
10633         }
10634         # setstripe on an empty pool should fail
10635         $SETSTRIPE -p $pool $file 2>/dev/null && {
10636                 error_noexit "expected failure when creating file" \
10637                                                         "with missing pool"
10638                 return 2
10639         }
10640
10641         # get param should return err once pool is gone
10642         if wait_update $HOSTNAME "lctl get_param -n \
10643                 lov.$FSNAME-*.pools.$pool 2>/dev/null || echo foo" "foo"
10644         then
10645                 remove_pool_from_list $FSNAME.$pool
10646                 return 0
10647         fi
10648         error_noexit "Pool $FSNAME.$pool is not destroyed"
10649         return 3
10650 }
10651
10652 test_200() {
10653         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10654         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
10655
10656         local POOL=${POOL:-cea1}
10657         local POOL_ROOT=${POOL_ROOT:-$DIR/d200.pools}
10658         local POOL_DIR_NAME=${POOL_DIR_NAME:-dir_tst}
10659         # Pool OST targets
10660         local first_ost=0
10661         local last_ost=$(($OSTCOUNT - 1))
10662         local ost_step=2
10663         local ost_list=$(seq $first_ost $ost_step $last_ost)
10664         local ost_range="$first_ost $last_ost $ost_step"
10665         local test_path=$POOL_ROOT/$POOL_DIR_NAME
10666         local file_dir=$POOL_ROOT/file_tst
10667
10668         local rc=0
10669         while : ; do
10670                 # former test_200a test_200b
10671                 pool_add $POOL                          || { rc=$? ; break; }
10672                 pool_add_targets  $POOL $ost_range      || { rc=$? ; break; }
10673                 # former test_200c test_200d
10674                 mkdir -p $test_path
10675                 pool_set_dir      $POOL $test_path      || { rc=$? ; break; }
10676                 pool_check_dir    $POOL $test_path      || { rc=$? ; break; }
10677                 pool_dir_rel_path $POOL $POOL_DIR_NAME $POOL_ROOT \
10678                                                         || { rc=$? ; break; }
10679                 # former test_200e test_200f
10680                 local files=$((OSTCOUNT*3))
10681                 pool_alloc_files  $POOL $test_path $files "$ost_list" \
10682                                                         || { rc=$? ; break; }
10683                 pool_create_files $POOL $file_dir $files "$ost_list" \
10684                                                         || { rc=$? ; break; }
10685                 # former test_200g test_200h
10686                 pool_lfs_df $POOL                       || { rc=$? ; break; }
10687                 pool_file_rel_path $POOL $test_path     || { rc=$? ; break; }
10688
10689                 # former test_201a test_201b test_201c
10690                 pool_remove_first_target $POOL          || { rc=$? ; break; }
10691
10692                 local f=$test_path/$tfile
10693                 pool_remove_all_targets $POOL $f        || { rc=$? ; break; }
10694                 pool_remove $POOL $f                    || { rc=$? ; break; }
10695                 break
10696         done
10697
10698         cleanup_pools
10699         return $rc
10700 }
10701 run_test 200 "OST pools"
10702
10703 # usage: default_attr <count | size | offset>
10704 default_attr() {
10705         $LCTL get_param -n lov.$FSNAME-clilov-\*.stripe${1}
10706 }
10707
10708 # usage: check_default_stripe_attr
10709 check_default_stripe_attr() {
10710         ACTUAL=$($GETSTRIPE $* $DIR/$tdir)
10711         case $1 in
10712         --stripe-count|--count)
10713                 [ -n "$2" ] && EXPECTED=0 || EXPECTED=$(default_attr count);;
10714         --stripe-size|--size)
10715                 [ -n "$2" ] && EXPECTED=0 || EXPECTED=$(default_attr size);;
10716         --stripe-index|--index)
10717                 EXPECTED=-1;;
10718         *)
10719                 error "unknown getstripe attr '$1'"
10720         esac
10721
10722         [ $ACTUAL != $EXPECTED ] &&
10723                 error "$DIR/$tdir has $1 '$ACTUAL', not '$EXPECTED'"
10724 }
10725
10726 test_204a() {
10727         test_mkdir -p $DIR/$tdir
10728         $SETSTRIPE --stripe-count 0 --stripe-size 0 --stripe-index -1 $DIR/$tdir
10729
10730         check_default_stripe_attr --stripe-count
10731         check_default_stripe_attr --stripe-size
10732         check_default_stripe_attr --stripe-index
10733
10734         return 0
10735 }
10736 run_test 204a "Print default stripe attributes ================="
10737
10738 test_204b() {
10739         test_mkdir -p $DIR/$tdir
10740         $SETSTRIPE --stripe-count 1 $DIR/$tdir
10741
10742         check_default_stripe_attr --stripe-size
10743         check_default_stripe_attr --stripe-index
10744
10745         return 0
10746 }
10747 run_test 204b "Print default stripe size and offset  ==========="
10748
10749 test_204c() {
10750         test_mkdir -p $DIR/$tdir
10751         $SETSTRIPE --stripe-size 65536 $DIR/$tdir
10752
10753         check_default_stripe_attr --stripe-count
10754         check_default_stripe_attr --stripe-index
10755
10756         return 0
10757 }
10758 run_test 204c "Print default stripe count and offset ==========="
10759
10760 test_204d() {
10761         test_mkdir -p $DIR/$tdir
10762         $SETSTRIPE --stripe-index 0 $DIR/$tdir
10763
10764         check_default_stripe_attr --stripe-count
10765         check_default_stripe_attr --stripe-size
10766
10767         return 0
10768 }
10769 run_test 204d "Print default stripe count and size ============="
10770
10771 test_204e() {
10772         test_mkdir -p $DIR/$tdir
10773         $SETSTRIPE -d $DIR/$tdir
10774
10775         check_default_stripe_attr --stripe-count --raw
10776         check_default_stripe_attr --stripe-size --raw
10777         check_default_stripe_attr --stripe-index --raw
10778
10779         return 0
10780 }
10781 run_test 204e "Print raw stripe attributes ================="
10782
10783 test_204f() {
10784         test_mkdir -p $DIR/$tdir
10785         $SETSTRIPE --stripe-count 1 $DIR/$tdir
10786
10787         check_default_stripe_attr --stripe-size --raw
10788         check_default_stripe_attr --stripe-index --raw
10789
10790         return 0
10791 }
10792 run_test 204f "Print raw stripe size and offset  ==========="
10793
10794 test_204g() {
10795         test_mkdir -p $DIR/$tdir
10796         $SETSTRIPE --stripe-size 65536 $DIR/$tdir
10797
10798         check_default_stripe_attr --stripe-count --raw
10799         check_default_stripe_attr --stripe-index --raw
10800
10801         return 0
10802 }
10803 run_test 204g "Print raw stripe count and offset ==========="
10804
10805 test_204h() {
10806         test_mkdir -p $DIR/$tdir
10807         $SETSTRIPE --stripe-index 0 $DIR/$tdir
10808
10809         check_default_stripe_attr --stripe-count --raw
10810         check_default_stripe_attr --stripe-size --raw
10811
10812         return 0
10813 }
10814 run_test 204h "Print raw stripe count and size ============="
10815
10816 # Figure out which job scheduler is being used, if any,
10817 # or use a fake one
10818 if [ -n "$SLURM_JOB_ID" ]; then # SLURM
10819         JOBENV=SLURM_JOB_ID
10820 elif [ -n "$LSB_JOBID" ]; then # Load Sharing Facility
10821         JOBENV=LSB_JOBID
10822 elif [ -n "$PBS_JOBID" ]; then # PBS/Maui/Moab
10823         JOBENV=PBS_JOBID
10824 elif [ -n "$LOADL_STEPID" ]; then # LoadLeveller
10825         JOBENV=LOADL_STEP_ID
10826 elif [ -n "$JOB_ID" ]; then # Sun Grid Engine
10827         JOBENV=JOB_ID
10828 else
10829         JOBENV=FAKE_JOBID
10830 fi
10831
10832 verify_jobstats() {
10833         local cmd=$1
10834         local target=$2
10835
10836         # clear old jobstats
10837         do_facet $SINGLEMDS lctl set_param mdt.*.job_stats="clear"
10838         do_facet ost1 lctl set_param obdfilter.*.job_stats="clear"
10839
10840         # use a new JobID for this test, or we might see an old one
10841         [ "$JOBENV" = "FAKE_JOBID" ] && FAKE_JOBID=test_id.$testnum.$RANDOM
10842
10843         JOBVAL=${!JOBENV}
10844         log "Test: $cmd"
10845         log "Using JobID environment variable $JOBENV=$JOBVAL"
10846
10847         if [ $JOBENV = "FAKE_JOBID" ]; then
10848                 FAKE_JOBID=$JOBVAL $cmd
10849         else
10850                 $cmd
10851         fi
10852
10853         if [ "$target" = "mdt" -o "$target" = "both" ]; then
10854                 FACET="$SINGLEMDS" # will need to get MDS number for DNE
10855                 do_facet $FACET lctl get_param mdt.*.job_stats |
10856                         grep $JOBVAL || error "No job stats found on MDT $FACET"
10857         fi
10858         if [ "$target" = "ost" -o "$target" = "both" ]; then
10859                 FACET=ost1
10860                 do_facet $FACET lctl get_param obdfilter.*.job_stats |
10861                         grep $JOBVAL || error "No job stats found on OST $FACET"
10862         fi
10863 }
10864
10865 jobstats_set() {
10866         trap 0
10867         NEW_JOBENV=${1:-$OLD_JOBENV}
10868         do_facet mgs $LCTL conf_param $FSNAME.sys.jobid_var=$NEW_JOBENV
10869         wait_update $HOSTNAME "$LCTL get_param -n jobid_var" $NEW_JOBENV
10870 }
10871
10872 test_205() { # Job stats
10873         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10874         [ -z "$(lctl get_param -n mdc.*.connect_flags | grep jobstats)" ] &&
10875                 skip "Server doesn't support jobstats" && return 0
10876
10877         local cmd
10878         OLD_JOBENV=`$LCTL get_param -n jobid_var`
10879         if [ $OLD_JOBENV != $JOBENV ]; then
10880                 jobstats_set $JOBENV
10881                 trap jobstats_set EXIT
10882         fi
10883
10884         # mkdir
10885         cmd="mkdir $DIR/$tfile"
10886         verify_jobstats "$cmd" "mdt"
10887         # rmdir
10888         cmd="rm -fr $DIR/$tfile"
10889         verify_jobstats "$cmd" "mdt"
10890         # mknod
10891         cmd="mknod $DIR/$tfile c 1 3"
10892         verify_jobstats "$cmd" "mdt"
10893         # unlink
10894         cmd="rm -f $DIR/$tfile"
10895         verify_jobstats "$cmd" "mdt"
10896         # open & close
10897         cmd="$SETSTRIPE -i 0 -c 1 $DIR/$tfile"
10898         verify_jobstats "$cmd" "mdt"
10899         # setattr
10900         cmd="touch $DIR/$tfile"
10901         verify_jobstats "$cmd" "both"
10902         # write
10903         cmd="dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 oflag=sync"
10904         verify_jobstats "$cmd" "ost"
10905         # read
10906         cmd="dd if=$DIR/$tfile of=/dev/null bs=1M count=1 iflag=direct"
10907         verify_jobstats "$cmd" "ost"
10908         # truncate
10909         cmd="$TRUNCATE $DIR/$tfile 0"
10910         verify_jobstats "$cmd" "both"
10911         # rename
10912         cmd="mv -f $DIR/$tfile $DIR/jobstats_test_rename"
10913         verify_jobstats "$cmd" "mdt"
10914
10915         # cleanup
10916         rm -f $DIR/jobstats_test_rename
10917
10918         [ $OLD_JOBENV != $JOBENV ] && jobstats_set $OLD_JOBENV
10919 }
10920 run_test 205 "Verify job stats"
10921
10922 # LU-1480, LU-1773 and LU-1657
10923 test_206() {
10924         mkdir -p $DIR/$tdir
10925         lfs setstripe -c -1 $DIR/$tdir
10926 #define OBD_FAIL_LOV_INIT 0x1403
10927         $LCTL set_param fail_loc=0xa0001403
10928         $LCTL set_param fail_val=1
10929         touch $DIR/$tdir/$tfile || true
10930 }
10931 run_test 206 "fail lov_init_raid0() doesn't lbug"
10932
10933 test_207a() {
10934         dd if=/dev/zero of=$DIR/$tfile bs=4k count=$((RANDOM%10+1))
10935         local fsz=`stat -c %s $DIR/$tfile`
10936         cancel_lru_locks mdc
10937
10938         # do not return layout in getattr intent
10939 #define OBD_FAIL_MDS_NO_LL_GETATTR 0x170
10940         $LCTL set_param fail_loc=0x170
10941         local sz=`stat -c %s $DIR/$tfile`
10942
10943         [ $fsz -eq $sz ] || error "file size expected $fsz, actual $sz"
10944
10945         rm -rf $DIR/$tfile
10946 }
10947 run_test 207a "can refresh layout at glimpse"
10948
10949 test_207b() {
10950         dd if=/dev/zero of=$DIR/$tfile bs=4k count=$((RANDOM%10+1))
10951         local cksum=`md5sum $DIR/$tfile`
10952         local fsz=`stat -c %s $DIR/$tfile`
10953         cancel_lru_locks mdc
10954         cancel_lru_locks osc
10955
10956         # do not return layout in getattr intent
10957 #define OBD_FAIL_MDS_NO_LL_OPEN 0x171
10958         $LCTL set_param fail_loc=0x171
10959
10960         # it will refresh layout after the file is opened but before read issues
10961         echo checksum is "$cksum"
10962         echo "$cksum" |md5sum -c --quiet || error "file differs"
10963
10964         rm -rf $DIR/$tfile
10965 }
10966 run_test 207b "can refresh layout at open"
10967
10968 test_208() {
10969         # FIXME: in this test suite, only RD lease is used. This is okay
10970         # for now as only exclusive open is supported. After generic lease
10971         # is done, this test suite should be revised. - Jinshan
10972
10973         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.4.52) ]] ||
10974                 { skip "Need MDS version at least 2.4.52"; return 0; }
10975
10976         echo "==== test 1: verify get lease work"
10977         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:eRE+eU || error "get lease error"
10978
10979         echo "==== test 2: verify lease can be broken by upcoming open"
10980         $MULTIOP $DIR/$tfile oO_RDONLY:eR_E-eUc &
10981         local PID=$!
10982         sleep 1
10983
10984         $MULTIOP $DIR/$tfile oO_RDONLY:c
10985         kill -USR1 $PID && wait $PID || error "break lease error"
10986
10987         echo "==== test 3: verify lease can't be granted if an open already exists"
10988         $MULTIOP $DIR/$tfile oO_RDONLY:_c &
10989         local PID=$!
10990         sleep 1
10991
10992         $MULTIOP $DIR/$tfile oO_RDONLY:eReUc && error "apply lease should fail"
10993         kill -USR1 $PID && wait $PID || error "open file error"
10994
10995         echo "==== test 4: lease can sustain over recovery"
10996         $MULTIOP $DIR/$tfile oO_RDONLY:eR_E+eUc &
10997         PID=$!
10998         sleep 1
10999
11000         fail mds1
11001
11002         kill -USR1 $PID && wait $PID || error "lease broken over recovery"
11003
11004         echo "==== test 5: lease broken can't be regained by replay"
11005         $MULTIOP $DIR/$tfile oO_RDONLY:eR_E-eUc &
11006         PID=$!
11007         sleep 1
11008
11009         # open file to break lease and then recovery
11010         $MULTIOP $DIR/$tfile oO_RDWR:c || error "open file error"
11011         fail mds1
11012
11013         kill -USR1 $PID && wait $PID || error "lease not broken over recovery"
11014
11015         rm -f $DIR/$tfile
11016 }
11017 run_test 208 "Exclusive open"
11018
11019 test_209() {
11020         [ -z "$(lctl get_param -n mdc.*.connect_flags | grep disp_stripe)" ] &&
11021                 skip_env "must have disp_stripe" && return
11022
11023         touch $DIR/$tfile
11024         sync; sleep 5; sync;
11025
11026         echo 3 > /proc/sys/vm/drop_caches
11027         req_before=$(awk '/ptlrpc_cache / { print $2 }' /proc/slabinfo)
11028
11029         # open/close 500 times
11030         for i in $(seq 500); do
11031                 cat $DIR/$tfile
11032         done
11033
11034         echo 3 > /proc/sys/vm/drop_caches
11035         req_after=$(awk '/ptlrpc_cache / { print $2 }' /proc/slabinfo)
11036
11037         echo "before: $req_before, after: $req_after"
11038         [ $((req_after - req_before)) -ge 300 ] &&
11039                 error "open/close requests are not freed"
11040         return 0
11041 }
11042 run_test 209 "read-only open/close requests should be freed promptly"
11043
11044 test_212() {
11045         size=`date +%s`
11046         size=$((size % 8192 + 1))
11047         dd if=/dev/urandom of=$DIR/f212 bs=1k count=$size
11048         sendfile $DIR/f212 $DIR/f212.xyz || error "sendfile wrong"
11049         rm -f $DIR/f212 $DIR/f212.xyz
11050 }
11051 run_test 212 "Sendfile test ============================================"
11052
11053 test_213() {
11054         dd if=/dev/zero of=$DIR/$tfile bs=4k count=4
11055         cancel_lru_locks osc
11056         lctl set_param fail_loc=0x8000040f
11057         # generate a read lock
11058         cat $DIR/$tfile > /dev/null
11059         # write to the file, it will try to cancel the above read lock.
11060         cat /etc/hosts >> $DIR/$tfile
11061 }
11062 run_test 213 "OSC lock completion and cancel race don't crash - bug 18829"
11063
11064 test_214() { # for bug 20133
11065         mkdir -p $DIR/$tdir/d214c || error "mkdir $DIR/$tdir/d214c failed"
11066         for (( i=0; i < 340; i++ )) ; do
11067                 touch $DIR/$tdir/d214c/a$i
11068         done
11069
11070         ls -l $DIR/$tdir || error "ls -l $DIR/d214p failed"
11071         mv $DIR/$tdir/d214c $DIR/ || error "mv $DIR/d214p/d214c $DIR/ failed"
11072         ls $DIR/d214c || error "ls $DIR/d214c failed"
11073         rm -rf $DIR/$tdir || error "rm -rf $DIR/d214* failed"
11074         rm -rf $DIR/d214* || error "rm -rf $DIR/d214* failed"
11075 }
11076 run_test 214 "hash-indexed directory test - bug 20133"
11077
11078 # having "abc" as 1st arg, creates $TMP/lnet_abc.out and $TMP/lnet_abc.sys
11079 create_lnet_proc_files() {
11080         cat /proc/sys/lnet/$1 >$TMP/lnet_$1.out || error "cannot read /proc/sys/lnet/$1"
11081         sysctl lnet.$1 >$TMP/lnet_$1.sys_tmp || error "cannot read lnet.$1"
11082
11083         sed "s/^lnet.$1\ =\ //g" "$TMP/lnet_$1.sys_tmp" >$TMP/lnet_$1.sys
11084         rm -f "$TMP/lnet_$1.sys_tmp"
11085 }
11086
11087 # counterpart of create_lnet_proc_files
11088 remove_lnet_proc_files() {
11089         rm -f $TMP/lnet_$1.out $TMP/lnet_$1.sys
11090 }
11091
11092 # uses 1st arg as trailing part of filename, 2nd arg as description for reports,
11093 # 3rd arg as regexp for body
11094 check_lnet_proc_stats() {
11095         local l=$(cat "$TMP/lnet_$1" |wc -l)
11096         [ $l = 1 ] || (cat "$TMP/lnet_$1" && error "$2 is not of 1 line: $l")
11097
11098         grep -E "$3" "$TMP/lnet_$1" || (cat "$TMP/lnet_$1" && error "$2 misformatted")
11099 }
11100
11101 # uses 1st arg as trailing part of filename, 2nd arg as description for reports,
11102 # 3rd arg as regexp for body, 4th arg as regexp for 1st line, 5th arg is
11103 # optional and can be regexp for 2nd line (lnet.routes case)
11104 check_lnet_proc_entry() {
11105         local blp=2            # blp stands for 'position of 1st line of body'
11106         [ "$5" = "" ] || blp=3 # lnet.routes case
11107
11108         local l=$(cat "$TMP/lnet_$1" |wc -l)
11109         # subtracting one from $blp because the body can be empty
11110         [ "$l" -ge "$(($blp - 1))" ] || (cat "$TMP/lnet_$1" && error "$2 is too short: $l")
11111
11112         sed -n '1 p' "$TMP/lnet_$1" |grep -E "$4" >/dev/null ||
11113                 (cat "$TMP/lnet_$1" && error "1st line of $2 misformatted")
11114
11115         [ "$5" = "" ] || sed -n '2 p' "$TMP/lnet_$1" |grep -E "$5" >/dev/null ||
11116                 (cat "$TMP/lnet_$1" && error "2nd line of $2 misformatted")
11117
11118         # bail out if any unexpected line happened
11119         sed -n "$blp~1 p" "$TMP/lnet_$1" |grep -Ev "$3"
11120         [ "$?" != 0 ] || error "$2 misformatted"
11121 }
11122
11123 test_215() { # for bugs 18102, 21079, 21517
11124         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11125         local N='(0|[1-9][0-9]*)'       # non-negative numeric
11126         local P='[1-9][0-9]*'           # positive numeric
11127         local I='(0|-?[1-9][0-9]*|NA)'  # any numeric (0 | >0 | <0) or NA if no value
11128         local NET='[a-z][a-z0-9]*'      # LNET net like o2ib2
11129         local ADDR='[0-9.]+'            # LNET addr like 10.0.0.1
11130         local NID="$ADDR@$NET"          # LNET nid like 10.0.0.1@o2ib2
11131
11132         local L1 # regexp for 1st line
11133         local L2 # regexp for 2nd line (optional)
11134         local BR # regexp for the rest (body)
11135
11136         # /proc/sys/lnet/stats should look as 11 space-separated non-negative numerics
11137         BR="^$N $N $N $N $N $N $N $N $N $N $N$"
11138         create_lnet_proc_files "stats"
11139         check_lnet_proc_stats "stats.out" "/proc/sys/lnet/stats" "$BR"
11140         check_lnet_proc_stats "stats.sys" "lnet.stats" "$BR"
11141         remove_lnet_proc_files "stats"
11142
11143         # /proc/sys/lnet/routes should look like this:
11144         # Routing disabled/enabled
11145         # net hops priority state router
11146         # where net is a string like tcp0, hops > 0, priority >= 0,
11147         # state is up/down,
11148         # router is a string like 192.168.1.1@tcp2
11149         L1="^Routing (disabled|enabled)$"
11150         L2="^net +hops +priority +state +router$"
11151         BR="^$NET +$N +(0|1) +(up|down) +$NID$"
11152         create_lnet_proc_files "routes"
11153         check_lnet_proc_entry "routes.out" "/proc/sys/lnet/routes" "$BR" "$L1" "$L2"
11154         check_lnet_proc_entry "routes.sys" "lnet.routes" "$BR" "$L1" "$L2"
11155         remove_lnet_proc_files "routes"
11156
11157         # /proc/sys/lnet/routers should look like this:
11158         # ref rtr_ref alive_cnt state last_ping ping_sent deadline down_ni router
11159         # where ref > 0, rtr_ref > 0, alive_cnt >= 0, state is up/down,
11160         # last_ping >= 0, ping_sent is boolean (0/1), deadline and down_ni are
11161         # numeric (0 or >0 or <0), router is a string like 192.168.1.1@tcp2
11162         L1="^ref +rtr_ref +alive_cnt +state +last_ping +ping_sent +deadline +down_ni +router$"
11163         BR="^$P +$P +$N +(up|down) +$N +(0|1) +$I +$I +$NID$"
11164         create_lnet_proc_files "routers"
11165         check_lnet_proc_entry "routers.out" "/proc/sys/lnet/routers" "$BR" "$L1"
11166         check_lnet_proc_entry "routers.sys" "lnet.routers" "$BR" "$L1"
11167         remove_lnet_proc_files "routers"
11168
11169         # /proc/sys/lnet/peers should look like this:
11170         # nid refs state last max rtr min tx min queue
11171         # where nid is a string like 192.168.1.1@tcp2, refs > 0,
11172         # state is up/down/NA, max >= 0. last, rtr, min, tx, min are
11173         # numeric (0 or >0 or <0), queue >= 0.
11174         L1="^nid +refs +state +last +max +rtr +min +tx +min +queue$"
11175         BR="^$NID +$P +(up|down|NA) +$I +$N +$I +$I +$I +$I +$N$"
11176         create_lnet_proc_files "peers"
11177         check_lnet_proc_entry "peers.out" "/proc/sys/lnet/peers" "$BR" "$L1"
11178         check_lnet_proc_entry "peers.sys" "lnet.peers" "$BR" "$L1"
11179         remove_lnet_proc_files "peers"
11180
11181         # /proc/sys/lnet/buffers  should look like this:
11182         # pages count credits min
11183         # where pages >=0, count >=0, credits and min are numeric (0 or >0 or <0)
11184         L1="^pages +count +credits +min$"
11185         BR="^ +$N +$N +$I +$I$"
11186         create_lnet_proc_files "buffers"
11187         check_lnet_proc_entry "buffers.out" "/proc/sys/lnet/buffers" "$BR" "$L1"
11188         check_lnet_proc_entry "buffers.sys" "lnet.buffers" "$BR" "$L1"
11189         remove_lnet_proc_files "buffers"
11190
11191         # /proc/sys/lnet/nis should look like this:
11192         # nid status alive refs peer rtr max tx min
11193         # where nid is a string like 192.168.1.1@tcp2, status is up/down,
11194         # alive is numeric (0 or >0 or <0), refs >= 0, peer >= 0,
11195         # rtr >= 0, max >=0, tx and min are numeric (0 or >0 or <0).
11196         L1="^nid +status +alive +refs +peer +rtr +max +tx +min$"
11197         BR="^$NID +(up|down) +$I +$N +$N +$N +$N +$I +$I$"
11198         create_lnet_proc_files "nis"
11199         check_lnet_proc_entry "nis.out" "/proc/sys/lnet/nis" "$BR" "$L1"
11200         check_lnet_proc_entry "nis.sys" "lnet.nis" "$BR" "$L1"
11201         remove_lnet_proc_files "nis"
11202
11203         # can we successfully write to /proc/sys/lnet/stats?
11204         echo "0" >/proc/sys/lnet/stats || error "cannot write to /proc/sys/lnet/stats"
11205         sysctl -w lnet.stats=0 || error "cannot write to lnet.stats"
11206 }
11207 run_test 215 "/proc/sys/lnet exists and has proper content - bugs 18102, 21079, 21517"
11208
11209 test_216() { # bug 20317
11210         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11211         remote_ost_nodsh && skip "remote OST with nodsh" && return
11212
11213         local node
11214         local facets=$(get_facets OST)
11215         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
11216
11217         save_lustre_params client "osc.*.contention_seconds" > $p
11218         save_lustre_params $facets \
11219                 "ldlm.namespaces.filter-*.max_nolock_bytes" >> $p
11220         save_lustre_params $facets \
11221                 "ldlm.namespaces.filter-*.contended_locks" >> $p
11222         save_lustre_params $facets \
11223                 "ldlm.namespaces.filter-*.contention_seconds" >> $p
11224         clear_osc_stats
11225
11226         # agressive lockless i/o settings
11227         for node in $(osts_nodes); do
11228                 do_node $node 'lctl set_param -n ldlm.namespaces.filter-*.max_nolock_bytes 2000000; lctl set_param -n ldlm.namespaces.filter-*.contended_locks 0; lctl set_param -n ldlm.namespaces.filter-*.contention_seconds 60'
11229         done
11230         lctl set_param -n osc.*.contention_seconds 60
11231
11232         $DIRECTIO write $DIR/$tfile 0 10 4096
11233         $CHECKSTAT -s 40960 $DIR/$tfile
11234
11235         # disable lockless i/o
11236         for node in $(osts_nodes); do
11237                 do_node $node 'lctl set_param -n ldlm.namespaces.filter-*.max_nolock_bytes 0; lctl set_param -n ldlm.namespaces.filter-*.contended_locks 32; lctl set_param -n ldlm.namespaces.filter-*.contention_seconds 0'
11238         done
11239         lctl set_param -n osc.*.contention_seconds 0
11240         clear_osc_stats
11241
11242         dd if=/dev/zero of=$DIR/$tfile count=0
11243         $CHECKSTAT -s 0 $DIR/$tfile
11244
11245         restore_lustre_params <$p
11246         rm -f $p
11247         rm $DIR/$tfile
11248 }
11249 run_test 216 "check lockless direct write works and updates file size and kms correctly"
11250
11251 test_217() { # bug 22430
11252         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11253         local node
11254         local nid
11255
11256         for node in $(nodes_list); do
11257                 nid=$(host_nids_address $node $NETTYPE)
11258                 if [[ $nid = *-* ]] ; then
11259                         echo "lctl ping $nid@$NETTYPE"
11260                         lctl ping $nid@$NETTYPE
11261                 else
11262                         echo "skipping $node (no hyphen detected)"
11263                 fi
11264         done
11265 }
11266 run_test 217 "check lctl ping for hostnames with hiphen ('-')"
11267
11268 test_218() {
11269        # do directio so as not to populate the page cache
11270        log "creating a 10 Mb file"
11271        $MULTIOP $DIR/$tfile oO_CREAT:O_DIRECT:O_RDWR:w$((10*1048576))c || error "multiop failed while creating a file"
11272        log "starting reads"
11273        dd if=$DIR/$tfile of=/dev/null bs=4096 &
11274        log "truncating the file"
11275        $MULTIOP $DIR/$tfile oO_TRUNC:c || error "multiop failed while truncating the file"
11276        log "killing dd"
11277        kill %+ || true # reads might have finished
11278        echo "wait until dd is finished"
11279        wait
11280        log "removing the temporary file"
11281        rm -rf $DIR/$tfile || error "tmp file removal failed"
11282 }
11283 run_test 218 "parallel read and truncate should not deadlock ======================="
11284
11285 test_219() {
11286         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11287         # write one partial page
11288         dd if=/dev/zero of=$DIR/$tfile bs=1024 count=1
11289         # set no grant so vvp_io_commit_write will do sync write
11290         $LCTL set_param fail_loc=0x411
11291         # write a full page at the end of file
11292         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 seek=1 conv=notrunc
11293
11294         $LCTL set_param fail_loc=0
11295         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 seek=3
11296         $LCTL set_param fail_loc=0x411
11297         dd if=/dev/zero of=$DIR/$tfile bs=1024 count=1 seek=2 conv=notrunc
11298
11299         # LU-4201
11300         dd if=/dev/zero of=$DIR/$tfile-2 bs=1024 count=1
11301         $CHECKSTAT -s 1024 $DIR/$tfile-2 || error "checkstat wrong size"
11302 }
11303 run_test 219 "LU-394: Write partial won't cause uncontiguous pages vec at LND"
11304
11305 test_220() { #LU-325
11306         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11307         remote_ost_nodsh && skip "remote OST with nodsh" && return
11308         local OSTIDX=0
11309
11310         test_mkdir -p $DIR/$tdir
11311         local OST=$(lfs osts | grep ${OSTIDX}": " | \
11312                 awk '{print $2}' | sed -e 's/_UUID$//')
11313
11314         # on the mdt's osc
11315         local mdtosc_proc1=$(get_mdtosc_proc_path $SINGLEMDS $OST)
11316         local last_id=$(do_facet $SINGLEMDS lctl get_param -n \
11317                         osc.$mdtosc_proc1.prealloc_last_id)
11318         local next_id=$(do_facet $SINGLEMDS lctl get_param -n \
11319                         osc.$mdtosc_proc1.prealloc_next_id)
11320
11321         $LFS df -i
11322
11323         do_facet ost$((OSTIDX + 1)) lctl set_param fail_val=-1
11324         #define OBD_FAIL_OST_ENOINO              0x229
11325         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=0x229
11326         do_facet mgs $LCTL pool_new $FSNAME.$TESTNAME || return 1
11327         do_facet mgs $LCTL pool_add $FSNAME.$TESTNAME $OST || return 2
11328
11329         $SETSTRIPE $DIR/$tdir -i $OSTIDX -c 1 -p $FSNAME.$TESTNAME
11330
11331         MDSOBJS=$((last_id - next_id))
11332         echo "preallocated objects on MDS is $MDSOBJS" "($last_id - $next_id)"
11333
11334         blocks=$($LFS df $MOUNT | awk '($1 == '$OSTIDX') { print $4 }')
11335         echo "OST still has $count kbytes free"
11336
11337         echo "create $MDSOBJS files @next_id..."
11338         createmany -o $DIR/$tdir/f $MDSOBJS || return 3
11339
11340         local last_id2=$(do_facet mds${MDSIDX} lctl get_param -n \
11341                         osc.$mdtosc_proc1.prealloc_last_id)
11342         local next_id2=$(do_facet mds${MDSIDX} lctl get_param -n \
11343                         osc.$mdtosc_proc1.prealloc_next_id)
11344
11345         echo "after creation, last_id=$last_id2, next_id=$next_id2"
11346         $LFS df -i
11347
11348         echo "cleanup..."
11349
11350         do_facet ost$((OSTIDX + 1)) lctl set_param fail_val=0
11351         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=0
11352
11353         do_facet mgs $LCTL pool_remove $FSNAME.$TESTNAME $OST || return 4
11354         do_facet mgs $LCTL pool_destroy $FSNAME.$TESTNAME || return 5
11355         echo "unlink $MDSOBJS files @$next_id..."
11356         unlinkmany $DIR/$tdir/f $MDSOBJS || return 6
11357 }
11358 run_test 220 "preallocated MDS objects still used if ENOSPC from OST"
11359
11360 test_221() {
11361         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11362         dd if=`which date` of=$MOUNT/date oflag=sync
11363         chmod +x $MOUNT/date
11364
11365         #define OBD_FAIL_LLITE_FAULT_TRUNC_RACE  0x1401
11366         $LCTL set_param fail_loc=0x80001401
11367
11368         $MOUNT/date > /dev/null
11369         rm -f $MOUNT/date
11370 }
11371 run_test 221 "make sure fault and truncate race to not cause OOM"
11372
11373 test_222a () {
11374         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11375        rm -rf $DIR/$tdir
11376        test_mkdir -p $DIR/$tdir
11377        $SETSTRIPE -c 1 -i 0 $DIR/$tdir
11378        createmany -o $DIR/$tdir/$tfile 10
11379        cancel_lru_locks mdc
11380        cancel_lru_locks osc
11381        #define OBD_FAIL_LDLM_AGL_DELAY           0x31a
11382        $LCTL set_param fail_loc=0x31a
11383        ls -l $DIR/$tdir > /dev/null || error "AGL for ls failed"
11384        $LCTL set_param fail_loc=0
11385        rm -r $DIR/$tdir
11386 }
11387 run_test 222a "AGL for ls should not trigger CLIO lock failure ================"
11388
11389 test_222b () {
11390         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11391        rm -rf $DIR/$tdir
11392        test_mkdir -p $DIR/$tdir
11393        $SETSTRIPE -c 1 -i 0 $DIR/$tdir
11394        createmany -o $DIR/$tdir/$tfile 10
11395        cancel_lru_locks mdc
11396        cancel_lru_locks osc
11397        #define OBD_FAIL_LDLM_AGL_DELAY           0x31a
11398        $LCTL set_param fail_loc=0x31a
11399        rm -r $DIR/$tdir || "AGL for rmdir failed"
11400        $LCTL set_param fail_loc=0
11401 }
11402 run_test 222b "AGL for rmdir should not trigger CLIO lock failure ============="
11403
11404 test_223 () {
11405         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11406        rm -rf $DIR/$tdir
11407        test_mkdir -p $DIR/$tdir
11408        $SETSTRIPE -c 1 -i 0 $DIR/$tdir
11409        createmany -o $DIR/$tdir/$tfile 10
11410        cancel_lru_locks mdc
11411        cancel_lru_locks osc
11412        #define OBD_FAIL_LDLM_AGL_NOLOCK          0x31b
11413        $LCTL set_param fail_loc=0x31b
11414        ls -l $DIR/$tdir > /dev/null || error "reenqueue failed"
11415        $LCTL set_param fail_loc=0
11416        rm -r $DIR/$tdir
11417 }
11418 run_test 223 "osc reenqueue if without AGL lock granted ======================="
11419
11420 test_224a() { # LU-1039, MRP-303
11421         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11422         #define OBD_FAIL_PTLRPC_CLIENT_BULK_CB   0x508
11423         $LCTL set_param fail_loc=0x508
11424         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 conv=fsync
11425         $LCTL set_param fail_loc=0
11426         df $DIR
11427 }
11428 run_test 224a "Don't panic on bulk IO failure"
11429
11430 test_224b() { # LU-1039, MRP-303
11431         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11432         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1
11433         cancel_lru_locks osc
11434         #define OBD_FAIL_PTLRPC_CLIENT_BULK_CB2   0x515
11435         $LCTL set_param fail_loc=0x515
11436         dd of=/dev/null if=$DIR/$tfile bs=4096 count=1
11437         $LCTL set_param fail_loc=0
11438         df $DIR
11439 }
11440 run_test 224b "Don't panic on bulk IO failure"
11441
11442 MDSSURVEY=${MDSSURVEY:-$(which mds-survey 2>/dev/null || true)}
11443 test_225a () {
11444         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11445         if [ -z ${MDSSURVEY} ]; then
11446               skip_env "mds-survey not found" && return
11447         fi
11448
11449         [ $MDSCOUNT -ge 2 ] &&
11450                 skip "skipping now for more than one MDT" && return
11451
11452        [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.51) ] ||
11453             { skip "Need MDS version at least 2.2.51"; return; }
11454
11455        local mds=$(facet_host $SINGLEMDS)
11456        local target=$(do_nodes $mds 'lctl dl' | \
11457                       awk "{if (\$2 == \"UP\" && \$3 == \"mdt\") {print \$4}}")
11458
11459        local cmd1="file_count=1000 thrhi=4"
11460        local cmd2="dir_count=2 layer=mdd stripe_count=0"
11461        local cmd3="rslt_loc=${TMP} targets=\"$mds:$target\" $MDSSURVEY"
11462        local cmd="$cmd1 $cmd2 $cmd3"
11463
11464        rm -f ${TMP}/mds_survey*
11465        echo + $cmd
11466        eval $cmd || error "mds-survey with zero-stripe failed"
11467        cat ${TMP}/mds_survey*
11468        rm -f ${TMP}/mds_survey*
11469 }
11470 run_test 225a "Metadata survey sanity with zero-stripe"
11471
11472 test_225b () {
11473         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11474
11475         if [ -z ${MDSSURVEY} ]; then
11476               skip_env "mds-survey not found" && return
11477         fi
11478         [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.51) ] ||
11479             { skip "Need MDS version at least 2.2.51"; return; }
11480
11481         if [ $($LCTL dl | grep -c osc) -eq 0 ]; then
11482               skip_env "Need to mount OST to test" && return
11483         fi
11484
11485         [ $MDSCOUNT -ge 2 ] &&
11486                 skip "skipping now for more than one MDT" && return
11487        local mds=$(facet_host $SINGLEMDS)
11488        local target=$(do_nodes $mds 'lctl dl' | \
11489                       awk "{if (\$2 == \"UP\" && \$3 == \"mdt\") {print \$4}}")
11490
11491        local cmd1="file_count=1000 thrhi=4"
11492        local cmd2="dir_count=2 layer=mdd stripe_count=1"
11493        local cmd3="rslt_loc=${TMP} targets=\"$mds:$target\" $MDSSURVEY"
11494        local cmd="$cmd1 $cmd2 $cmd3"
11495
11496        rm -f ${TMP}/mds_survey*
11497        echo + $cmd
11498        eval $cmd || error "mds-survey with stripe_count failed"
11499        cat ${TMP}/mds_survey*
11500        rm -f ${TMP}/mds_survey*
11501 }
11502 run_test 225b "Metadata survey sanity with stripe_count = 1"
11503
11504 mcreate_path2fid () {
11505         local mode=$1
11506         local major=$2
11507         local minor=$3
11508         local name=$4
11509         local desc=$5
11510         local path=$DIR/$tdir/$name
11511         local fid
11512         local rc
11513         local fid_path
11514
11515         $MCREATE --mode=$1 --major=$2 --minor=$3 $path ||
11516                 error "cannot create $desc"
11517
11518         fid=$($LFS path2fid $path | tr -d '[' | tr -d ']')
11519         rc=$?
11520         [ $rc -ne 0 ] && error "cannot get fid of a $desc"
11521
11522         fid_path=$($LFS fid2path $MOUNT $fid)
11523         rc=$?
11524         [ $rc -ne 0 ] && error "cannot get path of $desc by $DIR $path $fid"
11525
11526         [ "$path" == "$fid_path" ] ||
11527                 error "fid2path returned $fid_path, expected $path"
11528
11529         echo "pass with $path and $fid"
11530 }
11531
11532 test_226a () {
11533         rm -rf $DIR/$tdir
11534         mkdir -p $DIR/$tdir
11535
11536         mcreate_path2fid 0010666 0 0 fifo "FIFO"
11537         mcreate_path2fid 0020666 1 3 null "character special file (null)"
11538         mcreate_path2fid 0020666 1 255 none "character special file (no device)"
11539         mcreate_path2fid 0040666 0 0 dir "directory"
11540         mcreate_path2fid 0060666 7 0 loop0 "block special file (loop)"
11541         mcreate_path2fid 0100666 0 0 file "regular file"
11542         mcreate_path2fid 0120666 0 0 link "symbolic link"
11543         mcreate_path2fid 0140666 0 0 sock "socket"
11544 }
11545 run_test 226a "call path2fid and fid2path on files of all type"
11546
11547 test_226b () {
11548         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
11549         rm -rf $DIR/$tdir
11550         local MDTIDX=1
11551
11552         mkdir -p $DIR/$tdir
11553         $LFS setdirstripe -i $MDTIDX $DIR/$tdir/remote_dir ||
11554                 error "create remote directory failed"
11555         mcreate_path2fid 0010666 0 0 "remote_dir/fifo" "FIFO"
11556         mcreate_path2fid 0020666 1 3 "remote_dir/null" \
11557                                 "character special file (null)"
11558         mcreate_path2fid 0020666 1 255 "remote_dir/none" \
11559                                 "character special file (no device)"
11560         mcreate_path2fid 0040666 0 0 "remote_dir/dir" "directory"
11561         mcreate_path2fid 0060666 7 0 "remote_dir/loop0" \
11562                                 "block special file (loop)"
11563         mcreate_path2fid 0100666 0 0 "remote_dir/file" "regular file"
11564         mcreate_path2fid 0120666 0 0 "remote_dir/link" "symbolic link"
11565         mcreate_path2fid 0140666 0 0 "remote_dir/sock" "socket"
11566 }
11567 run_test 226b "call path2fid and fid2path on files of all type under remote dir"
11568
11569 # LU-1299 Executing or running ldd on a truncated executable does not
11570 # cause an out-of-memory condition.
11571 test_227() {
11572         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11573         dd if=`which date` of=$MOUNT/date bs=1k count=1
11574         chmod +x $MOUNT/date
11575
11576         $MOUNT/date > /dev/null
11577         ldd $MOUNT/date > /dev/null
11578         rm -f $MOUNT/date
11579 }
11580 run_test 227 "running truncated executable does not cause OOM"
11581
11582 # LU-1512 try to reuse idle OI blocks
11583 test_228a() {
11584         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11585         [ "$(facet_fstype $SINGLEMDS)" != "ldiskfs" ] &&
11586                 skip "non-ldiskfs backend" && return
11587
11588         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
11589         local myDIR=$DIR/$tdir
11590
11591         mkdir -p $myDIR
11592         #define OBD_FAIL_SEQ_EXHAUST             0x1002
11593         $LCTL set_param fail_loc=0x80001002
11594         createmany -o $myDIR/t- 10000
11595         $LCTL set_param fail_loc=0
11596         # The guard is current the largest FID holder
11597         touch $myDIR/guard
11598         local SEQ=$($LFS path2fid $myDIR/guard | awk -F ':' '{print $1}' |
11599                     tr -d '[')
11600         local IDX=$(($SEQ % 64))
11601
11602         do_facet $SINGLEMDS sync
11603         # Make sure journal flushed.
11604         sleep 6
11605         local blk1=$(do_facet $SINGLEMDS \
11606                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
11607                      grep Blockcount | awk '{print $4}')
11608
11609         # Remove old files, some OI blocks will become idle.
11610         unlinkmany $myDIR/t- 10000
11611         # Create new files, idle OI blocks should be reused.
11612         createmany -o $myDIR/t- 2000
11613         do_facet $SINGLEMDS sync
11614         # Make sure journal flushed.
11615         sleep 6
11616         local blk2=$(do_facet $SINGLEMDS \
11617                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
11618                      grep Blockcount | awk '{print $4}')
11619
11620         [ $blk1 == $blk2 ] || error "old blk1=$blk1, new blk2=$blk2, unmatched!"
11621 }
11622 run_test 228a "try to reuse idle OI blocks"
11623
11624 test_228b() {
11625         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11626         [ "$(facet_fstype $SINGLEMDS)" != "ldiskfs" ] &&
11627                 skip "non-ldiskfs backend" && return
11628
11629         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
11630         local myDIR=$DIR/$tdir
11631
11632         mkdir -p $myDIR
11633         #define OBD_FAIL_SEQ_EXHAUST             0x1002
11634         $LCTL set_param fail_loc=0x80001002
11635         createmany -o $myDIR/t- 10000
11636         $LCTL set_param fail_loc=0
11637         # The guard is current the largest FID holder
11638         touch $myDIR/guard
11639         local SEQ=$($LFS path2fid $myDIR/guard | awk -F ':' '{print $1}' |
11640                     tr -d '[')
11641         local IDX=$(($SEQ % 64))
11642
11643         do_facet $SINGLEMDS sync
11644         # Make sure journal flushed.
11645         sleep 6
11646         local blk1=$(do_facet $SINGLEMDS \
11647                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
11648                      grep Blockcount | awk '{print $4}')
11649
11650         # Remove old files, some OI blocks will become idle.
11651         unlinkmany $myDIR/t- 10000
11652
11653         # stop the MDT
11654         stop $SINGLEMDS || error "Fail to stop MDT."
11655         # remount the MDT
11656         start $SINGLEMDS $MDT_DEV $MDS_MOUNT_OPTS || error "Fail to start MDT."
11657
11658         df $MOUNT || error "Fail to df."
11659         # Create new files, idle OI blocks should be reused.
11660         createmany -o $myDIR/t- 2000
11661         do_facet $SINGLEMDS sync
11662         # Make sure journal flushed.
11663         sleep 6
11664         local blk2=$(do_facet $SINGLEMDS \
11665                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
11666                      grep Blockcount | awk '{print $4}')
11667
11668         [ $blk1 == $blk2 ] || error "old blk1=$blk1, new blk2=$blk2, unmatched!"
11669 }
11670 run_test 228b "idle OI blocks can be reused after MDT restart"
11671
11672 #LU-1881
11673 test_228c() {
11674         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11675         [ "$(facet_fstype $SINGLEMDS)" != "ldiskfs" ] &&
11676                 skip "non-ldiskfs backend" && return
11677
11678         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
11679         local myDIR=$DIR/$tdir
11680
11681         mkdir -p $myDIR
11682         #define OBD_FAIL_SEQ_EXHAUST             0x1002
11683         $LCTL set_param fail_loc=0x80001002
11684         # 20000 files can guarantee there are index nodes in the OI file
11685         createmany -o $myDIR/t- 20000
11686         $LCTL set_param fail_loc=0
11687         # The guard is current the largest FID holder
11688         touch $myDIR/guard
11689         local SEQ=$($LFS path2fid $myDIR/guard | awk -F ':' '{print $1}' |
11690                     tr -d '[')
11691         local IDX=$(($SEQ % 64))
11692
11693         do_facet $SINGLEMDS sync
11694         # Make sure journal flushed.
11695         sleep 6
11696         local blk1=$(do_facet $SINGLEMDS \
11697                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
11698                      grep Blockcount | awk '{print $4}')
11699
11700         # Remove old files, some OI blocks will become idle.
11701         unlinkmany $myDIR/t- 20000
11702         rm -f $myDIR/guard
11703         # The OI file should become empty now
11704
11705         # Create new files, idle OI blocks should be reused.
11706         createmany -o $myDIR/t- 2000
11707         do_facet $SINGLEMDS sync
11708         # Make sure journal flushed.
11709         sleep 6
11710         local blk2=$(do_facet $SINGLEMDS \
11711                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
11712                      grep Blockcount | awk '{print $4}')
11713
11714         [ $blk1 == $blk2 ] || error "old blk1=$blk1, new blk2=$blk2, unmatched!"
11715 }
11716 run_test 228c "NOT shrink the last entry in OI index node to recycle idle leaf"
11717
11718 test_229() { # LU-2482, LU-3448
11719         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.4.53) ] &&
11720                 skip "No HSM support on MDS of $(get_lustre_version)," \
11721                          "need 2.4.53 at least" && return
11722         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11723         [ $OSTCOUNT -lt 2 ] && skip "needs >= 2 OSTs" && return
11724
11725         rm -f $DIR/$tfile
11726
11727         # Create a file with a released layout and stripe count 2.
11728         $MULTIOP $DIR/$tfile H2c ||
11729                 error "failed to create file with released layout"
11730
11731         $GETSTRIPE -v $DIR/$tfile
11732
11733         local pattern=$($GETSTRIPE -L $DIR/$tfile)
11734         [ X"$pattern" = X"80000001" ] || error "pattern error ($pattern)"
11735
11736         local stripe_count=$($GETSTRIPE -c $DIR/$tfile) || error "getstripe"
11737         [ $stripe_count -eq 2 ] || error "stripe count not 2 ($stripe_count)"
11738         stat $DIR/$tfile || error "failed to stat released file"
11739
11740         chown $RUNAS_ID $DIR/$tfile ||
11741                 error "chown $RUNAS_ID $DIR/$tfile failed"
11742
11743         chgrp $RUNAS_ID $DIR/$tfile ||
11744                 error "chgrp $RUNAS_ID $DIR/$tfile failed"
11745
11746         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
11747         rm $DIR/$tfile || error "failed to remove released file"
11748 }
11749 run_test 229 "getstripe/stat/rm/attr changes work on released files"
11750
11751 test_230a() {
11752         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11753         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
11754         local MDTIDX=1
11755
11756         mkdir -p $DIR/$tdir/test_230_local
11757         local mdt_idx=$($GETSTRIPE -M $DIR/$tdir/test_230_local)
11758         [ $mdt_idx -ne 0 ] &&
11759                 error "create local directory on wrong MDT $mdt_idx"
11760
11761         $LFS mkdir -i $MDTIDX $DIR/$tdir/test_230 ||
11762                         error "create remote directory failed"
11763         local mdt_idx=$($GETSTRIPE -M $DIR/$tdir/test_230)
11764         [ $mdt_idx -ne $MDTIDX ] &&
11765                 error "create remote directory on wrong MDT $mdt_idx"
11766
11767         createmany -o $DIR/$tdir/test_230/t- 10 ||
11768                 error "create files on remote directory failed"
11769         mdt_idx=$($GETSTRIPE -M $DIR/$tdir/test_230/t-0)
11770         [ $mdt_idx -ne $MDTIDX ] && error "create files on wrong MDT $mdt_idx"
11771         rm -r $DIR/$tdir || error "unlink remote directory failed"
11772 }
11773 run_test 230a "Create remote directory and files under the remote directory"
11774
11775 test_231a()
11776 {
11777         # For simplicity this test assumes that max_pages_per_rpc
11778         # is the same across all OSCs
11779         local max_pages=$($LCTL get_param -n osc.*.max_pages_per_rpc | head -1)
11780         local bulk_size=$((max_pages * 4096))
11781
11782         mkdir -p $DIR/$tdir
11783
11784         # clear the OSC stats
11785         $LCTL set_param osc.*.stats=0 &>/dev/null
11786
11787         # Client writes $bulk_size - there must be 1 rpc for $max_pages.
11788         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=$bulk_size count=1 \
11789                 oflag=direct &>/dev/null || error "dd failed"
11790
11791         local nrpcs=$($LCTL get_param osc.*.stats |awk '/ost_write/ {print $2}')
11792         if [ x$nrpcs != "x1" ]; then
11793                 error "found $nrpc ost_write RPCs, not 1 as expected"
11794         fi
11795
11796         # Drop the OSC cache, otherwise we will read from it
11797         cancel_lru_locks osc
11798
11799         # clear the OSC stats
11800         $LCTL set_param osc.*.stats=0 &>/dev/null
11801
11802         # Client reads $bulk_size.
11803         dd if=$DIR/$tdir/$tfile of=/dev/null bs=$bulk_size count=1 \
11804                 iflag=direct &>/dev/null || error "dd failed"
11805
11806         nrpcs=$($LCTL get_param osc.*.stats | awk '/ost_read/ { print $2 }')
11807         if [ x$nrpcs != "x1" ]; then
11808                 error "found $nrpc ost_read RPCs, not 1 as expected"
11809         fi
11810 }
11811 run_test 231a "checking that reading/writing of BRW RPC size results in one RPC"
11812
11813 test_231b() {
11814         mkdir -p $DIR/$tdir
11815         local i
11816         for i in {0..1023}; do
11817                 dd if=/dev/zero of=$DIR/$tdir/$tfile conv=notrunc \
11818                         seek=$((2 * i)) bs=4096 count=1 &>/dev/null ||
11819                         error "dd of=$DIR/$tdir/$tfile seek=$((2 * i)) failed"
11820         done
11821         sync
11822 }
11823 run_test 231b "must not assert on fully utilized OST request buffer"
11824
11825 test_232() {
11826         mkdir -p $DIR/$tdir
11827         #define OBD_FAIL_LDLM_OST_LVB            0x31c
11828         $LCTL set_param fail_loc=0x31c
11829
11830         # ignore dd failure
11831         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=1 || true
11832
11833         $LCTL set_param fail_loc=0
11834         umount_client $MOUNT || error "umount failed"
11835         mount_client $MOUNT || error "mount failed"
11836 }
11837 run_test 232 "failed lock should not block umount"
11838
11839 test_233a() {
11840         [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.3.64) ] ||
11841         { skip "Need MDS version at least 2.3.64"; return; }
11842
11843         local fid=$($LFS path2fid $MOUNT)
11844         stat $MOUNT/.lustre/fid/$fid > /dev/null ||
11845                 error "cannot access $MOUNT using its FID '$fid'"
11846 }
11847 run_test 233a "checking that OBF of the FS root succeeds"
11848
11849 test_233b() {
11850         [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.5.90) ] ||
11851         { skip "Need MDS version at least 2.5.90"; return; }
11852
11853         local fid=$($LFS path2fid $MOUNT/.lustre)
11854         stat $MOUNT/.lustre/fid/$fid > /dev/null ||
11855                 error "cannot access $MOUNT/.lustre using its FID '$fid'"
11856
11857         fid=$($LFS path2fid $MOUNT/.lustre/fid)
11858         stat $MOUNT/.lustre/fid/$fid > /dev/null ||
11859                 error "cannot access $MOUNT/.lustre/fid using its FID '$fid'"
11860 }
11861 run_test 233b "checking that OBF of the FS .lustre succeeds"
11862
11863 test_234() {
11864         local p="$TMP/sanityN-$TESTNAME.parameters"
11865         save_lustre_params client "llite.*.xattr_cache" > $p
11866         lctl set_param llite.*.xattr_cache 1 ||
11867                 { skip "xattr cache is not supported"; return 0; }
11868
11869         mkdir -p $DIR/$tdir || error "mkdir failed"
11870         touch $DIR/$tdir/$tfile || error "touch failed"
11871         # OBD_FAIL_LLITE_XATTR_ENOMEM
11872         $LCTL set_param fail_loc=0x1405
11873         if [ ! -f /etc/SuSE-release ]; then
11874                 # attr pre-2.4.44-7 had a bug with rc
11875                 # LU-3703 - SLES clients have older attr
11876                 getfattr -n user.attr $DIR/$tdir/$tfile &&
11877                         error "getfattr should have failed with ENOMEM"
11878         fi
11879         $LCTL set_param fail_loc=0x0
11880         rm -rf $DIR/$tdir
11881
11882         restore_lustre_params < $p
11883         rm -f $p
11884 }
11885 run_test 234 "xattr cache should not crash on ENOMEM"
11886
11887 test_235() {
11888          [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.4.52) ] &&
11889                 skip "Need MDS version at least 2.4.52" && return
11890         flock_deadlock $DIR/$tfile
11891         local RC=$?
11892         case $RC in
11893                 0)
11894                 ;;
11895                 124) error "process hangs on a deadlock"
11896                 ;;
11897                 *) error "error executing flock_deadlock $DIR/$tfile"
11898                 ;;
11899         esac
11900 }
11901 run_test 235 "LU-1715: flock deadlock detection does not work properly"
11902
11903 #LU-2935
11904 test_236() {
11905         check_swap_layouts_support && return 0
11906         test_mkdir -p $DIR/$tdir || error "mkdir $tdir failed"
11907
11908         local ref1=/etc/passwd
11909         local ref2=/etc/group
11910         local file1=$DIR/$tdir/f1
11911         local file2=$DIR/$tdir/f2
11912
11913         $SETSTRIPE -c 1 $file1 || error "cannot setstripe on '$file1': rc = $?"
11914         cp $ref1 $file1 || error "cp $ref1 $file1 failed: rc = $?"
11915         $SETSTRIPE -c 2 $file2 || error "cannot setstripe on '$file2': rc = $?"
11916         cp $ref2 $file2 || error "cp $ref2 $file2 failed: rc = $?"
11917         local fd=$(free_fd)
11918         local cmd="exec $fd<>$file2"
11919         eval $cmd
11920         rm $file2
11921         $LFS swap_layouts $file1 /proc/self/fd/${fd} ||
11922                 error "cannot swap layouts of '$file1' and /proc/self/fd/${fd}"
11923         cmd="exec $fd>&-"
11924         eval $cmd
11925         cmp $ref2 $file1 || error "content compare failed ($ref2 != $file1)"
11926
11927         #cleanup
11928         rm -rf $DIR/$tdir
11929 }
11930 run_test 236 "Layout swap on open unlinked file"
11931
11932 # test to verify file handle related system calls
11933 # (name_to_handle_at/open_by_handle_at)
11934 # The new system calls are supported in glibc >= 2.14.
11935
11936 test_237() {
11937         echo "Test file_handle syscalls" > $DIR/$tfile
11938         check_fhandle_syscalls $DIR/$tfile ||
11939                 error "check_fhandle_syscalls failed"
11940 }
11941 run_test 237 "Verify name_to_handle_at/open_by_handle_at syscalls"
11942
11943 #
11944 # tests that do cleanup/setup should be run at the end
11945 #
11946
11947 test_900() {
11948         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11949         local ls
11950         #define OBD_FAIL_MGC_PAUSE_PROCESS_LOG   0x903
11951         $LCTL set_param fail_loc=0x903
11952         # cancel_lru_locks mgc - does not work due to lctl set_param syntax
11953         for ls in /proc/fs/lustre/ldlm/namespaces/MGC*/lru_size; do
11954                 echo "clear" > $ls
11955         done
11956         FAIL_ON_ERROR=true cleanup
11957         FAIL_ON_ERROR=true setup
11958 }
11959 run_test 900 "umount should not race with any mgc requeue thread"
11960
11961 complete $SECONDS
11962 check_and_cleanup_lustre
11963 if [ "$I_MOUNTED" != "yes" ]; then
11964         lctl set_param debug="$OLDDEBUG" 2> /dev/null || true
11965 fi
11966 exit_status