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_0() {
 145         touch $DIR/$tfile
 146         $CHECKSTAT -t file $DIR/$tfile || error
 147         rm $DIR/$tfile
 148         $CHECKSTAT -a $DIR/$tfile || error
 149 }
 150 run_test 0 "touch .../$tfile ; rm .../$tfile ====================="
 151
 152 test_0b() {
 153         chmod 0755 $DIR || error
 154         $CHECKSTAT -p 0755 $DIR || error
 155 }
 156 run_test 0b "chmod 0755 $DIR ============================="
 157
 158 test_0c() {
 159     $LCTL get_param mdc.*.import | grep  "state: FULL" || error "import not FULL"
 160     $LCTL get_param mdc.*.import | grep  "target: $FSNAME-MDT" || error "bad target"
 161 }
 162 run_test 0c "check import proc ============================="
 163
 164 test_1a() {
 165         test_mkdir -p $DIR/$tdir
 166         test_mkdir -p $DIR/$tdir/d2
 167         test_mkdir $DIR/$tdir/d2 && error "we expect EEXIST, but not returned"
 168         $CHECKSTAT -t dir $DIR/$tdir/d2 || error
 169 }
 170 run_test 1a "mkdir .../d1; mkdir .../d1/d2 ====================="
 171
 172 test_1b() {
 173         rmdir $DIR/$tdir/d2
 174         rmdir $DIR/$tdir
 175         $CHECKSTAT -a $DIR/$tdir || error
 176 }
 177 run_test 1b "rmdir .../d1/d2; rmdir .../d1 ====================="
 178
 179 test_2a() {
 180         test_mkdir $DIR/$tdir
 181         touch $DIR/$tdir/$tfile
 182         $CHECKSTAT -t file $DIR/$tdir/$tfile || error
 183 }
 184 run_test 2a "mkdir .../d2; touch .../d2/f ======================"
 185
 186 test_2b() {
 187         rm -r $DIR/$tdir
 188         $CHECKSTAT -a $DIR/$tdir || error
 189 }
 190 run_test 2b "rm -r .../d2; checkstat .../d2/f ======================"
 191
 192 test_3a() {
 193         test_mkdir -p $DIR/$tdir
 194         $CHECKSTAT -t dir $DIR/$tdir || error
 195 }
 196 run_test 3a "mkdir .../d3 ======================================"
 197
 198 test_3b() {
 199         if [ ! -d $DIR/$tdir ]; then
 200                 mkdir $DIR/$tdir
 201         fi
 202         touch $DIR/$tdir/$tfile
 203         $CHECKSTAT -t file $DIR/$tdir/$tfile || error
 204 }
 205 run_test 3b "touch .../d3/f ===================================="
 206
 207 test_3c() {
 208         rm -r $DIR/$tdir
 209         $CHECKSTAT -a $DIR/$tdir || error
 210 }
 211 run_test 3c "rm -r .../d3 ======================================"
 212
 213 test_4a() {
 214         test_mkdir -p $DIR/$tdir
 215         $CHECKSTAT -t dir $DIR/$tdir || error
 216 }
 217 run_test 4a "mkdir .../d4 ======================================"
 218
 219 test_4b() {
 220         if [ ! -d $DIR/$tdir ]; then
 221                 test_mkdir $DIR/$tdir
 222         fi
 223         test_mkdir $DIR/$tdir/d2
 224         mkdir $DIR/$tdir/d2
 225         $CHECKSTAT -t dir $DIR/$tdir/d2 || error
 226 }
 227 run_test 4b "mkdir .../d4/d2 ==================================="
 228
 229 test_5() {
 230         test_mkdir $DIR/$tdir
 231         test_mkdir $DIR/$tdir/d2
 232         chmod 0707 $DIR/$tdir/d2
 233         $CHECKSTAT -t dir -p 0707 $DIR/$tdir/d2 || error
 234 }
 235 run_test 5 "mkdir .../d5 .../d5/d2; chmod .../d5/d2 ============"
 236
 237 test_6a() {
 238         touch $DIR/$tfile
 239         chmod 0666 $DIR/$tfile || error
 240         $CHECKSTAT -t file -p 0666 -u \#$UID $DIR/$tfile || error
 241 }
 242 run_test 6a "touch .../f6a; chmod .../f6a ======================"
 243
 244 test_6b() {
 245         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID" && return
 246         if [ ! -f $DIR/$tfile ]; then
 247                 touch $DIR/$tfile
 248                 chmod 0666 $DIR/$tfile
 249         fi
 250         $RUNAS chmod 0444 $DIR/$tfile && error
 251         $CHECKSTAT -t file -p 0666 -u \#$UID $DIR/$tfile || error
 252 }
 253 run_test 6b "$RUNAS chmod .../f6a (should return error) =="
 254
 255 test_6c() {
 256         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID" && return
 257         touch $DIR/$tfile
 258         chown $RUNAS_ID $DIR/$tfile || error
 259         $CHECKSTAT -t file -u \#$RUNAS_ID $DIR/$tfile || error
 260 }
 261 run_test 6c "touch .../f6c; chown .../f6c ======================"
 262
 263 test_6d() {
 264         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID" && return
 265         if [ ! -f $DIR/$tfile ]; then
 266                 touch $DIR/$tfile
 267                 chown $RUNAS_ID $DIR/$tfile
 268         fi
 269         $RUNAS chown $UID $DIR/$tfile && error
 270         $CHECKSTAT -t file -u \#$RUNAS_ID $DIR/$tfile || error
 271 }
 272 run_test 6d "$RUNAS chown .../f6c (should return error) =="
 273
 274 test_6e() {
 275         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID" && return
 276         touch $DIR/$tfile
 277         chgrp $RUNAS_ID $DIR/$tfile || error
 278         $CHECKSTAT -t file -u \#$UID -g \#$RUNAS_ID $DIR/$tfile || error
 279 }
 280 run_test 6e "touch .../f6e; chgrp .../f6e ======================"
 281
 282 test_6f() {
 283         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID" && return
 284         if [ ! -f $DIR/$tfile ]; then
 285                 touch $DIR/$tfile
 286                 chgrp $RUNAS_ID $DIR/$tfile
 287         fi
 288         $RUNAS chgrp $UID $DIR/$tfile && error
 289         $CHECKSTAT -t file -u \#$UID -g \#$RUNAS_ID $DIR/$tfile || error
 290 }
 291 run_test 6f "$RUNAS chgrp .../f6e (should return error) =="
 292
 293 test_6g() {
 294         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID" && return
 295         test_mkdir $DIR/$tdir || error
 296         chmod 777 $DIR/$tdir || error
 297         $RUNAS mkdir $DIR/$tdir/d || error
 298         chmod g+s $DIR/$tdir/d || error
 299         test_mkdir $DIR/$tdir/d/subdir
 300         $CHECKSTAT -g \#$RUNAS_GID $DIR/$tdir/d/subdir || error
 301 }
 302 run_test 6g "Is new dir in sgid dir inheriting group?"
 303
 304 test_6h() { # bug 7331
 305         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID" && return
 306         touch $DIR/$tfile || error "touch failed"
 307         chown $RUNAS_ID:$RUNAS_GID $DIR/$tfile || error "initial chown failed"
 308         $RUNAS -G$RUNAS_GID chown $RUNAS_ID:0 $DIR/$tfile &&
 309                 error "chown worked"
 310         $CHECKSTAT -t file -u \#$RUNAS_ID -g \#$RUNAS_GID $DIR/$tfile || error
 311 }
 312 run_test 6h "$RUNAS chown RUNAS_ID.0 .../f6h (should return error)"
 313
 314 test_7a() {
 315         test_mkdir $DIR/$tdir
 316         $MCREATE $DIR/$tdir/$tfile
 317         chmod 0666 $DIR/$tdir/$tfile
 318         $CHECKSTAT -t file -p 0666 $DIR/$tdir/$tfile || error
 319 }
 320 run_test 7a "mkdir .../d7; mcreate .../d7/f; chmod .../d7/f ===="
 321
 322 test_7b() {
 323         if [ ! -d $DIR/$tdir ]; then
 324                 mkdir $DIR/$tdir
 325         fi
 326         $MCREATE $DIR/$tdir/$tfile
 327         echo -n foo > $DIR/$tdir/$tfile
 328         [ "`cat $DIR/$tdir/$tfile`" = "foo" ] || error
 329         $CHECKSTAT -t file -s 3 $DIR/$tdir/$tfile || error
 330 }
 331 run_test 7b "mkdir .../d7; mcreate d7/f2; echo foo > d7/f2 ====="
 332
 333 test_8() {
 334         test_mkdir $DIR/$tdir
 335         touch $DIR/$tdir/$tfile
 336         chmod 0666 $DIR/$tdir/$tfile
 337         $CHECKSTAT -t file -p 0666 $DIR/$tdir/$tfile || error
 338 }
 339 run_test 8 "mkdir .../d8; touch .../d8/f; chmod .../d8/f ======="
 340
 341 test_9() {
 342         test_mkdir $DIR/$tdir
 343         test_mkdir $DIR/$tdir/d2
 344         test_mkdir $DIR/$tdir/d2/d3
 345         $CHECKSTAT -t dir $DIR/$tdir/d2/d3 || error
 346 }
 347 run_test 9 "mkdir .../d9 .../d9/d2 .../d9/d2/d3 ================"
 348
 349 test_10() {
 350         test_mkdir $DIR/$tdir
 351         test_mkdir $DIR/$tdir/d2
 352         touch $DIR/$tdir/d2/$tfile
 353         $CHECKSTAT -t file $DIR/$tdir/d2/$tfile || error
 354 }
 355 run_test 10 "mkdir .../d10 .../d10/d2; touch .../d10/d2/f ======"
 356
 357 test_11() {
 358         test_mkdir $DIR/$tdir
 359         test_mkdir $DIR/$tdir/d2
 360         chmod 0666 $DIR/$tdir/d2
 361         chmod 0705 $DIR/$tdir/d2
 362         $CHECKSTAT -t dir -p 0705 $DIR/$tdir/d2 || error
 363 }
 364 run_test 11 "mkdir .../d11 d11/d2; chmod .../d11/d2 ============"
 365
 366 test_12() {
 367         test_mkdir $DIR/$tdir
 368         touch $DIR/$tdir/$tfile
 369         chmod 0666 $DIR/$tdir/$tfile
 370         chmod 0654 $DIR/$tdir/$tfile
 371         $CHECKSTAT -t file -p 0654 $DIR/$tdir/$tfile || error
 372 }
 373 run_test 12 "touch .../d12/f; chmod .../d12/f .../d12/f ========"
 374
 375 test_13() {
 376         test_mkdir $DIR/$tdir
 377         dd if=/dev/zero of=$DIR/$tdir/$tfile count=10
 378         >  $DIR/$tdir/$tfile
 379         $CHECKSTAT -t file -s 0 $DIR/$tdir/$tfile || error
 380 }
 381 run_test 13 "creat .../d13/f; dd .../d13/f; > .../d13/f ========"
 382
 383 test_14() {
 384         test_mkdir $DIR/$tdir
 385         touch $DIR/$tdir/$tfile
 386         rm $DIR/$tdir/$tfile
 387         $CHECKSTAT -a $DIR/$tdir/$tfile || error
 388 }
 389 run_test 14 "touch .../d14/f; rm .../d14/f; rm .../d14/f ======="
 390
 391 test_15() {
 392         test_mkdir $DIR/$tdir
 393         touch $DIR/$tdir/$tfile
 394         mv $DIR/$tdir/$tfile $DIR/$tdir/${tfile}_2
 395         $CHECKSTAT -t file $DIR/$tdir/${tfile}_2 || error
 396 }
 397 run_test 15 "touch .../d15/f; mv .../d15/f .../d15/f2 =========="
 398
 399 test_16() {
 400         test_mkdir $DIR/$tdir
 401         touch $DIR/$tdir/$tfile
 402         rm -rf $DIR/$tdir/$tfile
 403         $CHECKSTAT -a $DIR/$tdir/$tfile || error
 404 }
 405 run_test 16 "touch .../d16/f; rm -rf .../d16/f ================="
 406
 407 test_17a() {
 408         test_mkdir -p $DIR/$tdir
 409         touch $DIR/$tdir/$tfile
 410         ln -s $DIR/$tdir/$tfile $DIR/$tdir/l-exist
 411         ls -l $DIR/$tdir
 412         $CHECKSTAT -l $DIR/$tdir/$tfile $DIR/$tdir/l-exist || error
 413         $CHECKSTAT -f -t f $DIR/$tdir/l-exist || error
 414         rm -f $DIR/$tdir/l-exist
 415         $CHECKSTAT -a $DIR/$tdir/l-exist || error
 416 }
 417 run_test 17a "symlinks: create, remove (real) =================="
 418
 419 test_17b() {
 420         test_mkdir -p $DIR/$tdir
 421         ln -s no-such-file $DIR/$tdir/l-dangle
 422         ls -l $DIR/$tdir
 423         $CHECKSTAT -l no-such-file $DIR/$tdir/l-dangle || error
 424         $CHECKSTAT -fa $DIR/$tdir/l-dangle || error
 425         rm -f $DIR/$tdir/l-dangle
 426         $CHECKSTAT -a $DIR/$tdir/l-dangle || error
 427 }
 428 run_test 17b "symlinks: create, remove (dangling) =============="
 429
 430 test_17c() { # bug 3440 - don't save failed open RPC for replay
 431         test_mkdir -p $DIR/$tdir
 432         ln -s foo $DIR/$tdir/$tfile
 433         cat $DIR/$tdir/$tfile && error "opened non-existent symlink" || true
 434 }
 435 run_test 17c "symlinks: open dangling (should return error) ===="
 436
 437 test_17d() {
 438         test_mkdir -p $DIR/$tdir
 439         ln -s foo $DIR/$tdir/$tfile
 440         touch $DIR/$tdir/$tfile || error "creating to new symlink"
 441 }
 442 run_test 17d "symlinks: create dangling ========================"
 443
 444 test_17e() {
 445         test_mkdir -p $DIR/$tdir
 446         local foo=$DIR/$tdir/$tfile
 447         ln -s $foo $foo || error "create symlink failed"
 448         ls -l $foo || error "ls -l failed"
 449         ls $foo && error "ls not failed" || true
 450 }
 451 run_test 17e "symlinks: create recursive symlink (should return error) ===="
 452
 453 test_17f() {
 454         test_mkdir -p $DIR/d17f
 455         ln -s 1234567890/2234567890/3234567890/4234567890 $DIR/d17f/111
 456         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890 $DIR/d17f/222
 457         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890 $DIR/d17f/333
 458         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890 $DIR/d17f/444
 459         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890/c234567890/d234567890/f234567890 $DIR/d17f/555
 460         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
 461         ls -l  $DIR/d17f
 462 }
 463 run_test 17f "symlinks: long and very long symlink name ========================"
 464
 465 # str_repeat(S, N) generate a string that is string S repeated N times
 466 str_repeat() {
 467         local s=$1
 468         local n=$2
 469         local ret=''
 470         while [ $((n -= 1)) -ge 0 ]; do
 471                 ret=$ret$s
 472         done
 473         echo $ret
 474 }
 475
 476 # Long symlinks and LU-2241
 477 test_17g() {
 478         test_mkdir -p $DIR/$tdir
 479         local TESTS="59 60 61 4094 4095"
 480
 481         # Fix for inode size boundary in 2.1.4
 482         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.1.4) ] &&
 483                 TESTS="4094 4095"
 484
 485         # Patch not applied to 2.2 or 2.3 branches
 486         [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.0) ] &&
 487         [ $(lustre_version_code $SINGLEMDS) -le $(version_code 2.3.55) ] &&
 488                 TESTS="4094 4095"
 489
 490         for i in $TESTS; do
 491                 local SYMNAME=$(str_repeat 'x' $i)
 492                 ln -s $SYMNAME $DIR/$tdir/f$i || error "failed $i-char symlink"
 493                 readlink $DIR/$tdir/f$i || error "failed $i-char readlink"
 494         done
 495 }
 496 run_test 17g "symlinks: really long symlink name and inode boundaries"
 497
 498 test_17h() { #bug 17378
 499         remote_mds_nodsh && skip "remote MDS with nodsh" && return
 500         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
 501         local mdt_idx
 502         test_mkdir -p $DIR/$tdir
 503         if [ $MDSCOUNT -gt 1 ]; then
 504                 mdt_idx=$($LFS getdirstripe -i $DIR/$tdir)
 505         else
 506                 mdt_idx=0
 507         fi
 508         $SETSTRIPE -c -1 $DIR/$tdir
 509 #define OBD_FAIL_MDS_LOV_PREP_CREATE 0x141
 510         do_facet mds$((mdt_idx + 1)) lctl set_param fail_loc=0x80000141
 511         touch $DIR/$tdir/$tfile || true
 512 }
 513 run_test 17h "create objects: lov_free_memmd() doesn't lbug"
 514
 515 test_17i() { #bug 20018
 516         remote_mds_nodsh && skip "remote MDS with nodsh" && return
 517         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
 518         test_mkdir -p $DIR/$tdir
 519         local foo=$DIR/$tdir/$tfile
 520         local mdt_idx
 521         if [ $MDSCOUNT -gt 1 ]; then
 522                 mdt_idx=$($LFS getdirstripe -i $DIR/$tdir)
 523         else
 524                 mdt_idx=0
 525         fi
 526         ln -s $foo $foo || error "create symlink failed"
 527 #define OBD_FAIL_MDS_READLINK_EPROTO     0x143
 528         do_facet mds$((mdt_idx + 1)) lctl set_param fail_loc=0x80000143
 529         ls -l $foo && error "error not detected"
 530         return 0
 531 }
 532 run_test 17i "don't panic on short symlink"
 533
 534 test_17k() { #bug 22301
 535         rsync --help | grep -q xattr ||
 536                 skip_env "$(rsync --version| head -1) does not support xattrs"
 537         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
 538         test_mkdir -p $DIR/$tdir
 539         test_mkdir -p $DIR/$tdir.new
 540         touch $DIR/$tdir/$tfile
 541         ln -s $DIR/$tdir/$tfile $DIR/$tdir/$tfile.lnk
 542         rsync -av -X $DIR/$tdir/ $DIR/$tdir.new ||
 543                 error "rsync failed with xattrs enabled"
 544 }
 545 run_test 17k "symlinks: rsync with xattrs enabled ========================="
 546
 547 test_17l() { # LU-279
 548         mkdir -p $DIR/$tdir
 549         touch $DIR/$tdir/$tfile
 550         ln -s $DIR/$tdir/$tfile $DIR/$tdir/$tfile.lnk
 551         for path in "$DIR/$tdir" "$DIR/$tdir/$tfile" "$DIR/$tdir/$tfile.lnk"; do
 552                 # -h to not follow symlinks. -m '' to list all the xattrs.
 553                 # grep to remove first line: '# file: $path'.
 554                 for xattr in `getfattr -hm '' $path 2>/dev/null | grep -v '^#'`;
 555                 do
 556                         lgetxattr_size_check $path $xattr ||
 557                                 error "lgetxattr_size_check $path $xattr failed"
 558                 done
 559         done
 560 }
 561 run_test 17l "Ensure lgetxattr's returned xattr size is consistent ========"
 562
 563 # LU-1540
 564 test_17m() {
 565         local short_sym="0123456789"
 566         local WDIR=$DIR/${tdir}m
 567         local mds_index
 568         local devname
 569         local cmd
 570         local i
 571         local rc=0
 572
 573         [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.0) ] &&
 574         [ $(lustre_version_code $SINGLEMDS) -le $(version_code 2.2.93) ] &&
 575                 skip "MDS 2.2.0-2.2.93 do not NUL-terminate symlinks" && return
 576
 577         [ "$(facet_fstype $SINGLEMDS)" != "ldiskfs" ] &&
 578                 skip "only for ldiskfs MDT" && return 0
 579
 580         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
 581
 582         mkdir -p $WDIR
 583         long_sym=$short_sym
 584         # create a long symlink file
 585         for ((i = 0; i < 4; ++i)); do
 586                 long_sym=${long_sym}${long_sym}
 587         done
 588
 589         echo "create 512 short and long symlink files under $WDIR"
 590         for ((i = 0; i < 256; ++i)); do
 591                 ln -sf ${long_sym}"a5a5" $WDIR/long-$i
 592                 ln -sf ${short_sym}"a5a5" $WDIR/short-$i
 593         done
 594
 595         echo "erase them"
 596         rm -f $WDIR/*
 597         sync
 598         wait_delete_completed
 599
 600         echo "recreate the 512 symlink files with a shorter string"
 601         for ((i = 0; i < 512; ++i)); do
 602                 # rewrite the symlink file with a shorter string
 603                 ln -sf ${long_sym} $WDIR/long-$i
 604                 ln -sf ${short_sym} $WDIR/short-$i
 605         done
 606
 607         mds_index=$($LFS getstripe -M $WDIR)
 608         mds_index=$((mds_index+1))
 609         devname=$(mdsdevname $mds_index)
 610         cmd="$E2FSCK -fnvd $devname"
 611
 612         echo "stop and checking mds${mds_index}: $cmd"
 613         # e2fsck should not return error
 614         stop mds${mds_index} -f
 615         do_facet mds${mds_index} $cmd || rc=$?
 616
 617         start mds${mds_index} $devname $MDS_MOUNT_OPTS
 618         df $MOUNT > /dev/null 2>&1
 619         [ $rc -ne 0 ] && error "e2fsck should not report error upon "\
 620                 "short/long symlink MDT: rc=$rc"
 621         return $rc
 622 }
 623 run_test 17m "run e2fsck against MDT which contains short/long symlink"
 624
 625 check_fs_consistency_17n() {
 626         local mdt_index
 627         local devname
 628         local cmd
 629         local rc=0
 630
 631         for mdt_index in $(seq 1 $MDSCOUNT); do
 632                 devname=$(mdsdevname $mdt_index)
 633                 cmd="$E2FSCK -fnvd $devname"
 634
 635                 echo "stop and checking mds${mdt_index}: $cmd"
 636                 # e2fsck should not return error
 637                 stop mds${mdt_index}
 638                 do_facet mds${mdt_index} $cmd || rc=$?
 639
 640                 start mds${mdt_index} $devname $MDS_MOUNT_OPTS
 641                 df $MOUNT > /dev/null 2>&1
 642                 [ $rc -ne 0 ] && break
 643         done
 644         return $rc
 645 }
 646
 647 test_17n() {
 648         local i
 649
 650         [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.0) ] &&
 651         [ $(lustre_version_code $SINGLEMDS) -le $(version_code 2.2.93) ] &&
 652                 skip "MDS 2.2.0-2.2.93 do not NUL-terminate symlinks" && return
 653
 654         [ "$(facet_fstype $SINGLEMDS)" != "ldiskfs" ] &&
 655                 skip "only for ldiskfs MDT" && return 0
 656
 657         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
 658
 659         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
 660
 661         mkdir -p $DIR/$tdir
 662         for ((i=0; i<10; i++)); do
 663                 $LFS mkdir -i 1 $DIR/$tdir/remote_dir_${i} ||
 664                         error "create remote dir error $i"
 665                 createmany -o $DIR/$tdir/remote_dir_${i}/f 10 ||
 666                         error "create files under remote dir failed $i"
 667         done
 668
 669         check_fs_consistency_17n || error "e2fsck report error"
 670
 671         for ((i=0;i<10;i++)); do
 672                 rm -rf $DIR/$tdir/remote_dir_${i} ||
 673                         error "destroy remote dir error $i"
 674         done
 675
 676         check_fs_consistency_17n || error "e2fsck report error"
 677 }
 678 run_test 17n "run e2fsck against master/slave MDT which contains remote dir"
 679
 680 test_18() {
 681         touch $DIR/f || error "Failed to touch $DIR/f: $?"
 682         ls $DIR || error "Failed to ls $DIR: $?"
 683 }
 684 run_test 18 "touch .../f ; ls ... =============================="
 685
 686 test_19a() {
 687         touch $DIR/f19
 688         ls -l $DIR
 689         rm $DIR/f19
 690         $CHECKSTAT -a $DIR/f19 || error
 691 }
 692 run_test 19a "touch .../f19 ; ls -l ... ; rm .../f19 ==========="
 693
 694 test_19b() {
 695         ls -l $DIR/f19 && error || true
 696 }
 697 run_test 19b "ls -l .../f19 (should return error) =============="
 698
 699 test_19c() {
 700         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
 701         $RUNAS touch $DIR/f19 && error || true
 702 }
 703 run_test 19c "$RUNAS touch .../f19 (should return error) =="
 704
 705 test_19d() {
 706         cat $DIR/f19 && error || true
 707 }
 708 run_test 19d "cat .../f19 (should return error) =============="
 709
 710 test_20() {
 711         touch $DIR/f
 712         rm $DIR/f
 713         log "1 done"
 714         touch $DIR/f
 715         rm $DIR/f
 716         log "2 done"
 717         touch $DIR/f
 718         rm $DIR/f
 719         log "3 done"
 720         $CHECKSTAT -a $DIR/f || error
 721 }
 722 run_test 20 "touch .../f ; ls -l ... ==========================="
 723
 724 test_21() {
 725         test_mkdir $DIR/d21
 726         [ -f $DIR/d21/dangle ] && rm -f $DIR/d21/dangle
 727         ln -s dangle $DIR/d21/link
 728         echo foo >> $DIR/d21/link
 729         cat $DIR/d21/dangle
 730         $CHECKSTAT -t link $DIR/d21/link || error
 731         $CHECKSTAT -f -t file $DIR/d21/link || error
 732 }
 733 run_test 21 "write to dangling link ============================"
 734
 735 test_22() {
 736         WDIR=$DIR/$tdir
 737         test_mkdir -p $DIR/$tdir
 738         chown $RUNAS_ID:$RUNAS_GID $WDIR
 739         (cd $WDIR || error "cd $WDIR failed";
 740         $RUNAS tar cf - /etc/hosts /etc/sysconfig/network | \
 741         $RUNAS tar xf -)
 742         ls -lR $WDIR/etc || error "ls -lR $WDIR/etc failed"
 743         $CHECKSTAT -t dir $WDIR/etc || error "checkstat -t dir failed"
 744         $CHECKSTAT -u \#$RUNAS_ID -g \#$RUNAS_GID $WDIR/etc || error "checkstat -u failed"
 745 }
 746 run_test 22 "unpack tar archive as non-root user ==============="
 747
 748 # was test_23
 749 test_23a() {
 750         test_mkdir -p $DIR/$tdir
 751         local file=$DIR/$tdir/$tfile
 752
 753         openfile -f O_CREAT:O_EXCL $file || error "$file create failed"
 754         openfile -f O_CREAT:O_EXCL $file &&
 755                 error "$file recreate succeeded" || true
 756 }
 757 run_test 23a "O_CREAT|O_EXCL in subdir =========================="
 758
 759 test_23b() { # bug 18988
 760         test_mkdir -p $DIR/$tdir
 761         local file=$DIR/$tdir/$tfile
 762
 763         rm -f $file
 764         echo foo > $file || error "write filed"
 765         echo bar >> $file || error "append filed"
 766         $CHECKSTAT -s 8 $file || error "wrong size"
 767         rm $file
 768 }
 769 run_test 23b "O_APPEND check =========================="
 770
 771 test_24a() {
 772         echo '== rename sanity =============================================='
 773         echo '-- same directory rename'
 774         test_mkdir $DIR/R1
 775         touch $DIR/R1/f
 776         mv $DIR/R1/f $DIR/R1/g
 777         $CHECKSTAT -t file $DIR/R1/g || error
 778 }
 779 run_test 24a "touch .../R1/f; rename .../R1/f .../R1/g ========="
 780
 781 test_24b() {
 782         test_mkdir $DIR/R2
 783         touch $DIR/R2/{f,g}
 784         mv $DIR/R2/f $DIR/R2/g
 785         $CHECKSTAT -a $DIR/R2/f || error
 786         $CHECKSTAT -t file $DIR/R2/g || error
 787 }
 788 run_test 24b "touch .../R2/{f,g}; rename .../R2/f .../R2/g ====="
 789
 790 test_24c() {
 791         test_mkdir $DIR/R3
 792         test_mkdir $DIR/R3/f
 793         mv $DIR/R3/f $DIR/R3/g
 794         $CHECKSTAT -a $DIR/R3/f || error
 795         $CHECKSTAT -t dir $DIR/R3/g || error
 796 }
 797 run_test 24c "mkdir .../R3/f; rename .../R3/f .../R3/g ========="
 798
 799 test_24d() {
 800         test_mkdir $DIR/R4
 801         test_mkdir $DIR/R4/f
 802         test_mkdir $DIR/R4/g
 803         mrename $DIR/R4/f $DIR/R4/g
 804         $CHECKSTAT -a $DIR/R4/f || error
 805         $CHECKSTAT -t dir $DIR/R4/g || error
 806 }
 807 run_test 24d "mkdir .../R4/{f,g}; rename .../R4/f .../R4/g ====="
 808
 809 test_24e() {
 810         echo '-- cross directory renames --'
 811         test_mkdir $DIR/R5a
 812         test_mkdir $DIR/R5b
 813         touch $DIR/R5a/f
 814         mv $DIR/R5a/f $DIR/R5b/g
 815         $CHECKSTAT -a $DIR/R5a/f || error
 816         $CHECKSTAT -t file $DIR/R5b/g || error
 817 }
 818 run_test 24e "touch .../R5a/f; rename .../R5a/f .../R5b/g ======"
 819
 820 test_24f() {
 821         test_mkdir $DIR/R6a
 822         test_mkdir $DIR/R6b
 823         touch $DIR/R6a/f $DIR/R6b/g
 824         mv $DIR/R6a/f $DIR/R6b/g
 825         $CHECKSTAT -a $DIR/R6a/f || error
 826         $CHECKSTAT -t file $DIR/R6b/g || error
 827 }
 828 run_test 24f "touch .../R6a/f R6b/g; mv .../R6a/f .../R6b/g ===="
 829
 830 test_24g() {
 831         test_mkdir $DIR/R7a
 832         test_mkdir $DIR/R7b
 833         test_mkdir $DIR/R7a/d
 834         mv $DIR/R7a/d $DIR/R7b/e
 835         $CHECKSTAT -a $DIR/R7a/d || error
 836         $CHECKSTAT -t dir $DIR/R7b/e || error
 837 }
 838 run_test 24g "mkdir .../R7{a,b}/d; mv .../R7a/d .../R7b/e ======"
 839
 840 test_24h() {
 841         test_mkdir $DIR/R8a
 842         test_mkdir $DIR/R8b
 843         test_mkdir $DIR/R8a/d
 844         test_mkdir $DIR/R8b/e
 845         mrename $DIR/R8a/d $DIR/R8b/e
 846         $CHECKSTAT -a $DIR/R8a/d || error
 847         $CHECKSTAT -t dir $DIR/R8b/e || error
 848 }
 849 run_test 24h "mkdir .../R8{a,b}/{d,e}; rename .../R8a/d .../R8b/e"
 850
 851 test_24i() {
 852         echo "-- rename error cases"
 853         test_mkdir $DIR/R9
 854         test_mkdir $DIR/R9/a
 855         touch $DIR/R9/f
 856         mrename $DIR/R9/f $DIR/R9/a
 857         $CHECKSTAT -t file $DIR/R9/f || error
 858         $CHECKSTAT -t dir  $DIR/R9/a || error
 859         $CHECKSTAT -a $DIR/R9/a/f || error
 860 }
 861 run_test 24i "rename file to dir error: touch f ; mkdir a ; rename f a"
 862
 863 test_24j() {
 864         test_mkdir $DIR/R10
 865         mrename $DIR/R10/f $DIR/R10/g
 866         $CHECKSTAT -t dir $DIR/R10 || error
 867         $CHECKSTAT -a $DIR/R10/f || error
 868         $CHECKSTAT -a $DIR/R10/g || error
 869 }
 870 run_test 24j "source does not exist ============================"
 871
 872 test_24k() {
 873         test_mkdir $DIR/R11a
 874         test_mkdir $DIR/R11a/d
 875         touch $DIR/R11a/f
 876         mv $DIR/R11a/f $DIR/R11a/d
 877         $CHECKSTAT -a $DIR/R11a/f || error
 878         $CHECKSTAT -t file $DIR/R11a/d/f || error
 879 }
 880 run_test 24k "touch .../R11a/f; mv .../R11a/f .../R11a/d ======="
 881
 882 # bug 2429 - rename foo foo foo creates invalid file
 883 test_24l() {
 884         f="$DIR/f24l"
 885         $MULTIOP $f OcNs || error
 886 }
 887 run_test 24l "Renaming a file to itself ========================"
 888
 889 test_24m() {
 890         f="$DIR/f24m"
 891         $MULTIOP $f OcLN ${f}2 ${f}2 || error "link ${f}2 ${f}2 failed"
 892         # on ext3 this does not remove either the source or target files
 893         # though the "expected" operation would be to remove the source
 894         $CHECKSTAT -t file ${f} || error "${f} missing"
 895         $CHECKSTAT -t file ${f}2 || error "${f}2 missing"
 896 }
 897 run_test 24m "Renaming a file to a hard link to itself ========="
 898
 899 test_24n() {
 900     f="$DIR/f24n"
 901     # this stats the old file after it was renamed, so it should fail
 902     touch ${f}
 903     $CHECKSTAT ${f}
 904     mv ${f} ${f}.rename
 905     $CHECKSTAT ${f}.rename
 906     $CHECKSTAT -a ${f}
 907 }
 908 run_test 24n "Statting the old file after renaming (Posix rename 2)"
 909
 910 test_24o() {
 911         check_kernel_version 37 || return 0
 912         test_mkdir -p $DIR/d24o
 913         rename_many -s random -v -n 10 $DIR/d24o
 914 }
 915 run_test 24o "rename of files during htree split ==============="
 916
 917 test_24p() {
 918         test_mkdir $DIR/R12a
 919         test_mkdir $DIR/R12b
 920         DIRINO=`ls -lid $DIR/R12a | awk '{ print $1 }'`
 921         mrename $DIR/R12a $DIR/R12b
 922         $CHECKSTAT -a $DIR/R12a || error
 923         $CHECKSTAT -t dir $DIR/R12b || error
 924         DIRINO2=`ls -lid $DIR/R12b | awk '{ print $1 }'`
 925         [ "$DIRINO" = "$DIRINO2" ] || error "R12a $DIRINO != R12b $DIRINO2"
 926 }
 927 run_test 24p "mkdir .../R12{a,b}; rename .../R12a .../R12b"
 928
 929 cleanup_multiop_pause() {
 930         trap 0
 931         kill -USR1 $MULTIPID
 932 }
 933
 934 test_24q() {
 935         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
 936         test_mkdir $DIR/R13a
 937         test_mkdir $DIR/R13b
 938         local DIRINO=$(ls -lid $DIR/R13a | awk '{ print $1 }')
 939         multiop_bg_pause $DIR/R13b D_c || error "multiop failed to start"
 940         MULTIPID=$!
 941
 942         trap cleanup_multiop_pause EXIT
 943         mrename $DIR/R13a $DIR/R13b
 944         $CHECKSTAT -a $DIR/R13a || error "R13a still exists"
 945         $CHECKSTAT -t dir $DIR/R13b || error "R13b does not exist"
 946         local DIRINO2=$(ls -lid $DIR/R13b | awk '{ print $1 }')
 947         [ "$DIRINO" = "$DIRINO2" ] || error "R13a $DIRINO != R13b $DIRINO2"
 948         cleanup_multiop_pause
 949         wait $MULTIPID || error "multiop close failed"
 950 }
 951 run_test 24q "mkdir .../R13{a,b}; open R13b rename R13a R13b ==="
 952
 953 test_24r() { #bug 3789
 954         test_mkdir $DIR/R14a
 955         test_mkdir $DIR/R14a/b
 956         mrename $DIR/R14a $DIR/R14a/b && error "rename to subdir worked!"
 957         $CHECKSTAT -t dir $DIR/R14a || error "$DIR/R14a missing"
 958         $CHECKSTAT -t dir $DIR/R14a/b || error "$DIR/R14a/b missing"
 959 }
 960 run_test 24r "mkdir .../R14a/b; rename .../R14a .../R14a/b ====="
 961
 962 test_24s() {
 963         test_mkdir $DIR/R15a
 964         test_mkdir $DIR/R15a/b
 965         test_mkdir $DIR/R15a/b/c
 966         mrename $DIR/R15a $DIR/R15a/b/c && error "rename to sub-subdir worked!"
 967         $CHECKSTAT -t dir $DIR/R15a || error "$DIR/R15a missing"
 968         $CHECKSTAT -t dir $DIR/R15a/b/c || error "$DIR/R15a/b/c missing"
 969 }
 970 run_test 24s "mkdir .../R15a/b/c; rename .../R15a .../R15a/b/c ="
 971 test_24t() {
 972         test_mkdir $DIR/R16a
 973         test_mkdir $DIR/R16a/b
 974         test_mkdir $DIR/R16a/b/c
 975         mrename $DIR/R16a/b/c $DIR/R16a && error "rename to sub-subdir worked!"
 976         $CHECKSTAT -t dir $DIR/R16a || error "$DIR/R16a missing"
 977         $CHECKSTAT -t dir $DIR/R16a/b/c || error "$DIR/R16a/b/c missing"
 978 }
 979 run_test 24t "mkdir .../R16a/b/c; rename .../R16a/b/c .../R16a ="
 980
 981 test_24u() { # bug12192
 982         rm -rf $DIR/$tfile
 983         $MULTIOP $DIR/$tfile C2w$((2048 * 1024))c || error
 984         $CHECKSTAT -s $((2048 * 1024)) $DIR/$tfile || error "wrong file size"
 985 }
 986 run_test 24u "create stripe file"
 987
 988 page_size() {
 989         getconf PAGE_SIZE
 990 }
 991
 992 simple_cleanup_common() {
 993         trap 0
 994         rm -rf $DIR/$tdir
 995         wait_delete_completed
 996 }
 997
 998 max_pages_per_rpc() {
 999         $LCTL get_param -n mdc.*.max_pages_per_rpc | head -1
1000 }
1001
1002 test_24v() {
1003         local NRFILES=100000
1004         local FREE_INODES=$(lfs_df -i | grep "summary" | awk '{print $4}')
1005         [ $FREE_INODES -lt $NRFILES ] && \
1006                 skip "not enough free inodes $FREE_INODES required $NRFILES" &&
1007                 return
1008
1009         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1010         trap simple_cleanup_common EXIT
1011
1012         mkdir -p $DIR/$tdir
1013         createmany -m $DIR/$tdir/$tfile $NRFILES
1014
1015         cancel_lru_locks mdc
1016         lctl set_param mdc.*.stats clear
1017
1018         ls $DIR/$tdir >/dev/null || error "error in listing large dir"
1019
1020         # LU-5 large readdir
1021         # DIRENT_SIZE = 32 bytes for sizeof(struct lu_dirent) +
1022         #               8 bytes for name(filename is mostly 5 in this test) +
1023         #               8 bytes for luda_type
1024         # take into account of overhead in lu_dirpage header and end mark in
1025         # each page, plus one in RPC_NUM calculation.
1026         DIRENT_SIZE=48
1027         RPC_SIZE=$(($(max_pages_per_rpc) * $(page_size)))
1028         RPC_NUM=$(((NRFILES * DIRENT_SIZE + RPC_SIZE - 1) / RPC_SIZE + 1))
1029         mds_readpage=$(lctl get_param mdc.*MDT0000*.stats | \
1030                                 awk '/^mds_readpage/ {print $2}')
1031         [ $mds_readpage -gt $RPC_NUM ] && \
1032                 error "large readdir doesn't take effect"
1033
1034         simple_cleanup_common
1035 }
1036 run_test 24v "list directory with large files (handle hash collision, bug: 17560)"
1037
1038 test_24w() { # bug21506
1039         SZ1=234852
1040         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=4096 || return 1
1041         dd if=/dev/zero bs=$SZ1 count=1 >> $DIR/$tfile || return 2
1042         dd if=$DIR/$tfile of=$DIR/${tfile}_left bs=1M skip=4097 || return 3
1043         SZ2=`ls -l $DIR/${tfile}_left | awk '{print $5}'`
1044         [ "$SZ1" = "$SZ2" ] || \
1045                 error "Error reading at the end of the file $tfile"
1046 }
1047 run_test 24w "Reading a file larger than 4Gb"
1048
1049 test_24x() {
1050         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
1051         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1052         local MDTIDX=1
1053         local remote_dir=$DIR/$tdir/remote_dir
1054
1055         mkdir -p $DIR/$tdir
1056         $LFS mkdir -i $MDTIDX $remote_dir ||
1057                 error "create remote directory failed"
1058
1059         mkdir -p $DIR/$tdir/src_dir
1060         touch $DIR/$tdir/src_file
1061         mkdir -p $remote_dir/tgt_dir
1062         touch $remote_dir/tgt_file
1063
1064         mrename $DIR/$tdir/src_dir $remote_dir/tgt_dir &&
1065                 error "rename dir cross MDT works!"
1066
1067         mrename $DIR/$tdir/src_file $remote_dir/tgt_file &&
1068                 error "rename file cross MDT works!"
1069
1070         ln $DIR/$tdir/src_file $remote_dir/tgt_file1 &&
1071                 error "ln file cross MDT should not work!"
1072
1073         rm -rf $DIR/$tdir || error "Can not delete directories"
1074 }
1075 run_test 24x "cross rename/link should be failed"
1076
1077 test_24y() {
1078         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
1079         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1080         local MDTIDX=1
1081         local remote_dir=$DIR/$tdir/remote_dir
1082
1083         mkdir -p $DIR/$tdir
1084         $LFS mkdir -i $MDTIDX $remote_dir ||
1085                    error "create remote directory failed"
1086
1087         mkdir -p $remote_dir/src_dir
1088         touch $remote_dir/src_file
1089         mkdir -p $remote_dir/tgt_dir
1090         touch $remote_dir/tgt_file
1091
1092         mrename $remote_dir/src_dir $remote_dir/tgt_dir ||
1093                 error "rename subdir in the same remote dir failed!"
1094
1095         mrename $remote_dir/src_file $remote_dir/tgt_file ||
1096                 error "rename files in the same remote dir failed!"
1097
1098         ln $remote_dir/tgt_file $remote_dir/tgt_file1 ||
1099                 error "link files in the same remote dir failed!"
1100
1101         rm -rf $DIR/$tdir || error "Can not delete directories"
1102 }
1103 run_test 24y "rename/link on the same dir should succeed"
1104
1105 test_24z() {
1106         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
1107         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1108         local MDTIDX=1
1109         local remote_src=$DIR/$tdir/remote_dir
1110         local remote_tgt=$DIR/$tdir/remote_tgt
1111
1112         mkdir -p $DIR/$tdir
1113         $LFS mkdir -i $MDTIDX $remote_src ||
1114                    error "create remote directory failed"
1115
1116         $LFS mkdir -i $MDTIDX $remote_tgt ||
1117                    error "create remote directory failed"
1118
1119         mrename $remote_src $remote_tgt &&
1120                 error "rename remote dirs should not work!"
1121
1122         # If target dir does not exists, it should succeed
1123         rm -rf $remote_tgt
1124         mrename $remote_src $remote_tgt ||
1125                 error "rename remote dirs(tgt dir does not exists) failed!"
1126
1127         rm -rf $DIR/$tdir || error "Can not delete directories"
1128 }
1129 run_test 24z "rename one remote dir to another remote dir should fail"
1130
1131 test_25a() {
1132         echo '== symlink sanity ============================================='
1133
1134         test_mkdir $DIR/d25
1135         ln -s d25 $DIR/s25
1136         touch $DIR/s25/foo || error
1137 }
1138 run_test 25a "create file in symlinked directory ==============="
1139
1140 test_25b() {
1141         [ ! -d $DIR/d25 ] && test_25a
1142         $CHECKSTAT -t file $DIR/s25/foo || error
1143 }
1144 run_test 25b "lookup file in symlinked directory ==============="
1145
1146 test_26a() {
1147         test_mkdir $DIR/d26
1148         test_mkdir $DIR/d26/d26-2
1149         ln -s d26/d26-2 $DIR/s26
1150         touch $DIR/s26/foo || error
1151 }
1152 run_test 26a "multiple component symlink ======================="
1153
1154 test_26b() {
1155         test_mkdir -p $DIR/d26b/d26-2
1156         ln -s d26b/d26-2/foo $DIR/s26-2
1157         touch $DIR/s26-2 || error
1158 }
1159 run_test 26b "multiple component symlink at end of lookup ======"
1160
1161 test_26c() {
1162         test_mkdir $DIR/d26.2
1163         touch $DIR/d26.2/foo
1164         ln -s d26.2 $DIR/s26.2-1
1165         ln -s s26.2-1 $DIR/s26.2-2
1166         ln -s s26.2-2 $DIR/s26.2-3
1167         chmod 0666 $DIR/s26.2-3/foo
1168 }
1169 run_test 26c "chain of symlinks ================================"
1170
1171 # recursive symlinks (bug 439)
1172 test_26d() {
1173         ln -s d26-3/foo $DIR/d26-3
1174 }
1175 run_test 26d "create multiple component recursive symlink ======"
1176
1177 test_26e() {
1178         [ ! -h $DIR/d26-3 ] && test_26d
1179         rm $DIR/d26-3
1180 }
1181 run_test 26e "unlink multiple component recursive symlink ======"
1182
1183 # recursive symlinks (bug 7022)
1184 test_26f() {
1185         test_mkdir -p $DIR/$tdir
1186         test_mkdir $DIR/$tdir/$tfile   || error "mkdir $DIR/$tdir/$tfile failed"
1187         cd $DIR/$tdir/$tfile           || error "cd $DIR/$tdir/$tfile failed"
1188         test_mkdir -p lndir bar1      || error "mkdir lndir/bar1 failed"
1189         test_mkdir $DIR/$tdir/$tfile/$tfile   || error "mkdir $tfile failed"
1190         cd $tfile                || error "cd $tfile failed"
1191         ln -s .. dotdot          || error "ln dotdot failed"
1192         ln -s dotdot/lndir lndir || error "ln lndir failed"
1193         cd $DIR/$tdir                 || error "cd $DIR/$tdir failed"
1194         output=`ls $tfile/$tfile/lndir/bar1`
1195         [ "$output" = bar1 ] && error "unexpected output"
1196         rm -r $tfile             || error "rm $tfile failed"
1197         $CHECKSTAT -a $DIR/$tfile || error "$tfile not gone"
1198 }
1199 run_test 26f "rm -r of a directory which has recursive symlink ="
1200
1201 test_27a() {
1202         echo '== stripe sanity =============================================='
1203         test_mkdir -p $DIR/d27 || error "mkdir failed"
1204         $GETSTRIPE $DIR/d27
1205         $SETSTRIPE -c 1 $DIR/d27/f0 || error "setstripe failed"
1206         $CHECKSTAT -t file $DIR/d27/f0 || error "checkstat failed"
1207         pass
1208         log "== test_27a: write to one stripe file ========================="
1209         cp /etc/hosts $DIR/d27/f0 || error
1210 }
1211 run_test 27a "one stripe file =================================="
1212
1213 test_27b() {
1214         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
1215         test_mkdir -p $DIR/d27
1216         $SETSTRIPE -c 2 $DIR/d27/f01 || error "setstripe failed"
1217         $GETSTRIPE -c $DIR/d27/f01
1218         [ $($GETSTRIPE -c $DIR/d27/f01) -eq 2 ] ||
1219                 error "two-stripe file doesn't have two stripes"
1220 }
1221 run_test 27b "create two stripe file"
1222
1223 test_27c() {
1224         [ -f $DIR/d27/f01 ] || skip "test_27b not run" && return
1225
1226         dd if=/dev/zero of=$DIR/d27/f01 bs=4k count=4 || error "dd failed"
1227 }
1228 run_test 27c "write to two stripe file"
1229
1230 test_27d() {
1231         test_mkdir -p $DIR/d27
1232         $SETSTRIPE -c 0 -i -1 -S 0 $DIR/d27/fdef || error "setstripe failed"
1233         $CHECKSTAT -t file $DIR/d27/fdef || error "checkstat failed"
1234         dd if=/dev/zero of=$DIR/d27/fdef bs=4k count=4 || error
1235 }
1236 run_test 27d "create file with default settings ================"
1237
1238 test_27e() {
1239         test_mkdir -p $DIR/d27
1240         $SETSTRIPE -c 2 $DIR/d27/f12 || error "setstripe failed"
1241         $SETSTRIPE -c 2 $DIR/d27/f12 && error "setstripe succeeded twice"
1242         $CHECKSTAT -t file $DIR/d27/f12 || error "checkstat failed"
1243 }
1244 run_test 27e "setstripe existing file (should return error) ======"
1245
1246 test_27f() {
1247         test_mkdir -p $DIR/d27
1248         $SETSTRIPE -S 100 -i 0 -c 1 $DIR/d27/fbad && error "setstripe failed"
1249         dd if=/dev/zero of=$DIR/d27/fbad bs=4k count=4 || error "dd failed"
1250         $GETSTRIPE $DIR/d27/fbad || error "$GETSTRIPE failed"
1251 }
1252 run_test 27f "setstripe with bad stripe size (should return error)"
1253
1254 test_27g() {
1255         test_mkdir -p $DIR/d27
1256         $MCREATE $DIR/d27/fnone || error "mcreate failed"
1257         $GETSTRIPE $DIR/d27/fnone 2>&1 | grep "no stripe info" ||
1258                 error "$DIR/d27/fnone has object"
1259 }
1260 run_test 27g "$GETSTRIPE with no objects"
1261
1262 test_27i() {
1263         touch $DIR/d27/fsome || error "touch failed"
1264         [ $($GETSTRIPE -c $DIR/d27/fsome) -gt 0 ] || error "missing objects"
1265 }
1266 run_test 27i "$GETSTRIPE with some objects"
1267
1268 test_27j() {
1269         test_mkdir -p $DIR/d27
1270         $SETSTRIPE -i $OSTCOUNT $DIR/d27/f27j && error "setstripe failed"||true
1271 }
1272 run_test 27j "setstripe with bad stripe offset (should return error)"
1273
1274 test_27k() { # bug 2844
1275         test_mkdir -p $DIR/d27
1276         FILE=$DIR/d27/f27k
1277         LL_MAX_BLKSIZE=$((4 * 1024 * 1024))
1278         [ ! -d $DIR/d27 ] && test_mkdir -p $DIR d27
1279         $SETSTRIPE -S 67108864 $FILE || error "setstripe failed"
1280         BLKSIZE=`stat $FILE | awk '/IO Block:/ { print $7 }'`
1281         [ $BLKSIZE -le $LL_MAX_BLKSIZE ] || error "$BLKSIZE > $LL_MAX_BLKSIZE"
1282         dd if=/dev/zero of=$FILE bs=4k count=1
1283         BLKSIZE=`stat $FILE | awk '/IO Block:/ { print $7 }'`
1284         [ $BLKSIZE -le $LL_MAX_BLKSIZE ] || error "$BLKSIZE > $LL_MAX_BLKSIZE"
1285 }
1286 run_test 27k "limit i_blksize for broken user apps ============="
1287
1288 test_27l() {
1289         test_mkdir -p $DIR/d27
1290         mcreate $DIR/f27l || error "creating file"
1291         $RUNAS $SETSTRIPE -c 1 $DIR/f27l && \
1292                 error "setstripe should have failed" || true
1293 }
1294 run_test 27l "check setstripe permissions (should return error)"
1295
1296 test_27m() {
1297         [ "$OSTCOUNT" -lt "2" ] && skip_env "$OSTCOUNT < 2 OSTs -- skipping" &&
1298                 return
1299         if [ $ORIGFREE -gt $MAXFREE ]; then
1300                 skip "$ORIGFREE > $MAXFREE skipping out-of-space test on OST0"
1301                 return
1302         fi
1303         trap simple_cleanup_common EXIT
1304         test_mkdir -p $DIR/$tdir
1305         $SETSTRIPE -i 0 -c 1 $DIR/$tdir/f27m_1
1306         dd if=/dev/zero of=$DIR/$tdir/f27m_1 bs=1024 count=$MAXFREE &&
1307                 error "dd should fill OST0"
1308         i=2
1309         while $SETSTRIPE -i 0 -c 1 $DIR/$tdir/f27m_$i; do
1310                 i=`expr $i + 1`
1311                 [ $i -gt 256 ] && break
1312         done
1313         i=`expr $i + 1`
1314         touch $DIR/$tdir/f27m_$i
1315         [ `$GETSTRIPE $DIR/$tdir/f27m_$i | grep -A 10 obdidx | awk '{print $1}'| grep -w "0"` ] &&
1316                 error "OST0 was full but new created file still use it"
1317         i=`expr $i + 1`
1318         touch $DIR/$tdir/f27m_$i
1319         [ `$GETSTRIPE $DIR/$tdir/f27m_$i | grep -A 10 obdidx | awk '{print $1}'| grep -w "0"` ] &&
1320                 error "OST0 was full but new created file still use it"
1321         simple_cleanup_common
1322 }
1323 run_test 27m "create file while OST0 was full =================="
1324
1325 sleep_maxage() {
1326         local DELAY=$(do_facet $SINGLEMDS lctl get_param -n lov.*.qos_maxage | head -n 1 | awk '{print $1 * 2}')
1327         sleep $DELAY
1328 }
1329
1330 # OSCs keep a NOSPC flag that will be reset after ~5s (qos_maxage)
1331 # if the OST isn't full anymore.
1332 reset_enospc() {
1333         local OSTIDX=${1:-""}
1334
1335         local list=$(comma_list $(osts_nodes))
1336         [ "$OSTIDX" ] && list=$(facet_host ost$((OSTIDX + 1)))
1337
1338         do_nodes $list lctl set_param fail_loc=0
1339         sync    # initiate all OST_DESTROYs from MDS to OST
1340         sleep_maxage
1341 }
1342
1343 exhaust_precreations() {
1344         local OSTIDX=$1
1345         local FAILLOC=$2
1346         local FAILIDX=${3:-$OSTIDX}
1347
1348         test_mkdir -p $DIR/$tdir
1349         local MDSIDX=$(get_mds_dir "$DIR/$tdir")
1350         echo OSTIDX=$OSTIDX MDSIDX=$MDSIDX
1351
1352         local OST=$(ostname_from_index $OSTIDX)
1353         local MDT_INDEX=$(lfs df | grep "\[MDT:$((MDSIDX - 1))\]" | awk '{print $1}' | \
1354                           sed -e 's/_UUID$//;s/^.*-//')
1355
1356         # on the mdt's osc
1357         local mdtosc_proc1=$(get_mdtosc_proc_path mds${MDSIDX} $OST)
1358         local last_id=$(do_facet mds${MDSIDX} lctl get_param -n \
1359         osc.$mdtosc_proc1.prealloc_last_id)
1360         local next_id=$(do_facet mds${MDSIDX} lctl get_param -n \
1361         osc.$mdtosc_proc1.prealloc_next_id)
1362
1363         local mdtosc_proc2=$(get_mdtosc_proc_path mds${MDSIDX})
1364         do_facet mds${MDSIDX} lctl get_param osc.$mdtosc_proc2.prealloc*
1365
1366         test_mkdir -p $DIR/$tdir/${OST}
1367         $SETSTRIPE -i $OSTIDX -c 1 $DIR/$tdir/${OST}
1368 #define OBD_FAIL_OST_ENOSPC              0x215
1369         do_facet ost$((OSTIDX + 1)) lctl set_param fail_val=$FAILIDX
1370         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=0x215
1371         echo "Creating to objid $last_id on ost $OST..."
1372         createmany -o $DIR/$tdir/${OST}/f $next_id $((last_id - next_id + 2))
1373         do_facet mds${MDSIDX} lctl get_param osc.$mdtosc_proc2.prealloc*
1374         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=$FAILLOC
1375         sleep_maxage
1376 }
1377
1378 exhaust_all_precreations() {
1379         local i
1380         for (( i=0; i < OSTCOUNT; i++ )) ; do
1381                 exhaust_precreations $i $1 -1
1382         done
1383 }
1384
1385 test_27n() {
1386         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1387         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1388         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1389         remote_ost_nodsh && skip "remote OST with nodsh" && return
1390
1391         reset_enospc
1392         rm -f $DIR/$tdir/$tfile
1393         exhaust_precreations 0 0x80000215
1394         $SETSTRIPE -c -1 $DIR/$tdir
1395         touch $DIR/$tdir/$tfile || error
1396         $GETSTRIPE $DIR/$tdir/$tfile
1397         reset_enospc
1398 }
1399 run_test 27n "create file with some full OSTs =================="
1400
1401 test_27o() {
1402         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1403         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1404         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1405         remote_ost_nodsh && skip "remote OST with nodsh" && return
1406
1407         reset_enospc
1408         rm -f $DIR/$tdir/$tfile
1409         exhaust_all_precreations 0x215
1410
1411         touch $DIR/$tdir/$tfile && error "able to create $DIR/$tdir/$tfile"
1412
1413         reset_enospc
1414         rm -rf $DIR/$tdir/*
1415 }
1416 run_test 27o "create file with all full OSTs (should error) ===="
1417
1418 test_27p() {
1419         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1420         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1421         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1422         remote_ost_nodsh && skip "remote OST with nodsh" && return
1423
1424         reset_enospc
1425         rm -f $DIR/$tdir/$tfile
1426         test_mkdir -p $DIR/$tdir
1427
1428         $MCREATE $DIR/$tdir/$tfile || error "mcreate failed"
1429         $TRUNCATE $DIR/$tdir/$tfile 80000000 || error "truncate failed"
1430         $CHECKSTAT -s 80000000 $DIR/$tdir/$tfile || error "checkstat failed"
1431
1432         exhaust_precreations 0 0x80000215
1433         echo foo >> $DIR/$tdir/$tfile || error "append failed"
1434         $CHECKSTAT -s 80000004 $DIR/$tdir/$tfile || error "checkstat failed"
1435         $GETSTRIPE $DIR/$tdir/$tfile
1436
1437         reset_enospc
1438 }
1439 run_test 27p "append to a truncated file with some full OSTs ==="
1440
1441 test_27q() {
1442         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1443         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1444         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1445         remote_ost_nodsh && skip "remote OST with nodsh" && return
1446
1447         reset_enospc
1448         rm -f $DIR/$tdir/$tfile
1449
1450         test_mkdir -p $DIR/$tdir
1451         $MCREATE $DIR/$tdir/$tfile || error "mcreate $DIR/$tdir/$tfile failed"
1452         $TRUNCATE $DIR/$tdir/$tfile 80000000 ||error "truncate $DIR/$tdir/$tfile failed"
1453         $CHECKSTAT -s 80000000 $DIR/$tdir/$tfile || error "checkstat failed"
1454
1455         exhaust_all_precreations 0x215
1456
1457         echo foo >> $DIR/$tdir/$tfile && error "append succeeded"
1458         $CHECKSTAT -s 80000000 $DIR/$tdir/$tfile || error "checkstat 2 failed"
1459
1460         reset_enospc
1461 }
1462 run_test 27q "append to truncated file with all OSTs full (should error) ==="
1463
1464 test_27r() {
1465         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1466         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1467         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1468         remote_ost_nodsh && skip "remote OST with nodsh" && return
1469
1470         reset_enospc
1471         rm -f $DIR/$tdir/$tfile
1472         exhaust_precreations 0 0x80000215
1473
1474         $SETSTRIPE -i 0 -c 2 $DIR/$tdir/$tfile # && error
1475
1476         reset_enospc
1477 }
1478 run_test 27r "stripe file with some full OSTs (shouldn't LBUG) ="
1479
1480 test_27s() { # bug 10725
1481         test_mkdir -p $DIR/$tdir
1482         local stripe_size=$((4096 * 1024 * 1024))       # 2^32
1483         local stripe_count=0
1484         [ $OSTCOUNT -eq 1 ] || stripe_count=2
1485         $SETSTRIPE -S $stripe_size -c $stripe_count $DIR/$tdir &&
1486                 error "stripe width >= 2^32 succeeded" || true
1487
1488 }
1489 run_test 27s "lsm_xfersize overflow (should error) (bug 10725)"
1490
1491 test_27t() { # bug 10864
1492         WDIR=`pwd`
1493         WLFS=`which lfs`
1494         cd $DIR
1495         touch $tfile
1496         $WLFS getstripe $tfile
1497         cd $WDIR
1498 }
1499 run_test 27t "check that utils parse path correctly"
1500
1501 test_27u() { # bug 4900
1502         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1503         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1504         local index
1505         local list=$(comma_list $(mdts_nodes))
1506
1507 #define OBD_FAIL_MDS_OSC_PRECREATE      0x139
1508         do_nodes $list $LCTL set_param fail_loc=0x139
1509         test_mkdir -p $DIR/$tdir
1510         rm -rf $DIR/$tdir/*
1511         createmany -o $DIR/$tdir/t- 1000
1512         do_nodes $list $LCTL set_param fail_loc=0
1513
1514         TLOG=$DIR/$tfile.getstripe
1515         $GETSTRIPE $DIR/$tdir > $TLOG
1516         OBJS=`awk -vobj=0 '($1 == 0) { obj += 1 } END { print obj;}' $TLOG`
1517         unlinkmany $DIR/$tdir/t- 1000
1518         [ $OBJS -gt 0 ] && \
1519                 error "$OBJS objects created on OST-0.  See $TLOG" || pass
1520 }
1521 run_test 27u "skip object creation on OSC w/o objects =========="
1522
1523 test_27v() { # bug 4900
1524         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1525         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1526         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1527         remote_ost_nodsh && skip "remote OST with nodsh" && return
1528
1529         exhaust_all_precreations 0x215
1530         reset_enospc
1531
1532         test_mkdir -p $DIR/$tdir
1533         $SETSTRIPE -c 1 $DIR/$tdir         # 1 stripe / file
1534
1535         touch $DIR/$tdir/$tfile
1536         #define OBD_FAIL_TGT_DELAY_PRECREATE     0x705
1537         # all except ost1
1538         for (( i=1; i < OSTCOUNT; i++ )); do
1539                 do_facet ost$i lctl set_param fail_loc=0x705
1540         done
1541         local START=`date +%s`
1542         createmany -o $DIR/$tdir/$tfile 32
1543
1544         local FINISH=`date +%s`
1545         local TIMEOUT=`lctl get_param -n timeout`
1546         local PROCESS=$((FINISH - START))
1547         [ $PROCESS -ge $((TIMEOUT / 2)) ] && \
1548                error "$FINISH - $START >= $TIMEOUT / 2"
1549         sleep $((TIMEOUT / 2 - PROCESS))
1550         reset_enospc
1551 }
1552 run_test 27v "skip object creation on slow OST ================="
1553
1554 test_27w() { # bug 10997
1555         test_mkdir -p $DIR/$tdir || error "mkdir failed"
1556         $SETSTRIPE -S 65536 $DIR/$tdir/f0 || error "setstripe failed"
1557         [ $($GETSTRIPE -S $DIR/$tdir/f0) -ne 65536 ] &&
1558                 error "stripe size $size != 65536" || true
1559         [ $($GETSTRIPE -d $DIR/$tdir | grep -c "stripe_count") -ne 1 ] &&
1560                 error "$GETSTRIPE -d $DIR/$tdir failed" || true
1561 }
1562 run_test 27w "check $SETSTRIPE -S option"
1563
1564 test_27wa() {
1565         [ "$OSTCOUNT" -lt "2" ] &&
1566                 skip_env "skipping multiple stripe count/offset test" && return
1567
1568         test_mkdir -p $DIR/$tdir || error "mkdir failed"
1569         for i in $(seq 1 $OSTCOUNT); do
1570                 offset=$((i - 1))
1571                 $SETSTRIPE -c $i -i $offset $DIR/$tdir/f$i ||
1572                         error "setstripe -c $i -i $offset failed"
1573                 count=$($GETSTRIPE -c $DIR/$tdir/f$i)
1574                 index=$($GETSTRIPE -i $DIR/$tdir/f$i)
1575                 [ $count -ne $i ] && error "stripe count $count != $i" || true
1576                 [ $index -ne $offset ] &&
1577                         error "stripe offset $index != $offset" || true
1578         done
1579 }
1580 run_test 27wa "check $SETSTRIPE -c -i options"
1581
1582 test_27x() {
1583         remote_ost_nodsh && skip "remote OST with nodsh" && return
1584         [ "$OSTCOUNT" -lt "2" ] && skip_env "$OSTCOUNT < 2 OSTs" && return
1585         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1586         OFFSET=$(($OSTCOUNT - 1))
1587         OSTIDX=0
1588         local OST=$(ostname_from_index $OSTIDX)
1589
1590         test_mkdir -p $DIR/$tdir
1591         $SETSTRIPE -c 1 $DIR/$tdir      # 1 stripe per file
1592         do_facet ost$((OSTIDX + 1)) lctl set_param -n obdfilter.$OST.degraded 1
1593         sleep_maxage
1594         createmany -o $DIR/$tdir/$tfile $OSTCOUNT
1595         for i in `seq 0 $OFFSET`; do
1596                 [ `$GETSTRIPE $DIR/$tdir/$tfile$i | grep -A 10 obdidx | awk '{print $1}' | grep -w "$OSTIDX"` ] &&
1597                 error "OST0 was degraded but new created file still use it"
1598         done
1599         do_facet ost$((OSTIDX + 1)) lctl set_param -n obdfilter.$OST.degraded 0
1600 }
1601 run_test 27x "create files while OST0 is degraded"
1602
1603 test_27y() {
1604         [ "$OSTCOUNT" -lt "2" ] && skip_env "$OSTCOUNT < 2 OSTs -- skipping" && return
1605         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1606         remote_ost_nodsh && skip "remote OST with nodsh" && return
1607         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1608
1609         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS $FSNAME-OST0000)
1610         local last_id=$(do_facet $SINGLEMDS lctl get_param -n \
1611             osc.$mdtosc.prealloc_last_id)
1612         local next_id=$(do_facet $SINGLEMDS lctl get_param -n \
1613             osc.$mdtosc.prealloc_next_id)
1614         local fcount=$((last_id - next_id))
1615         [ $fcount -eq 0 ] && skip "not enough space on OST0" && return
1616         [ $fcount -gt $OSTCOUNT ] && fcount=$OSTCOUNT
1617
1618         local MDS_OSCS=$(do_facet $SINGLEMDS lctl dl |
1619                          awk '/[oO][sS][cC].*md[ts]/ { print $4 }')
1620         local OST_DEACTIVE_IDX=-1
1621         local OSC
1622         local OSTIDX
1623         local OST
1624
1625         for OSC in $MDS_OSCS; do
1626                 OST=$(osc_to_ost $OSC)
1627                 OSTIDX=$(index_from_ostuuid $OST)
1628                 if [ $OST_DEACTIVE_IDX == -1 ]; then
1629                         OST_DEACTIVE_IDX=$OSTIDX
1630                 fi
1631                 if [ $OSTIDX != $OST_DEACTIVE_IDX ]; then
1632                         echo $OSC "is Deactivated:"
1633                         do_facet $SINGLEMDS lctl --device  %$OSC deactivate
1634                 fi
1635         done
1636
1637         OSTIDX=$(index_from_ostuuid $OST)
1638         mkdir -p $DIR/$tdir
1639         $SETSTRIPE -c 1 $DIR/$tdir      # 1 stripe / file
1640
1641         for OSC in $MDS_OSCS; do
1642                 OST=$(osc_to_ost $OSC)
1643                 OSTIDX=$(index_from_ostuuid $OST)
1644                 if [ $OSTIDX == $OST_DEACTIVE_IDX ]; then
1645                         echo $OST "is degraded:"
1646                         do_facet ost$((OSTIDX+1)) lctl set_param -n \
1647                                                 obdfilter.$OST.degraded=1
1648                 fi
1649         done
1650
1651         sleep_maxage
1652         createmany -o $DIR/$tdir/$tfile $fcount
1653
1654         for OSC in $MDS_OSCS; do
1655                 OST=$(osc_to_ost $OSC)
1656                 OSTIDX=$(index_from_ostuuid $OST)
1657                 if [ $OSTIDX == $OST_DEACTIVE_IDX ]; then
1658                         echo $OST "is recovered from degraded:"
1659                         do_facet ost$((OSTIDX+1)) lctl set_param -n \
1660                                                 obdfilter.$OST.degraded=0
1661                 else
1662                         do_facet $SINGLEMDS lctl --device %$OSC activate
1663                 fi
1664         done
1665
1666         # all osp devices get activated, hence -1 stripe count restored
1667         local stripecnt=0
1668
1669         # sleep 2*lod_qos_maxage seconds waiting for lod qos to notice osp
1670         # devices get activated.
1671         sleep_maxage
1672         $SETSTRIPE -c -1 $DIR/$tfile
1673         stripecnt=$($GETSTRIPE -c $DIR/$tfile)
1674         rm -f $DIR/$tfile
1675         [ $stripecnt -ne $OSTCOUNT ] &&
1676                 error "Of $OSTCOUNT OSTs, only $stripecnt is available"
1677         return 0
1678 }
1679 run_test 27y "create files while OST0 is degraded and the rest inactive"
1680
1681 check_seq_oid()
1682 {
1683         log "check file $1"
1684
1685         lmm_count=$($GETSTRIPE -c $1)
1686         lmm_seq=$($GETSTRIPE -v $1 | awk '/lmm_seq/ { print $2 }')
1687         lmm_oid=$($GETSTRIPE -v $1 | awk '/lmm_object_id/ { print $2 }')
1688
1689         local old_ifs="$IFS"
1690         IFS=$'[:]'
1691         fid=($($LFS path2fid $1))
1692         IFS="$old_ifs"
1693
1694         log "FID seq ${fid[1]}, oid ${fid[2]} ver ${fid[3]}"
1695         log "LOV seq $lmm_seq, oid $lmm_oid, count: $lmm_count"
1696
1697         # compare lmm_seq and lu_fid->f_seq
1698         [ $lmm_seq = ${fid[1]} ] || { error "SEQ mismatch"; return 1; }
1699         # compare lmm_object_id and lu_fid->oid
1700         [ $lmm_oid = ${fid[2]} ] || { error "OID mismatch"; return 2; }
1701
1702         # check the trusted.fid attribute of the OST objects of the file
1703         local have_obdidx=false
1704         local stripe_nr=0
1705         $GETSTRIPE $1 | while read obdidx oid hex seq; do
1706                 # skip lines up to and including "obdidx"
1707                 [ -z "$obdidx" ] && break
1708                 [ "$obdidx" = "obdidx" ] && have_obdidx=true && continue
1709                 $have_obdidx || continue
1710
1711                 local ost=$((obdidx + 1))
1712                 local dev=$(ostdevname $ost)
1713                 local oid_hex
1714
1715                 if [ $(facet_fstype ost$ost) != ldiskfs ]; then
1716                         echo "Currently only works with ldiskfs-based OSTs"
1717                         continue
1718                 fi
1719
1720                 log "want: stripe:$stripe_nr ost:$obdidx oid:$oid/$hex seq:$seq"
1721
1722                 #don't unmount/remount the OSTs if we don't need to do that
1723                 # LU-2577 changes filter_fid to be smaller, so debugfs needs
1724                 # update too, until that use mount/ll_decode_filter_fid/mount
1725                 local dir=$(facet_mntpt ost$ost)
1726                 local opts=${OST_MOUNT_OPTS}
1727
1728                 if !  do_facet ost$ost test -b ${dev}; then
1729                         opts=$(csa_add "$opts" -o loop)
1730                 fi
1731
1732                 stop ost$ost
1733                 do_facet ost$ost mount -t $(facet_fstype ost$ost) $opts $dev $dir ||
1734                         { error "mounting $dev as $FSTYPE failed"; return 3; }
1735
1736                 seq=$(echo $seq | sed -e "s/^0x//g")
1737                 if [ $seq == 0 ]; then
1738                         oid_hex=$(echo $oid)
1739                 else
1740                         oid_hex=$(echo $hex | sed -e "s/^0x//g")
1741                 fi
1742                 local obj_file=$(do_facet ost$ost find $dir/O/$seq -name $oid_hex)
1743                 local ff=$(do_facet ost$ost $LL_DECODE_FILTER_FID $obj_file)
1744                 do_facet ost$ost umount -d $dir
1745                 start ost$ost $dev $OST_MOUNT_OPTS
1746
1747                 # re-enable when debugfs will understand new filter_fid
1748                 #local ff=$(do_facet ost$ost "$DEBUGFS -c -R 'stat $obj_file' \
1749                 #           $dev 2>/dev/null" | grep "parent=")
1750
1751                 [ -z "$ff" ] && error "$obj_file: no filter_fid info"
1752
1753                 echo "$ff" | sed -e 's#.*objid=#got: objid=#'
1754
1755                 # /mnt/O/0/d23/23: objid=23 seq=0 parent=[0x200000400:0x1e:0x1]
1756                 # fid: objid=23 seq=0 parent=[0x200000400:0x1e:0x0] stripe=1
1757                 local ff_parent=$(echo $ff|sed -e 's/.*parent=.//')
1758                 local ff_pseq=$(echo $ff_parent | cut -d: -f1)
1759                 local ff_poid=$(echo $ff_parent | cut -d: -f2)
1760                 local ff_pstripe=$(echo $ff_parent | sed -e 's/.*stripe=//')
1761
1762                 # compare lmm_seq and filter_fid->ff_parent.f_seq
1763                 [ $ff_pseq = $lmm_seq ] ||
1764                         error "FF parent SEQ $ff_pseq != $lmm_seq"
1765                 # compare lmm_object_id and filter_fid->ff_parent.f_oid
1766                 [ $ff_poid = $lmm_oid ] ||
1767                         error "FF parent OID $ff_poid != $lmm_oid"
1768                 [ $ff_pstripe = $stripe_nr ] ||
1769                         error "FF stripe $ff_pstripe != $stripe_nr"
1770
1771                 stripe_nr=$((stripe_nr + 1))
1772         done
1773 }
1774
1775 test_27z() {
1776         remote_ost_nodsh && skip "remote OST with nodsh" && return
1777         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1778         test_mkdir -p $DIR/$tdir
1779
1780         $SETSTRIPE -c 1 -i 0 -S 64k $DIR/$tdir/$tfile-1 ||
1781                 { error "setstripe -c -1 failed"; return 1; }
1782         # We need to send a write to every object to get parent FID info set.
1783         # This _should_ also work for setattr, but does not currently.
1784         # touch $DIR/$tdir/$tfile-1 ||
1785         dd if=/dev/zero of=$DIR/$tdir/$tfile-1 bs=1M count=1 ||
1786                 { error "dd $tfile-1 failed"; return 2; }
1787         $SETSTRIPE -c -1 -i $((OSTCOUNT - 1)) -S 1M $DIR/$tdir/$tfile-2 ||
1788                 { error "setstripe -c -1 failed"; return 3; }
1789         dd if=/dev/zero of=$DIR/$tdir/$tfile-2 bs=1M count=$OSTCOUNT ||
1790                 { error "dd $tfile-2 failed"; return 4; }
1791
1792         # make sure write RPCs have been sent to OSTs
1793         sync; sleep 5; sync
1794
1795         check_seq_oid $DIR/$tdir/$tfile-1 || return 5
1796         check_seq_oid $DIR/$tdir/$tfile-2 || return 6
1797 }
1798 run_test 27z "check SEQ/OID on the MDT and OST filesystems"
1799
1800 test_27A() { # b=19102
1801         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1802         local restore_size=$($GETSTRIPE -S $MOUNT)
1803         local restore_count=$($GETSTRIPE -c $MOUNT)
1804         local restore_offset=$($GETSTRIPE -i $MOUNT)
1805         $SETSTRIPE -c 0 -i -1 -S 0 $MOUNT
1806         local default_size=$($GETSTRIPE -S $MOUNT)
1807         local default_count=$($GETSTRIPE -c $MOUNT)
1808         local default_offset=$($GETSTRIPE -i $MOUNT)
1809         local dsize=$((1024 * 1024))
1810         [ $default_size -eq $dsize ] ||
1811                 error "stripe size $default_size != $dsize"
1812         [ $default_count -eq 1 ] || error "stripe count $default_count != 1"
1813         [ $default_offset -eq -1 ] ||error "stripe offset $default_offset != -1"
1814         $SETSTRIPE -c $restore_count -i $restore_offset -S $restore_size $MOUNT
1815 }
1816 run_test 27A "check filesystem-wide default LOV EA values"
1817
1818 test_27B() { # LU-2523
1819         test_mkdir -p $DIR/$tdir
1820         rm -f $DIR/$tdir/f0 $DIR/$tdir/f1
1821         touch $DIR/$tdir/f0
1822         # open f1 with O_LOV_DELAY_CREATE
1823         # rename f0 onto f1
1824         # call setstripe ioctl on open file descriptor for f1
1825         # close
1826         multiop $DIR/$tdir/f1 oO_RDWR:O_CREAT:O_LOV_DELAY_CREATE:nB1c \
1827                 $DIR/$tdir/f0
1828
1829         rm -f $DIR/$tdir/f1
1830         # open f1 with O_LOV_DELAY_CREATE
1831         # unlink f1
1832         # call setstripe ioctl on open file descriptor for f1
1833         # close
1834         multiop $DIR/$tdir/f1 oO_RDWR:O_CREAT:O_LOV_DELAY_CREATE:uB1c
1835
1836         # Allow multiop to fail in imitation of NFS's busted semantics.
1837         true
1838 }
1839 run_test 27B "call setstripe on open unlinked file/rename victim"
1840
1841 test_27C() { #LU-2871
1842         [ $OSTCOUNT -lt 2 ] && skip "needs >= 2 OSTs" && return
1843
1844         declare -a ost_idx
1845         local index
1846         local i
1847         local j
1848
1849         test_mkdir -p $DIR/$tdir
1850         cd $DIR/$tdir
1851         for i in $(seq 0 $((OSTCOUNT - 1))); do
1852                 # set stripe across all OSTs starting from OST$i
1853                 $SETSTRIPE -i $i -c -1 $tfile$i
1854                 # get striping information
1855                 ost_idx=($($GETSTRIPE $tfile$i |
1856                          tail -n $((OSTCOUNT + 1)) | awk '{print $1}'))
1857                 echo ${ost_idx[@]}
1858                 # check the layout
1859                 for j in $(seq 0 $((OSTCOUNT - 1))); do
1860                         index=$(((i + j) % OSTCOUNT))
1861                         [ ${ost_idx[$j]} -eq $index ] ||
1862                                 error "$j:${ost_idx[$j]} != $index"
1863                 done
1864         done
1865 }
1866 run_test 27C "check full striping across all OSTs"
1867
1868 # createtest also checks that device nodes are created and
1869 # then visible correctly (#2091)
1870 test_28() { # bug 2091
1871         test_mkdir $DIR/d28
1872         $CREATETEST $DIR/d28/ct || error
1873 }
1874 run_test 28 "create/mknod/mkdir with bad file types ============"
1875
1876 test_29() {
1877         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1878         cancel_lru_locks mdc
1879         test_mkdir $DIR/d29
1880         touch $DIR/d29/foo
1881         log 'first d29'
1882         ls -l $DIR/d29
1883
1884         declare -i LOCKCOUNTORIG=0
1885         for lock_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_count); do
1886                 let LOCKCOUNTORIG=$LOCKCOUNTORIG+$lock_count
1887         done
1888         [ $LOCKCOUNTORIG -eq 0 ] && echo "No mdc lock count" && return 1
1889
1890         declare -i LOCKUNUSEDCOUNTORIG=0
1891         for unused_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_unused_count); do
1892                 let LOCKUNUSEDCOUNTORIG=$LOCKUNUSEDCOUNTORIG+$unused_count
1893         done
1894
1895         log 'second d29'
1896         ls -l $DIR/d29
1897         log 'done'
1898
1899         declare -i LOCKCOUNTCURRENT=0
1900         for lock_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_count); do
1901                 let LOCKCOUNTCURRENT=$LOCKCOUNTCURRENT+$lock_count
1902         done
1903
1904         declare -i LOCKUNUSEDCOUNTCURRENT=0
1905         for unused_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_unused_count); do
1906                 let LOCKUNUSEDCOUNTCURRENT=$LOCKUNUSEDCOUNTCURRENT+$unused_count
1907         done
1908
1909         if [ "$LOCKCOUNTCURRENT" -gt "$LOCKCOUNTORIG" ]; then
1910                 lctl set_param -n ldlm.dump_namespaces ""
1911                 error "CURRENT: $LOCKCOUNTCURRENT > $LOCKCOUNTORIG"
1912                 $LCTL dk | sort -k4 -t: > $TMP/test_29.dk
1913                 log "dumped log to $TMP/test_29.dk (bug 5793)"
1914                 return 2
1915         fi
1916         if [ "$LOCKUNUSEDCOUNTCURRENT" -gt "$LOCKUNUSEDCOUNTORIG" ]; then
1917                 error "UNUSED: $LOCKUNUSEDCOUNTCURRENT > $LOCKUNUSEDCOUNTORIG"
1918                 $LCTL dk | sort -k4 -t: > $TMP/test_29.dk
1919                 log "dumped log to $TMP/test_29.dk (bug 5793)"
1920                 return 3
1921         fi
1922 }
1923 run_test 29 "IT_GETATTR regression  ============================"
1924
1925 test_30a() { # was test_30
1926         cp `which ls` $DIR || cp /bin/ls $DIR
1927         $DIR/ls / || error
1928         rm $DIR/ls
1929 }
1930 run_test 30a "execute binary from Lustre (execve) =============="
1931
1932 test_30b() {
1933         cp `which ls` $DIR || cp /bin/ls $DIR
1934         chmod go+rx $DIR/ls
1935         $RUNAS $DIR/ls / || error
1936         rm $DIR/ls
1937 }
1938 run_test 30b "execute binary from Lustre as non-root ==========="
1939
1940 test_30c() { # b=22376
1941         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1942         cp `which ls` $DIR || cp /bin/ls $DIR
1943         chmod a-rw $DIR/ls
1944         cancel_lru_locks mdc
1945         cancel_lru_locks osc
1946         $RUNAS $DIR/ls / || error
1947         rm -f $DIR/ls
1948 }
1949 run_test 30c "execute binary from Lustre without read perms ===="
1950
1951 test_31a() {
1952         $OPENUNLINK $DIR/f31 $DIR/f31 || error
1953         $CHECKSTAT -a $DIR/f31 || error
1954 }
1955 run_test 31a "open-unlink file =================================="
1956
1957 test_31b() {
1958         touch $DIR/f31 || error
1959         ln $DIR/f31 $DIR/f31b || error
1960         $MULTIOP $DIR/f31b Ouc || error
1961         $CHECKSTAT -t file $DIR/f31 || error
1962 }
1963 run_test 31b "unlink file with multiple links while open ======="
1964
1965 test_31c() {
1966         touch $DIR/f31 || error
1967         ln $DIR/f31 $DIR/f31c || error
1968         multiop_bg_pause $DIR/f31 O_uc || return 1
1969         MULTIPID=$!
1970         $MULTIOP $DIR/f31c Ouc
1971         kill -USR1 $MULTIPID
1972         wait $MULTIPID
1973 }
1974 run_test 31c "open-unlink file with multiple links ============="
1975
1976 test_31d() {
1977         opendirunlink $DIR/d31d $DIR/d31d || error
1978         $CHECKSTAT -a $DIR/d31d || error
1979 }
1980 run_test 31d "remove of open directory ========================="
1981
1982 test_31e() { # bug 2904
1983         check_kernel_version 34 || return 0
1984         openfilleddirunlink $DIR/d31e || error
1985 }
1986 run_test 31e "remove of open non-empty directory ==============="
1987
1988 test_31f() { # bug 4554
1989         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
1990         set -vx
1991         test_mkdir $DIR/d31f
1992         $SETSTRIPE -S 1048576 -c 1 $DIR/d31f
1993         cp /etc/hosts $DIR/d31f
1994         ls -l $DIR/d31f
1995         $GETSTRIPE $DIR/d31f/hosts
1996         multiop_bg_pause $DIR/d31f D_c || return 1
1997         MULTIPID=$!
1998
1999         rm -rv $DIR/d31f || error "first of $DIR/d31f"
2000         test_mkdir $DIR/d31f
2001         $SETSTRIPE -S 1048576 -c 1 $DIR/d31f
2002         cp /etc/hosts $DIR/d31f
2003         ls -l $DIR/d31f
2004         $GETSTRIPE $DIR/d31f/hosts
2005         multiop_bg_pause $DIR/d31f D_c || return 1
2006         MULTIPID2=$!
2007
2008         kill -USR1 $MULTIPID || error "first opendir $MULTIPID not running"
2009         wait $MULTIPID || error "first opendir $MULTIPID failed"
2010
2011         sleep 6
2012
2013         kill -USR1 $MULTIPID2 || error "second opendir $MULTIPID not running"
2014         wait $MULTIPID2 || error "second opendir $MULTIPID2 failed"
2015         set +vx
2016 }
2017 run_test 31f "remove of open directory with open-unlink file ==="
2018
2019 test_31g() {
2020         echo "-- cross directory link --"
2021         test_mkdir $DIR/d31ga
2022         test_mkdir $DIR/d31gb
2023         touch $DIR/d31ga/f
2024         ln $DIR/d31ga/f $DIR/d31gb/g
2025         $CHECKSTAT -t file $DIR/d31ga/f || error "source"
2026         [ `stat -c%h $DIR/d31ga/f` == '2' ] || error "source nlink"
2027         $CHECKSTAT -t file $DIR/d31gb/g || error "target"
2028         [ `stat -c%h $DIR/d31gb/g` == '2' ] || error "target nlink"
2029 }
2030 run_test 31g "cross directory link==============="
2031
2032 test_31h() {
2033         echo "-- cross directory link --"
2034         test_mkdir $DIR/d31h
2035         test_mkdir $DIR/d31h/dir
2036         touch $DIR/d31h/f
2037         ln $DIR/d31h/f $DIR/d31h/dir/g
2038         $CHECKSTAT -t file $DIR/d31h/f || error "source"
2039         [ `stat -c%h $DIR/d31h/f` == '2' ] || error "source nlink"
2040         $CHECKSTAT -t file $DIR/d31h/dir/g || error "target"
2041         [ `stat -c%h $DIR/d31h/dir/g` == '2' ] || error "target nlink"
2042 }
2043 run_test 31h "cross directory link under child==============="
2044
2045 test_31i() {
2046         echo "-- cross directory link --"
2047         test_mkdir $DIR/d31i
2048         test_mkdir $DIR/d31i/dir
2049         touch $DIR/d31i/dir/f
2050         ln $DIR/d31i/dir/f $DIR/d31i/g
2051         $CHECKSTAT -t file $DIR/d31i/dir/f || error "source"
2052         [ `stat -c%h $DIR/d31i/dir/f` == '2' ] || error "source nlink"
2053         $CHECKSTAT -t file $DIR/d31i/g || error "target"
2054         [ `stat -c%h $DIR/d31i/g` == '2' ] || error "target nlink"
2055 }
2056 run_test 31i "cross directory link under parent==============="
2057
2058
2059 test_31j() {
2060         test_mkdir $DIR/d31j
2061         test_mkdir $DIR/d31j/dir1
2062         ln $DIR/d31j/dir1 $DIR/d31j/dir2 && error "ln for dir"
2063         link $DIR/d31j/dir1 $DIR/d31j/dir3 && error "link for dir"
2064         mlink $DIR/d31j/dir1 $DIR/d31j/dir4 && error "mlink for dir"
2065         mlink $DIR/d31j/dir1 $DIR/d31j/dir1 && error "mlink to the same dir"
2066         return 0
2067 }
2068 run_test 31j "link for directory==============="
2069
2070
2071 test_31k() {
2072         test_mkdir $DIR/d31k
2073         touch $DIR/d31k/s
2074         touch $DIR/d31k/exist
2075         mlink $DIR/d31k/s $DIR/d31k/t || error "mlink"
2076         mlink $DIR/d31k/s $DIR/d31k/exist && error "mlink to exist file"
2077         mlink $DIR/d31k/s $DIR/d31k/s && error "mlink to the same file"
2078         mlink $DIR/d31k/s $DIR/d31k && error "mlink to parent dir"
2079         mlink $DIR/d31k $DIR/d31k/s && error "mlink parent dir to target"
2080         mlink $DIR/d31k/not-exist $DIR/d31k/foo && error "mlink non-existing to new"
2081         mlink $DIR/d31k/not-exist $DIR/d31k/s && error "mlink non-existing to exist"
2082         return 0
2083 }
2084 run_test 31k "link to file: the same, non-existing, dir==============="
2085
2086 test_31m() {
2087         test_mkdir $DIR/d31m
2088         touch $DIR/d31m/s
2089         test_mkdir $DIR/d31m2
2090         touch $DIR/d31m2/exist
2091         mlink $DIR/d31m/s $DIR/d31m2/t || error "mlink"
2092         mlink $DIR/d31m/s $DIR/d31m2/exist && error "mlink to exist file"
2093         mlink $DIR/d31m/s $DIR/d31m2 && error "mlink to parent dir"
2094         mlink $DIR/d31m2 $DIR/d31m/s && error "mlink parent dir to target"
2095         mlink $DIR/d31m/not-exist $DIR/d31m2/foo && error "mlink non-existing to new"
2096         mlink $DIR/d31m/not-exist $DIR/d31m2/s && error "mlink non-existing to exist"
2097         return 0
2098 }
2099 run_test 31m "link to file: the same, non-existing, dir==============="
2100
2101 test_31n() {
2102         [ -e /proc/self/fd/173 ] && echo "skipping, fd 173 is in use" && return
2103         touch $DIR/$tfile || error "cannot create '$DIR/$tfile'"
2104         nlink=$(stat --format=%h $DIR/$tfile)
2105         [ ${nlink:--1} -eq 1 ] || error "nlink is $nlink, expected 1"
2106         exec 173<$DIR/$tfile
2107         trap "exec 173<&-" EXIT
2108         nlink=$(stat --dereference --format=%h /proc/self/fd/173)
2109         [ ${nlink:--1} -eq 1 ] || error "nlink is $nlink, expected 1"
2110         rm $DIR/$tfile || error "cannot remove '$DIR/$tfile'"
2111         nlink=$(stat --dereference --format=%h /proc/self/fd/173)
2112         [ ${nlink:--1} -eq 0 ] || error "nlink is $nlink, expected 0"
2113         exec 173<&-
2114 }
2115 run_test 31n "check link count of unlinked file"
2116
2117 cleanup_test32_mount() {
2118         trap 0
2119         $UMOUNT $DIR/$tdir/ext2-mountpoint
2120 }
2121
2122 test_32a() {
2123         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2124         echo "== more mountpoints and symlinks ================="
2125         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2126         trap cleanup_test32_mount EXIT
2127         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2128         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2129         $CHECKSTAT -t dir $DIR/$tdir/ext2-mountpoint/.. || error
2130         cleanup_test32_mount
2131 }
2132 run_test 32a "stat d32a/ext2-mountpoint/.. ====================="
2133
2134 test_32b() {
2135         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2136         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2137         trap cleanup_test32_mount EXIT
2138         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2139         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2140         ls -al $DIR/$tdir/ext2-mountpoint/.. || error
2141         cleanup_test32_mount
2142 }
2143 run_test 32b "open d32b/ext2-mountpoint/.. ====================="
2144
2145 test_32c() {
2146         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2147         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2148         trap cleanup_test32_mount EXIT
2149         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2150         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2151         test_mkdir -p $DIR/$tdir/d2/test_dir
2152         $CHECKSTAT -t dir $DIR/$tdir/ext2-mountpoint/../d2/test_dir || error
2153         cleanup_test32_mount
2154 }
2155 run_test 32c "stat d32c/ext2-mountpoint/../d2/test_dir ========="
2156
2157 test_32d() {
2158         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2159         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2160         trap cleanup_test32_mount EXIT
2161         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2162         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2163         test_mkdir -p $DIR/$tdir/d2/test_dir
2164         ls -al $DIR/$tdir/ext2-mountpoint/../d2/test_dir || error
2165         cleanup_test32_mount
2166 }
2167 run_test 32d "open d32d/ext2-mountpoint/../d2/test_dir ========="
2168
2169 test_32e() {
2170         [ -e $DIR/d32e ] && rm -fr $DIR/d32e
2171         test_mkdir -p $DIR/d32e/tmp
2172         TMP_DIR=$DIR/d32e/tmp
2173         ln -s $DIR/d32e $TMP_DIR/symlink11
2174         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
2175         $CHECKSTAT -t link $DIR/d32e/tmp/symlink11 || error
2176         $CHECKSTAT -t link $DIR/d32e/symlink01 || error
2177 }
2178 run_test 32e "stat d32e/symlink->tmp/symlink->lustre-subdir ===="
2179
2180 test_32f() {
2181         [ -e $DIR/d32f ] && rm -fr $DIR/d32f
2182         test_mkdir -p $DIR/d32f/tmp
2183         TMP_DIR=$DIR/d32f/tmp
2184         ln -s $DIR/d32f $TMP_DIR/symlink11
2185         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
2186         ls $DIR/d32f/tmp/symlink11  || error
2187         ls $DIR/d32f/symlink01 || error
2188 }
2189 run_test 32f "open d32f/symlink->tmp/symlink->lustre-subdir ===="
2190
2191 test_32g() {
2192         TMP_DIR=$DIR/$tdir/tmp
2193         test_mkdir -p $DIR/$tdir/tmp
2194         test_mkdir $DIR/${tdir}2
2195         ln -s $DIR/${tdir}2 $TMP_DIR/symlink12
2196         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
2197         $CHECKSTAT -t link $TMP_DIR/symlink12 || error
2198         $CHECKSTAT -t link $DIR/$tdir/symlink02 || error
2199         $CHECKSTAT -t dir -f $TMP_DIR/symlink12 || error
2200         $CHECKSTAT -t dir -f $DIR/$tdir/symlink02 || error
2201 }
2202 run_test 32g "stat d32g/symlink->tmp/symlink->lustre-subdir/${tdir}2"
2203
2204 test_32h() {
2205         rm -fr $DIR/$tdir $DIR/${tdir}2
2206         TMP_DIR=$DIR/$tdir/tmp
2207         test_mkdir -p $DIR/$tdir/tmp
2208         test_mkdir $DIR/${tdir}2
2209         ln -s $DIR/${tdir}2 $TMP_DIR/symlink12
2210         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
2211         ls $TMP_DIR/symlink12 || error
2212         ls $DIR/$tdir/symlink02  || error
2213 }
2214 run_test 32h "open d32h/symlink->tmp/symlink->lustre-subdir/${tdir}2"
2215
2216 test_32i() {
2217         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2218         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2219         trap cleanup_test32_mount EXIT
2220         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2221         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2222         touch $DIR/$tdir/test_file
2223         $CHECKSTAT -t file $DIR/$tdir/ext2-mountpoint/../test_file || error
2224         cleanup_test32_mount
2225 }
2226 run_test 32i "stat d32i/ext2-mountpoint/../test_file ==========="
2227
2228 test_32j() {
2229         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2230         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2231         trap cleanup_test32_mount EXIT
2232         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2233         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2234         touch $DIR/$tdir/test_file
2235         cat $DIR/$tdir/ext2-mountpoint/../test_file || error
2236         cleanup_test32_mount
2237 }
2238 run_test 32j "open d32j/ext2-mountpoint/../test_file ==========="
2239
2240 test_32k() {
2241         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2242         rm -fr $DIR/$tdir
2243         trap cleanup_test32_mount EXIT
2244         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2245         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint
2246         test_mkdir -p $DIR/$tdir/d2
2247         touch $DIR/$tdir/d2/test_file || error
2248         $CHECKSTAT -t file $DIR/$tdir/ext2-mountpoint/../d2/test_file || error
2249         cleanup_test32_mount
2250 }
2251 run_test 32k "stat d32k/ext2-mountpoint/../d2/test_file ========"
2252
2253 test_32l() {
2254         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2255         rm -fr $DIR/$tdir
2256         trap cleanup_test32_mount EXIT
2257         test_mkdir -p $DIR/$tdir/ext2-mountpoint
2258         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir/ext2-mountpoint || error
2259         test_mkdir -p $DIR/$tdir/d2
2260         touch $DIR/$tdir/d2/test_file
2261         cat  $DIR/$tdir/ext2-mountpoint/../d2/test_file || error
2262         cleanup_test32_mount
2263 }
2264 run_test 32l "open d32l/ext2-mountpoint/../d2/test_file ========"
2265
2266 test_32m() {
2267         rm -fr $DIR/d32m
2268         test_mkdir -p $DIR/d32m/tmp
2269         TMP_DIR=$DIR/d32m/tmp
2270         ln -s $DIR $TMP_DIR/symlink11
2271         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
2272         $CHECKSTAT -t link $DIR/d32m/tmp/symlink11 || error
2273         $CHECKSTAT -t link $DIR/d32m/symlink01 || error
2274 }
2275 run_test 32m "stat d32m/symlink->tmp/symlink->lustre-root ======"
2276
2277 test_32n() {
2278         rm -fr $DIR/d32n
2279         test_mkdir -p $DIR/d32n/tmp
2280         TMP_DIR=$DIR/d32n/tmp
2281         ln -s $DIR $TMP_DIR/symlink11
2282         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
2283         ls -l $DIR/d32n/tmp/symlink11  || error
2284         ls -l $DIR/d32n/symlink01 || error
2285 }
2286 run_test 32n "open d32n/symlink->tmp/symlink->lustre-root ======"
2287
2288 test_32o() {
2289         rm -fr $DIR/d32o $DIR/$tfile
2290         touch $DIR/$tfile
2291         test_mkdir -p $DIR/d32o/tmp
2292         TMP_DIR=$DIR/d32o/tmp
2293         ln -s $DIR/$tfile $TMP_DIR/symlink12
2294         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
2295         $CHECKSTAT -t link $DIR/d32o/tmp/symlink12 || error
2296         $CHECKSTAT -t link $DIR/d32o/symlink02 || error
2297         $CHECKSTAT -t file -f $DIR/d32o/tmp/symlink12 || error
2298         $CHECKSTAT -t file -f $DIR/d32o/symlink02 || error
2299 }
2300 run_test 32o "stat d32o/symlink->tmp/symlink->lustre-root/$tfile"
2301
2302 test_32p() {
2303     log 32p_1
2304         rm -fr $DIR/d32p
2305     log 32p_2
2306         rm -f $DIR/$tfile
2307     log 32p_3
2308         touch $DIR/$tfile
2309     log 32p_4
2310         test_mkdir -p $DIR/d32p/tmp
2311     log 32p_5
2312         TMP_DIR=$DIR/d32p/tmp
2313     log 32p_6
2314         ln -s $DIR/$tfile $TMP_DIR/symlink12
2315     log 32p_7
2316         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
2317     log 32p_8
2318         cat $DIR/d32p/tmp/symlink12 || error
2319     log 32p_9
2320         cat $DIR/d32p/symlink02 || error
2321     log 32p_10
2322 }
2323 run_test 32p "open d32p/symlink->tmp/symlink->lustre-root/$tfile"
2324
2325 cleanup_testdir_mount() {
2326         trap 0
2327         $UMOUNT $DIR/$tdir
2328 }
2329
2330 test_32q() {
2331         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2332         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2333         trap cleanup_testdir_mount EXIT
2334         test_mkdir -p $DIR/$tdir
2335         touch $DIR/$tdir/under_the_mount
2336         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir
2337         ls $DIR/$tdir | grep "\<under_the_mount\>" && error
2338         cleanup_testdir_mount
2339 }
2340 run_test 32q "stat follows mountpoints in Lustre (should return error)"
2341
2342 test_32r() {
2343         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2344         [ -e $DIR/$tdir ] && rm -fr $DIR/$tdir
2345         trap cleanup_testdir_mount EXIT
2346         test_mkdir -p $DIR/$tdir
2347         touch $DIR/$tdir/under_the_mount
2348         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir
2349         ls $DIR/$tdir | grep -q under_the_mount && error || true
2350         cleanup_testdir_mount
2351 }
2352 run_test 32r "opendir follows mountpoints in Lustre (should return error)"
2353
2354 test_33aa() {
2355         rm -f $DIR/$tfile
2356         touch $DIR/$tfile
2357         chmod 444 $DIR/$tfile
2358         chown $RUNAS_ID $DIR/$tfile
2359         log 33_1
2360         $RUNAS $OPENFILE -f O_RDWR $DIR/$tfile && error || true
2361         log 33_2
2362 }
2363 run_test 33aa "write file with mode 444 (should return error) ===="
2364
2365 test_33a() {
2366         rm -fr $DIR/d33
2367         test_mkdir -p $DIR/d33
2368         chown $RUNAS_ID $DIR/d33
2369         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/d33/f33|| error "create"
2370         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/d33/f33 && \
2371                 error "open RDWR" || true
2372 }
2373 run_test 33a "test open file(mode=0444) with O_RDWR (should return error)"
2374
2375 test_33b() {
2376         rm -fr $DIR/d33
2377         test_mkdir -p $DIR/d33
2378         chown $RUNAS_ID $DIR/d33
2379         $RUNAS $OPENFILE -f 1286739555 $DIR/d33/f33 && error "create" || true
2380 }
2381 run_test 33b "test open file with malformed flags (No panic and return error)"
2382
2383 test_33c() {
2384         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2385         local ostnum
2386         local ostname
2387         local write_bytes
2388         local all_zeros
2389
2390         remote_ost_nodsh && skip "remote OST with nodsh" && return
2391         all_zeros=:
2392         rm -fr $DIR/d33
2393         test_mkdir -p $DIR/d33
2394         # Read: 0, Write: 4, create/destroy: 2/0, stat: 1, punch: 0
2395
2396         sync
2397         for ostnum in $(seq $OSTCOUNT); do
2398                 # test-framework's OST numbering is one-based, while Lustre's
2399                 # is zero-based
2400                 ostname=$(printf "$FSNAME-OST%.4d" $((ostnum - 1)))
2401                 # Parsing llobdstat's output sucks; we could grep the /proc
2402                 # path, but that's likely to not be as portable as using the
2403                 # llobdstat utility.  So we parse lctl output instead.
2404                 write_bytes=$(do_facet ost$ostnum lctl get_param -n \
2405                         obdfilter/$ostname/stats |
2406                         awk '/^write_bytes/ {print $7}' )
2407                 echo "baseline_write_bytes@$OSTnum/$ostname=$write_bytes"
2408                 if (( ${write_bytes:-0} > 0 ))
2409                 then
2410                         all_zeros=false
2411                         break;
2412                 fi
2413         done
2414
2415         $all_zeros || return 0
2416
2417         # Write four bytes
2418         echo foo > $DIR/d33/bar
2419         # Really write them
2420         sync
2421
2422         # Total up write_bytes after writing.  We'd better find non-zeros.
2423         for ostnum in $(seq $OSTCOUNT); do
2424                 ostname=$(printf "$FSNAME-OST%.4d" $((ostnum - 1)))
2425                 write_bytes=$(do_facet ost$ostnum lctl get_param -n \
2426                         obdfilter/$ostname/stats |
2427                         awk '/^write_bytes/ {print $7}' )
2428                 echo "write_bytes@$OSTnum/$ostname=$write_bytes"
2429                 if (( ${write_bytes:-0} > 0 ))
2430                 then
2431                         all_zeros=false
2432                         break;
2433                 fi
2434         done
2435
2436         if $all_zeros
2437         then
2438                 for ostnum in $(seq $OSTCOUNT); do
2439                         ostname=$(printf "$FSNAME-OST%.4d" $((ostnum - 1)))
2440                         echo "Check that write_bytes is present in obdfilter/*/stats:"
2441                         do_facet ost$ostnum lctl get_param -n \
2442                                 obdfilter/$ostname/stats
2443                 done
2444                 error "OST not keeping write_bytes stats (b22312)"
2445         fi
2446 }
2447 run_test 33c "test llobdstat and write_bytes"
2448
2449 test_33d() {
2450         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2451         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2452         local MDTIDX=1
2453         local remote_dir=$DIR/$tdir/remote_dir
2454
2455         mkdir -p $DIR/$tdir
2456         $LFS mkdir -i $MDTIDX $remote_dir ||
2457                 error "create remote directory failed"
2458
2459         touch $remote_dir/$tfile
2460         chmod 444 $remote_dir/$tfile
2461         chown $RUNAS_ID $remote_dir/$tfile
2462
2463         $RUNAS $OPENFILE -f O_RDWR $DIR/$tfile && error || true
2464
2465         chown $RUNAS_ID $remote_dir
2466         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $remote_dir/f33 ||
2467                                         error "create" || true
2468         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $remote_dir/f33 &&
2469                                     error "open RDWR" || true
2470         $RUNAS $OPENFILE -f 1286739555 $remote_dir/f33 &&
2471                                     error "create" || true
2472 }
2473 run_test 33d "openfile with 444 modes and malformed flags under remote dir"
2474
2475 TEST_34_SIZE=${TEST_34_SIZE:-2000000000000}
2476 test_34a() {
2477         rm -f $DIR/f34
2478         $MCREATE $DIR/f34 || error
2479         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" || error
2480         $TRUNCATE $DIR/f34 $TEST_34_SIZE || error
2481         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" || error
2482         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
2483 }
2484 run_test 34a "truncate file that has not been opened ==========="
2485
2486 test_34b() {
2487         [ ! -f $DIR/f34 ] && test_34a
2488         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
2489         $OPENFILE -f O_RDONLY $DIR/f34
2490         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" || error
2491         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
2492 }
2493 run_test 34b "O_RDONLY opening file doesn't create objects ====="
2494
2495 test_34c() {
2496         [ ! -f $DIR/f34 ] && test_34a
2497         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
2498         $OPENFILE -f O_RDWR $DIR/f34
2499         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" && error
2500         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
2501 }
2502 run_test 34c "O_RDWR opening file-with-size works =============="
2503
2504 test_34d() {
2505         [ ! -f $DIR/f34 ] && test_34a
2506         dd if=/dev/zero of=$DIR/f34 conv=notrunc bs=4k count=1 || error
2507         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
2508         rm $DIR/f34
2509 }
2510 run_test 34d "write to sparse file ============================="
2511
2512 test_34e() {
2513         rm -f $DIR/f34e
2514         $MCREATE $DIR/f34e || error
2515         $TRUNCATE $DIR/f34e 1000 || error
2516         $CHECKSTAT -s 1000 $DIR/f34e || error
2517         $OPENFILE -f O_RDWR $DIR/f34e
2518         $CHECKSTAT -s 1000 $DIR/f34e || error
2519 }
2520 run_test 34e "create objects, some with size and some without =="
2521
2522 test_34f() { # bug 6242, 6243
2523         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2524         SIZE34F=48000
2525         rm -f $DIR/f34f
2526         $MCREATE $DIR/f34f || error
2527         $TRUNCATE $DIR/f34f $SIZE34F || error "truncating $DIR/f3f to $SIZE34F"
2528         dd if=$DIR/f34f of=$TMP/f34f
2529         $CHECKSTAT -s $SIZE34F $TMP/f34f || error "$TMP/f34f not $SIZE34F bytes"
2530         dd if=/dev/zero of=$TMP/f34fzero bs=$SIZE34F count=1
2531         cmp $DIR/f34f $TMP/f34fzero || error "$DIR/f34f not all zero"
2532         cmp $TMP/f34f $TMP/f34fzero || error "$TMP/f34f not all zero"
2533         rm $TMP/f34f $TMP/f34fzero $DIR/f34f
2534 }
2535 run_test 34f "read from a file with no objects until EOF ======="
2536
2537 test_34g() {
2538         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2539         dd if=/dev/zero of=$DIR/$tfile bs=1 count=100 seek=$TEST_34_SIZE || error
2540         $TRUNCATE $DIR/$tfile $((TEST_34_SIZE / 2))|| error
2541         $CHECKSTAT -s $((TEST_34_SIZE / 2)) $DIR/$tfile || error "truncate failed"
2542         cancel_lru_locks osc
2543         $CHECKSTAT -s $((TEST_34_SIZE / 2)) $DIR/$tfile || \
2544                 error "wrong size after lock cancel"
2545
2546         $TRUNCATE $DIR/$tfile $TEST_34_SIZE || error
2547         $CHECKSTAT -s $TEST_34_SIZE $DIR/$tfile || \
2548                 error "expanding truncate failed"
2549         cancel_lru_locks osc
2550         $CHECKSTAT -s $TEST_34_SIZE $DIR/$tfile || \
2551                 error "wrong expanded size after lock cancel"
2552 }
2553 run_test 34g "truncate long file ==============================="
2554
2555 test_34h() {
2556         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2557         local gid=10
2558         local sz=1000
2559
2560         dd if=/dev/zero of=$DIR/$tfile bs=1M count=10 || error
2561         sync # Flush the cache so that multiop below does not block on cache
2562              # flush when getting the group lock
2563         $MULTIOP $DIR/$tfile OG${gid}T${sz}g${gid}c &
2564         MULTIPID=$!
2565         sleep 2
2566
2567         if [[ `ps h -o comm -p $MULTIPID` == "multiop" ]]; then
2568                 error "Multiop blocked on ftruncate, pid=$MULTIPID"
2569                 kill -9 $MULTIPID
2570         fi
2571         wait $MULTIPID
2572         local nsz=`stat -c %s $DIR/$tfile`
2573         [[ $nsz == $sz ]] || error "New size wrong $nsz != $sz"
2574 }
2575 run_test 34h "ftruncate file under grouplock should not block"
2576
2577 test_35a() {
2578         cp /bin/sh $DIR/f35a
2579         chmod 444 $DIR/f35a
2580         chown $RUNAS_ID $DIR/f35a
2581         $RUNAS $DIR/f35a && error || true
2582         rm $DIR/f35a
2583 }
2584 run_test 35a "exec file with mode 444 (should return and not leak) ====="
2585
2586 test_36a() {
2587         rm -f $DIR/f36
2588         utime $DIR/f36 || error
2589 }
2590 run_test 36a "MDS utime check (mknod, utime) ==================="
2591
2592 test_36b() {
2593         echo "" > $DIR/f36
2594         utime $DIR/f36 || error
2595 }
2596 run_test 36b "OST utime check (open, utime) ===================="
2597
2598 test_36c() {
2599         rm -f $DIR/d36/f36
2600         test_mkdir $DIR/d36
2601         chown $RUNAS_ID $DIR/d36
2602         $RUNAS utime $DIR/d36/f36 || error
2603 }
2604 run_test 36c "non-root MDS utime check (mknod, utime) =========="
2605
2606 test_36d() {
2607         [ ! -d $DIR/d36 ] && test_36c
2608         echo "" > $DIR/d36/f36
2609         $RUNAS utime $DIR/d36/f36 || error
2610 }
2611 run_test 36d "non-root OST utime check (open, utime) ==========="
2612
2613 test_36e() {
2614         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
2615         test_mkdir -p $DIR/$tdir
2616         touch $DIR/$tdir/$tfile
2617         $RUNAS utime $DIR/$tdir/$tfile && \
2618                 error "utime worked, expected failure" || true
2619 }
2620 run_test 36e "utime on non-owned file (should return error) ===="
2621
2622 subr_36fh() {
2623         local fl="$1"
2624         local LANG_SAVE=$LANG
2625         local LC_LANG_SAVE=$LC_LANG
2626         export LANG=C LC_LANG=C # for date language
2627
2628         DATESTR="Dec 20  2000"
2629         test_mkdir -p $DIR/$tdir
2630         lctl set_param fail_loc=$fl
2631         date; date +%s
2632         cp /etc/hosts $DIR/$tdir/$tfile
2633         sync & # write RPC generated with "current" inode timestamp, but delayed
2634         sleep 1
2635         touch --date="$DATESTR" $DIR/$tdir/$tfile # setattr timestamp in past
2636         LS_BEFORE="`ls -l $DIR/$tdir/$tfile`" # old timestamp from client cache
2637         cancel_lru_locks osc
2638         LS_AFTER="`ls -l $DIR/$tdir/$tfile`"  # timestamp from OST object
2639         date; date +%s
2640         [ "$LS_BEFORE" != "$LS_AFTER" ] && \
2641                 echo "BEFORE: $LS_BEFORE" && \
2642                 echo "AFTER : $LS_AFTER" && \
2643                 echo "WANT  : $DATESTR" && \
2644                 error "$DIR/$tdir/$tfile timestamps changed" || true
2645
2646         export LANG=$LANG_SAVE LC_LANG=$LC_LANG_SAVE
2647 }
2648
2649 test_36f() {
2650         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2651         #define OBD_FAIL_OST_BRW_PAUSE_BULK 0x214
2652         subr_36fh "0x80000214"
2653 }
2654 run_test 36f "utime on file racing with OST BRW write =========="
2655
2656 test_36g() {
2657         remote_ost_nodsh && skip "remote OST with nodsh" && return
2658         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2659         local fmd_max_age
2660         local fmd_before
2661         local fmd_after
2662
2663         test_mkdir -p $DIR/$tdir
2664         fmd_max_age=$(do_facet ost1 \
2665                 "lctl get_param -n obdfilter.*.client_cache_seconds 2> /dev/null | \
2666                 head -n 1")
2667
2668         fmd_before=$(do_facet ost1 \
2669                 "awk '/ll_fmd_cache/ {print \\\$2}' /proc/slabinfo")
2670         touch $DIR/$tdir/$tfile
2671         sleep $((fmd_max_age + 12))
2672         fmd_after=$(do_facet ost1 \
2673                 "awk '/ll_fmd_cache/ {print \\\$2}' /proc/slabinfo")
2674
2675         echo "fmd_before: $fmd_before"
2676         echo "fmd_after: $fmd_after"
2677         [ "$fmd_after" -gt "$fmd_before" ] && \
2678                 echo "AFTER: $fmd_after > BEFORE: $fmd_before" && \
2679                 error "fmd didn't expire after ping" || true
2680 }
2681 run_test 36g "filter mod data cache expiry ====================="
2682
2683 test_36h() {
2684         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2685         #define OBD_FAIL_OST_BRW_PAUSE_BULK2 0x227
2686         subr_36fh "0x80000227"
2687 }
2688 run_test 36h "utime on file racing with OST BRW write =========="
2689
2690 # test_37 - duplicate with tests 32q 32r
2691
2692 test_38() {
2693         local file=$DIR/$tfile
2694         touch $file
2695         openfile -f O_DIRECTORY $file
2696         local RC=$?
2697         local ENOTDIR=20
2698         [ $RC -eq 0 ] && error "opened file $file with O_DIRECTORY" || true
2699         [ $RC -eq $ENOTDIR ] || error "error $RC should be ENOTDIR ($ENOTDIR)"
2700 }
2701 run_test 38 "open a regular file with O_DIRECTORY should return -ENOTDIR ==="
2702
2703 test_39() {
2704         touch $DIR/$tfile
2705         touch $DIR/${tfile}2
2706 #       ls -l  $DIR/$tfile $DIR/${tfile}2
2707 #       ls -lu  $DIR/$tfile $DIR/${tfile}2
2708 #       ls -lc  $DIR/$tfile $DIR/${tfile}2
2709         sleep 2
2710         $OPENFILE -f O_CREAT:O_TRUNC:O_WRONLY $DIR/${tfile}2
2711         if [ ! $DIR/${tfile}2 -nt $DIR/$tfile ]; then
2712                 echo "mtime"
2713                 ls -l --full-time $DIR/$tfile $DIR/${tfile}2
2714                 echo "atime"
2715                 ls -lu --full-time $DIR/$tfile $DIR/${tfile}2
2716                 echo "ctime"
2717                 ls -lc --full-time $DIR/$tfile $DIR/${tfile}2
2718                 error "O_TRUNC didn't change timestamps"
2719         fi
2720 }
2721 run_test 39 "mtime changed on create ==========================="
2722
2723 test_39b() {
2724         test_mkdir -p $DIR/$tdir
2725         cp -p /etc/passwd $DIR/$tdir/fopen
2726         cp -p /etc/passwd $DIR/$tdir/flink
2727         cp -p /etc/passwd $DIR/$tdir/funlink
2728         cp -p /etc/passwd $DIR/$tdir/frename
2729         ln $DIR/$tdir/funlink $DIR/$tdir/funlink2
2730
2731         sleep 1
2732         echo "aaaaaa" >> $DIR/$tdir/fopen
2733         echo "aaaaaa" >> $DIR/$tdir/flink
2734         echo "aaaaaa" >> $DIR/$tdir/funlink
2735         echo "aaaaaa" >> $DIR/$tdir/frename
2736
2737         local open_new=`stat -c %Y $DIR/$tdir/fopen`
2738         local link_new=`stat -c %Y $DIR/$tdir/flink`
2739         local unlink_new=`stat -c %Y $DIR/$tdir/funlink`
2740         local rename_new=`stat -c %Y $DIR/$tdir/frename`
2741
2742         cat $DIR/$tdir/fopen > /dev/null
2743         ln $DIR/$tdir/flink $DIR/$tdir/flink2
2744         rm -f $DIR/$tdir/funlink2
2745         mv -f $DIR/$tdir/frename $DIR/$tdir/frename2
2746
2747         for (( i=0; i < 2; i++ )) ; do
2748                 local open_new2=`stat -c %Y $DIR/$tdir/fopen`
2749                 local link_new2=`stat -c %Y $DIR/$tdir/flink`
2750                 local unlink_new2=`stat -c %Y $DIR/$tdir/funlink`
2751                 local rename_new2=`stat -c %Y $DIR/$tdir/frename2`
2752
2753                 [ $open_new2 -eq $open_new ] || error "open file reverses mtime"
2754                 [ $link_new2 -eq $link_new ] || error "link file reverses mtime"
2755                 [ $unlink_new2 -eq $unlink_new ] || error "unlink file reverses mtime"
2756                 [ $rename_new2 -eq $rename_new ] || error "rename file reverses mtime"
2757
2758                 cancel_lru_locks osc
2759                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2760         done
2761 }
2762 run_test 39b "mtime change on open, link, unlink, rename  ======"
2763
2764 # this should be set to past
2765 TEST_39_MTIME=`date -d "1 year ago" +%s`
2766
2767 # bug 11063
2768 test_39c() {
2769         touch $DIR1/$tfile
2770         sleep 2
2771         local mtime0=`stat -c %Y $DIR1/$tfile`
2772
2773         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
2774         local mtime1=`stat -c %Y $DIR1/$tfile`
2775         [ "$mtime1" = $TEST_39_MTIME ] || \
2776                 error "mtime is not set to past: $mtime1, should be $TEST_39_MTIME"
2777
2778         local d1=`date +%s`
2779         echo hello >> $DIR1/$tfile
2780         local d2=`date +%s`
2781         local mtime2=`stat -c %Y $DIR1/$tfile`
2782         [ "$mtime2" -ge "$d1" ] && [ "$mtime2" -le "$d2" ] || \
2783                 error "mtime is not updated on write: $d1 <= $mtime2 <= $d2"
2784
2785         mv $DIR1/$tfile $DIR1/$tfile-1
2786
2787         for (( i=0; i < 2; i++ )) ; do
2788                 local mtime3=`stat -c %Y $DIR1/$tfile-1`
2789                 [ "$mtime2" = "$mtime3" ] || \
2790                         error "mtime ($mtime2) changed (to $mtime3) on rename"
2791
2792                 cancel_lru_locks osc
2793                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2794         done
2795 }
2796 run_test 39c "mtime change on rename ==========================="
2797
2798 # bug 21114
2799 test_39d() {
2800         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2801         touch $DIR1/$tfile
2802
2803         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
2804
2805         for (( i=0; i < 2; i++ )) ; do
2806                 local mtime=`stat -c %Y $DIR1/$tfile`
2807                 [ $mtime = $TEST_39_MTIME ] || \
2808                         error "mtime($mtime) is not set to $TEST_39_MTIME"
2809
2810                 cancel_lru_locks osc
2811                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2812         done
2813 }
2814 run_test 39d "create, utime, stat =============================="
2815
2816 # bug 21114
2817 test_39e() {
2818         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2819         touch $DIR1/$tfile
2820         local mtime1=`stat -c %Y $DIR1/$tfile`
2821
2822         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
2823
2824         for (( i=0; i < 2; i++ )) ; do
2825                 local mtime2=`stat -c %Y $DIR1/$tfile`
2826                 [ $mtime2 = $TEST_39_MTIME ] || \
2827                         error "mtime($mtime2) is not set to $TEST_39_MTIME"
2828
2829                 cancel_lru_locks osc
2830                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2831         done
2832 }
2833 run_test 39e "create, stat, utime, stat ========================"
2834
2835 # bug 21114
2836 test_39f() {
2837         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2838         touch $DIR1/$tfile
2839         mtime1=`stat -c %Y $DIR1/$tfile`
2840
2841         sleep 2
2842         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
2843
2844         for (( i=0; i < 2; i++ )) ; do
2845                 local mtime2=`stat -c %Y $DIR1/$tfile`
2846                 [ $mtime2 = $TEST_39_MTIME ] || \
2847                         error "mtime($mtime2) is not set to $TEST_39_MTIME"
2848
2849                 cancel_lru_locks osc
2850                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2851         done
2852 }
2853 run_test 39f "create, stat, sleep, utime, stat ================="
2854
2855 # bug 11063
2856 test_39g() {
2857         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2858         echo hello >> $DIR1/$tfile
2859         local mtime1=`stat -c %Y $DIR1/$tfile`
2860
2861         sleep 2
2862         chmod o+r $DIR1/$tfile
2863
2864         for (( i=0; i < 2; i++ )) ; do
2865                 local mtime2=`stat -c %Y $DIR1/$tfile`
2866                 [ "$mtime1" = "$mtime2" ] || \
2867                         error "lost mtime: $mtime2, should be $mtime1"
2868
2869                 cancel_lru_locks osc
2870                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2871         done
2872 }
2873 run_test 39g "write, chmod, stat ==============================="
2874
2875 # bug 11063
2876 test_39h() {
2877         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2878         touch $DIR1/$tfile
2879         sleep 1
2880
2881         local d1=`date`
2882         echo hello >> $DIR1/$tfile
2883         local mtime1=`stat -c %Y $DIR1/$tfile`
2884
2885         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
2886         local d2=`date`
2887         if [ "$d1" != "$d2" ]; then
2888                 echo "write and touch not within one second"
2889         else
2890                 for (( i=0; i < 2; i++ )) ; do
2891                         local mtime2=`stat -c %Y $DIR1/$tfile`
2892                         [ "$mtime2" = $TEST_39_MTIME ] || \
2893                                 error "lost mtime: $mtime2, should be $TEST_39_MTIME"
2894
2895                         cancel_lru_locks osc
2896                         if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2897                 done
2898         fi
2899 }
2900 run_test 39h "write, utime within one second, stat ============="
2901
2902 test_39i() {
2903         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2904         touch $DIR1/$tfile
2905         sleep 1
2906
2907         echo hello >> $DIR1/$tfile
2908         local mtime1=`stat -c %Y $DIR1/$tfile`
2909
2910         mv $DIR1/$tfile $DIR1/$tfile-1
2911
2912         for (( i=0; i < 2; i++ )) ; do
2913                 local mtime2=`stat -c %Y $DIR1/$tfile-1`
2914
2915                 [ "$mtime1" = "$mtime2" ] || \
2916                         error "lost mtime: $mtime2, should be $mtime1"
2917
2918                 cancel_lru_locks osc
2919                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2920         done
2921 }
2922 run_test 39i "write, rename, stat =============================="
2923
2924 test_39j() {
2925         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2926         start_full_debug_logging
2927         touch $DIR1/$tfile
2928         sleep 1
2929
2930         #define OBD_FAIL_OSC_DELAY_SETTIME       0x412
2931         lctl set_param fail_loc=0x80000412
2932         multiop_bg_pause $DIR1/$tfile oO_RDWR:w2097152_c ||
2933                 error "multiop failed"
2934         local multipid=$!
2935         local mtime1=`stat -c %Y $DIR1/$tfile`
2936
2937         mv $DIR1/$tfile $DIR1/$tfile-1
2938
2939         kill -USR1 $multipid
2940         wait $multipid || error "multiop close failed"
2941
2942         for (( i=0; i < 2; i++ )) ; do
2943                 local mtime2=`stat -c %Y $DIR1/$tfile-1`
2944                 [ "$mtime1" = "$mtime2" ] ||
2945                         error "mtime is lost on close: $mtime2, " \
2946                               "should be $mtime1"
2947
2948                 cancel_lru_locks osc
2949                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2950         done
2951         lctl set_param fail_loc=0
2952         stop_full_debug_logging
2953 }
2954 run_test 39j "write, rename, close, stat ======================="
2955
2956 test_39k() {
2957         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2958         touch $DIR1/$tfile
2959         sleep 1
2960
2961         multiop_bg_pause $DIR1/$tfile oO_RDWR:w2097152_c || error "multiop failed"
2962         local multipid=$!
2963         local mtime1=`stat -c %Y $DIR1/$tfile`
2964
2965         touch -m -d @$TEST_39_MTIME $DIR1/$tfile
2966
2967         kill -USR1 $multipid
2968         wait $multipid || error "multiop close failed"
2969
2970         for (( i=0; i < 2; i++ )) ; do
2971                 local mtime2=`stat -c %Y $DIR1/$tfile`
2972
2973                 [ "$mtime2" = $TEST_39_MTIME ] || \
2974                         error "mtime is lost on close: $mtime2, should be $TEST_39_MTIME"
2975
2976                 cancel_lru_locks osc
2977                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
2978         done
2979 }
2980 run_test 39k "write, utime, close, stat ========================"
2981
2982 # this should be set to future
2983 TEST_39_ATIME=`date -d "1 year" +%s`
2984
2985 test_39l() {
2986         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
2987         remote_mds_nodsh && skip "remote MDS with nodsh" && return
2988         local atime_diff=$(do_facet $SINGLEMDS \
2989                                 lctl get_param -n mdd.*MDT0000*.atime_diff)
2990         rm -rf $DIR/$tdir
2991         mkdir -p $DIR/$tdir
2992
2993         # test setting directory atime to future
2994         touch -a -d @$TEST_39_ATIME $DIR/$tdir
2995         local atime=$(stat -c %X $DIR/$tdir)
2996         [ "$atime" = $TEST_39_ATIME ] || \
2997                 error "atime is not set to future: $atime, $TEST_39_ATIME"
2998
2999         # test setting directory atime from future to now
3000         local d1=$(date +%s)
3001         ls $DIR/$tdir
3002         local d2=$(date +%s)
3003
3004         cancel_lru_locks mdc
3005         atime=$(stat -c %X $DIR/$tdir)
3006         [ "$atime" -ge "$d1" -a "$atime" -le "$d2" ] || \
3007                 error "atime is not updated from future: $atime, $d1<atime<$d2"
3008
3009         do_facet $SINGLEMDS lctl set_param -n mdd.*MDT0000*.atime_diff=2
3010         sleep 3
3011
3012         # test setting directory atime when now > dir atime + atime_diff
3013         d1=$(date +%s)
3014         ls $DIR/$tdir
3015         d2=$(date +%s)
3016         cancel_lru_locks mdc
3017         atime=$(stat -c %X $DIR/$tdir)
3018         [ "$atime" -ge "$d1" -a "$atime" -le "$d2" ] || \
3019                 error "atime is not updated  : $atime, should be $d2"
3020
3021         do_facet $SINGLEMDS lctl set_param -n mdd.*MDT0000*.atime_diff=60
3022         sleep 3
3023
3024         # test not setting directory atime when now < dir atime + atime_diff
3025         ls $DIR/$tdir
3026         cancel_lru_locks mdc
3027         atime=$(stat -c %X $DIR/$tdir)
3028         [ "$atime" -ge "$d1" -a "$atime" -le "$d2" ] || \
3029                 error "atime is updated to $atime, should remain $d1<atime<$d2"
3030
3031         do_facet $SINGLEMDS \
3032                 lctl set_param -n mdd.*MDT0000*.atime_diff=$atime_diff
3033 }
3034 run_test 39l "directory atime update ==========================="
3035
3036 test_39m() {
3037         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3038         touch $DIR1/$tfile
3039         sleep 2
3040         local far_past_mtime=$(date -d "May 29 1953" +%s)
3041         local far_past_atime=$(date -d "Dec 17 1903" +%s)
3042
3043         touch -m -d @$far_past_mtime $DIR1/$tfile
3044         touch -a -d @$far_past_atime $DIR1/$tfile
3045
3046         for (( i=0; i < 2; i++ )) ; do
3047                 local timestamps=$(stat -c "%X %Y" $DIR1/$tfile)
3048                 [ "$timestamps" = "$far_past_atime $far_past_mtime" ] || \
3049                         error "atime or mtime set incorrectly"
3050
3051                 cancel_lru_locks osc
3052                 if [ $i = 0 ] ; then echo "repeat after cancel_lru_locks"; fi
3053         done
3054 }
3055 run_test 39m "test atime and mtime before 1970"
3056
3057 test_40() {
3058         dd if=/dev/zero of=$DIR/f40 bs=4096 count=1
3059         $RUNAS $OPENFILE -f O_WRONLY:O_TRUNC $DIR/f40 && error
3060         $CHECKSTAT -t file -s 4096 $DIR/f40 || error
3061 }
3062 run_test 40 "failed open(O_TRUNC) doesn't truncate ============="
3063
3064 test_41() {
3065         # bug 1553
3066         small_write $DIR/f41 18
3067 }
3068 run_test 41 "test small file write + fstat ====================="
3069
3070 count_ost_writes() {
3071         lctl get_param -n osc.*.stats |
3072             awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }'
3073 }
3074
3075 # decent default
3076 WRITEBACK_SAVE=500
3077 DIRTY_RATIO_SAVE=40
3078 MAX_DIRTY_RATIO=50
3079 BG_DIRTY_RATIO_SAVE=10
3080 MAX_BG_DIRTY_RATIO=25
3081
3082 start_writeback() {
3083         trap 0
3084         # in 2.6, restore /proc/sys/vm/dirty_writeback_centisecs,
3085         # dirty_ratio, dirty_background_ratio
3086         if [ -f /proc/sys/vm/dirty_writeback_centisecs ]; then
3087                 sysctl -w vm.dirty_writeback_centisecs=$WRITEBACK_SAVE
3088                 sysctl -w vm.dirty_background_ratio=$BG_DIRTY_RATIO_SAVE
3089                 sysctl -w vm.dirty_ratio=$DIRTY_RATIO_SAVE
3090         else
3091                 # if file not here, we are a 2.4 kernel
3092                 kill -CONT `pidof kupdated`
3093         fi
3094 }
3095
3096 stop_writeback() {
3097         # setup the trap first, so someone cannot exit the test at the
3098         # exact wrong time and mess up a machine
3099         trap start_writeback EXIT
3100         # in 2.6, save and 0 /proc/sys/vm/dirty_writeback_centisecs
3101         if [ -f /proc/sys/vm/dirty_writeback_centisecs ]; then
3102                 WRITEBACK_SAVE=`sysctl -n vm.dirty_writeback_centisecs`
3103                 sysctl -w vm.dirty_writeback_centisecs=0
3104                 sysctl -w vm.dirty_writeback_centisecs=0
3105                 # save and increase /proc/sys/vm/dirty_ratio
3106                 DIRTY_RATIO_SAVE=`sysctl -n vm.dirty_ratio`
3107                 sysctl -w vm.dirty_ratio=$MAX_DIRTY_RATIO
3108                 # save and increase /proc/sys/vm/dirty_background_ratio
3109                 BG_DIRTY_RATIO_SAVE=`sysctl -n vm.dirty_background_ratio`
3110                 sysctl -w vm.dirty_background_ratio=$MAX_BG_DIRTY_RATIO
3111         else
3112                 # if file not here, we are a 2.4 kernel
3113                 kill -STOP `pidof kupdated`
3114         fi
3115 }
3116
3117 # ensure that all stripes have some grant before we test client-side cache
3118 setup_test42() {
3119         for i in `seq -f $DIR/f42-%g 1 $OSTCOUNT`; do
3120                 dd if=/dev/zero of=$i bs=4k count=1
3121                 rm $i
3122         done
3123 }
3124
3125 # Tests 42* verify that our behaviour is correct WRT caching, file closure,
3126 # file truncation, and file removal.
3127 test_42a() {
3128         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3129         setup_test42
3130         cancel_lru_locks osc
3131         stop_writeback
3132         sync; sleep 1; sync # just to be safe
3133         BEFOREWRITES=`count_ost_writes`
3134         lctl get_param -n osc.*[oO][sS][cC][_-]*.cur_grant_bytes | grep "[0-9]"
3135         dd if=/dev/zero of=$DIR/f42a bs=1024 count=100
3136         AFTERWRITES=`count_ost_writes`
3137         [ $BEFOREWRITES -eq $AFTERWRITES ] || \
3138                 error "$BEFOREWRITES < $AFTERWRITES"
3139         start_writeback
3140 }
3141 run_test 42a "ensure that we don't flush on close =============="
3142
3143 test_42b() {
3144         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3145         setup_test42
3146         cancel_lru_locks osc
3147         stop_writeback
3148         sync
3149         dd if=/dev/zero of=$DIR/f42b bs=1024 count=100
3150         BEFOREWRITES=`count_ost_writes`
3151         $MUNLINK $DIR/f42b || error "$MUNLINK $DIR/f42b: $?"
3152         AFTERWRITES=`count_ost_writes`
3153         if [ $BEFOREWRITES -lt $AFTERWRITES ]; then
3154                 error "$BEFOREWRITES < $AFTERWRITES on unlink"
3155         fi
3156         BEFOREWRITES=`count_ost_writes`
3157         sync || error "sync: $?"
3158         AFTERWRITES=`count_ost_writes`
3159         if [ $BEFOREWRITES -lt $AFTERWRITES ]; then
3160                 error "$BEFOREWRITES < $AFTERWRITES on sync"
3161         fi
3162         dmesg | grep 'error from obd_brw_async' && error 'error writing back'
3163         start_writeback
3164         return 0
3165 }
3166 run_test 42b "test destroy of file with cached dirty data ======"
3167
3168 # if these tests just want to test the effect of truncation,
3169 # they have to be very careful.  consider:
3170 # - the first open gets a {0,EOF}PR lock
3171 # - the first write conflicts and gets a {0, count-1}PW
3172 # - the rest of the writes are under {count,EOF}PW
3173 # - the open for truncate tries to match a {0,EOF}PR
3174 #   for the filesize and cancels the PWs.
3175 # any number of fixes (don't get {0,EOF} on open, match
3176 # composite locks, do smarter file size management) fix
3177 # this, but for now we want these tests to verify that
3178 # the cancellation with truncate intent works, so we
3179 # start the file with a full-file pw lock to match against
3180 # until the truncate.
3181 trunc_test() {
3182         test=$1
3183         file=$DIR/$test
3184         offset=$2
3185         cancel_lru_locks osc
3186         stop_writeback
3187         # prime the file with 0,EOF PW to match
3188         touch $file
3189         $TRUNCATE $file 0
3190         sync; sync
3191         # now the real test..
3192         dd if=/dev/zero of=$file bs=1024 count=100
3193         BEFOREWRITES=`count_ost_writes`
3194         $TRUNCATE $file $offset
3195         cancel_lru_locks osc
3196         AFTERWRITES=`count_ost_writes`
3197         start_writeback
3198 }
3199
3200 test_42c() {
3201         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3202         trunc_test 42c 1024
3203         [ $BEFOREWRITES -eq $AFTERWRITES ] && \
3204             error "beforewrites $BEFOREWRITES == afterwrites $AFTERWRITES on truncate"
3205         rm $file
3206 }
3207 run_test 42c "test partial truncate of file with cached dirty data"
3208
3209 test_42d() {
3210         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3211         trunc_test 42d 0
3212         [ $BEFOREWRITES -eq $AFTERWRITES ] || \
3213             error "beforewrites $BEFOREWRITES != afterwrites $AFTERWRITES on truncate"
3214         rm $file
3215 }
3216 run_test 42d "test complete truncate of file with cached dirty data"
3217
3218 test_42e() { # bug22074
3219         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3220         local TDIR=$DIR/${tdir}e
3221         local pagesz=$(page_size)
3222         local pages=16 # hardcoded 16 pages, don't change it.
3223         local files=$((OSTCOUNT * 500)) # hopefully 500 files on each OST
3224         local proc_osc0="osc.${FSNAME}-OST0000-osc-[^MDT]*"
3225         local max_dirty_mb
3226         local warmup_files
3227
3228         test_mkdir -p $DIR/${tdir}e
3229         $SETSTRIPE -c 1 $TDIR
3230         createmany -o $TDIR/f $files
3231
3232         max_dirty_mb=$($LCTL get_param -n $proc_osc0/max_dirty_mb)
3233
3234         # we assume that with $OSTCOUNT files, at least one of them will
3235         # be allocated on OST0.
3236         warmup_files=$((OSTCOUNT * max_dirty_mb))
3237         createmany -o $TDIR/w $warmup_files
3238
3239         # write a large amount of data into one file and sync, to get good
3240         # avail_grant number from OST.
3241         for ((i=0; i<$warmup_files; i++)); do
3242                 idx=$($GETSTRIPE -i $TDIR/w$i)
3243                 [ $idx -ne 0 ] && continue
3244                 dd if=/dev/zero of=$TDIR/w$i bs="$max_dirty_mb"M count=1
3245                 break
3246         done
3247         [ $i -gt $warmup_files ] && error "OST0 is still cold"
3248         sync
3249         $LCTL get_param $proc_osc0/cur_dirty_bytes
3250         $LCTL get_param $proc_osc0/cur_grant_bytes
3251
3252         # create as much dirty pages as we can while not to trigger the actual
3253         # RPCs directly. but depends on the env, VFS may trigger flush during this
3254         # period, hopefully we are good.
3255         for ((i=0; i<$warmup_files; i++)); do
3256                 idx=$($GETSTRIPE -i $TDIR/w$i)
3257                 [ $idx -ne 0 ] && continue
3258                 dd if=/dev/zero of=$TDIR/w$i bs=1M count=1 2>/dev/null
3259         done
3260         $LCTL get_param $proc_osc0/cur_dirty_bytes
3261         $LCTL get_param $proc_osc0/cur_grant_bytes
3262
3263         # perform the real test
3264         $LCTL set_param $proc_osc0/rpc_stats 0
3265         for ((;i<$files; i++)); do
3266                 [ $($GETSTRIPE -i $TDIR/f$i) -eq 0 ] || continue
3267                 dd if=/dev/zero of=$TDIR/f$i bs=$pagesz count=$pages 2>/dev/null
3268         done
3269         sync
3270         $LCTL get_param $proc_osc0/rpc_stats
3271
3272         local percent=0
3273         local have_ppr=false
3274         $LCTL get_param $proc_osc0/rpc_stats |
3275                 while read PPR RRPC RPCT RCUM BAR WRPC WPCT WCUM; do
3276                         # skip lines until we are at the RPC histogram data
3277                         [ "$PPR" == "pages" ] && have_ppr=true && continue
3278                         $have_ppr || continue
3279
3280                         # we only want the percent stat for < 16 pages
3281                         [ $(echo $PPR | tr -d ':') -ge $pages ] && break
3282
3283                         percent=$((percent + WPCT))
3284                         if [ $percent -gt 15 ]; then
3285                                 error "less than 16-pages write RPCs" \
3286                                       "$percent% > 15%"
3287                                 break
3288                         fi
3289                 done
3290         rm -rf $TDIR
3291 }
3292 run_test 42e "verify sub-RPC writes are not done synchronously"
3293
3294 test_43() {
3295         test_mkdir -p $DIR/$tdir
3296         cp -p /bin/ls $DIR/$tdir/$tfile
3297         $MULTIOP $DIR/$tdir/$tfile Ow_c &
3298         pid=$!
3299         # give multiop a chance to open
3300         sleep 1
3301
3302         $DIR/$tdir/$tfile && error || true
3303         kill -USR1 $pid
3304 }
3305 run_test 43 "execution of file opened for write should return -ETXTBSY"
3306
3307 test_43a() {
3308         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3309         test_mkdir -p $DIR/$tdir
3310         cp -p `which $MULTIOP` $DIR/$tdir/multiop ||
3311                         cp -p multiop $DIR/$tdir/multiop
3312         MULTIOP_PROG=$DIR/$tdir/multiop multiop_bg_pause $TMP/test43.junk O_c ||
3313                         return 1
3314         MULTIOP_PID=$!
3315         $MULTIOP $DIR/$tdir/multiop Oc && error "expected error, got success"
3316         kill -USR1 $MULTIOP_PID || return 2
3317         wait $MULTIOP_PID || return 3
3318         rm $TMP/test43.junk
3319 }
3320 run_test 43a "open(RDWR) of file being executed should return -ETXTBSY"
3321
3322 test_43b() {
3323         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3324         test_mkdir -p $DIR/$tdir
3325         cp -p `which $MULTIOP` $DIR/$tdir/multiop ||
3326                         cp -p multiop $DIR/$tdir/multiop
3327         MULTIOP_PROG=$DIR/$tdir/multiop multiop_bg_pause $TMP/test43.junk O_c ||
3328                         return 1
3329         MULTIOP_PID=$!
3330         $TRUNCATE $DIR/$tdir/multiop 0 && error "expected error, got success"
3331         kill -USR1 $MULTIOP_PID || return 2
3332         wait $MULTIOP_PID || return 3
3333         rm $TMP/test43.junk
3334 }
3335 run_test 43b "truncate of file being executed should return -ETXTBSY"
3336
3337 test_43c() {
3338         local testdir="$DIR/$tdir"
3339         test_mkdir -p $DIR/$tdir
3340         cp $SHELL $testdir/
3341         ( cd $(dirname $SHELL) && md5sum $(basename $SHELL) ) | \
3342                 ( cd $testdir && md5sum -c)
3343 }
3344 run_test 43c "md5sum of copy into lustre========================"
3345
3346 test_44() {
3347         [  "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
3348         dd if=/dev/zero of=$DIR/f1 bs=4k count=1 seek=1023
3349         dd if=$DIR/f1 bs=4k count=1 > /dev/null
3350 }
3351 run_test 44 "zero length read from a sparse stripe ============="
3352
3353 test_44a() {
3354     local nstripe=`$LCTL lov_getconfig $DIR | grep default_stripe_count: | \
3355                          awk '{print $2}'`
3356     [ -z "$nstripe" ] && skip "can't get stripe info" && return
3357     [ "$nstripe" -gt "$OSTCOUNT" ] && skip "Wrong default_stripe_count: $nstripe (OSTCOUNT: $OSTCOUNT)" && return
3358     local stride=`$LCTL lov_getconfig $DIR | grep default_stripe_size: | \
3359                       awk '{print $2}'`
3360     if [ $nstripe -eq 0 -o $nstripe -eq -1 ] ; then
3361         nstripe=`$LCTL lov_getconfig $DIR | grep obd_count: | awk '{print $2}'`
3362     fi
3363
3364     OFFSETS="0 $((stride/2)) $((stride-1))"
3365     for offset in $OFFSETS ; do
3366       for i in `seq 0 $((nstripe-1))`; do
3367         local GLOBALOFFSETS=""
3368         local size=$((((i + 2 * $nstripe )*$stride + $offset)))  # Bytes
3369         local myfn=$DIR/d44a-$size
3370         echo "--------writing $myfn at $size"
3371         ll_sparseness_write $myfn $size  || error "ll_sparseness_write"
3372         GLOBALOFFSETS="$GLOBALOFFSETS $size"
3373         ll_sparseness_verify $myfn $GLOBALOFFSETS \
3374                             || error "ll_sparseness_verify $GLOBALOFFSETS"
3375
3376         for j in `seq 0 $((nstripe-1))`; do
3377             size=$((((j + $nstripe )*$stride + $offset)))  # Bytes
3378             ll_sparseness_write $myfn $size || error "ll_sparseness_write"
3379             GLOBALOFFSETS="$GLOBALOFFSETS $size"
3380         done
3381         ll_sparseness_verify $myfn $GLOBALOFFSETS \
3382                             || error "ll_sparseness_verify $GLOBALOFFSETS"
3383         rm -f $myfn
3384       done
3385     done
3386 }
3387 run_test 44a "test sparse pwrite ==============================="
3388
3389 dirty_osc_total() {
3390         tot=0
3391         for d in `lctl get_param -n osc.*.cur_dirty_bytes`; do
3392                 tot=$(($tot + $d))
3393         done
3394         echo $tot
3395 }
3396 do_dirty_record() {
3397         before=`dirty_osc_total`
3398         echo executing "\"$*\""
3399         eval $*
3400         after=`dirty_osc_total`
3401         echo before $before, after $after
3402 }
3403 test_45() {
3404         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3405         f="$DIR/f45"
3406         # Obtain grants from OST if it supports it
3407         echo blah > ${f}_grant
3408         stop_writeback
3409         sync
3410         do_dirty_record "echo blah > $f"
3411         [ $before -eq $after ] && error "write wasn't cached"
3412         do_dirty_record "> $f"
3413         [ $before -gt $after ] || error "truncate didn't lower dirty count"
3414         do_dirty_record "echo blah > $f"
3415         [ $before -eq $after ] && error "write wasn't cached"
3416         do_dirty_record "sync"
3417         [ $before -gt $after ] || error "writeback didn't lower dirty count"
3418         do_dirty_record "echo blah > $f"
3419         [ $before -eq $after ] && error "write wasn't cached"
3420         do_dirty_record "cancel_lru_locks osc"
3421         [ $before -gt $after ] || error "lock cancellation didn't lower dirty count"
3422         start_writeback
3423 }
3424 run_test 45 "osc io page accounting ============================"
3425
3426 # in a 2 stripe file (lov.sh), page 1023 maps to page 511 in its object.  this
3427 # test tickles a bug where re-dirtying a page was failing to be mapped to the
3428 # objects offset and an assert hit when an rpc was built with 1023's mapped
3429 # offset 511 and 511's raw 511 offset. it also found general redirtying bugs.
3430 test_46() {
3431         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3432         f="$DIR/f46"
3433         stop_writeback
3434         sync
3435         dd if=/dev/zero of=$f bs=`page_size` seek=511 count=1
3436         sync
3437         dd conv=notrunc if=/dev/zero of=$f bs=`page_size` seek=1023 count=1
3438         dd conv=notrunc if=/dev/zero of=$f bs=`page_size` seek=511 count=1
3439         sync
3440         start_writeback
3441 }
3442 run_test 46 "dirtying a previously written page ================"
3443
3444 # test_47 is removed "Device nodes check" is moved to test_28
3445
3446 test_48a() { # bug 2399
3447         check_kernel_version 34 || return 0
3448         test_mkdir -p $DIR/$tdir
3449         cd $DIR/$tdir
3450         mv $DIR/$tdir $DIR/d48.new || error "move directory failed"
3451         test_mkdir $DIR/$tdir || error "recreate directory failed"
3452         touch foo || error "'touch foo' failed after recreating cwd"
3453         test_mkdir $DIR/$tdir/bar ||
3454                      error "'mkdir foo' failed after recreating cwd"
3455         if check_kernel_version 44; then
3456                 touch .foo || error "'touch .foo' failed after recreating cwd"
3457                 test_mkdir $DIR/$tdir/.bar ||
3458                               error "'mkdir .foo' failed after recreating cwd"
3459         fi
3460         ls . > /dev/null || error "'ls .' failed after recreating cwd"
3461         ls .. > /dev/null || error "'ls ..' failed after removing cwd"
3462         cd . || error "'cd .' failed after recreating cwd"
3463         test_mkdir . && error "'mkdir .' worked after recreating cwd"
3464         rmdir . && error "'rmdir .' worked after recreating cwd"
3465         ln -s . baz || error "'ln -s .' failed after recreating cwd"
3466         cd .. || error "'cd ..' failed after recreating cwd"
3467 }
3468 run_test 48a "Access renamed working dir (should return errors)="
3469
3470 test_48b() { # bug 2399
3471         check_kernel_version 34 || return 0
3472         rm -rf $DIR/$tdir
3473         test_mkdir -p $DIR/$tdir
3474         cd $DIR/$tdir
3475         rmdir $DIR/$tdir || error "remove cwd $DIR/$tdir failed"
3476         touch foo && error "'touch foo' worked after removing cwd"
3477         test_mkdir $DIR/$tdir/foo &&
3478                      error "'mkdir foo' worked after removing cwd"
3479         if check_kernel_version 44; then
3480                 touch .foo && error "'touch .foo' worked after removing cwd"
3481                 test_mkdir $DIR/$tdir/.foo &&
3482                               error "'mkdir .foo' worked after removing cwd"
3483         fi
3484         ls . > /dev/null && error "'ls .' worked after removing cwd"
3485         ls .. > /dev/null || error "'ls ..' failed after removing cwd"
3486         is_patchless || ( cd . && error "'cd .' worked after removing cwd" )
3487         test_mkdir $DIR/$tdir/. && error "'mkdir .' worked after removing cwd"
3488         rmdir . && error "'rmdir .' worked after removing cwd"
3489         ln -s . foo && error "'ln -s .' worked after removing cwd"
3490         cd .. || echo "'cd ..' failed after removing cwd `pwd`"  #bug 3517
3491 }
3492 run_test 48b "Access removed working dir (should return errors)="
3493
3494 test_48c() { # bug 2350
3495         check_kernel_version 36 || return 0
3496         #lctl set_param debug=-1
3497         #set -vx
3498         rm -rf $DIR/$tdir
3499         test_mkdir -p $DIR/$tdir/dir
3500         cd $DIR/$tdir/dir
3501         $TRACE rmdir $DIR/$tdir/dir || error "remove cwd $DIR/$tdir/dir failed"
3502         $TRACE touch foo && error "touch foo worked after removing cwd"
3503         $TRACE test_mkdir foo && error "'mkdir foo' worked after removing cwd"
3504         if check_kernel_version 44; then
3505                 touch .foo && error "touch .foo worked after removing cwd"
3506                 test_mkdir .foo && error "mkdir .foo worked after removing cwd"
3507         fi
3508         $TRACE ls . && error "'ls .' worked after removing cwd"
3509         $TRACE ls .. || error "'ls ..' failed after removing cwd"
3510         is_patchless || ( $TRACE cd . &&
3511                         error "'cd .' worked after removing cwd" )
3512         $TRACE test_mkdir . && error "'mkdir .' worked after removing cwd"
3513         $TRACE rmdir . && error "'rmdir .' worked after removing cwd"
3514         $TRACE ln -s . foo && error "'ln -s .' worked after removing cwd"
3515         $TRACE cd .. || echo "'cd ..' failed after removing cwd `pwd`" #bug 3415
3516 }
3517 run_test 48c "Access removed working subdir (should return errors)"
3518
3519 test_48d() { # bug 2350
3520         check_kernel_version 36 || return 0
3521         #lctl set_param debug=-1
3522         #set -vx
3523         rm -rf $DIR/$tdir
3524         test_mkdir -p $DIR/$tdir/dir
3525         cd $DIR/$tdir/dir
3526         $TRACE rmdir $DIR/$tdir/dir || error "remove cwd $DIR/$tdir/dir failed"
3527         $TRACE rmdir $DIR/$tdir || error "remove parent $DIR/$tdir failed"
3528         $TRACE touch foo && error "'touch foo' worked after removing parent"
3529         $TRACE test_mkdir foo && error "mkdir foo worked after removing parent"
3530         if check_kernel_version 44; then
3531                 touch .foo && error "'touch .foo' worked after removing parent"
3532                 test_mkdir .foo &&
3533                               error "mkdir .foo worked after removing parent"
3534         fi
3535         $TRACE ls . && error "'ls .' worked after removing parent"
3536         $TRACE ls .. && error "'ls ..' worked after removing parent"
3537         is_patchless || ( $TRACE cd . &&
3538                         error "'cd .' worked after recreate parent" )
3539         $TRACE test_mkdir . && error "'mkdir .' worked after removing parent"
3540         $TRACE rmdir . && error "'rmdir .' worked after removing parent"
3541         $TRACE ln -s . foo && error "'ln -s .' worked after removing parent"
3542         is_patchless || ( $TRACE cd .. &&
3543                         error "'cd ..' worked after removing parent" || true )
3544 }
3545 run_test 48d "Access removed parent subdir (should return errors)"
3546
3547 test_48e() { # bug 4134
3548         check_kernel_version 41 || return 0
3549         #lctl set_param debug=-1
3550         #set -vx
3551         rm -rf $DIR/$tdir
3552         test_mkdir -p $DIR/$tdir/dir
3553         cd $DIR/$tdir/dir
3554         $TRACE rmdir $DIR/$tdir/dir || error "remove cwd $DIR/$tdir/dir failed"
3555         $TRACE rmdir $DIR/$tdir || error "remove parent $DIR/$tdir failed"
3556         $TRACE touch $DIR/$tdir || error "'touch $DIR/$tdir' failed"
3557         $TRACE chmod +x $DIR/$tdir || error "'chmod +x $DIR/$tdir' failed"
3558         # On a buggy kernel addition of "touch foo" after cd .. will
3559         # produce kernel oops in lookup_hash_it
3560         touch ../foo && error "'cd ..' worked after recreate parent"
3561         cd $DIR
3562         $TRACE rm $DIR/$tdir || error "rm '$DIR/$tdir' failed"
3563 }
3564 run_test 48e "Access to recreated parent subdir (should return errors)"
3565
3566 test_49() { # LU-1030
3567         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3568         # get ost1 size - lustre-OST0000
3569         ost1_size=$(do_facet ost1 lfs df |grep ${ost1_svc} |awk '{print $4}')
3570         # write 800M at maximum
3571         [ $ost1_size -gt 819200 ] && ost1_size=819200
3572
3573         lfs setstripe -c 1 -i 0 $DIR/$tfile
3574         dd if=/dev/zero of=$DIR/$tfile bs=4k count=$((ost1_size >> 2)) &
3575         local dd_pid=$!
3576
3577         # change max_pages_per_rpc while writing the file
3578         local osc1_mppc=osc.$(get_osc_import_name client ost1).max_pages_per_rpc
3579         local orig_mppc=`$LCTL get_param -n $osc1_mppc`
3580         # loop until dd process exits
3581         while ps ax -opid | grep -wq $dd_pid; do
3582                 $LCTL set_param $osc1_mppc=$((RANDOM % 256 + 1))
3583                 sleep $((RANDOM % 5 + 1))
3584         done
3585         # restore original max_pages_per_rpc
3586         $LCTL set_param $osc1_mppc=$orig_mppc
3587         rm $DIR/$tfile || error "rm $DIR/$tfile failed"
3588 }
3589 run_test 49 "Change max_pages_per_rpc won't break osc extent"
3590
3591 test_50() {
3592         # bug 1485
3593         test_mkdir $DIR/$tdir
3594         cd $DIR/$tdir
3595         ls /proc/$$/cwd || error
3596 }
3597 run_test 50 "special situations: /proc symlinks  ==============="
3598
3599 test_51a() {    # was test_51
3600         # bug 1516 - create an empty entry right after ".." then split dir
3601         test_mkdir -p $DIR/$tdir
3602         touch $DIR/$tdir/foo
3603         $MCREATE $DIR/$tdir/bar
3604         rm $DIR/$tdir/foo
3605         createmany -m $DIR/$tdir/longfile 201
3606         FNUM=202
3607         while [ `ls -sd $DIR/$tdir | awk '{ print $1 }'` -eq 4 ]; do
3608                 $MCREATE $DIR/$tdir/longfile$FNUM
3609                 FNUM=$(($FNUM + 1))
3610                 echo -n "+"
3611         done
3612         echo
3613         ls -l $DIR/$tdir > /dev/null || error
3614 }
3615 run_test 51a "special situations: split htree with empty entry =="
3616
3617 export NUMTEST=70000
3618 test_51b() {
3619         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3620         local BASE=$DIR/$tdir
3621
3622         # cleanup the directory
3623         rm -fr $BASE
3624
3625         test_mkdir -p $BASE
3626
3627         local mdtidx=$(printf "%04x" $($LFS getstripe -M $BASE))
3628         local numfree=$(lctl get_param -n mdc.$FSNAME-MDT$mdtidx*.filesfree)
3629         [ $numfree -lt 21000 ] && skip "not enough free inodes ($numfree)" &&
3630                 return
3631
3632         [ $numfree -lt $NUMTEST ] && NUMTEST=$(($numfree - 50)) &&
3633                 echo "reduced count to $NUMTEST due to inodes"
3634
3635         # need to check free space for the directories as well
3636         local blkfree=$(lctl get_param -n mdc.$FSNAME-MDT$mdtidx*.kbytesavail)
3637         numfree=$((blkfree / 4))
3638         [ $numfree -lt $NUMTEST ] && NUMTEST=$(($numfree - 50)) &&
3639                 echo "reduced count to $NUMTEST due to blocks"
3640
3641         createmany -d $BASE/d $NUMTEST && echo $NUMTEST > $BASE/fnum ||
3642                 echo "failed" > $BASE/fnum
3643 }
3644 run_test 51b "exceed 64k subdirectory nlink limit"
3645
3646 test_51ba() { # LU-993
3647         local BASE=$DIR/$tdir
3648         # unlink all but 100 subdirectories, then check it still works
3649         local LEFT=100
3650         [ -f $BASE/fnum ] && local NUMPREV=$(cat $BASE/fnum) && rm $BASE/fnum
3651
3652         [ "$NUMPREV" != "failed" ] && NUMTEST=$NUMPREV
3653         local DELETE=$((NUMTEST - LEFT))
3654
3655         # continue on to run this test even if 51b didn't finish,
3656         # just to delete the many subdirectories created.
3657         [ ! -d "${BASE}/d1" ] && skip "test_51b() not run" && return 0
3658
3659         # for ldiskfs the nlink count should be 1, but this is OSD specific
3660         # and so this is listed for informational purposes only
3661         echo "nlink before: $(stat -c %h $BASE), created before: $NUMTEST"
3662         unlinkmany -d $BASE/d $DELETE
3663         RC=$?
3664
3665         if [ $RC -ne 0 ]; then
3666                 if [ "$NUMPREV" == "failed" ]; then
3667                         skip "previous setup failed"
3668                         return 0
3669                 else
3670                         error "unlink of first $DELETE subdirs failed"
3671                         return $RC
3672                 fi
3673         fi
3674
3675         echo "nlink between: $(stat -c %h $BASE)"
3676         # trim the first line of ls output
3677         local FOUND=$(($(ls -l ${BASE} | wc -l) - 1))
3678         [ $FOUND -ne $LEFT ] &&
3679                 error "can't find subdirs: found only $FOUND/$LEFT"
3680
3681         unlinkmany -d $BASE/d $DELETE $LEFT ||
3682                 error "unlink of second $LEFT subdirs failed"
3683         # regardless of whether the backing filesystem tracks nlink accurately
3684         # or not, the nlink count shouldn't be more than "." and ".." here
3685         local AFTER=$(stat -c %h $BASE)
3686         [ $AFTER -gt 2 ] && error "nlink after: $AFTER > 2" ||
3687                 echo "nlink after: $AFTER"
3688 }
3689 run_test 51ba "verify nlink for many subdirectory cleanup"
3690
3691 test_51d() {
3692         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3693         [  "$OSTCOUNT" -lt "3" ] && skip_env "skipping test with few OSTs" && return
3694         test_mkdir -p $DIR/$tdir
3695         createmany -o $DIR/$tdir/t- 1000
3696         $GETSTRIPE $DIR/$tdir > $TMP/files
3697         for N in `seq 0 $((OSTCOUNT - 1))`; do
3698             OBJS[$N]=`awk -vobjs=0 '($1 == '$N') { objs += 1 } END { print objs;}' $TMP/files`
3699             OBJS0[$N]=`grep -A 1 idx $TMP/files | awk -vobjs=0 '($1 == '$N') { objs += 1 } END { print objs;}'`
3700             log "OST$N has ${OBJS[$N]} objects, ${OBJS0[$N]} are index 0"
3701         done
3702         unlinkmany $DIR/$tdir/t- 1000
3703
3704         NLAST=0
3705         for N in `seq 1 $((OSTCOUNT - 1))`; do
3706             [ ${OBJS[$N]} -lt $((${OBJS[$NLAST]} - 20)) ] && \
3707                 error "OST $N has less objects vs OST $NLAST (${OBJS[$N]} < ${OBJS[$NLAST]}"
3708             [ ${OBJS[$N]} -gt $((${OBJS[$NLAST]} + 20)) ] && \
3709                 error "OST $N has less objects vs OST $NLAST (${OBJS[$N]} < ${OBJS[$NLAST]}"
3710
3711             [ ${OBJS0[$N]} -lt $((${OBJS0[$NLAST]} - 20)) ] && \
3712                 error "OST $N has less #0 objects vs OST $NLAST (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
3713             [ ${OBJS0[$N]} -gt $((${OBJS0[$NLAST]} + 20)) ] && \
3714                 error "OST $N has less #0 objects vs OST $NLAST (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
3715             NLAST=$N
3716         done
3717 }
3718 run_test 51d "check object distribution ===================="
3719
3720 test_52a() {
3721         [ -f $DIR/$tdir/foo ] && chattr -a $DIR/$tdir/foo
3722         test_mkdir -p $DIR/$tdir
3723         touch $DIR/$tdir/foo
3724         chattr +a $DIR/$tdir/foo || error "chattr +a failed"
3725         echo bar >> $DIR/$tdir/foo || error "append bar failed"
3726         cp /etc/hosts $DIR/$tdir/foo && error "cp worked"
3727         rm -f $DIR/$tdir/foo 2>/dev/null && error "rm worked"
3728         link $DIR/$tdir/foo $DIR/$tdir/foo_link 2>/dev/null &&
3729                                         error "link worked"
3730         echo foo >> $DIR/$tdir/foo || error "append foo failed"
3731         mrename $DIR/$tdir/foo $DIR/$tdir/foo_ren && error "rename worked"
3732         lsattr $DIR/$tdir/foo | egrep -q "^-+a[-e]+ $DIR/$tdir/foo" ||
3733                                                      error "lsattr"
3734         chattr -a $DIR/$tdir/foo || error "chattr -a failed"
3735         cp -r $DIR/$tdir /tmp/
3736         rm -fr $DIR/$tdir || error "cleanup rm failed"
3737 }
3738 run_test 52a "append-only flag test (should return errors) ====="
3739
3740 test_52b() {
3741         [ -f $DIR/$tdir/foo ] && chattr -i $DIR/$tdir/foo
3742         test_mkdir -p $DIR/$tdir
3743         touch $DIR/$tdir/foo
3744         chattr +i $DIR/$tdir/foo || error "chattr +i failed"
3745         cat test > $DIR/$tdir/foo && error "cat test worked"
3746         cp /etc/hosts $DIR/$tdir/foo && error "cp worked"
3747         rm -f $DIR/$tdir/foo 2>/dev/null && error "rm worked"
3748         link $DIR/$tdir/foo $DIR/$tdir/foo_link 2>/dev/null &&
3749                                         error "link worked"
3750         echo foo >> $DIR/$tdir/foo && error "echo worked"
3751         mrename $DIR/$tdir/foo $DIR/$tdir/foo_ren && error "rename worked"
3752         [ -f $DIR/$tdir/foo ] || error
3753         [ -f $DIR/$tdir/foo_ren ] && error
3754         lsattr $DIR/$tdir/foo | egrep -q "^-+i[-e]+ $DIR/$tdir/foo" ||
3755                                                         error "lsattr"
3756         chattr -i $DIR/$tdir/foo || error "chattr failed"
3757
3758         rm -fr $DIR/$tdir || error
3759 }
3760 run_test 52b "immutable flag test (should return errors) ======="
3761
3762 test_53() {
3763         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3764         remote_mds_nodsh && skip "remote MDS with nodsh" && return
3765         remote_ost_nodsh && skip "remote OST with nodsh" && return
3766
3767         local param
3768         local param_seq
3769         local ostname
3770         local mds_last
3771         local mds_last_seq
3772         local ost_last
3773         local ost_last_seq
3774         local ost_last_id
3775         local ostnum
3776         local node
3777         local found=0
3778
3779         # only test MDT0000
3780         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS)
3781         for value in $(do_facet $SINGLEMDS lctl get_param osc.$mdtosc.prealloc_last_id) ; do
3782                 param=$(echo ${value[0]} | cut -d "=" -f1)
3783                 ostname=$(echo $param | cut -d "." -f2 | cut -d - -f 1-2)
3784                 param_seq=$(echo ${param} |
3785                             sed -e s/prealloc_last_id/prealloc_last_seq/g)
3786                 mds_last_seq=$(do_facet $SINGLEMDS lctl get_param -n $param_seq)
3787                 mds_last=$(do_facet $SINGLEMDS lctl get_param -n $param)
3788
3789                 ostnum=$(index_from_ostuuid ${ostname}_UUID)
3790                 node=$(facet_active_host ost$((ostnum+1)))
3791                 param="obdfilter.$ostname.last_id"
3792                 for ost_last in $(do_node $node lctl get_param -n $param) ; do
3793                         echo "$ostname.last_id=$ost_last ;MDS.last_id=$mds_last"
3794                         ost_last_id=$(echo $ost_last | awk -F':' '{print $2}' |
3795                                       sed -e "s/^0x//g")
3796                         ost_last_seq=$(echo $ost_last | awk -F':' '{print $1}')
3797                         if [ $ost_last_seq = $mds_last_seq ]; then
3798                                 if [ $ost_last_id != $mds_last ]; then
3799                                         error "$ost_last != $mds_last_id"
3800                                 else
3801                                         found=1
3802                                         break
3803                                 fi
3804                         fi
3805                 done
3806         done
3807         [ $found = 0 ] && error "can not match last_seq/last_id for $mdtosc"
3808         return 0
3809 }
3810 run_test 53 "verify that MDS and OSTs agree on pre-creation ===="
3811
3812 test_54a() {
3813         [ ! -f "$SOCKETSERVER" ] && skip_env "no socketserver, skipping" && return
3814         [ ! -f "$SOCKETCLIENT" ] && skip_env "no socketclient, skipping" && return
3815         $SOCKETSERVER $DIR/socket
3816         $SOCKETCLIENT $DIR/socket || error
3817         $MUNLINK $DIR/socket
3818 }
3819 run_test 54a "unix domain socket test =========================="
3820
3821 test_54b() {
3822         f="$DIR/f54b"
3823         mknod $f c 1 3
3824         chmod 0666 $f
3825         dd if=/dev/zero of=$f bs=`page_size` count=1
3826 }
3827 run_test 54b "char device works in lustre ======================"
3828
3829 find_loop_dev() {
3830         [ -b /dev/loop/0 ] && LOOPBASE=/dev/loop/
3831         [ -b /dev/loop0 ] && LOOPBASE=/dev/loop
3832         [ -z "$LOOPBASE" ] && echo "/dev/loop/0 and /dev/loop0 gone?" && return
3833
3834         for i in `seq 3 7`; do
3835                 losetup $LOOPBASE$i > /dev/null 2>&1 && continue
3836                 LOOPDEV=$LOOPBASE$i
3837                 LOOPNUM=$i
3838                 break
3839         done
3840 }
3841
3842 test_54c() {
3843         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
3844         tfile="$DIR/f54c"
3845         tdir="$DIR/d54c"
3846         loopdev="$DIR/loop54c"
3847
3848         find_loop_dev
3849         [ -z "$LOOPNUM" ] && echo "couldn't find empty loop device" && return
3850         mknod $loopdev b 7 $LOOPNUM
3851         echo "make a loop file system with $tfile on $loopdev ($LOOPNUM)..."
3852         dd if=/dev/zero of=$tfile bs=`page_size` seek=1024 count=1 > /dev/null
3853         losetup $loopdev $tfile || error "can't set up $loopdev for $tfile"
3854         mkfs.ext2 $loopdev || error "mke2fs on $loopdev"
3855         test_mkdir -p $tdir
3856         mount -t ext2 $loopdev $tdir || error "error mounting $loopdev on $tdir"
3857         dd if=/dev/zero of=$tdir/tmp bs=`page_size` count=30 || error "dd write"
3858         df $tdir
3859         dd if=$tdir/tmp of=/dev/zero bs=`page_size` count=30 || error "dd read"
3860         $UMOUNT $tdir
3861         losetup -d $loopdev
3862         rm $loopdev
3863 }
3864 run_test 54c "block device works in lustre ====================="
3865
3866 test_54d() {
3867         f="$DIR/f54d"
3868         string="aaaaaa"
3869         mknod $f p
3870         [ "$string" = `echo $string > $f | cat $f` ] || error
3871 }
3872 run_test 54d "fifo device works in lustre ======================"
3873
3874 test_54e() {
3875         check_kernel_version 46 || return 0
3876         f="$DIR/f54e"
3877         string="aaaaaa"
3878         cp -aL /dev/console $f
3879         echo $string > $f || error
3880 }
3881 run_test 54e "console/tty device works in lustre ======================"
3882
3883 #The test_55 used to be iopen test and it was removed by bz#24037.
3884 #run_test 55 "check iopen_connect_dentry() ======================"
3885
3886 test_56a() {    # was test_56
3887         rm -rf $DIR/$tdir
3888         $SETSTRIPE -d $DIR
3889         test_mkdir $DIR/$tdir
3890         test_mkdir $DIR/$tdir/dir
3891         NUMFILES=3
3892         NUMFILESx2=$(($NUMFILES * 2))
3893         for i in `seq 1 $NUMFILES` ; do
3894                 touch $DIR/$tdir/file$i
3895                 touch $DIR/$tdir/dir/file$i
3896         done
3897
3898         # test lfs getstripe with --recursive
3899         FILENUM=`$GETSTRIPE --recursive $DIR/$tdir | grep -c obdidx`
3900         [ $FILENUM -eq $NUMFILESx2 ] ||
3901                 error "$GETSTRIPE --recursive: found $FILENUM, not $NUMFILESx2"
3902         FILENUM=`$GETSTRIPE $DIR/$tdir | grep -c obdidx`
3903         [ $FILENUM -eq $NUMFILES ] ||
3904                 error "$GETSTRIPE $DIR/$tdir: found $FILENUM, not $NUMFILES"
3905         echo "$GETSTRIPE --recursive passed."
3906
3907         # test lfs getstripe with file instead of dir
3908         FILENUM=`$GETSTRIPE $DIR/$tdir/file1 | grep -c obdidx`
3909         [ $FILENUM  -eq 1 ] || error \
3910                  "$GETSTRIPE $DIR/$tdir/file1: found $FILENUM, not 1"
3911         echo "$GETSTRIPE file1 passed."
3912
3913         #test lfs getstripe with --verbose
3914         [ `$GETSTRIPE --verbose $DIR/$tdir |
3915                         grep -c lmm_magic` -eq $NUMFILES ] ||
3916                 error "$GETSTRIPE --verbose $DIR/$tdir: want $NUMFILES"
3917         [ `$GETSTRIPE $DIR/$tdir | grep -c lmm_magic` -eq 0 ] ||
3918             error "$GETSTRIPE $DIR/$tdir: showed lmm_magic"
3919         echo "$GETSTRIPE --verbose passed."
3920
3921         #test lfs getstripe with --obd
3922         $GETSTRIPE --obd wrong_uuid $DIR/$tdir 2>&1 |
3923                                         grep -q "unknown obduuid" ||
3924                 error "$GETSTRIPE --obd wrong_uuid should return error message"
3925
3926         [  "$OSTCOUNT" -lt 2 ] &&
3927                 skip_env "skipping other $GETSTRIPE --obd test" && return
3928
3929         OSTIDX=1
3930         OBDUUID=$(ostuuid_from_index $OSTIDX)
3931         FILENUM=`$GETSTRIPE -ir $DIR/$tdir | grep -x $OSTIDX | wc -l`
3932         FOUND=`$GETSTRIPE -r --obd $OBDUUID $DIR/$tdir | grep obdidx | wc -l`
3933         [ $FOUND -eq $FILENUM ] ||
3934                 error "$GETSTRIPE --obd wrong: found $FOUND, expected $FILENUM"
3935         [ `$GETSTRIPE -r -v --obd $OBDUUID $DIR/$tdir |
3936                 sed '/^[         ]*'${OSTIDX}'[  ]/d' |
3937                 sed -n '/^[      ]*[0-9][0-9]*[  ]/p' | wc -l` -eq 0 ] ||
3938                 error "$GETSTRIPE --obd: should not show file on other obd"
3939         echo "$GETSTRIPE --obd passed"
3940 }
3941 run_test 56a "check $GETSTRIPE"
3942
3943 NUMFILES=3
3944 NUMDIRS=3
3945 setup_56() {
3946         local LOCAL_NUMFILES="$1"
3947         local LOCAL_NUMDIRS="$2"
3948         local MKDIR_PARAMS="$3"
3949
3950         if [ ! -d "$TDIR" ] ; then
3951                 test_mkdir -p $TDIR
3952                 [ "$MKDIR_PARAMS" ] && $SETSTRIPE $MKDIR_PARAMS $TDIR
3953                 for i in `seq 1 $LOCAL_NUMFILES` ; do
3954                         touch $TDIR/file$i
3955                 done
3956                 for i in `seq 1 $LOCAL_NUMDIRS` ; do
3957                         test_mkdir $TDIR/dir$i
3958                         for j in `seq 1 $LOCAL_NUMFILES` ; do
3959                                 touch $TDIR/dir$i/file$j
3960                         done
3961                 done
3962         fi
3963 }
3964
3965 setup_56_special() {
3966         LOCAL_NUMFILES=$1
3967         LOCAL_NUMDIRS=$2
3968         setup_56 $1 $2
3969         if [ ! -e "$TDIR/loop1b" ] ; then
3970                 for i in `seq 1 $LOCAL_NUMFILES` ; do
3971                         mknod $TDIR/loop${i}b b 7 $i
3972                         mknod $TDIR/null${i}c c 1 3
3973                         ln -s $TDIR/file1 $TDIR/link${i}l
3974                 done
3975                 for i in `seq 1 $LOCAL_NUMDIRS` ; do
3976                         mknod $TDIR/dir$i/loop${i}b b 7 $i
3977                         mknod $TDIR/dir$i/null${i}c c 1 3
3978                         ln -s $TDIR/dir$i/file1 $TDIR/dir$i/link${i}l
3979                 done
3980         fi
3981 }
3982
3983 test_56g() {
3984         $SETSTRIPE -d $DIR
3985
3986         TDIR=$DIR/${tdir}g
3987         setup_56 $NUMFILES $NUMDIRS
3988
3989         EXPECTED=$(($NUMDIRS + 2))
3990         # test lfs find with -name
3991         for i in $(seq 1 $NUMFILES) ; do
3992                 NUMS=$($LFIND -name "*$i" $TDIR | wc -l)
3993                 [ $NUMS -eq $EXPECTED ] ||
3994                         error "lfs find -name \"*$i\" $TDIR wrong: "\
3995                               "found $NUMS, expected $EXPECTED"
3996         done
3997 }
3998 run_test 56g "check lfs find -name ============================="
3999
4000 test_56h() {
4001         $SETSTRIPE -d $DIR
4002
4003         TDIR=$DIR/${tdir}g
4004         setup_56 $NUMFILES $NUMDIRS
4005
4006         EXPECTED=$(((NUMDIRS + 1) * (NUMFILES - 1) + NUMFILES))
4007         # test lfs find with ! -name
4008         for i in $(seq 1 $NUMFILES) ; do
4009                 NUMS=$($LFIND ! -name "*$i" $TDIR | wc -l)
4010                 [ $NUMS -eq $EXPECTED ] ||
4011                         error "lfs find ! -name \"*$i\" $TDIR wrong: "\
4012                               "found $NUMS, expected $EXPECTED"
4013         done
4014 }
4015 run_test 56h "check lfs find ! -name ============================="
4016
4017 test_56i() {
4018        tdir=${tdir}i
4019        test_mkdir -p $DIR/$tdir
4020        UUID=$(ostuuid_from_index 0 $DIR/$tdir)
4021        CMD="$LFIND -ost $UUID $DIR/$tdir"
4022        OUT=$($CMD)
4023        [ -z "$OUT" ] || error "\"$CMD\" returned directory '$OUT'"
4024 }
4025 run_test 56i "check 'lfs find -ost UUID' skips directories ======="
4026
4027 test_56j() {
4028         TDIR=$DIR/${tdir}g
4029         setup_56_special $NUMFILES $NUMDIRS
4030
4031         EXPECTED=$((NUMDIRS + 1))
4032         CMD="$LFIND -type d $TDIR"
4033         NUMS=$($CMD | wc -l)
4034         [ $NUMS -eq $EXPECTED ] ||
4035                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4036 }
4037 run_test 56j "check lfs find -type d ============================="
4038
4039 test_56k() {
4040         TDIR=$DIR/${tdir}g
4041         setup_56_special $NUMFILES $NUMDIRS
4042
4043         EXPECTED=$(((NUMDIRS + 1) * NUMFILES))
4044         CMD="$LFIND -type f $TDIR"
4045         NUMS=$($CMD | wc -l)
4046         [ $NUMS -eq $EXPECTED ] ||
4047                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4048 }
4049 run_test 56k "check lfs find -type f ============================="
4050
4051 test_56l() {
4052         TDIR=$DIR/${tdir}g
4053         setup_56_special $NUMFILES $NUMDIRS
4054
4055         EXPECTED=$((NUMDIRS + NUMFILES))
4056         CMD="$LFIND -type b $TDIR"
4057         NUMS=$($CMD | wc -l)
4058         [ $NUMS -eq $EXPECTED ] ||
4059                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4060 }
4061 run_test 56l "check lfs find -type b ============================="
4062
4063 test_56m() {
4064         TDIR=$DIR/${tdir}g
4065         setup_56_special $NUMFILES $NUMDIRS
4066
4067         EXPECTED=$((NUMDIRS + NUMFILES))
4068         CMD="$LFIND -type c $TDIR"
4069         NUMS=$($CMD | wc -l)
4070         [ $NUMS -eq $EXPECTED ] ||
4071                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4072 }
4073 run_test 56m "check lfs find -type c ============================="
4074
4075 test_56n() {
4076         TDIR=$DIR/${tdir}g
4077         setup_56_special $NUMFILES $NUMDIRS
4078
4079         EXPECTED=$((NUMDIRS + NUMFILES))
4080         CMD="$LFIND -type l $TDIR"
4081         NUMS=$($CMD | wc -l)
4082         [ $NUMS -eq $EXPECTED ] ||
4083                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4084 }
4085 run_test 56n "check lfs find -type l ============================="
4086
4087 test_56o() {
4088         TDIR=$DIR/${tdir}o
4089         setup_56 $NUMFILES $NUMDIRS
4090
4091         utime $TDIR/file1 > /dev/null || error "utime (1)"
4092         utime $TDIR/file2 > /dev/null || error "utime (2)"
4093         utime $TDIR/dir1 > /dev/null || error "utime (3)"
4094         utime $TDIR/dir2 > /dev/null || error "utime (4)"
4095         utime $TDIR/dir1/file1 > /dev/null || error "utime (5)"
4096         dd if=/dev/zero count=1 >> $TDIR/dir1/file1 && sync
4097
4098         EXPECTED=4
4099         NUMS=`$LFIND -mtime +0 $TDIR | wc -l`
4100         [ $NUMS -eq $EXPECTED ] || \
4101                 error "lfs find -mtime +0 $TDIR wrong: found $NUMS, expected $EXPECTED"
4102
4103         EXPECTED=12
4104         CMD="$LFIND -mtime 0 $TDIR"
4105         NUMS=$($CMD | wc -l)
4106         [ $NUMS -eq $EXPECTED ] ||
4107                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4108 }
4109 run_test 56o "check lfs find -mtime for old files =========================="
4110
4111 test_56p() {
4112         [ $RUNAS_ID -eq $UID ] &&
4113                 skip_env "RUNAS_ID = UID = $UID -- skipping" && return
4114
4115         TDIR=$DIR/${tdir}p
4116         setup_56 $NUMFILES $NUMDIRS
4117
4118         chown $RUNAS_ID $TDIR/file* || error "chown $DIR/${tdir}g/file$i failed"
4119         EXPECTED=$NUMFILES
4120         CMD="$LFIND -uid $RUNAS_ID $TDIR"
4121         NUMS=$($CMD | wc -l)
4122         [ $NUMS -eq $EXPECTED ] || \
4123                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4124
4125         EXPECTED=$(((NUMFILES + 1) * NUMDIRS + 1))
4126         CMD="$LFIND ! -uid $RUNAS_ID $TDIR"
4127         NUMS=$($CMD | wc -l)
4128         [ $NUMS -eq $EXPECTED ] || \
4129                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4130 }
4131 run_test 56p "check lfs find -uid and ! -uid ==============================="
4132
4133 test_56q() {
4134         [ $RUNAS_ID -eq $UID ] &&
4135                 skip_env "RUNAS_ID = UID = $UID -- skipping" && return
4136
4137         TDIR=$DIR/${tdir}q
4138         setup_56 $NUMFILES $NUMDIRS
4139
4140         chgrp $RUNAS_GID $TDIR/file* || error "chown $TDIR/file$i failed"
4141
4142         EXPECTED=$NUMFILES
4143         CMD="$LFIND -gid $RUNAS_GID $TDIR"
4144         NUMS=$($CMD | wc -l)
4145         [ $NUMS -eq $EXPECTED ] ||
4146                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4147
4148         EXPECTED=$(( ($NUMFILES+1) * $NUMDIRS + 1))
4149         CMD="$LFIND ! -gid $RUNAS_GID $TDIR"
4150         NUMS=$($CMD | wc -l)
4151         [ $NUMS -eq $EXPECTED ] ||
4152                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4153 }
4154 run_test 56q "check lfs find -gid and ! -gid ==============================="
4155
4156 test_56r() {
4157         TDIR=$DIR/${tdir}r
4158         setup_56 $NUMFILES $NUMDIRS
4159
4160         EXPECTED=12
4161         CMD="$LFIND -size 0 -type f $TDIR"
4162         NUMS=$($CMD | wc -l)
4163         [ $NUMS -eq $EXPECTED ] ||
4164                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4165         EXPECTED=0
4166         CMD="$LFIND ! -size 0 -type f $TDIR"
4167         NUMS=$($CMD | wc -l)
4168         [ $NUMS -eq $EXPECTED ] ||
4169                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4170         echo "test" > $TDIR/$tfile
4171         echo "test2" > $TDIR/$tfile.2 && sync
4172         EXPECTED=1
4173         CMD="$LFIND -size 5 -type f $TDIR"
4174         NUMS=$($CMD | wc -l)
4175         [ $NUMS -eq $EXPECTED ] ||
4176                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4177         EXPECTED=1
4178         CMD="$LFIND -size +5 -type f $TDIR"
4179         NUMS=$($CMD | wc -l)
4180         [ $NUMS -eq $EXPECTED ] ||
4181                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4182         EXPECTED=2
4183         CMD="$LFIND -size +0 -type f $TDIR"
4184         NUMS=$($CMD | wc -l)
4185         [ $NUMS -eq $EXPECTED ] ||
4186                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4187         EXPECTED=2
4188         CMD="$LFIND ! -size -5 -type f $TDIR"
4189         NUMS=$($CMD | wc -l)
4190         [ $NUMS -eq $EXPECTED ] ||
4191                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4192         EXPECTED=12
4193         CMD="$LFIND -size -5 -type f $TDIR"
4194         NUMS=$($CMD | wc -l)
4195         [ $NUMS -eq $EXPECTED ] ||
4196                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4197 }
4198 run_test 56r "check lfs find -size works =========================="
4199
4200 test_56s() { # LU-611
4201         TDIR=$DIR/${tdir}s
4202         setup_56 $NUMFILES $NUMDIRS "-c $OSTCOUNT"
4203
4204         if [ $OSTCOUNT -gt 1 ]; then
4205                 $SETSTRIPE -c 1 $TDIR/$tfile.{0,1,2,3}
4206                 ONESTRIPE=4
4207                 EXTRA=4
4208         else
4209                 ONESTRIPE=$(((NUMDIRS + 1) * NUMFILES))
4210                 EXTRA=0
4211         fi
4212
4213         EXPECTED=$(((NUMDIRS + 1) * NUMFILES))
4214         CMD="$LFIND -stripe-count $OSTCOUNT -type f $TDIR"
4215         NUMS=$($CMD | wc -l)
4216         [ $NUMS -eq $EXPECTED ] ||
4217                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4218
4219         EXPECTED=$(((NUMDIRS + 1) * NUMFILES + EXTRA))
4220         CMD="$LFIND -stripe-count +0 -type f $TDIR"
4221         NUMS=$($CMD | wc -l)
4222         [ $NUMS -eq $EXPECTED ] ||
4223                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4224
4225         EXPECTED=$ONESTRIPE
4226         CMD="$LFIND -stripe-count 1 -type f $TDIR"
4227         NUMS=$($CMD | wc -l)
4228         [ $NUMS -eq $EXPECTED ] ||
4229                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4230
4231         CMD="$LFIND -stripe-count -2 -type f $TDIR"
4232         NUMS=$($CMD | wc -l)
4233         [ $NUMS -eq $EXPECTED ] ||
4234                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4235
4236         EXPECTED=0
4237         CMD="$LFIND -stripe-count $((OSTCOUNT + 1)) -type f $TDIR"
4238         NUMS=$($CMD | wc -l)
4239         [ $NUMS -eq $EXPECTED ] ||
4240                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4241 }
4242 run_test 56s "check lfs find -stripe-count works"
4243
4244 test_56t() { # LU-611
4245         TDIR=$DIR/${tdir}t
4246         setup_56 $NUMFILES $NUMDIRS "-s 512k"
4247
4248         $SETSTRIPE -S 256k $TDIR/$tfile.{0,1,2,3}
4249
4250         EXPECTED=$(((NUMDIRS + 1) * NUMFILES))
4251         CMD="$LFIND -stripe-size 512k -type f $TDIR"
4252         NUMS=$($CMD | wc -l)
4253         [ $NUMS -eq $EXPECTED ] ||
4254                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4255
4256         CMD="$LFIND -stripe-size +320k -type f $TDIR"
4257         NUMS=$($CMD | wc -l)
4258         [ $NUMS -eq $EXPECTED ] ||
4259                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4260
4261         EXPECTED=$(((NUMDIRS + 1) * NUMFILES + 4))
4262         CMD="$LFIND -stripe-size +200k -type f $TDIR"
4263         NUMS=$($CMD | wc -l)
4264         [ $NUMS -eq $EXPECTED ] ||
4265                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4266
4267         CMD="$LFIND -stripe-size -640k -type f $TDIR"
4268         NUMS=$($CMD | wc -l)
4269         [ $NUMS -eq $EXPECTED ] ||
4270                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4271
4272         EXPECTED=4
4273         CMD="$LFIND -stripe-size 256k -type f $TDIR"
4274         NUMS=$($CMD | wc -l)
4275         [ $NUMS -eq $EXPECTED ] ||
4276                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4277
4278         CMD="$LFIND -stripe-size -320k -type f $TDIR"
4279         NUMS=$($CMD | wc -l)
4280         [ $NUMS -eq $EXPECTED ] ||
4281                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4282
4283         EXPECTED=0
4284         CMD="$LFIND -stripe-size 1024k -type f $TDIR"
4285         NUMS=$($CMD | wc -l)
4286         [ $NUMS -eq $EXPECTED ] ||
4287                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4288 }
4289 run_test 56t "check lfs find -stripe-size works"
4290
4291 test_56u() { # LU-611
4292         TDIR=$DIR/${tdir}u
4293         setup_56 $NUMFILES $NUMDIRS "-i 0"
4294
4295         if [ $OSTCOUNT -gt 1 ]; then
4296                 $SETSTRIPE -i 1 $TDIR/$tfile.{0,1,2,3}
4297                 ONESTRIPE=4
4298         else
4299                 ONESTRIPE=0
4300         fi
4301
4302         EXPECTED=$(((NUMDIRS + 1) * NUMFILES))
4303         CMD="$LFIND -stripe-index 0 -type f $TDIR"
4304         NUMS=$($CMD | wc -l)
4305         [ $NUMS -eq $EXPECTED ] ||
4306                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4307
4308         EXPECTED=$ONESTRIPE
4309         CMD="$LFIND -stripe-index 1 -type f $TDIR"
4310         NUMS=$($CMD | wc -l)
4311         [ $NUMS -eq $EXPECTED ] ||
4312                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4313
4314         CMD="$LFIND ! -stripe-index 0 -type f $TDIR"
4315         NUMS=$($CMD | wc -l)
4316         [ $NUMS -eq $EXPECTED ] ||
4317                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4318
4319         EXPECTED=0
4320         # This should produce an error and not return any files
4321         CMD="$LFIND -stripe-index $OSTCOUNT -type f $TDIR"
4322         NUMS=$($CMD 2>/dev/null | wc -l)
4323         [ $NUMS -eq $EXPECTED ] ||
4324                 error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4325
4326         if [ $OSTCOUNT -gt 1 ]; then
4327                 EXPECTED=$(((NUMDIRS + 1) * NUMFILES + ONESTRIPE))
4328                 CMD="$LFIND -stripe-index 0,1 -type f $TDIR"
4329                 NUMS=$($CMD | wc -l)
4330                 [ $NUMS -eq $EXPECTED ] ||
4331                         error "\"$CMD\" wrong: found $NUMS, expected $EXPECTED"
4332         fi
4333 }
4334 run_test 56u "check lfs find -stripe-index works"
4335
4336 test_56v() {
4337     local MDT_IDX=0
4338
4339     TDIR=$DIR/${tdir}v
4340     rm -rf $TDIR
4341     setup_56 $NUMFILES $NUMDIRS
4342
4343     UUID=$(mdtuuid_from_index $MDT_IDX $TDIR)
4344     [ -z "$UUID" ] && error "mdtuuid_from_index cannot find MDT index $MDT_IDX"
4345
4346     for file in $($LFIND -mdt $UUID $TDIR); do
4347         file_mdt_idx=$($GETSTRIPE -M $file)
4348         [ $file_mdt_idx -eq $MDT_IDX ] ||
4349             error "'lfind -mdt $UUID' != 'getstripe -M' ($file_mdt_idx)"
4350     done
4351 }
4352 run_test 56v "check 'lfs find -mdt match with lfs getstripe -M' ======="
4353
4354 # Get and check the actual stripe count of one file.
4355 # Usage: check_stripe_count <file> <expected_stripe_count>
4356 check_stripe_count() {
4357     local file=$1
4358     local expected=$2
4359     local actual
4360
4361     [[ -z "$file" || -z "$expected" ]] &&
4362         error "check_stripe_count: invalid argument!"
4363
4364     local cmd="$GETSTRIPE -c $file"
4365     actual=$($cmd) || error "$cmd failed"
4366     actual=${actual%% *}
4367
4368     if [[ $actual -ne $expected ]]; then
4369         [[ $expected -eq -1 ]] ||
4370             error "$cmd wrong: found $actual, expected $expected"
4371         [[ $actual -eq $OSTCOUNT ]] ||
4372             error "$cmd wrong: found $actual, expected $OSTCOUNT"
4373     fi
4374 }
4375
4376 test_56w() {
4377         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4378         TDIR=$DIR/${tdir}w
4379
4380     rm -rf $TDIR || error "remove $TDIR failed"
4381     setup_56 $NUMFILES $NUMDIRS "-c $OSTCOUNT"
4382
4383     local stripe_size
4384     stripe_size=$($GETSTRIPE -S -d $TDIR) ||
4385         error "$GETSTRIPE -S -d $TDIR failed"
4386     stripe_size=${stripe_size%% *}
4387
4388     local file_size=$((stripe_size * OSTCOUNT))
4389     local file_num=$((NUMDIRS * NUMFILES + NUMFILES))
4390     local required_space=$((file_num * file_size))
4391     local free_space=$($LCTL get_param -n lov.$LOVNAME.kbytesavail)
4392     [[ $free_space -le $((required_space / 1024)) ]] &&
4393         skip_env "need at least $required_space bytes free space," \
4394                  "have $free_space kbytes" && return
4395
4396     local dd_bs=65536
4397     local dd_count=$((file_size / dd_bs))
4398
4399     # write data into the files
4400     local i
4401     local j
4402     local file
4403     for i in $(seq 1 $NUMFILES); do
4404         file=$TDIR/file$i
4405         yes | dd bs=$dd_bs count=$dd_count of=$file >/dev/null 2>&1 ||
4406             error "write data into $file failed"
4407     done
4408     for i in $(seq 1 $NUMDIRS); do
4409         for j in $(seq 1 $NUMFILES); do
4410             file=$TDIR/dir$i/file$j
4411             yes | dd bs=$dd_bs count=$dd_count of=$file \
4412                 >/dev/null 2>&1 ||
4413                 error "write data into $file failed"
4414         done
4415     done
4416
4417     local expected=-1
4418     [[ $OSTCOUNT -gt 1 ]] && expected=$((OSTCOUNT - 1))
4419
4420     # lfs_migrate file
4421     local cmd="$LFS_MIGRATE -y -c $expected $TDIR/file1"
4422     echo "$cmd"
4423     eval $cmd || error "$cmd failed"
4424
4425     check_stripe_count $TDIR/file1 $expected
4426
4427     # lfs_migrate dir
4428     cmd="$LFS_MIGRATE -y -c $expected $TDIR/dir1"
4429     echo "$cmd"
4430     eval $cmd || error "$cmd failed"
4431
4432     for j in $(seq 1 $NUMFILES); do
4433         check_stripe_count $TDIR/dir1/file$j $expected
4434     done
4435
4436     # lfs_migrate works with lfs find
4437     cmd="$LFIND -stripe_count $OSTCOUNT -type f $TDIR |
4438          $LFS_MIGRATE -y -c $expected"
4439     echo "$cmd"
4440     eval $cmd || error "$cmd failed"
4441
4442     for i in $(seq 2 $NUMFILES); do
4443         check_stripe_count $TDIR/file$i $expected
4444     done
4445     for i in $(seq 2 $NUMDIRS); do
4446         for j in $(seq 1 $NUMFILES); do
4447             check_stripe_count $TDIR/dir$i/file$j $expected
4448         done
4449     done
4450 }
4451 run_test 56w "check lfs_migrate -c stripe_count works"
4452
4453 test_56x() {
4454         check_swap_layouts_support && return 0
4455         [ "$OSTCOUNT" -lt "2" ] &&
4456                 skip_env "need 2 OST, skipping test" && return
4457
4458         local dir0=$DIR/$tdir/$testnum
4459         mkdir -p $dir0 || error "creating dir $dir0"
4460
4461         local ref1=/etc/passwd
4462         local file1=$dir0/file1
4463
4464         $SETSTRIPE -c 2 $file1
4465         cp $ref1 $file1
4466         $LFS migrate -c 1 $file1 || error "migrate failed rc = $?"
4467         stripe=$($GETSTRIPE -c $file1)
4468         [[ $stripe == 1 ]] || error "stripe of $file1 is $stripe != 1"
4469         cmp $file1 $ref1 || error "content mismatch $file1 differs from $ref1"
4470
4471         # clean up
4472         rm -f $file1
4473 }
4474 run_test 56x "lfs migration support"
4475
4476 test_57a() {
4477         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4478         # note test will not do anything if MDS is not local
4479         if [ "$(facet_fstype $SINGLEMDS)" != ldiskfs ]; then
4480                 skip "Only applicable to ldiskfs-based MDTs"
4481                 return
4482         fi
4483
4484         remote_mds_nodsh && skip "remote MDS with nodsh" && return
4485         local MNTDEV="osd*.*MDT*.mntdev"
4486         DEV=$(do_facet $SINGLEMDS lctl get_param -n $MNTDEV)
4487         [ -z "$DEV" ] && error "can't access $MNTDEV"
4488         for DEV in $(do_facet $SINGLEMDS lctl get_param -n $MNTDEV); do
4489                 do_facet $SINGLEMDS $DUMPE2FS -h $DEV > $TMP/t57a.dump ||
4490                         error "can't access $DEV"
4491                 DEVISIZE=`awk '/Inode size:/ { print $3 }' $TMP/t57a.dump`
4492                 [ "$DEVISIZE" -gt 128 ] || error "inode size $DEVISIZE"
4493                 rm $TMP/t57a.dump
4494         done
4495 }
4496 run_test 57a "verify MDS filesystem created with large inodes =="
4497
4498 test_57b() {
4499         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4500         if [ "$(facet_fstype $SINGLEMDS)" != ldiskfs ]; then
4501                 skip "Only applicable to ldiskfs-based MDTs"
4502                 return
4503         fi
4504
4505         remote_mds_nodsh && skip "remote MDS with nodsh" && return
4506         local dir=$DIR/d57b
4507
4508         local FILECOUNT=100
4509         local FILE1=$dir/f1
4510         local FILEN=$dir/f$FILECOUNT
4511
4512         rm -rf $dir || error "removing $dir"
4513         test_mkdir -p $dir || error "creating $dir"
4514         local num=$(get_mds_dir $dir)
4515         local mymds=mds$num
4516
4517         echo "mcreating $FILECOUNT files"
4518         createmany -m $dir/f 1 $FILECOUNT || \
4519                 error "creating files in $dir"
4520
4521         # verify that files do not have EAs yet
4522         $GETSTRIPE $FILE1 2>&1 | grep -q "no stripe" || error "$FILE1 has an EA"
4523         $GETSTRIPE $FILEN 2>&1 | grep -q "no stripe" || error "$FILEN has an EA"
4524
4525         sync
4526         sleep 1
4527         df $dir  #make sure we get new statfs data
4528         local MDSFREE=$(do_facet $mymds \
4529                 lctl get_param -n osd*.*MDT000$((num -1)).kbytesfree)
4530         local MDCFREE=$(lctl get_param -n mdc.*MDT000$((num -1))-mdc-*.kbytesfree)
4531         echo "opening files to create objects/EAs"
4532         local FILE
4533         for FILE in `seq -f $dir/f%g 1 $FILECOUNT`; do
4534                 $OPENFILE -f O_RDWR $FILE > /dev/null 2>&1 || error "opening $FILE"
4535         done
4536
4537         # verify that files have EAs now
4538         $GETSTRIPE $FILE1 | grep -q "obdidx" || error "$FILE1 missing EA"
4539         $GETSTRIPE $FILEN | grep -q "obdidx" || error "$FILEN missing EA"
4540
4541         sleep 1  #make sure we get new statfs data
4542         df $dir
4543         local MDSFREE2=$(do_facet $mymds \
4544                 lctl get_param -n osd*.*MDT000$((num -1)).kbytesfree)
4545         local MDCFREE2=$(lctl get_param -n mdc.*MDT000$((num -1))-mdc-*.kbytesfree)
4546         if [ "$MDCFREE2" -lt "$((MDCFREE - 8))" ]; then
4547                 if [ "$MDSFREE" != "$MDSFREE2" ]; then
4548                         error "MDC before $MDCFREE != after $MDCFREE2"
4549                 else
4550                         echo "MDC before $MDCFREE != after $MDCFREE2"
4551                         echo "unable to confirm if MDS has large inodes"
4552                 fi
4553         fi
4554         rm -rf $dir
4555 }
4556 run_test 57b "default LOV EAs are stored inside large inodes ==="
4557
4558 test_58() {
4559         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4560         [ -z "$(which wiretest 2>/dev/null)" ] &&
4561                         skip_env "could not find wiretest" && return
4562         wiretest
4563 }
4564 run_test 58 "verify cross-platform wire constants =============="
4565
4566 test_59() {
4567         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4568         echo "touch 130 files"
4569         createmany -o $DIR/f59- 130
4570         echo "rm 130 files"
4571         unlinkmany $DIR/f59- 130
4572         sync
4573         # wait for commitment of removal
4574         wait_delete_completed
4575 }
4576 run_test 59 "verify cancellation of llog records async ========="
4577
4578 TEST60_HEAD="test_60 run $RANDOM"
4579 test_60a() {
4580         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4581         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
4582         [ ! -f run-llog.sh ] && skip_env "missing subtest run-llog.sh" && return
4583         log "$TEST60_HEAD - from kernel mode"
4584         do_facet mgs sh run-llog.sh
4585 }
4586 run_test 60a "llog sanity tests run from kernel module =========="
4587
4588 test_60b() { # bug 6411
4589         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4590         dmesg > $DIR/$tfile
4591         LLOG_COUNT=`dmesg | awk "/$TEST60_HEAD/{marker = 1; from_marker = 0;}
4592                                  /llog.test/ {
4593                                          if (marker)
4594                                                  from_marker++
4595                                          from_begin++
4596                                  }
4597                                  END {
4598                                          if (marker)
4599                                                  print from_marker
4600                                          else
4601                                                  print from_begin
4602                                  }"`
4603         [ $LLOG_COUNT -gt 50 ] && error "CDEBUG_LIMIT not limiting messages ($LLOG_COUNT)"|| true
4604 }
4605 run_test 60b "limit repeated messages from CERROR/CWARN ========"
4606
4607 test_60c() {
4608         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4609         echo "create 5000 files"
4610         createmany -o $DIR/f60c- 5000
4611 #define OBD_FAIL_MDS_LLOG_CREATE_FAILED  0x137
4612         lctl set_param fail_loc=0x80000137
4613         unlinkmany $DIR/f60c- 5000
4614         lctl set_param fail_loc=0
4615 }
4616 run_test 60c "unlink file when mds full"
4617
4618 test_60d() {
4619         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4620         SAVEPRINTK=$(lctl get_param -n printk)
4621
4622         # verify "lctl mark" is even working"
4623         MESSAGE="test message ID $RANDOM $$"
4624         $LCTL mark "$MESSAGE" || error "$LCTL mark failed"
4625         dmesg | grep -q "$MESSAGE" || error "didn't find debug marker in log"
4626
4627         lctl set_param printk=0 || error "set lnet.printk failed"
4628         lctl get_param -n printk | grep emerg || error "lnet.printk dropped emerg"
4629         MESSAGE="new test message ID $RANDOM $$"
4630         # Assume here that libcfs_debug_mark_buffer() uses D_WARNING
4631         $LCTL mark "$MESSAGE" || error "$LCTL mark failed"
4632         dmesg | grep -q "$MESSAGE" && error "D_WARNING wasn't masked" || true
4633
4634         lctl set_param -n printk="$SAVEPRINTK"
4635 }
4636 run_test 60d "test printk console message masking"
4637
4638 test_61() {
4639         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4640         f="$DIR/f61"
4641         dd if=/dev/zero of=$f bs=`page_size` count=1
4642         cancel_lru_locks osc
4643         $MULTIOP $f OSMWUc || error
4644         sync
4645 }
4646 run_test 61 "mmap() writes don't make sync hang ================"
4647
4648 # bug 2330 - insufficient obd_match error checking causes LBUG
4649 test_62() {
4650         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4651         f="$DIR/f62"
4652         echo foo > $f
4653         cancel_lru_locks osc
4654         lctl set_param fail_loc=0x405
4655         cat $f && error "cat succeeded, expect -EIO"
4656         lctl set_param fail_loc=0
4657 }
4658 # This test is now irrelevant (as of bug 10718 inclusion), we no longer
4659 # match every page all of the time.
4660 #run_test 62 "verify obd_match failure doesn't LBUG (should -EIO)"
4661
4662 # bug 2319 - oig_wait() interrupted causes crash because of invalid waitq.
4663 test_63a() {    # was test_63
4664         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4665         MAX_DIRTY_MB=`lctl get_param -n osc.*.max_dirty_mb | head -n 1`
4666         lctl set_param -n osc.*.max_dirty_mb 0
4667         for i in `seq 10` ; do
4668                 dd if=/dev/zero of=$DIR/f63 bs=8k &
4669                 sleep 5
4670                 kill $!
4671                 sleep 1
4672         done
4673
4674         lctl set_param -n osc.*.max_dirty_mb $MAX_DIRTY_MB
4675         rm -f $DIR/f63 || true
4676 }
4677 run_test 63a "Verify oig_wait interruption does not crash ======="
4678
4679 # bug 2248 - async write errors didn't return to application on sync
4680 # bug 3677 - async write errors left page locked
4681 test_63b() {
4682         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4683         debugsave
4684         lctl set_param debug=-1
4685
4686         # ensure we have a grant to do async writes
4687         dd if=/dev/zero of=$DIR/$tfile bs=4k count=1
4688         rm $DIR/$tfile
4689
4690         #define OBD_FAIL_OSC_BRW_PREP_REQ        0x406
4691         lctl set_param fail_loc=0x80000406
4692         $MULTIOP $DIR/$tfile Owy && \
4693                 error "sync didn't return ENOMEM"
4694         sync; sleep 2; sync     # do a real sync this time to flush page
4695         lctl get_param -n llite.*.dump_page_cache | grep locked && \
4696                 error "locked page left in cache after async error" || true
4697         debugrestore
4698 }
4699 run_test 63b "async write errors should be returned to fsync ==="
4700
4701 test_64a () {
4702         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4703         df $DIR
4704         lctl get_param -n osc.*[oO][sS][cC][_-]*.cur* | grep "[0-9]"
4705 }
4706 run_test 64a "verify filter grant calculations (in kernel) ====="
4707
4708 test_64b () {
4709         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4710         [ ! -f oos.sh ] && skip_env "missing subtest oos.sh" && return
4711         sh oos.sh $MOUNT
4712 }
4713 run_test 64b "check out-of-space detection on client ==========="
4714
4715 test_64c() {
4716         $LCTL set_param osc.*OST0000-osc-[^mM]*.cur_grant_bytes=0
4717 }
4718 run_test 64c "verify grant shrink ========================------"
4719
4720 # bug 1414 - set/get directories' stripe info
4721 test_65a() {
4722         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4723         test_mkdir -p $DIR/$tdir
4724         touch $DIR/$tdir/f1
4725         $LVERIFY $DIR/$tdir $DIR/$tdir/f1 || error "lverify failed"
4726 }
4727 run_test 65a "directory with no stripe info ===================="
4728
4729 test_65b() {
4730         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4731         test_mkdir -p $DIR/$tdir
4732         $SETSTRIPE -S $((STRIPESIZE * 2)) -i 0 -c 1 $DIR/$tdir ||
4733                                                 error "setstripe"
4734         touch $DIR/$tdir/f2
4735         $LVERIFY $DIR/$tdir $DIR/$tdir/f2 || error "lverify failed"
4736 }
4737 run_test 65b "directory setstripe -S $((STRIPESIZE * 2)) -i 0 -c 1"
4738
4739 test_65c() {
4740         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4741         if [ $OSTCOUNT -gt 1 ]; then
4742                 test_mkdir -p $DIR/$tdir
4743                 $SETSTRIPE -S $(($STRIPESIZE * 4)) -i 1 \
4744                         -c $(($OSTCOUNT - 1)) $DIR/$tdir || error "setstripe"
4745                 touch $DIR/$tdir/f3
4746                 $LVERIFY $DIR/$tdir $DIR/$tdir/f3 || error "lverify failed"
4747         fi
4748 }
4749 run_test 65c "directory setstripe -S $((STRIPESIZE*4)) -i 1 -c $((OSTCOUNT-1))"
4750
4751 test_65d() {
4752         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4753         test_mkdir -p $DIR/$tdir
4754         if [ $STRIPECOUNT -le 0 ]; then
4755                 sc=1
4756         elif [ $STRIPECOUNT -gt 2000 ]; then
4757 #LOV_MAX_STRIPE_COUNT is 2000
4758                 [ $OSTCOUNT -gt 2000 ] && sc=2000 || sc=$(($OSTCOUNT - 1))
4759         else
4760                 sc=$(($STRIPECOUNT - 1))
4761         fi
4762         $SETSTRIPE -S $STRIPESIZE -c $sc $DIR/$tdir || error "setstripe"
4763         touch $DIR/$tdir/f4 $DIR/$tdir/f5
4764         $LVERIFY $DIR/$tdir $DIR/$tdir/f4 $DIR/$tdir/f5 ||
4765                                                 error "lverify failed"
4766 }
4767 run_test 65d "directory setstripe -S $STRIPESIZE -c stripe_count"
4768
4769 test_65e() {
4770         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4771         test_mkdir -p $DIR/$tdir
4772
4773         $SETSTRIPE $DIR/$tdir || error "setstripe"
4774         $GETSTRIPE -v $DIR/$tdir | grep "Default" ||
4775                                         error "no stripe info failed"
4776         touch $DIR/$tdir/f6
4777         $LVERIFY $DIR/$tdir $DIR/$tdir/f6 || error "lverify failed"
4778 }
4779 run_test 65e "directory setstripe defaults ======================="
4780
4781 test_65f() {
4782         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4783         test_mkdir -p $DIR/${tdir}f
4784         $RUNAS $SETSTRIPE $DIR/${tdir}f && error "setstripe succeeded" || true
4785 }
4786 run_test 65f "dir setstripe permission (should return error) ==="
4787
4788 test_65g() {
4789         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4790         test_mkdir -p $DIR/$tdir
4791         $SETSTRIPE -S $((STRIPESIZE * 2)) -i 0 -c 1 $DIR/$tdir ||
4792                                                         error "setstripe"
4793         $SETSTRIPE -d $DIR/$tdir || error "setstripe"
4794         $GETSTRIPE -v $DIR/$tdir | grep "Default" ||
4795                 error "delete default stripe failed"
4796 }
4797 run_test 65g "directory setstripe -d ==========================="
4798
4799 test_65h() {
4800         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4801         test_mkdir -p $DIR/$tdir
4802         $SETSTRIPE -S $((STRIPESIZE * 2)) -i 0 -c 1 $DIR/$tdir ||
4803                                                         error "setstripe"
4804         test_mkdir -p $DIR/$tdir/dd1
4805         [ $($GETSTRIPE -c $DIR/$tdir) == $($GETSTRIPE -c $DIR/$tdir/dd1) ] ||
4806                 error "stripe info inherit failed"
4807 }
4808 run_test 65h "directory stripe info inherit ===================="
4809
4810 test_65i() { # bug6367
4811         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4812         $SETSTRIPE -S 65536 -c -1 $MOUNT
4813 }
4814 run_test 65i "set non-default striping on root directory (bug 6367)="
4815
4816 test_65ia() { # bug12836
4817         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4818         $GETSTRIPE $MOUNT || error "getstripe $MOUNT failed"
4819 }
4820 run_test 65ia "getstripe on -1 default directory striping"
4821
4822 test_65ib() { # bug12836
4823         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4824         $GETSTRIPE -v $MOUNT || error "getstripe -v $MOUNT failed"
4825 }
4826 run_test 65ib "getstripe -v on -1 default directory striping"
4827
4828 test_65ic() { # bug12836
4829         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4830         $LFS find -mtime -1 $MOUNT > /dev/null || error "find $MOUNT failed"
4831 }
4832 run_test 65ic "new find on -1 default directory striping"
4833
4834 test_65j() { # bug6367
4835         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4836         sync; sleep 1
4837         # if we aren't already remounting for each test, do so for this test
4838         if [ "$CLEANUP" = ":" -a "$I_MOUNTED" = "yes" ]; then
4839                 cleanup || error "failed to unmount"
4840                 setup
4841         fi
4842         $SETSTRIPE -d $MOUNT || error "setstripe failed"
4843 }
4844 run_test 65j "set default striping on root directory (bug 6367)="
4845
4846 test_65k() { # bug11679
4847         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4848         [ "$OSTCOUNT" -lt 2 ] && skip_env "too few OSTs" && return
4849         remote_mds_nodsh && skip "remote MDS with nodsh" && return
4850
4851     echo "Check OST status: "
4852     local MDS_OSCS=`do_facet $SINGLEMDS lctl dl |
4853               awk '/[oO][sS][cC].*md[ts]/ { print $4 }'`
4854
4855     for OSC in $MDS_OSCS; do
4856         echo $OSC "is activate"
4857         do_facet $SINGLEMDS lctl --device %$OSC activate
4858     done
4859
4860     mkdir -p $DIR/$tdir
4861     for INACTIVE_OSC in $MDS_OSCS; do
4862         echo "Deactivate: " $INACTIVE_OSC
4863         do_facet $SINGLEMDS lctl --device %$INACTIVE_OSC deactivate
4864         for STRIPE_OSC in $MDS_OSCS; do
4865             OST=`osc_to_ost $STRIPE_OSC`
4866             IDX=`do_facet $SINGLEMDS lctl get_param -n lov.*md*.target_obd |
4867                  awk -F: /$OST/'{ print $1 }' | head -n 1`
4868
4869             [ -f $DIR/$tdir/$IDX ] && continue
4870             echo "$SETSTRIPE -i $IDX -c 1 $DIR/$tdir/$IDX"
4871             $SETSTRIPE -i $IDX -c 1 $DIR/$tdir/$IDX
4872             RC=$?
4873             [ $RC -ne 0 ] && error "setstripe should have succeeded"
4874         done
4875         rm -f $DIR/$tdir/*
4876         echo $INACTIVE_OSC "is Activate."
4877         do_facet $SINGLEMDS lctl --device  %$INACTIVE_OSC activate
4878     done
4879 }
4880 run_test 65k "validate manual striping works properly with deactivated OSCs"
4881
4882 test_65l() { # bug 12836
4883         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4884         test_mkdir -p $DIR/$tdir/test_dir
4885         $SETSTRIPE -c -1 $DIR/$tdir/test_dir
4886         $LFS find -mtime -1 $DIR/$tdir >/dev/null
4887 }
4888 run_test 65l "lfs find on -1 stripe dir ========================"
4889
4890 # bug 2543 - update blocks count on client
4891 test_66() {
4892         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4893         COUNT=${COUNT:-8}
4894         dd if=/dev/zero of=$DIR/f66 bs=1k count=$COUNT
4895         sync; sync_all_data; sync; sync_all_data
4896         cancel_lru_locks osc
4897         BLOCKS=`ls -s $DIR/f66 | awk '{ print $1 }'`
4898         [ $BLOCKS -ge $COUNT ] || error "$DIR/f66 blocks $BLOCKS < $COUNT"
4899 }
4900 run_test 66 "update inode blocks count on client ==============="
4901
4902 LLOOP=
4903 LLITELOOPLOAD=
4904 cleanup_68() {
4905         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4906         trap 0
4907         if [ ! -z "$LLOOP" ]; then
4908                 if swapon -s | grep -q $LLOOP; then
4909                         swapoff $LLOOP || error "swapoff failed"
4910                 fi
4911
4912                 $LCTL blockdev_detach $LLOOP || error "detach failed"
4913                 rm -f $LLOOP
4914                 unset LLOOP
4915         fi
4916         if [ ! -z "$LLITELOOPLOAD" ]; then
4917                 rmmod llite_lloop
4918                 unset LLITELOOPLOAD
4919         fi
4920         rm -f $DIR/f68*
4921 }
4922
4923 meminfo() {
4924         awk '($1 == "'$1':") { print $2 }' /proc/meminfo
4925 }
4926
4927 swap_used() {
4928         swapon -s | awk '($1 == "'$1'") { print $4 }'
4929 }
4930
4931 # test case for lloop driver, basic function
4932 test_68a() {
4933         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4934         [ "$UID" != 0 ] && skip_env "must run as root" && return
4935         llite_lloop_enabled || \
4936                 { skip_env "llite_lloop module disabled" && return; }
4937
4938         trap cleanup_68 EXIT
4939
4940         if ! module_loaded llite_lloop; then
4941                 if load_module llite/llite_lloop; then
4942                         LLITELOOPLOAD=yes
4943                 else
4944                         skip_env "can't find module llite_lloop"
4945                         return
4946                 fi
4947         fi
4948
4949         LLOOP=$TMP/lloop.`date +%s`.`date +%N`
4950         dd if=/dev/zero of=$DIR/f68a bs=4k count=1024
4951         $LCTL blockdev_attach $DIR/f68a $LLOOP || error "attach failed"
4952
4953         directio rdwr $LLOOP 0 1024 4096 || error "direct write failed"
4954         directio rdwr $LLOOP 0 1025 4096 && error "direct write should fail"
4955
4956         cleanup_68
4957 }
4958 run_test 68a "lloop driver - basic test ========================"
4959
4960 # excercise swapping to lustre by adding a high priority swapfile entry
4961 # and then consuming memory until it is used.
4962 test_68b() {  # was test_68
4963         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
4964         [ "$UID" != 0 ] && skip_env "must run as root" && return
4965         lctl get_param -n devices | grep -q obdfilter && \
4966                 skip "local OST" && return
4967
4968         grep -q llite_lloop /proc/modules
4969         [ $? -ne 0 ] && skip "can't find module llite_lloop" && return
4970
4971         [ -z "`$LCTL list_nids | grep -v tcp`" ] && \
4972                 skip "can't reliably test swap with TCP" && return
4973
4974         MEMTOTAL=`meminfo MemTotal`
4975         NR_BLOCKS=$((MEMTOTAL>>8))
4976         [[ $NR_BLOCKS -le 2048 ]] && NR_BLOCKS=2048
4977
4978         LLOOP=$TMP/lloop.`date +%s`.`date +%N`
4979         dd if=/dev/zero of=$DIR/f68b bs=64k seek=$NR_BLOCKS count=1
4980         mkswap $DIR/f68b
4981
4982         $LCTL blockdev_attach $DIR/f68b $LLOOP || error "attach failed"
4983
4984         trap cleanup_68 EXIT
4985
4986         swapon -p 32767 $LLOOP || error "swapon $LLOOP failed"
4987
4988         echo "before: `swapon -s | grep $LLOOP`"
4989         $MEMHOG $MEMTOTAL || error "error allocating $MEMTOTAL kB"
4990         echo "after: `swapon -s | grep $LLOOP`"
4991         SWAPUSED=`swap_used $LLOOP`
4992
4993         cleanup_68
4994
4995         [ $SWAPUSED -eq 0 ] && echo "no swap used???" || true
4996 }
4997 run_test 68b "support swapping to Lustre ========================"
4998
4999 # bug5265, obdfilter oa2dentry return -ENOENT
5000 # #define OBD_FAIL_OST_ENOENT 0x217
5001 test_69() {
5002         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5003         remote_ost_nodsh && skip "remote OST with nodsh" && return
5004
5005         f="$DIR/$tfile"
5006         $SETSTRIPE -c 1 -i 0 $f
5007
5008         $DIRECTIO write ${f}.2 0 1 || error "directio write error"
5009
5010         do_facet ost1 lctl set_param fail_loc=0x217
5011         $TRUNCATE $f 1 # vmtruncate() will ignore truncate() error.
5012         $DIRECTIO write $f 0 2 && error "write succeeded, expect -ENOENT"
5013
5014         do_facet ost1 lctl set_param fail_loc=0
5015         $DIRECTIO write $f 0 2 || error "write error"
5016
5017         cancel_lru_locks osc
5018         $DIRECTIO read $f 0 1 || error "read error"
5019
5020         do_facet ost1 lctl set_param fail_loc=0x217
5021         $DIRECTIO read $f 1 1 && error "read succeeded, expect -ENOENT"
5022
5023         do_facet ost1 lctl set_param fail_loc=0
5024         rm -f $f
5025 }
5026 run_test 69 "verify oa2dentry return -ENOENT doesn't LBUG ======"
5027
5028 test_71() {
5029     test_mkdir -p $DIR/$tdir
5030     sh rundbench -C -D $DIR/$tdir 2 || error "dbench failed!"
5031 }
5032 run_test 71 "Running dbench on lustre (don't segment fault) ===="
5033
5034 test_72a() { # bug 5695 - Test that on 2.6 remove_suid works properly
5035         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5036         check_kernel_version 43 || return 0
5037         [ "$RUNAS_ID" = "$UID" ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
5038
5039         # Check that testing environment is properly set up. Skip if not
5040         FAIL_ON_ERROR=false check_runas_id_ret $RUNAS_ID $RUNAS_GID $RUNAS || {
5041                 skip_env "User $RUNAS_ID does not exist - skipping"
5042                 return 0
5043         }
5044         # We had better clear the $DIR to get enough space for dd
5045         rm -rf $DIR/*
5046         touch $DIR/f72
5047         chmod 777 $DIR/f72
5048         chmod ug+s $DIR/f72
5049         $RUNAS dd if=/dev/zero of=$DIR/f72 bs=512 count=1 || error
5050         # See if we are still setuid/sgid
5051         test -u $DIR/f72 -o -g $DIR/f72 && error "S/gid is not dropped on write"
5052         # Now test that MDS is updated too
5053         cancel_lru_locks mdc
5054         test -u $DIR/f72 -o -g $DIR/f72 && error "S/gid is not dropped on MDS"
5055         rm -f $DIR/f72
5056 }
5057 run_test 72a "Test that remove suid works properly (bug5695) ===="
5058
5059 test_72b() { # bug 24226 -- keep mode setting when size is not changing
5060         local perm
5061
5062         [ "$RUNAS_ID" = "$UID" ] && \
5063                 skip_env "RUNAS_ID = UID = $UID -- skipping" && return
5064         [ "$RUNAS_ID" -eq 0 ] && \
5065                 skip_env "RUNAS_ID = 0 -- skipping" && return
5066
5067         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5068         # Check that testing environment is properly set up. Skip if not
5069         FAIL_ON_ERROR=false check_runas_id_ret $RUNAS_ID $RUNAS_ID $RUNAS || {
5070                 skip_env "User $RUNAS_ID does not exist - skipping"
5071                 return 0
5072         }
5073         touch $DIR/${tfile}-f{g,u}
5074         test_mkdir $DIR/${tfile}-dg
5075         test_mkdir $DIR/${tfile}-du
5076         chmod 770 $DIR/${tfile}-{f,d}{g,u}
5077         chmod g+s $DIR/${tfile}-{f,d}g
5078         chmod u+s $DIR/${tfile}-{f,d}u
5079         for perm in 777 2777 4777; do
5080                 $RUNAS chmod $perm $DIR/${tfile}-fg && error "S/gid file allowed improper chmod to $perm"
5081                 $RUNAS chmod $perm $DIR/${tfile}-fu && error "S/uid file allowed improper chmod to $perm"
5082                 $RUNAS chmod $perm $DIR/${tfile}-dg && error "S/gid dir allowed improper chmod to $perm"
5083                 $RUNAS chmod $perm $DIR/${tfile}-du && error "S/uid dir allowed improper chmod to $perm"
5084         done
5085         true
5086 }
5087 run_test 72b "Test that we keep mode setting if without file data changed (bug 24226)"
5088
5089 # bug 3462 - multiple simultaneous MDC requests
5090 test_73() {
5091         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5092         test_mkdir $DIR/d73-1
5093         test_mkdir $DIR/d73-2
5094         multiop_bg_pause $DIR/d73-1/f73-1 O_c || return 1
5095         pid1=$!
5096
5097         lctl set_param fail_loc=0x80000129
5098         $MULTIOP $DIR/d73-1/f73-2 Oc &
5099         sleep 1
5100         lctl set_param fail_loc=0
5101
5102         $MULTIOP $DIR/d73-2/f73-3 Oc &
5103         pid3=$!
5104
5105         kill -USR1 $pid1
5106         wait $pid1 || return 1
5107
5108         sleep 25
5109
5110         $CHECKSTAT -t file $DIR/d73-1/f73-1 || return 4
5111         $CHECKSTAT -t file $DIR/d73-1/f73-2 || return 5
5112         $CHECKSTAT -t file $DIR/d73-2/f73-3 || return 6
5113
5114         rm -rf $DIR/d73-*
5115 }
5116 run_test 73 "multiple MDC requests (should not deadlock)"
5117
5118 test_74a() { # bug 6149, 6184
5119         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5120         #define OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT 0x30e
5121         #
5122         # very important to OR with OBD_FAIL_ONCE (0x80000000) -- otherwise it
5123         # will spin in a tight reconnection loop
5124         touch $DIR/f74a
5125         lctl set_param fail_loc=0x8000030e
5126         # get any lock that won't be difficult - lookup works.
5127         ls $DIR/f74a
5128         lctl set_param fail_loc=0
5129         true
5130         rm -f $DIR/f74a
5131 }
5132 run_test 74a "ldlm_enqueue freed-export error path, ls (shouldn't LBUG)"
5133
5134 test_74b() { # bug 13310
5135         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5136         #define OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT 0x30e
5137         #
5138         # very important to OR with OBD_FAIL_ONCE (0x80000000) -- otherwise it
5139         # will spin in a tight reconnection loop
5140         lctl set_param fail_loc=0x8000030e
5141         # get a "difficult" lock
5142         touch $DIR/f74b
5143         lctl set_param fail_loc=0
5144         true
5145         rm -f $DIR/f74b
5146 }
5147 run_test 74b "ldlm_enqueue freed-export error path, touch (shouldn't LBUG)"
5148
5149 test_74c() {
5150         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5151 #define OBD_FAIL_LDLM_NEW_LOCK
5152         lctl set_param fail_loc=0x80000319
5153         touch $DIR/$tfile && error "Touch successful"
5154         true
5155 }
5156 run_test 74c "ldlm_lock_create error path, (shouldn't LBUG)"
5157
5158 num_inodes() {
5159         awk '/lustre_inode_cache/ {print $2; exit}' /proc/slabinfo
5160 }
5161
5162 get_inode_slab_tunables() {
5163         awk '/lustre_inode_cache/ {print $9," ",$10," ",$11; exit}' /proc/slabinfo
5164 }
5165
5166 set_inode_slab_tunables() {
5167         echo "lustre_inode_cache $1" > /proc/slabinfo
5168 }
5169
5170 test_76() { # Now for bug 20433, added originally in bug 1443
5171         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5172         local SLAB_SETTINGS=`get_inode_slab_tunables`
5173         local CPUS=`getconf _NPROCESSORS_ONLN`
5174         # we cannot set limit below 1 which means 1 inode in each
5175         # per-cpu cache is still allowed
5176         set_inode_slab_tunables "1 1 0"
5177         cancel_lru_locks osc
5178         BEFORE_INODES=`num_inodes`
5179         echo "before inodes: $BEFORE_INODES"
5180         local COUNT=1000
5181         [ "$SLOW" = "no" ] && COUNT=100
5182         for i in `seq $COUNT`; do
5183                 touch $DIR/$tfile
5184                 rm -f $DIR/$tfile
5185         done
5186         cancel_lru_locks osc
5187         AFTER_INODES=`num_inodes`
5188         echo "after inodes: $AFTER_INODES"
5189         local wait=0
5190         while [ $((AFTER_INODES-1*CPUS)) -gt $BEFORE_INODES ]; do
5191                 sleep 2
5192                 AFTER_INODES=`num_inodes`
5193                 wait=$((wait+2))
5194                 echo "wait $wait seconds inodes: $AFTER_INODES"
5195                 if [ $wait -gt 30 ]; then
5196                         error "inode slab grew from $BEFORE_INODES to $AFTER_INODES"
5197                 fi
5198         done
5199         set_inode_slab_tunables "$SLAB_SETTINGS"
5200 }
5201 run_test 76 "confirm clients recycle inodes properly ===="
5202
5203
5204 export ORIG_CSUM=""
5205 set_checksums()
5206 {
5207         # Note: in sptlrpc modes which enable its own bulk checksum, the
5208         # original crc32_le bulk checksum will be automatically disabled,
5209         # and the OBD_FAIL_OSC_CHECKSUM_SEND/OBD_FAIL_OSC_CHECKSUM_RECEIVE
5210         # will be checked by sptlrpc code against sptlrpc bulk checksum.
5211         # In this case set_checksums() will not be no-op, because sptlrpc
5212         # bulk checksum will be enabled all through the test.
5213
5214         [ "$ORIG_CSUM" ] || ORIG_CSUM=`lctl get_param -n osc.*.checksums | head -n1`
5215         lctl set_param -n osc.*.checksums $1
5216         return 0
5217 }
5218
5219 export ORIG_CSUM_TYPE="`lctl get_param -n osc.*osc-[^mM]*.checksum_type |
5220                         sed 's/.*\[\(.*\)\].*/\1/g' | head -n1`"
5221 CKSUM_TYPES=${CKSUM_TYPES:-"crc32 adler"}
5222 [ "$ORIG_CSUM_TYPE" = "crc32c" ] && CKSUM_TYPES="$CKSUM_TYPES crc32c"
5223 set_checksum_type()
5224 {
5225         lctl set_param -n osc.*osc-[^mM]*.checksum_type $1
5226         log "set checksum type to $1"
5227         return 0
5228 }
5229 F77_TMP=$TMP/f77-temp
5230 F77SZ=8
5231 setup_f77() {
5232         dd if=/dev/urandom of=$F77_TMP bs=1M count=$F77SZ || \
5233                 error "error writing to $F77_TMP"
5234 }
5235
5236 test_77a() { # bug 10889
5237         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5238         $GSS && skip "could not run with gss" && return
5239         [ ! -f $F77_TMP ] && setup_f77
5240         set_checksums 1
5241         dd if=$F77_TMP of=$DIR/$tfile bs=1M count=$F77SZ || error "dd error"
5242         set_checksums 0
5243         rm -f $DIR/$tfile
5244 }
5245 run_test 77a "normal checksum read/write operation ============="
5246
5247 test_77b() { # bug 10889
5248         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5249         $GSS && skip "could not run with gss" && return
5250         [ ! -f $F77_TMP ] && setup_f77
5251         #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
5252         lctl set_param fail_loc=0x80000409
5253         set_checksums 1
5254         dd if=$F77_TMP of=$DIR/f77b bs=1M count=$F77SZ conv=sync || \
5255                 error "dd error: $?"
5256         lctl set_param fail_loc=0
5257         set_checksums 0
5258 }
5259 run_test 77b "checksum error on client write ===================="
5260
5261 test_77c() { # bug 10889
5262         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5263         $GSS && skip "could not run with gss" && return
5264         [ ! -f $DIR/f77b ] && skip "requires 77b - skipping" && return
5265         set_checksums 1
5266         for algo in $CKSUM_TYPES; do
5267                 cancel_lru_locks osc
5268                 set_checksum_type $algo
5269                 #define OBD_FAIL_OSC_CHECKSUM_RECEIVE    0x408
5270                 lctl set_param fail_loc=0x80000408
5271                 cmp $F77_TMP $DIR/f77b || error "file compare failed"
5272                 lctl set_param fail_loc=0
5273         done
5274         set_checksums 0
5275         set_checksum_type $ORIG_CSUM_TYPE
5276         rm -f $DIR/f77b
5277 }
5278 run_test 77c "checksum error on client read ==================="
5279
5280 test_77d() { # bug 10889
5281         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5282         $GSS && skip "could not run with gss" && return
5283         #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
5284         lctl set_param fail_loc=0x80000409
5285         set_checksums 1
5286         directio write $DIR/f77 0 $F77SZ $((1024 * 1024)) || \
5287                 error "direct write: rc=$?"
5288         lctl set_param fail_loc=0
5289         set_checksums 0
5290 }
5291 run_test 77d "checksum error on OST direct write ==============="
5292
5293 test_77e() { # bug 10889
5294         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5295         $GSS && skip "could not run with gss" && return
5296         [ ! -f $DIR/f77 ] && skip "requires 77d - skipping" && return
5297         #define OBD_FAIL_OSC_CHECKSUM_RECEIVE    0x408
5298         lctl set_param fail_loc=0x80000408
5299         set_checksums 1
5300         cancel_lru_locks osc
5301         directio read $DIR/f77 0 $F77SZ $((1024 * 1024)) || \
5302                 error "direct read: rc=$?"
5303         lctl set_param fail_loc=0
5304         set_checksums 0
5305 }
5306 run_test 77e "checksum error on OST direct read ================"
5307
5308 test_77f() { # bug 10889
5309         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5310         $GSS && skip "could not run with gss" && return
5311         set_checksums 1
5312         for algo in $CKSUM_TYPES; do
5313                 cancel_lru_locks osc
5314                 set_checksum_type $algo
5315                 #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
5316                 lctl set_param fail_loc=0x409
5317                 directio write $DIR/f77 0 $F77SZ $((1024 * 1024)) && \
5318                         error "direct write succeeded"
5319                 lctl set_param fail_loc=0
5320         done
5321         set_checksum_type $ORIG_CSUM_TYPE
5322         set_checksums 0
5323 }
5324 run_test 77f "repeat checksum error on write (expect error) ===="
5325
5326 test_77g() { # bug 10889
5327         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5328         $GSS && skip "could not run with gss" && return
5329         remote_ost_nodsh && skip "remote OST with nodsh" && return
5330
5331         [ ! -f $F77_TMP ] && setup_f77
5332
5333         $SETSTRIPE -c 1 -i 0 $DIR/f77g
5334         #define OBD_FAIL_OST_CHECKSUM_RECEIVE       0x21a
5335         do_facet ost1 lctl set_param fail_loc=0x8000021a
5336         set_checksums 1
5337         dd if=$F77_TMP of=$DIR/f77g bs=1M count=$F77SZ || \
5338                 error "write error: rc=$?"
5339         do_facet ost1 lctl set_param fail_loc=0
5340         set_checksums 0
5341 }
5342 run_test 77g "checksum error on OST write ======================"
5343
5344 test_77h() { # bug 10889
5345         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5346         $GSS && skip "could not run with gss" && return
5347         remote_ost_nodsh && skip "remote OST with nodsh" && return
5348
5349         [ ! -f $DIR/f77g ] && skip "requires 77g - skipping" && return
5350         cancel_lru_locks osc
5351         #define OBD_FAIL_OST_CHECKSUM_SEND          0x21b
5352         do_facet ost1 lctl set_param fail_loc=0x8000021b
5353         set_checksums 1
5354         cmp $F77_TMP $DIR/f77g || error "file compare failed"
5355         do_facet ost1 lctl set_param fail_loc=0
5356         set_checksums 0
5357 }
5358 run_test 77h "checksum error on OST read ======================="
5359
5360 test_77i() { # bug 13805
5361         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5362         $GSS && skip "could not run with gss" && return
5363         #define OBD_FAIL_OSC_CONNECT_CKSUM       0x40b
5364         lctl set_param fail_loc=0x40b
5365         remount_client $MOUNT
5366         lctl set_param fail_loc=0
5367         for VALUE in `lctl get_param osc.*osc-[^mM]*.checksum_type`; do
5368                 PARAM=`echo ${VALUE[0]} | cut -d "=" -f1`
5369                 algo=`lctl get_param -n $PARAM | sed 's/.*\[\(.*\)\].*/\1/g'`
5370                 [ "$algo" = "adler" ] || error "algo set to $algo instead of adler"
5371         done
5372         remount_client $MOUNT
5373 }
5374 run_test 77i "client not supporting OSD_CONNECT_CKSUM =========="
5375
5376 test_77j() { # bug 13805
5377         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5378         $GSS && skip "could not run with gss" && return
5379         #define OBD_FAIL_OSC_CKSUM_ADLER_ONLY    0x40c
5380         lctl set_param fail_loc=0x40c
5381         remount_client $MOUNT
5382         lctl set_param fail_loc=0
5383         sleep 2 # wait async osc connect to finish
5384         for VALUE in `lctl get_param osc.*osc-[^mM]*.checksum_type`; do
5385                 PARAM=`echo ${VALUE[0]} | cut -d "=" -f1`
5386                 algo=`lctl get_param -n $PARAM | sed 's/.*\[\(.*\)\].*/\1/g'`
5387                 [ "$algo" = "adler" ] || error "algo set to $algo instead of adler"
5388         done
5389         remount_client $MOUNT
5390 }
5391 run_test 77j "client only supporting ADLER32 ===================="
5392
5393 [ "$ORIG_CSUM" ] && set_checksums $ORIG_CSUM || true
5394 rm -f $F77_TMP
5395 unset F77_TMP
5396
5397 test_78() { # bug 10901
5398         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5399         remote_ost || { skip_env "local OST" && return; }
5400
5401         NSEQ=5
5402         F78SIZE=$(($(awk '/MemFree:/ { print $2 }' /proc/meminfo) / 1024))
5403         echo "MemFree: $F78SIZE, Max file size: $MAXFREE"
5404         MEMTOTAL=$(($(awk '/MemTotal:/ { print $2 }' /proc/meminfo) / 1024))
5405         echo "MemTotal: $MEMTOTAL"
5406 # reserve 256MB of memory for the kernel and other running processes,
5407 # and then take 1/2 of the remaining memory for the read/write buffers.
5408     if [ $MEMTOTAL -gt 512 ] ;then
5409         MEMTOTAL=$(((MEMTOTAL - 256 ) / 2))
5410     else
5411         # for those poor memory-starved high-end clusters...
5412         MEMTOTAL=$((MEMTOTAL / 2))
5413     fi
5414         echo "Mem to use for directio: $MEMTOTAL"
5415         [ $F78SIZE -gt $MEMTOTAL ] && F78SIZE=$MEMTOTAL
5416         [ $F78SIZE -gt 512 ] && F78SIZE=512
5417         [ $F78SIZE -gt $((MAXFREE / 1024)) ] && F78SIZE=$((MAXFREE / 1024))
5418         SMALLESTOST=`lfs df $DIR |grep OST | awk '{print $4}' |sort -n |head -1`
5419         echo "Smallest OST: $SMALLESTOST"
5420         [ $SMALLESTOST -lt 10240 ] && \
5421                 skip "too small OSTSIZE, useless to run large O_DIRECT test" && return 0
5422
5423         [ $F78SIZE -gt $((SMALLESTOST * $OSTCOUNT / 1024 - 80)) ] && \
5424                 F78SIZE=$((SMALLESTOST * $OSTCOUNT / 1024 - 80))
5425
5426         [ "$SLOW" = "no" ] && NSEQ=1 && [ $F78SIZE -gt 32 ] && F78SIZE=32
5427         echo "File size: $F78SIZE"
5428         $SETSTRIPE -c $OSTCOUNT $DIR/$tfile || error "setstripe failed"
5429         for i in `seq 1 $NSEQ`
5430         do
5431                 FSIZE=$(($F78SIZE / ($NSEQ - $i + 1)))
5432                 echo directIO rdwr round $i of $NSEQ
5433                 $DIRECTIO rdwr $DIR/$tfile 0 $FSIZE 1048576||error "rdwr failed"
5434         done
5435
5436         rm -f $DIR/$tfile
5437 }
5438 run_test 78 "handle large O_DIRECT writes correctly ============"
5439
5440 test_79() { # bug 12743
5441         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5442         wait_delete_completed
5443
5444         BKTOTAL=$(calc_osc_kbytes kbytestotal)
5445         BKFREE=$(calc_osc_kbytes kbytesfree)
5446         BKAVAIL=$(calc_osc_kbytes kbytesavail)
5447
5448         STRING=`df -P $MOUNT | tail -n 1 | awk '{print $2","$3","$4}'`
5449         DFTOTAL=`echo $STRING | cut -d, -f1`
5450         DFUSED=`echo $STRING  | cut -d, -f2`
5451         DFAVAIL=`echo $STRING | cut -d, -f3`
5452         DFFREE=$(($DFTOTAL - $DFUSED))
5453
5454         ALLOWANCE=$((64 * $OSTCOUNT))
5455
5456         if [ $DFTOTAL -lt $(($BKTOTAL - $ALLOWANCE)) ] ||
5457            [ $DFTOTAL -gt $(($BKTOTAL + $ALLOWANCE)) ] ; then
5458                 error "df total($DFTOTAL) mismatch OST total($BKTOTAL)"
5459         fi
5460         if [ $DFFREE -lt $(($BKFREE - $ALLOWANCE)) ] ||
5461            [ $DFFREE -gt $(($BKFREE + $ALLOWANCE)) ] ; then
5462                 error "df free($DFFREE) mismatch OST free($BKFREE)"
5463         fi
5464         if [ $DFAVAIL -lt $(($BKAVAIL - $ALLOWANCE)) ] ||
5465            [ $DFAVAIL -gt $(($BKAVAIL + $ALLOWANCE)) ] ; then
5466                 error "df avail($DFAVAIL) mismatch OST avail($BKAVAIL)"
5467         fi
5468 }
5469 run_test 79 "df report consistency check ======================="
5470
5471 test_80() { # bug 10718
5472         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5473         # relax strong synchronous semantics for slow backends like ZFS
5474         local soc="obdfilter.*.sync_on_lock_cancel"
5475         local soc_old=$(do_facet ost1 lctl get_param -n $soc | head -n1)
5476         local hosts=
5477         if [ "$soc_old" != "never" -a "$(facet_fstype ost1)" != "ldiskfs" ]; then
5478                 hosts=$(for host in $(seq -f "ost%g" 1 $OSTCOUNT); do
5479                           facet_active_host $host; done | sort -u)
5480                 do_nodes $hosts lctl set_param $soc=never
5481         fi
5482
5483         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1M
5484         sync; sleep 1; sync
5485         local BEFORE=`date +%s`
5486         cancel_lru_locks osc
5487         local AFTER=`date +%s`
5488         local DIFF=$((AFTER-BEFORE))
5489         if [ $DIFF -gt 1 ] ; then
5490                 error "elapsed for 1M@1T = $DIFF"
5491         fi
5492
5493         [ -n "$hosts" ] && do_nodes $hosts lctl set_param $soc=$soc_old
5494
5495         rm -f $DIR/$tfile
5496 }
5497 run_test 80 "Page eviction is equally fast at high offsets too  ===="
5498
5499 test_81a() { # LU-456
5500         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5501         remote_ost_nodsh && skip "remote OST with nodsh" && return
5502         # define OBD_FAIL_OST_MAPBLK_ENOSPC    0x228
5503         # MUST OR with the OBD_FAIL_ONCE (0x80000000)
5504         do_facet ost1 lctl set_param fail_loc=0x80000228
5505
5506         # write should trigger a retry and success
5507         $SETSTRIPE -i 0 -c 1 $DIR/$tfile
5508         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
5509         RC=$?
5510         if [ $RC -ne 0 ] ; then
5511                 error "write should success, but failed for $RC"
5512         fi
5513 }
5514 run_test 81a "OST should retry write when get -ENOSPC ==============="
5515
5516 test_81b() { # LU-456
5517         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5518         remote_ost_nodsh && skip "remote OST with nodsh" && return
5519         # define OBD_FAIL_OST_MAPBLK_ENOSPC    0x228
5520         # Don't OR with the OBD_FAIL_ONCE (0x80000000)
5521         do_facet ost1 lctl set_param fail_loc=0x228
5522
5523         # write should retry several times and return -ENOSPC finally
5524         $SETSTRIPE -i 0 -c 1 $DIR/$tfile
5525         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
5526         RC=$?
5527         ENOSPC=28
5528         if [ $RC -ne $ENOSPC ] ; then
5529                 error "dd should fail for -ENOSPC, but succeed."
5530         fi
5531 }
5532 run_test 81b "OST should return -ENOSPC when retry still fails ======="
5533
5534 test_82() { # LU-1031
5535         dd if=/dev/zero of=$DIR/$tfile bs=1M count=10
5536         local gid1=14091995
5537         local gid2=16022000
5538
5539         multiop_bg_pause $DIR/$tfile OG${gid1}_g${gid1}c || return 1
5540         local MULTIPID1=$!
5541         multiop_bg_pause $DIR/$tfile O_G${gid2}r10g${gid2}c || return 2
5542         local MULTIPID2=$!
5543         kill -USR1 $MULTIPID2
5544         sleep 2
5545         if [[ `ps h -o comm -p $MULTIPID2` == "" ]]; then
5546                 error "First grouplock does not block second one"
5547         else
5548                 echo "Second grouplock blocks first one"
5549         fi
5550         kill -USR1 $MULTIPID1
5551         wait $MULTIPID1
5552         wait $MULTIPID2
5553 }
5554 run_test 82 "Basic grouplock test ==============================="
5555
5556 test_99a() {
5557         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && \
5558             return
5559         test_mkdir -p $DIR/d99cvsroot
5560         chown $RUNAS_ID $DIR/d99cvsroot
5561         local oldPWD=$PWD       # bug 13584, use $TMP as working dir
5562         cd $TMP
5563
5564         $RUNAS cvs -d $DIR/d99cvsroot init || error
5565         cd $oldPWD
5566 }
5567 run_test 99a "cvs init ========================================="
5568
5569 test_99b() {
5570         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
5571         [ ! -d $DIR/d99cvsroot ] && test_99a
5572         cd /etc/init.d
5573         # some versions of cvs import exit(1) when asked to import links or
5574         # files they can't read.  ignore those files.
5575         TOIGNORE=$(find . -type l -printf '-I %f\n' -o \
5576                         ! -perm +4 -printf '-I %f\n')
5577         $RUNAS cvs -d $DIR/d99cvsroot import -m "nomesg" $TOIGNORE \
5578                 d99reposname vtag rtag
5579 }
5580 run_test 99b "cvs import ======================================="
5581
5582 test_99c() {
5583         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
5584         [ ! -d $DIR/d99cvsroot ] && test_99b
5585         cd $DIR
5586         test_mkdir -p $DIR/d99reposname
5587         chown $RUNAS_ID $DIR/d99reposname
5588         $RUNAS cvs -d $DIR/d99cvsroot co d99reposname
5589 }
5590 run_test 99c "cvs checkout ====================================="
5591
5592 test_99d() {
5593         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
5594         [ ! -d $DIR/d99cvsroot ] && test_99c
5595         cd $DIR/d99reposname
5596         $RUNAS touch foo99
5597         $RUNAS cvs add -m 'addmsg' foo99
5598 }
5599 run_test 99d "cvs add =========================================="
5600
5601 test_99e() {
5602         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
5603         [ ! -d $DIR/d99cvsroot ] && test_99c
5604         cd $DIR/d99reposname
5605         $RUNAS cvs update
5606 }
5607 run_test 99e "cvs update ======================================="
5608
5609 test_99f() {
5610         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
5611         [ ! -d $DIR/d99cvsroot ] && test_99d
5612         cd $DIR/d99reposname
5613         $RUNAS cvs commit -m 'nomsg' foo99
5614     rm -fr $DIR/d99cvsroot
5615 }
5616 run_test 99f "cvs commit ======================================="
5617
5618 test_100() {
5619         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5620         [ "$NETTYPE" = tcp ] || \
5621                 { skip "TCP secure port test, not useful for NETTYPE=$NETTYPE" && \
5622                         return ; }
5623
5624         remote_ost_nodsh && skip "remote OST with nodsh" && return
5625         remote_mds_nodsh && skip "remote MDS with nodsh" && return
5626         remote_servers || \
5627                 { skip "useless for local single node setup" && return; }
5628
5629         netstat -tna | ( rc=1; while read PROT SND RCV LOCAL REMOTE STAT; do
5630                 [ "$PROT" != "tcp" ] && continue
5631                 RPORT=$(echo $REMOTE | cut -d: -f2)
5632                 [ "$RPORT" != "$ACCEPTOR_PORT" ] && continue
5633
5634                 rc=0
5635                 LPORT=`echo $LOCAL | cut -d: -f2`
5636                 if [ $LPORT -ge 1024 ]; then
5637                         echo "bad: $PROT $SND $RCV $LOCAL $REMOTE $STAT"
5638                         netstat -tna
5639                         error_exit "local: $LPORT > 1024, remote: $RPORT"
5640                 fi
5641         done
5642         [ "$rc" = 0 ] || error_exit "privileged port not found" )
5643 }
5644 run_test 100 "check local port using privileged port ==========="
5645
5646 function get_named_value()
5647 {
5648     local tag
5649
5650     tag=$1
5651     while read ;do
5652         line=$REPLY
5653         case $line in
5654         $tag*)
5655             echo $line | sed "s/^$tag[ ]*//"
5656             break
5657             ;;
5658         esac
5659     done
5660 }
5661
5662 export CACHE_MAX=$($LCTL get_param -n llite.*.max_cached_mb |
5663                    awk '/^max_cached_mb/ { print $2 }')
5664
5665 cleanup_101a() {
5666         $LCTL set_param -n llite.*.max_cached_mb $CACHE_MAX
5667         trap 0
5668 }
5669
5670 test_101a() {
5671         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5672         local s
5673         local discard
5674         local nreads=10000
5675         local cache_limit=32
5676
5677         $LCTL set_param -n osc.*-osc*.rpc_stats 0
5678         trap cleanup_101a EXIT
5679         $LCTL set_param -n llite.*.read_ahead_stats 0
5680         $LCTL set_param -n llite.*.max_cached_mb $cache_limit
5681
5682         #
5683         # randomly read 10000 of 64K chunks from file 3x 32MB in size
5684         #
5685         echo "nreads: $nreads file size: $((cache_limit * 3))MB"
5686         $READS -f $DIR/$tfile -s$((cache_limit * 3192 * 1024)) -b65536 -C -n$nreads -t 180
5687
5688         discard=0
5689         for s in `$LCTL get_param -n llite.*.read_ahead_stats | \
5690                 get_named_value 'read but discarded' | cut -d" " -f1`; do
5691                         discard=$(($discard + $s))
5692         done
5693         cleanup_101a
5694
5695         if [ $(($discard * 10)) -gt $nreads ] ;then
5696                 $LCTL get_param osc.*-osc*.rpc_stats
5697                 $LCTL get_param llite.*.read_ahead_stats
5698                 error "too many ($discard) discarded pages"
5699         fi
5700         rm -f $DIR/$tfile || true
5701 }
5702 run_test 101a "check read-ahead for random reads ================"
5703
5704 setup_test101bc() {
5705         test_mkdir -p $DIR/$tdir
5706         STRIPE_SIZE=1048576
5707         STRIPE_COUNT=$OSTCOUNT
5708         STRIPE_OFFSET=0
5709
5710         local list=$(comma_list $(osts_nodes))
5711         set_osd_param $list '' read_cache_enable 0
5712         set_osd_param $list '' writethrough_cache_enable 0
5713
5714         trap cleanup_test101bc EXIT
5715         # prepare the read-ahead file
5716         $SETSTRIPE -S $STRIPE_SIZE -i $STRIPE_OFFSET -c $OSTCOUNT $DIR/$tfile
5717
5718         dd if=/dev/zero of=$DIR/$tfile bs=1024k count=100 2> /dev/null
5719 }
5720
5721 cleanup_test101bc() {
5722         trap 0
5723         rm -rf $DIR/$tdir
5724         rm -f $DIR/$tfile
5725
5726         local list=$(comma_list $(osts_nodes))
5727         set_osd_param $list '' read_cache_enable 1
5728         set_osd_param $list '' writethrough_cache_enable 1
5729 }
5730
5731 calc_total() {
5732         awk 'BEGIN{total=0}; {total+=$1}; END{print total}'
5733 }
5734
5735 ra_check_101() {
5736         local READ_SIZE=$1
5737         local STRIPE_SIZE=1048576
5738         local RA_INC=1048576
5739         local STRIDE_LENGTH=$((STRIPE_SIZE/READ_SIZE))
5740         local FILE_LENGTH=$((64*100))
5741         local discard_limit=$((((STRIDE_LENGTH - 1)*3/(STRIDE_LENGTH*OSTCOUNT))* \
5742                              (STRIDE_LENGTH*OSTCOUNT - STRIDE_LENGTH)))
5743         DISCARD=`$LCTL get_param -n llite.*.read_ahead_stats | \
5744                         get_named_value 'read but discarded' | \
5745                         cut -d" " -f1 | calc_total`
5746         if [ $DISCARD -gt $discard_limit ]; then
5747                 $LCTL get_param llite.*.read_ahead_stats
5748                 error "Too many ($DISCARD) discarded pages with size (${READ_SIZE})"
5749         else
5750                 echo "Read-ahead success for size ${READ_SIZE}"
5751         fi
5752 }
5753
5754 test_101b() {
5755         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5756         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping stride IO stride-ahead test" && return
5757         local STRIPE_SIZE=1048576
5758         local STRIDE_SIZE=$((STRIPE_SIZE*OSTCOUNT))
5759         local FILE_LENGTH=$((STRIPE_SIZE*100))
5760         local ITERATION=$((FILE_LENGTH/STRIDE_SIZE))
5761         # prepare the read-ahead file
5762         setup_test101bc
5763         cancel_lru_locks osc
5764         for BIDX in 2 4 8 16 32 64 128 256
5765         do
5766                 local BSIZE=$((BIDX*4096))
5767                 local READ_COUNT=$((STRIPE_SIZE/BSIZE))
5768                 local STRIDE_LENGTH=$((STRIDE_SIZE/BSIZE))
5769                 local OFFSET=$((STRIPE_SIZE/BSIZE*(OSTCOUNT - 1)))
5770                 $LCTL set_param -n llite.*.read_ahead_stats 0
5771                 $READS -f $DIR/$tfile  -l $STRIDE_LENGTH -o $OFFSET \
5772                               -s $FILE_LENGTH -b $STRIPE_SIZE -a $READ_COUNT -n $ITERATION
5773                 cancel_lru_locks osc
5774                 ra_check_101 $BSIZE
5775         done
5776         cleanup_test101bc
5777         true
5778 }
5779 run_test 101b "check stride-io mode read-ahead ================="
5780
5781 test_101c() {
5782         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5783         local STRIPE_SIZE=1048576
5784         local FILE_LENGTH=$((STRIPE_SIZE*100))
5785         local nreads=10000
5786         local osc
5787
5788     setup_test101bc
5789
5790     cancel_lru_locks osc
5791     $LCTL set_param osc.*.rpc_stats 0
5792     $READS -f $DIR/$tfile -s$FILE_LENGTH -b65536 -n$nreads -t 180
5793     for osc in $($LCTL get_param -N osc.*); do
5794         if [ "$osc" == "osc.num_refs" ]; then
5795             continue
5796         fi
5797
5798         local lines=$($LCTL get_param -n ${osc}.rpc_stats | wc | awk '{print $1}')
5799         if [ $lines -le 20 ]; then
5800             continue
5801         fi
5802
5803         local rpc4k=$($LCTL get_param -n ${osc}.rpc_stats |
5804                                      awk '$1 == "1:" { print $2; exit; }')
5805         local rpc8k=$($LCTL get_param -n ${osc}.rpc_stats |
5806                                      awk '$1 == "2:" { print $2; exit; }')
5807         local rpc16k=$($LCTL get_param -n ${osc}.rpc_stats |
5808                                      awk '$1 == "4:" { print $2; exit; }')
5809         local rpc32k=$($LCTL get_param -n ${osc}.rpc_stats |
5810                                      awk '$1 == "8:" { print $2; exit; }')
5811
5812         [ $rpc4k != 0 ]  && error "Small 4k read IO ${rpc4k}!"
5813         [ $rpc8k != 0 ]  && error "Small 8k read IO ${rpc8k}!"
5814         [ $rpc16k != 0 ] && error "Small 16k read IO ${rpc16k}!"
5815         [ $rpc32k != 0 ] && error "Small 32k read IO ${rpc32k}!"
5816         echo "${osc} rpc check passed!"
5817     done
5818     cleanup_test101bc
5819     true
5820 }
5821 run_test 101c "check stripe_size aligned read-ahead ================="
5822
5823 set_read_ahead() {
5824    $LCTL get_param -n llite.*.max_read_ahead_mb | head -n 1
5825    $LCTL set_param -n llite.*.max_read_ahead_mb $1 > /dev/null 2>&1
5826 }
5827
5828 test_101d() {
5829         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5830         local file=$DIR/$tfile
5831         local size=${FILESIZE_101c:-500}
5832         local ra_MB=${READAHEAD_MB:-40}
5833
5834         local space=$(df -P $DIR | tail -n 1 | awk '{ print $4 }')
5835         [ $space -gt $((size * 1024)) ] ||
5836                 { skip "Need free space ${size}M, have $space" && return; }
5837
5838     echo Creating ${size}M test file $file
5839     dd if=/dev/zero of=$file bs=1M count=$size || error "dd failed"
5840     echo Cancel LRU locks on lustre client to flush the client cache
5841     cancel_lru_locks osc
5842
5843     echo Disable read-ahead
5844     local old_READAHEAD=$(set_read_ahead 0)
5845
5846     echo Reading the test file $file with read-ahead disabled
5847     time_ra_OFF=$(do_and_time "dd if=$file of=/dev/null bs=1M count=$size")
5848
5849     echo Cancel LRU locks on lustre client to flush the client cache
5850     cancel_lru_locks osc
5851     echo Enable read-ahead with ${ra_MB}MB
5852     set_read_ahead $ra_MB
5853
5854     echo Reading the test file $file with read-ahead enabled
5855     time_ra_ON=$(do_and_time "dd if=$file of=/dev/null bs=1M count=$size")
5856
5857     echo read-ahead disabled time read $time_ra_OFF
5858     echo read-ahead enabled  time read $time_ra_ON
5859
5860         set_read_ahead $old_READAHEAD
5861         rm -f $file
5862         wait_delete_completed
5863
5864     [ $time_ra_ON -lt $time_ra_OFF ] ||
5865         error "read-ahead enabled  time read (${time_ra_ON}s) is more than
5866                read-ahead disabled time read (${time_ra_OFF}s) filesize ${size}M"
5867 }
5868 run_test 101d "file read with and without read-ahead enabled  ================="
5869
5870 test_101e() {
5871         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5872     local file=$DIR/$tfile
5873     local size=500  #KB
5874     local count=100
5875     local blksize=1024
5876
5877     local space=$(df -P $DIR | tail -n 1 | awk '{ print $4 }')
5878     local need_space=$((count * size))
5879     [ $space -gt $need_space ] ||
5880         { skip_env "Need free space $need_space, have $space" && return; }
5881
5882     echo Creating $count ${size}K test files
5883     for ((i = 0; i < $count; i++)); do
5884         dd if=/dev/zero of=${file}_${i} bs=$blksize count=$size 2>/dev/null
5885     done
5886
5887     echo Cancel LRU locks on lustre client to flush the client cache
5888     cancel_lru_locks osc
5889
5890     echo Reset readahead stats
5891     $LCTL set_param -n llite.*.read_ahead_stats 0
5892
5893     for ((i = 0; i < $count; i++)); do
5894         dd if=${file}_${i} of=/dev/null bs=$blksize count=$size 2>/dev/null
5895     done
5896
5897     local miss=$($LCTL get_param -n llite.*.read_ahead_stats | \
5898           get_named_value 'misses' | cut -d" " -f1 | calc_total)
5899
5900     for ((i = 0; i < $count; i++)); do
5901         rm -rf ${file}_${i} 2>/dev/null
5902     done
5903
5904     #10000 means 20% reads are missing in readahead
5905     [ $miss -lt 10000 ] ||  error "misses too much for small reads"
5906 }
5907 run_test 101e "check read-ahead for small read(1k) for small files(500k)"
5908
5909 cleanup_test101f() {
5910     trap 0
5911     $LCTL set_param -n llite.*.max_read_ahead_whole_mb $MAX_WHOLE_MB
5912     rm -rf $DIR/$tfile 2>/dev/null
5913 }
5914
5915 test_101f() {
5916         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
5917     local file=$DIR/$tfile
5918     local nreads=1000
5919
5920     MAX_WHOLE_MB=$($LCTL get_param -n llite.*.max_read_ahead_whole_mb)
5921     $LCTL set_param -n llite.*.max_read_ahead_whole_mb 2
5922     dd if=/dev/zero of=${file} bs=2097152 count=1 2>/dev/null
5923     trap cleanup_test101f EXIT
5924
5925     echo Cancel LRU locks on lustre client to flush the client cache
5926     cancel_lru_locks osc
5927
5928     echo Reset readahead stats
5929     $LCTL set_param -n llite.*.read_ahead_stats 0
5930     # Random read in a 2M file, because max_read_ahead_whole_mb = 2M,
5931     # readahead should read in 2M file on second read, so only miss
5932     # 2 pages.
5933     echo Random 4K reads on 2M file for 1000 times
5934     $READS -f $file -s 2097152 -b 4096 -n $nreads
5935
5936     echo checking missing pages
5937     local miss=$($LCTL get_param -n llite.*.read_ahead_stats |
5938           get_named_value 'misses' | cut -d" " -f1 | calc_total)
5939
5940     [ $miss -lt 3 ] || error "misses too much pages!"
5941     cleanup_test101f
5942 }
5943 run_test 101f "check read-ahead for max_read_ahead_whole_mb"
5944
5945 setup_test102() {
5946         test_mkdir -p $DIR/$tdir
5947         chown $RUNAS_ID $DIR/$tdir
5948         STRIPE_SIZE=65536
5949         STRIPE_OFFSET=1
5950         STRIPE_COUNT=$OSTCOUNT
5951         [ $OSTCOUNT -gt 4 ] && STRIPE_COUNT=4
5952
5953         trap cleanup_test102 EXIT
5954         cd $DIR
5955         $1 $SETSTRIPE -S $STRIPE_SIZE -i $STRIPE_OFFSET -c $STRIPE_COUNT $tdir
5956         cd $DIR/$tdir
5957         for num in 1 2 3 4; do
5958                 for count in $(seq 1 $STRIPE_COUNT); do
5959                         for idx in $(seq 0 $[$STRIPE_COUNT - 1]); do
5960                                 local size=`expr $STRIPE_SIZE \* $num`
5961                                 local file=file"$num-$idx-$count"
5962                                 $1 $SETSTRIPE -S $size -i $idx -c $count $file
5963                         done
5964                 done
5965         done
5966
5967         cd $DIR
5968         $1 $TAR cf $TMP/f102.tar $tdir --xattrs
5969 }
5970
5971 cleanup_test102() {
5972         trap 0
5973         rm -f $TMP/f102.tar
5974         rm -rf $DIR/d0.sanity/d102
5975 }
5976
5977 test_102a() {
5978         local testfile=$DIR/xattr_testfile
5979
5980         touch $testfile
5981
5982         [ "$UID" != 0 ] && skip_env "must run as root" && return
5983         [ -z "`lctl get_param -n mdc.*-mdc-*.connect_flags | grep xattr`" ] &&
5984                 skip_env "must have user_xattr" && return
5985
5986         [ -z "$(which setfattr 2>/dev/null)" ] &&
5987                 skip_env "could not find setfattr" && return
5988
5989         echo "set/get xattr..."
5990         setfattr -n trusted.name1 -v value1 $testfile || error
5991         getfattr -n trusted.name1 $testfile 2> /dev/null |
5992           grep "trusted.name1=.value1" ||
5993                 error "$testfile missing trusted.name1=value1"
5994
5995         setfattr -n user.author1 -v author1 $testfile || error
5996         getfattr -n user.author1 $testfile 2> /dev/null |
5997           grep "user.author1=.author1" ||
5998                 error "$testfile missing trusted.author1=author1"
5999
6000         echo "listxattr..."
6001         setfattr -n trusted.name2 -v value2 $testfile ||
6002                 error "$testfile unable to set trusted.name2"
6003         setfattr -n trusted.name3 -v value3 $testfile ||
6004                 error "$testfile unable to set trusted.name3"
6005         [ $(getfattr -d -m "^trusted" $testfile 2> /dev/null |
6006             grep "trusted.name" | wc -l) -eq 3 ] ||
6007                 error "$testfile missing 3 trusted.name xattrs"
6008
6009         setfattr -n user.author2 -v author2 $testfile ||
6010                 error "$testfile unable to set user.author2"
6011         setfattr -n user.author3 -v author3 $testfile ||
6012                 error "$testfile unable to set user.author3"
6013         [ $(getfattr -d -m "^user" $testfile 2> /dev/null |
6014             grep "user.author" | wc -l) -eq 3 ] ||
6015                 error "$testfile missing 3 user.author xattrs"
6016
6017         echo "remove xattr..."
6018         setfattr -x trusted.name1 $testfile ||
6019                 error "$testfile error deleting trusted.name1"
6020         getfattr -d -m trusted $testfile 2> /dev/null | grep "trusted.name1" &&
6021                 error "$testfile did not delete trusted.name1 xattr"
6022
6023         setfattr -x user.author1 $testfile ||
6024                 error "$testfile error deleting user.author1"
6025         getfattr -d -m user $testfile 2> /dev/null | grep "user.author1" &&
6026                 error "$testfile did not delete trusted.name1 xattr"
6027
6028         # b10667: setting lustre special xattr be silently discarded
6029         echo "set lustre special xattr ..."
6030         setfattr -n "trusted.lov" -v "invalid value" $testfile ||
6031                 error "$testfile allowed setting trusted.lov"
6032 }
6033 run_test 102a "user xattr test =================================="
6034
6035 test_102b() {
6036         # b10930: get/set/list trusted.lov xattr
6037         echo "get/set/list trusted.lov xattr ..."
6038         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
6039         local testfile=$DIR/$tfile
6040         $SETSTRIPE -S 65536 -i 1 -c $OSTCOUNT $testfile ||
6041                 error "setstripe failed"
6042         local STRIPECOUNT=$($GETSTRIPE -c $testfile) ||
6043                 error "getstripe failed"
6044         getfattr -d -m "^trusted" $testfile 2> /dev/null | \
6045         grep "trusted.lov" || error "can't get trusted.lov from $testfile"
6046
6047         local testfile2=${testfile}2
6048         local value=`getfattr -n trusted.lov $testfile 2> /dev/null | \
6049                      grep "trusted.lov" |sed -e 's/[^=]\+=//'`
6050
6051         $MCREATE $testfile2
6052         setfattr -n trusted.lov -v $value $testfile2
6053         local stripe_size=$($GETSTRIPE -S $testfile2)
6054         local stripe_count=$($GETSTRIPE -c $testfile2)
6055         [ $stripe_size -eq 65536 ] || error "stripe size $stripe_size != 65536"
6056         [ $stripe_count -eq $STRIPECOUNT ] ||
6057                 error "stripe count $stripe_count != $STRIPECOUNT"
6058         rm -f $DIR/$tfile
6059 }
6060 run_test 102b "getfattr/setfattr for trusted.lov EAs ============"
6061
6062 test_102c() {
6063         # b10930: get/set/list lustre.lov xattr
6064         echo "get/set/list lustre.lov xattr ..."
6065         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
6066         test_mkdir -p $DIR/$tdir
6067         chown $RUNAS_ID $DIR/$tdir
6068         local testfile=$DIR/$tdir/$tfile
6069         $RUNAS $SETSTRIPE -S 65536 -i 1 -c $OSTCOUNT $testfile ||
6070                 error "setstripe failed"
6071         local STRIPECOUNT=$($RUNAS $GETSTRIPE -c $testfile) ||
6072                 error "getstripe failed"
6073         $RUNAS getfattr -d -m "^lustre" $testfile 2> /dev/null | \
6074         grep "lustre.lov" || error "can't get lustre.lov from $testfile"
6075
6076         local testfile2=${testfile}2
6077         local value=`getfattr -n lustre.lov $testfile 2> /dev/null | \
6078                      grep "lustre.lov" |sed -e 's/[^=]\+=//'  `
6079
6080         $RUNAS $MCREATE $testfile2
6081         $RUNAS setfattr -n lustre.lov -v $value $testfile2
6082         local stripe_size=$($RUNAS $GETSTRIPE -S $testfile2)
6083         local stripe_count=$($RUNAS $GETSTRIPE -c $testfile2)
6084         [ $stripe_size -eq 65536 ] || error "stripe size $stripe_size != 65536"
6085         [ $stripe_count -eq $STRIPECOUNT ] ||
6086                 error "stripe count $stripe_count != $STRIPECOUNT"
6087 }
6088 run_test 102c "non-root getfattr/setfattr for lustre.lov EAs ==========="
6089
6090 compare_stripe_info1() {
6091         local stripe_index_all_zero=true
6092
6093         for num in 1 2 3 4; do
6094                 for count in $(seq 1 $STRIPE_COUNT); do
6095                         for offset in $(seq 0 $[$STRIPE_COUNT - 1]); do
6096                                 local size=$((STRIPE_SIZE * num))
6097                                 local file=file"$num-$offset-$count"
6098                                 stripe_size=$(lfs getstripe -S $PWD/$file)
6099                                 [ $stripe_size -ne $size ] &&
6100                                     error "$file: size $stripe_size != $size"
6101                                 stripe_count=$(lfs getstripe -c $PWD/$file)
6102                                 # allow fewer stripes to be created, ORI-601
6103                                 [ $stripe_count -lt $(((3 * count + 3) / 4)) ]&&
6104                                     error "$file: count $stripe_count != $count"
6105                                 stripe_index=$(lfs getstripe -i $PWD/$file)
6106                                 [ $stripe_index -ne 0 ] &&
6107                                         stripe_index_all_zero=false
6108                         done
6109                 done
6110         done
6111         $stripe_index_all_zero &&
6112                 error "all files are being extracted starting from OST index 0"
6113         return 0
6114 }
6115
6116 find_lustre_tar() {
6117         [ -n "$(which tar 2>/dev/null)" ] &&
6118                 strings $(which tar) | grep -q "lustre" && echo tar
6119 }
6120
6121 test_102d() {
6122         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6123         # b10930: tar test for trusted.lov xattr
6124         TAR=$(find_lustre_tar)
6125         [ -z "$TAR" ] && skip_env "lustre-aware tar is not installed" && return
6126         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping N-stripe test" && return
6127         setup_test102
6128         test_mkdir -p $DIR/d102d
6129         $TAR xf $TMP/f102.tar -C $DIR/d102d --xattrs
6130         cd $DIR/d102d/$tdir
6131         compare_stripe_info1
6132 }
6133 run_test 102d "tar restore stripe info from tarfile,not keep osts ==========="
6134
6135 test_102f() {
6136         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6137         # b10930: tar test for trusted.lov xattr
6138         TAR=$(find_lustre_tar)
6139         [ -z "$TAR" ] && skip_env "lustre-aware tar is not installed" && return
6140         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping N-stripe test" && return
6141         setup_test102
6142         test_mkdir -p $DIR/d102f
6143         cd $DIR
6144         $TAR cf - --xattrs $tdir | $TAR xf - --xattrs -C $DIR/d102f
6145         cd $DIR/d102f/$tdir
6146         compare_stripe_info1
6147 }
6148 run_test 102f "tar copy files, not keep osts ==========="
6149
6150 grow_xattr() {
6151         local xsize=${1:-1024}  # in bytes
6152         local file=$DIR/$tfile
6153
6154         [ -z $(lctl get_param -n mdc.*.connect_flags | grep xattr) ] &&
6155                 skip "must have user_xattr" && return 0
6156         [ -z "$(which setfattr 2>/dev/null)" ] &&
6157                 skip_env "could not find setfattr" && return 0
6158         [ -z "$(which getfattr 2>/dev/null)" ] &&
6159                 skip_env "could not find getfattr" && return 0
6160
6161         touch $file
6162
6163         local value="$(generate_string $xsize)"
6164
6165         local xbig=trusted.big
6166         log "save $xbig on $file"
6167         setfattr -n $xbig -v $value $file ||
6168                 error "saving $xbig on $file failed"
6169
6170         local orig=$(get_xattr_value $xbig $file)
6171         [[ "$orig" != "$value" ]] && error "$xbig different after saving $xbig"
6172
6173         local xsml=trusted.sml
6174         log "save $xsml on $file"
6175         setfattr -n $xsml -v val $file || error "saving $xsml on $file failed"
6176
6177         local new=$(get_xattr_value $xbig $file)
6178         [[ "$new" != "$orig" ]] && error "$xbig different after saving $xsml"
6179
6180         log "grow $xsml on $file"
6181         setfattr -n $xsml -v "$value" $file ||
6182                 error "growing $xsml on $file failed"
6183
6184         new=$(get_xattr_value $xbig $file)
6185         [[ "$new" != "$orig" ]] && error "$xbig different after growing $xsml"
6186         log "$xbig still valid after growing $xsml"
6187
6188         rm -f $file
6189 }
6190
6191 test_102h() { # bug 15777
6192         grow_xattr 1024
6193 }
6194 run_test 102h "grow xattr from inside inode to external block"
6195
6196 test_102ha() {
6197         large_xattr_enabled || { skip "large_xattr disabled" && return; }
6198         grow_xattr $(max_xattr_size)
6199 }
6200 run_test 102ha "grow xattr from inside inode to external inode"
6201
6202 test_102i() { # bug 17038
6203         touch $DIR/$tfile
6204         ln -s $DIR/$tfile $DIR/${tfile}link
6205         getfattr -n trusted.lov $DIR/$tfile || error "lgetxattr on $DIR/$tfile failed"
6206         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"
6207         rm -f $DIR/$tfile $DIR/${tfile}link
6208 }
6209 run_test 102i "lgetxattr test on symbolic link ============"
6210
6211 test_102j() {
6212         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6213         TAR=$(find_lustre_tar)
6214         [ -z "$TAR" ] && skip_env "lustre-aware tar is not installed" && return
6215         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping N-stripe test" && return
6216         setup_test102 "$RUNAS"
6217         test_mkdir -p $DIR/d102j
6218         chown $RUNAS_ID $DIR/d102j
6219         $RUNAS $TAR xf $TMP/f102.tar -C $DIR/d102j --xattrs
6220         cd $DIR/d102j/$tdir
6221         compare_stripe_info1 "$RUNAS"
6222 }
6223 run_test 102j "non-root tar restore stripe info from tarfile, not keep osts ==="
6224
6225 test_102k() {
6226         touch $DIR/$tfile
6227         # b22187 just check that does not crash for regular file.
6228         setfattr -n trusted.lov $DIR/$tfile
6229         # b22187 'setfattr -n trusted.lov' should work as remove LOV EA for directories
6230         local test_kdir=$DIR/d102k
6231         test_mkdir $test_kdir
6232         local default_size=`$GETSTRIPE -S $test_kdir`
6233         local default_count=`$GETSTRIPE -c $test_kdir`
6234         local default_offset=`$GETSTRIPE -i $test_kdir`
6235         $SETSTRIPE -S 65536 -i 0 -c $OSTCOUNT $test_kdir ||
6236                 error 'dir setstripe failed'
6237         setfattr -n trusted.lov $test_kdir
6238         local stripe_size=`$GETSTRIPE -S $test_kdir`
6239         local stripe_count=`$GETSTRIPE -c $test_kdir`
6240         local stripe_offset=`$GETSTRIPE -i $test_kdir`
6241         [ $stripe_size -eq $default_size ] ||
6242                 error "stripe size $stripe_size != $default_size"
6243         [ $stripe_count -eq $default_count ] ||
6244                 error "stripe count $stripe_count != $default_count"
6245         [ $stripe_offset -eq $default_offset ] ||
6246                 error "stripe offset $stripe_offset != $default_offset"
6247         rm -rf $DIR/$tfile $test_kdir
6248 }
6249 run_test 102k "setfattr without parameter of value shouldn't cause a crash"
6250
6251 test_102l() {
6252         # LU-532 trusted. xattr is invisible to non-root
6253         local testfile=$DIR/$tfile
6254
6255         touch $testfile
6256
6257         echo "listxattr as user..."
6258         chown $RUNAS_ID $testfile
6259         $RUNAS getfattr -d -m '.*' $testfile 2>&1 |
6260             grep -q "trusted" &&
6261                 error "$testfile trusted xattrs are user visible"
6262
6263         return 0;
6264 }
6265 run_test 102l "listxattr filter test =================================="
6266
6267 cleanup_test102
6268
6269 run_acl_subtest()
6270 {
6271     $LUSTRE/tests/acl/run $LUSTRE/tests/acl/$1.test
6272     return $?
6273 }
6274
6275 test_103 () {
6276     [ "$UID" != 0 ] && skip_env "must run as root" && return
6277     [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep acl)" ] && skip "must have acl enabled" && return
6278     [ -z "$(which setfacl 2>/dev/null)" ] && skip_env "could not find setfacl" && return
6279     $GSS && skip "could not run under gss" && return
6280
6281     declare -a identity_old
6282
6283         for num in $(seq $MDSCOUNT); do
6284                 switch_identity $num true || identity_old[$num]=$?
6285         done
6286
6287     SAVE_UMASK=`umask`
6288     umask 0022
6289     cd $DIR
6290
6291     echo "performing cp ..."
6292     run_acl_subtest cp || error
6293     echo "performing getfacl-noacl..."
6294     run_acl_subtest getfacl-noacl || error "getfacl-noacl test failed"
6295     echo "performing misc..."
6296     run_acl_subtest misc || error  "misc test failed"
6297     echo "performing permissions..."
6298     run_acl_subtest permissions || error "permissions failed"
6299     echo "performing setfacl..."
6300     run_acl_subtest setfacl || error  "setfacl test failed"
6301
6302     # inheritance test got from HP
6303     echo "performing inheritance..."
6304     cp $LUSTRE/tests/acl/make-tree . || error "cannot copy make-tree"
6305     chmod +x make-tree || error "chmod +x failed"
6306     run_acl_subtest inheritance || error "inheritance test failed"
6307     rm -f make-tree
6308
6309         echo "LU-974 ignore umask when acl is enabled..."
6310         run_acl_subtest 974 || error "LU-974 test failed"
6311         if [ $MDSCOUNT -ge 2 ]; then
6312                 run_acl_subtest 974_remote ||
6313                         error "LU-974 test failed under remote dir"
6314         fi
6315
6316     echo "LU-2561 newly created file is same size as directory..."
6317     run_acl_subtest 2561 || error "LU-2561 test failed"
6318
6319     cd $SAVE_PWD
6320     umask $SAVE_UMASK
6321
6322         for num in $(seq $MDSCOUNT); do
6323                 if [ "${identity_old[$num]}" = 1 ]; then
6324                         switch_identity $num false || identity_old[$num]=$?
6325                 fi
6326         done
6327 }
6328 run_test 103 "acl test ========================================="
6329
6330 test_104a() {
6331         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6332         touch $DIR/$tfile
6333         lfs df || error "lfs df failed"
6334         lfs df -ih || error "lfs df -ih failed"
6335         lfs df -h $DIR || error "lfs df -h $DIR failed"
6336         lfs df -i $DIR || error "lfs df -i $DIR failed"
6337         lfs df $DIR/$tfile || error "lfs df $DIR/$tfile failed"
6338         lfs df -ih $DIR/$tfile || error "lfs df -ih $DIR/$tfile failed"
6339
6340         OSC=`lctl dl |grep OST0000-osc-[^M] |awk '{print $4}'`
6341         lctl --device %$OSC deactivate
6342         lfs df || error "lfs df with deactivated OSC failed"
6343         lctl --device %$OSC activate
6344         # wait the osc back to normal
6345         wait_osc_import_state client ost FULL
6346
6347         lfs df || error "lfs df with reactivated OSC failed"
6348         rm -f $DIR/$tfile
6349 }
6350 run_test 104a "lfs df [-ih] [path] test ========================="
6351
6352 test_104b() {
6353         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6354         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
6355         chmod 666 /dev/obd
6356         denied_cnt=$((`$RUNAS $LFS check servers 2>&1 | grep "Permission denied" | wc -l`))
6357         if [ $denied_cnt -ne 0 ];
6358         then
6359                     error "lfs check servers test failed"
6360         fi
6361 }
6362 run_test 104b "$RUNAS lfs check servers test ===================="
6363
6364 test_105a() {
6365         # doesn't work on 2.4 kernels
6366         touch $DIR/$tfile
6367         if [ -n "`mount | grep \"$MOUNT.*flock\" | grep -v noflock`" ]; then
6368                 flocks_test 1 on -f $DIR/$tfile || error "fail flock on"
6369         else
6370                 flocks_test 1 off -f $DIR/$tfile || error "fail flock off"
6371         fi
6372         rm -f $DIR/$tfile
6373 }
6374 run_test 105a "flock when mounted without -o flock test ========"
6375
6376 test_105b() {
6377         touch $DIR/$tfile
6378         if [ -n "`mount | grep \"$MOUNT.*flock\" | grep -v noflock`" ]; then
6379                 flocks_test 1 on -c $DIR/$tfile || error "fail flock on"
6380         else
6381                 flocks_test 1 off -c $DIR/$tfile || error "fail flock off"
6382         fi
6383         rm -f $DIR/$tfile
6384 }
6385 run_test 105b "fcntl when mounted without -o flock test ========"
6386
6387 test_105c() {
6388         touch $DIR/$tfile
6389         if [ -n "`mount | grep \"$MOUNT.*flock\" | grep -v noflock`" ]; then
6390                 flocks_test 1 on -l $DIR/$tfile || error "fail flock on"
6391         else
6392                 flocks_test 1 off -l $DIR/$tfile || error "fail flock off"
6393         fi
6394         rm -f $DIR/$tfile
6395 }
6396 run_test 105c "lockf when mounted without -o flock test ========"
6397
6398 test_105d() { # bug 15924
6399         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6400         test_mkdir -p $DIR/$tdir
6401         [ -z "`mount | grep \"$MOUNT.*flock\" | grep -v noflock`" ] && \
6402                 skip "mount w/o flock enabled" && return
6403         #define OBD_FAIL_LDLM_CP_CB_WAIT  0x315
6404         $LCTL set_param fail_loc=0x80000315
6405         flocks_test 2 $DIR/$tdir
6406 }
6407 run_test 105d "flock race (should not freeze) ========"
6408
6409 test_105e() { # bug 22660 && 22040
6410         [ -z "`mount | grep \"$MOUNT.*flock\" | grep -v noflock`" ] && \
6411                 skip "mount w/o flock enabled" && return
6412         touch $DIR/$tfile
6413         flocks_test 3 $DIR/$tfile
6414 }
6415 run_test 105e "Two conflicting flocks from same process ======="
6416
6417 test_106() { #bug 10921
6418         test_mkdir -p $DIR/$tdir
6419         $DIR/$tdir && error "exec $DIR/$tdir succeeded"
6420         chmod 777 $DIR/$tdir || error "chmod $DIR/$tdir failed"
6421 }
6422 run_test 106 "attempt exec of dir followed by chown of that dir"
6423
6424 test_107() {
6425         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6426         CDIR=`pwd`
6427         cd $DIR
6428
6429         local file=core
6430         rm -f $file
6431
6432         local save_pattern=$(sysctl -n kernel.core_pattern)
6433         local save_uses_pid=$(sysctl -n kernel.core_uses_pid)
6434         sysctl -w kernel.core_pattern=$file
6435         sysctl -w kernel.core_uses_pid=0
6436
6437         ulimit -c unlimited
6438         sleep 60 &
6439         SLEEPPID=$!
6440
6441         sleep 1
6442
6443         kill -s 11 $SLEEPPID
6444         wait $SLEEPPID
6445         if [ -e $file ]; then
6446                 size=`stat -c%s $file`
6447                 [ $size -eq 0 ] && error "Fail to create core file $file"
6448         else
6449                 error "Fail to create core file $file"
6450         fi
6451         rm -f $file
6452         sysctl -w kernel.core_pattern=$save_pattern
6453         sysctl -w kernel.core_uses_pid=$save_uses_pid
6454         cd $CDIR
6455 }
6456 run_test 107 "Coredump on SIG"
6457
6458 test_110() {
6459         test_mkdir -p $DIR/$tdir
6460         test_mkdir $DIR/$tdir/$(str_repeat 'a' 255) ||
6461                 error "mkdir with 255 char failed"
6462         test_mkdir $DIR/$tdir/$(str_repeat 'b' 256) &&
6463                 error "mkdir with 256 char should fail, but did not"
6464         touch $DIR/$tdir/$(str_repeat 'x' 255) ||
6465                 error "create with 255 char failed"
6466         touch $DIR/$tdir/$(str_repeat 'y' 256) &&
6467                 error "create with 256 char should fail, but did not"
6468
6469         ls -l $DIR/$tdir
6470         rm -rf $DIR/$tdir
6471 }
6472 run_test 110 "filename length checking"
6473
6474 test_115() {
6475         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6476         OSTIO_pre=$(ps -e|grep ll_ost_io|awk '{print $4}'|sort -n|tail -1|\
6477             cut -c11-20)
6478         [ -z "$OSTIO_pre" ] && skip "no OSS threads" && \
6479             return
6480         echo "Starting with $OSTIO_pre threads"
6481
6482         NUMTEST=20000
6483         NUMFREE=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
6484         [ $NUMFREE -lt $NUMTEST ] && NUMTEST=$(($NUMFREE - 1000))
6485         echo "$NUMTEST creates/unlinks"
6486         test_mkdir -p $DIR/$tdir
6487         createmany -o $DIR/$tdir/$tfile $NUMTEST
6488         unlinkmany $DIR/$tdir/$tfile $NUMTEST
6489
6490         OSTIO_post=$(ps -e|grep ll_ost_io|awk '{print $4}'|sort -n|tail -1|\
6491             cut -c11-20)
6492
6493         # don't return an error
6494         [ $OSTIO_post == $OSTIO_pre ] && echo \
6495             "WARNING: No new ll_ost_io threads were created ($OSTIO_pre)" &&
6496             echo "This may be fine, depending on what ran before this test" &&
6497             echo "and how fast this system is." && return
6498
6499         echo "Started with $OSTIO_pre threads, ended with $OSTIO_post"
6500 }
6501 run_test 115 "verify dynamic thread creation===================="
6502
6503 free_min_max () {
6504         wait_delete_completed
6505         AVAIL=($(lctl get_param -n osc.*[oO][sS][cC]-[^M]*.kbytesavail))
6506         echo OST kbytes available: ${AVAIL[@]}
6507         MAXI=0; MAXV=${AVAIL[0]}
6508         MINI=0; MINV=${AVAIL[0]}
6509         for ((i = 0; i < ${#AVAIL[@]}; i++)); do
6510             #echo OST $i: ${AVAIL[i]}kb
6511             if [ ${AVAIL[i]} -gt $MAXV ]; then
6512                 MAXV=${AVAIL[i]}; MAXI=$i
6513             fi
6514             if [ ${AVAIL[i]} -lt $MINV ]; then
6515                 MINV=${AVAIL[i]}; MINI=$i
6516             fi
6517         done
6518         echo Min free space: OST $MINI: $MINV
6519         echo Max free space: OST $MAXI: $MAXV
6520 }
6521
6522 test_116a() { # was previously test_116()
6523         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6524         [ "$OSTCOUNT" -lt "2" ] && skip_env "$OSTCOUNT < 2 OSTs" && return
6525
6526         echo -n "Free space priority "
6527         lctl get_param -n lov.*-clilov-*.qos_prio_free
6528         declare -a AVAIL
6529         free_min_max
6530         [ $MINV -gt 960000 ] && skip "too much free space in OST$MINI, skip" &&\
6531                 return
6532
6533         # generate uneven OSTs
6534         test_mkdir -p $DIR/$tdir/OST${MINI}
6535         declare -i FILL
6536         FILL=$(($MINV / 4))
6537         echo "Filling 25% remaining space in OST${MINI} with ${FILL}Kb"
6538         $SETSTRIPE -i $MINI -c 1 $DIR/$tdir/OST${MINI}||error "setstripe failed"
6539         i=0
6540         while [ $FILL -gt 0 ]; do
6541             i=$(($i + 1))
6542             dd if=/dev/zero of=$DIR/$tdir/OST${MINI}/$tfile-$i bs=2M count=1 2>/dev/null
6543             FILL=$(($FILL - 2048))
6544             echo -n .
6545         done
6546         FILL=$(($MINV / 4))
6547         sync
6548         sleep_maxage
6549
6550         free_min_max
6551         DIFF=$(($MAXV - $MINV))
6552         DIFF2=$(($DIFF * 100 / $MINV))
6553         echo -n "diff=${DIFF}=${DIFF2}% must be > 20% for QOS mode..."
6554         if [ $DIFF2 -gt 20 ]; then
6555             echo "ok"
6556         else
6557             echo "failed - QOS mode won't be used"
6558             error_ignore "QOS imbalance criteria not met"
6559             return
6560         fi
6561
6562         MINI1=$MINI; MINV1=$MINV
6563         MAXI1=$MAXI; MAXV1=$MAXV
6564
6565         # now fill using QOS
6566         echo writing a bunch of files to QOS-assigned OSTs
6567         $SETSTRIPE -c 1 $DIR/$tdir
6568         i=0
6569         while [ $FILL -gt 0 ]; do
6570             i=$(($i + 1))
6571             dd if=/dev/zero of=$DIR/$tdir/$tfile-$i bs=1024 count=200 2>/dev/null
6572             FILL=$(($FILL - 200))
6573             echo -n .
6574         done
6575         echo "wrote $i 200k files"
6576         sync
6577         sleep_maxage
6578
6579         echo "Note: free space may not be updated, so measurements might be off"
6580         free_min_max
6581         DIFF2=$(($MAXV - $MINV))
6582         echo "free space delta: orig $DIFF final $DIFF2"
6583         [ $DIFF2 -gt $DIFF ] && echo "delta got worse!"
6584         DIFF=$(($MINV1 - ${AVAIL[$MINI1]}))
6585         echo "Wrote $DIFF to smaller OST $MINI1"
6586         DIFF2=$(($MAXV1 - ${AVAIL[$MAXI1]}))
6587         echo "Wrote $DIFF2 to larger OST $MAXI1"
6588         [ $DIFF -gt 0 ] && echo "Wrote $(($DIFF2 * 100 / $DIFF - 100))% more data to larger OST $MAXI1"
6589
6590         # Figure out which files were written where
6591         UUID=$(lctl get_param -n lov.${FSNAME}-clilov-*.target_obd |
6592                awk '/'$MINI1': / {print $2; exit}')
6593         echo $UUID
6594         MINC=$($GETSTRIPE --obd $UUID $DIR/$tdir | wc -l)
6595         echo "$MINC files created on smaller OST $MINI1"
6596         UUID=$(lctl get_param -n lov.${FSNAME}-clilov-*.target_obd |
6597                awk '/'$MAXI1': / {print $2; exit}')
6598         echo $UUID
6599         MAXC=$($GETSTRIPE --obd $UUID $DIR/$tdir | wc -l)
6600         echo "$MAXC files created on larger OST $MAXI1"
6601         [ $MINC -gt 0 ] && echo "Wrote $(($MAXC * 100 / $MINC - 100))% more files to larger OST $MAXI1"
6602         [ $MAXC -gt $MINC ] || error_ignore "stripe QOS didn't balance free space"
6603
6604         rm -rf $DIR/$tdir
6605 }
6606 run_test 116a "stripe QOS: free space balance ==================="
6607
6608 test_116b() { # LU-2093
6609         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6610 #define OBD_FAIL_MDS_OSC_CREATE_FAIL     0x147
6611         local old_rr
6612         old_rr=$(do_facet $SINGLEMDS lctl get_param -n lov.*mdtlov*.qos_threshold_rr)
6613         do_facet $SINGLEMDS lctl set_param lov.*mdtlov*.qos_threshold_rr 0
6614         mkdir -p $DIR/$tdir
6615         do_facet $SINGLEMDS lctl set_param fail_loc=0x147
6616         createmany -o $DIR/$tdir/f- 20 || error "can't create"
6617         do_facet $SINGLEMDS lctl set_param fail_loc=0
6618         rm -rf $DIR/$tdir
6619         do_facet $SINGLEMDS lctl set_param lov.*mdtlov*.qos_threshold_rr $old_rr
6620 }
6621 run_test 116b "QoS shouldn't LBUG if not enough OSTs found on the 2nd pass"
6622
6623 test_117() # bug 10891
6624 {
6625         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6626         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1
6627         #define OBD_FAIL_OST_SETATTR_CREDITS 0x21e
6628         lctl set_param fail_loc=0x21e
6629         > $DIR/$tfile || error "truncate failed"
6630         lctl set_param fail_loc=0
6631         echo "Truncate succeeded."
6632         rm -f $DIR/$tfile
6633 }
6634 run_test 117 "verify fsfilt_extend =========="
6635
6636 NO_SLOW_RESENDCOUNT=4
6637 export OLD_RESENDCOUNT=""
6638 set_resend_count () {
6639         local PROC_RESENDCOUNT="osc.${FSNAME}-OST*-osc-*.resend_count"
6640         OLD_RESENDCOUNT=$(lctl get_param -n $PROC_RESENDCOUNT | head -1)
6641         lctl set_param -n $PROC_RESENDCOUNT $1
6642         echo resend_count is set to $(lctl get_param -n $PROC_RESENDCOUNT)
6643 }
6644
6645 # for reduce test_118* time (b=14842)
6646 [ "$SLOW" = "no" ] && set_resend_count $NO_SLOW_RESENDCOUNT
6647
6648 # Reset async IO behavior after error case
6649 reset_async() {
6650         FILE=$DIR/reset_async
6651
6652         # Ensure all OSCs are cleared
6653         $SETSTRIPE -c -1 $FILE
6654         dd if=/dev/zero of=$FILE bs=64k count=$OSTCOUNT
6655         sync
6656         rm $FILE
6657 }
6658
6659 test_118a() #bug 11710
6660 {
6661         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6662         reset_async
6663
6664         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
6665         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
6666         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
6667
6668         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
6669                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
6670                 return 1;
6671         fi
6672         rm -f $DIR/$tfile
6673 }
6674 run_test 118a "verify O_SYNC works =========="
6675
6676 test_118b()
6677 {
6678         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6679         remote_ost_nodsh && skip "remote OST with nodsh" && return
6680
6681         reset_async
6682
6683         #define OBD_FAIL_OST_ENOENT 0x217
6684         set_nodes_failloc "$(osts_nodes)" 0x217
6685         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
6686         RC=$?
6687         set_nodes_failloc "$(osts_nodes)" 0
6688         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
6689         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
6690                     grep -c writeback)
6691
6692         if [[ $RC -eq 0 ]]; then
6693                 error "Must return error due to dropped pages, rc=$RC"
6694                 return 1;
6695         fi
6696
6697         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
6698                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
6699                 return 1;
6700         fi
6701
6702         echo "Dirty pages not leaked on ENOENT"
6703
6704         # Due to the above error the OSC will issue all RPCs syncronously
6705         # until a subsequent RPC completes successfully without error.
6706         $MULTIOP $DIR/$tfile Ow4096yc
6707         rm -f $DIR/$tfile
6708
6709         return 0
6710 }
6711 run_test 118b "Reclaim dirty pages on fatal error =========="
6712
6713 test_118c()
6714 {
6715         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6716
6717         # for 118c, restore the original resend count, LU-1940
6718         [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] &&
6719                                 set_resend_count $OLD_RESENDCOUNT
6720         remote_ost_nodsh && skip "remote OST with nodsh" && return
6721
6722         reset_async
6723
6724         #define OBD_FAIL_OST_EROFS               0x216
6725         set_nodes_failloc "$(osts_nodes)" 0x216
6726
6727         # multiop should block due to fsync until pages are written
6728         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
6729         MULTIPID=$!
6730         sleep 1
6731
6732         if [[ `ps h -o comm -p $MULTIPID` != "multiop" ]]; then
6733                 error "Multiop failed to block on fsync, pid=$MULTIPID"
6734         fi
6735
6736         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
6737                     grep -c writeback)
6738         if [[ $WRITEBACK -eq 0 ]]; then
6739                 error "No page in writeback, writeback=$WRITEBACK"
6740         fi
6741
6742         set_nodes_failloc "$(osts_nodes)" 0
6743         wait $MULTIPID
6744         RC=$?
6745         if [[ $RC -ne 0 ]]; then
6746                 error "Multiop fsync failed, rc=$RC"
6747         fi
6748
6749         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
6750         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
6751                     grep -c writeback)
6752         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
6753                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
6754         fi
6755
6756         rm -f $DIR/$tfile
6757         echo "Dirty pages flushed via fsync on EROFS"
6758         return 0
6759 }
6760 run_test 118c "Fsync blocks on EROFS until dirty pages are flushed =========="
6761
6762 # continue to use small resend count to reduce test_118* time (b=14842)
6763 [ "$SLOW" = "no" ] && set_resend_count $NO_SLOW_RESENDCOUNT
6764
6765 test_118d()
6766 {
6767         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6768         remote_ost_nodsh && skip "remote OST with nodsh" && return
6769
6770         reset_async
6771
6772         #define OBD_FAIL_OST_BRW_PAUSE_BULK
6773         set_nodes_failloc "$(osts_nodes)" 0x214
6774         # multiop should block due to fsync until pages are written
6775         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
6776         MULTIPID=$!
6777         sleep 1
6778
6779         if [[ `ps h -o comm -p $MULTIPID` != "multiop" ]]; then
6780                 error "Multiop failed to block on fsync, pid=$MULTIPID"
6781         fi
6782
6783         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
6784                     grep -c writeback)
6785         if [[ $WRITEBACK -eq 0 ]]; then
6786                 error "No page in writeback, writeback=$WRITEBACK"
6787         fi
6788
6789         wait $MULTIPID || error "Multiop fsync failed, rc=$?"
6790         set_nodes_failloc "$(osts_nodes)" 0
6791
6792         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
6793         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
6794                     grep -c writeback)
6795         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
6796                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
6797         fi
6798
6799         rm -f $DIR/$tfile
6800         echo "Dirty pages gaurenteed flushed via fsync"
6801         return 0
6802 }
6803 run_test 118d "Fsync validation inject a delay of the bulk =========="
6804
6805 test_118f() {
6806         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6807         reset_async
6808
6809         #define OBD_FAIL_OSC_BRW_PREP_REQ2        0x40a
6810         lctl set_param fail_loc=0x8000040a
6811
6812         # Should simulate EINVAL error which is fatal
6813         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
6814         RC=$?
6815         if [[ $RC -eq 0 ]]; then
6816                 error "Must return error due to dropped pages, rc=$RC"
6817         fi
6818
6819         lctl set_param fail_loc=0x0
6820
6821         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
6822         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
6823         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
6824                     grep -c writeback)
6825         if [[ $LOCKED -ne 0 ]]; then
6826                 error "Locked pages remain in cache, locked=$LOCKED"
6827         fi
6828
6829         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
6830                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
6831         fi
6832
6833         rm -f $DIR/$tfile
6834         echo "No pages locked after fsync"
6835
6836         reset_async
6837         return 0
6838 }
6839 run_test 118f "Simulate unrecoverable OSC side error =========="
6840
6841 test_118g() {
6842         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6843         reset_async
6844
6845         #define OBD_FAIL_OSC_BRW_PREP_REQ        0x406
6846         lctl set_param fail_loc=0x406
6847
6848         # simulate local -ENOMEM
6849         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
6850         RC=$?
6851
6852         lctl set_param fail_loc=0
6853         if [[ $RC -eq 0 ]]; then
6854                 error "Must return error due to dropped pages, rc=$RC"
6855         fi
6856
6857         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
6858         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
6859         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
6860                         grep -c writeback)
6861         if [[ $LOCKED -ne 0 ]]; then
6862                 error "Locked pages remain in cache, locked=$LOCKED"
6863         fi
6864
6865         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
6866                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
6867         fi
6868
6869         rm -f $DIR/$tfile
6870         echo "No pages locked after fsync"
6871
6872         reset_async
6873         return 0
6874 }
6875 run_test 118g "Don't stay in wait if we got local -ENOMEM  =========="
6876
6877 test_118h() {
6878         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6879         remote_ost_nodsh && skip "remote OST with nodsh" && return
6880
6881         reset_async
6882
6883         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
6884         set_nodes_failloc "$(osts_nodes)" 0x20e
6885         # Should simulate ENOMEM error which is recoverable and should be handled by timeout
6886         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
6887         RC=$?
6888
6889         set_nodes_failloc "$(osts_nodes)" 0
6890         if [[ $RC -eq 0 ]]; then
6891                 error "Must return error due to dropped pages, rc=$RC"
6892         fi
6893
6894         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
6895         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
6896         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
6897                     grep -c writeback)
6898         if [[ $LOCKED -ne 0 ]]; then
6899                 error "Locked pages remain in cache, locked=$LOCKED"
6900         fi
6901
6902         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
6903                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
6904         fi
6905
6906         rm -f $DIR/$tfile
6907         echo "No pages locked after fsync"
6908
6909         return 0
6910 }
6911 run_test 118h "Verify timeout in handling recoverables errors  =========="
6912
6913 [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] && set_resend_count $OLD_RESENDCOUNT
6914
6915 test_118i() {
6916         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6917         remote_ost_nodsh && skip "remote OST with nodsh" && return
6918
6919         reset_async
6920
6921         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
6922         set_nodes_failloc "$(osts_nodes)" 0x20e
6923
6924         # Should simulate ENOMEM error which is recoverable and should be handled by timeout
6925         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
6926         PID=$!
6927         sleep 5
6928         set_nodes_failloc "$(osts_nodes)" 0
6929
6930         wait $PID
6931         RC=$?
6932         if [[ $RC -ne 0 ]]; then
6933                 error "got error, but should be not, rc=$RC"
6934         fi
6935
6936         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
6937         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
6938         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
6939         if [[ $LOCKED -ne 0 ]]; then
6940                 error "Locked pages remain in cache, locked=$LOCKED"
6941         fi
6942
6943         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
6944                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
6945         fi
6946
6947         rm -f $DIR/$tfile
6948         echo "No pages locked after fsync"
6949
6950         return 0
6951 }
6952 run_test 118i "Fix error before timeout in recoverable error  =========="
6953
6954 [ "$SLOW" = "no" ] && set_resend_count 4
6955
6956 test_118j() {
6957         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6958         remote_ost_nodsh && skip "remote OST with nodsh" && return
6959
6960         reset_async
6961
6962         #define OBD_FAIL_OST_BRW_WRITE_BULK2     0x220
6963         set_nodes_failloc "$(osts_nodes)" 0x220
6964
6965         # return -EIO from OST
6966         $MULTIOP $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
6967         RC=$?
6968         set_nodes_failloc "$(osts_nodes)" 0x0
6969         if [[ $RC -eq 0 ]]; then
6970                 error "Must return error due to dropped pages, rc=$RC"
6971         fi
6972
6973         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
6974         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
6975         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
6976         if [[ $LOCKED -ne 0 ]]; then
6977                 error "Locked pages remain in cache, locked=$LOCKED"
6978         fi
6979
6980         # in recoverable error on OST we want resend and stay until it finished
6981         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
6982                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
6983         fi
6984
6985         rm -f $DIR/$tfile
6986         echo "No pages locked after fsync"
6987
6988         return 0
6989 }
6990 run_test 118j "Simulate unrecoverable OST side error =========="
6991
6992 test_118k()
6993 {
6994         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
6995         remote_ost_nodsh && skip "remote OSTs with nodsh" && return
6996
6997         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
6998         set_nodes_failloc "$(osts_nodes)" 0x20e
6999         test_mkdir -p $DIR/$tdir
7000
7001         for ((i=0;i<10;i++)); do
7002                 (dd if=/dev/zero of=$DIR/$tdir/$tfile-$i bs=1M count=10 || \
7003                         error "dd to $DIR/$tdir/$tfile-$i failed" )&
7004                 SLEEPPID=$!
7005                 sleep 0.500s
7006                 kill $SLEEPPID
7007                 wait $SLEEPPID
7008         done
7009
7010         set_nodes_failloc "$(osts_nodes)" 0
7011         rm -rf $DIR/$tdir
7012 }
7013 run_test 118k "bio alloc -ENOMEM and IO TERM handling ========="
7014
7015 test_118l()
7016 {
7017         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7018         # LU-646
7019         test_mkdir -p $DIR/$tdir
7020         $MULTIOP $DIR/$tdir Dy || error "fsync dir failed"
7021         rm -rf $DIR/$tdir
7022 }
7023 run_test 118l "fsync dir ========="
7024
7025 test_118m() # LU-3066
7026 {
7027         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7028         test_mkdir -p $DIR/$tdir
7029         $MULTIOP $DIR/$tdir DY || error "fdatasync dir failed"
7030         rm -rf $DIR/$tdir
7031 }
7032 run_test 118m "fdatasync dir ========="
7033
7034 [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] && set_resend_count $OLD_RESENDCOUNT
7035
7036 test_119a() # bug 11737
7037 {
7038         BSIZE=$((512 * 1024))
7039         directio write $DIR/$tfile 0 1 $BSIZE
7040         # We ask to read two blocks, which is more than a file size.
7041         # directio will indicate an error when requested and actual
7042         # sizes aren't equeal (a normal situation in this case) and
7043         # print actual read amount.
7044         NOB=`directio read $DIR/$tfile 0 2 $BSIZE | awk '/error/ {print $6}'`
7045         if [ "$NOB" != "$BSIZE" ]; then
7046                 error "read $NOB bytes instead of $BSIZE"
7047         fi
7048         rm -f $DIR/$tfile
7049 }
7050 run_test 119a "Short directIO read must return actual read amount"
7051
7052 test_119b() # bug 11737
7053 {
7054         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
7055
7056         $SETSTRIPE -c 2 $DIR/$tfile || error "setstripe failed"
7057         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1 || error "dd failed"
7058         sync
7059         $MULTIOP $DIR/$tfile oO_RDONLY:O_DIRECT:r$((2048 * 1024)) || \
7060                 error "direct read failed"
7061         rm -f $DIR/$tfile
7062 }
7063 run_test 119b "Sparse directIO read must return actual read amount"
7064
7065 test_119c() # bug 13099
7066 {
7067         BSIZE=1048576
7068         directio write $DIR/$tfile 3 1 $BSIZE || error "direct write failed"
7069         directio readhole $DIR/$tfile 0 2 $BSIZE || error "reading hole failed"
7070         rm -f $DIR/$tfile
7071 }
7072 run_test 119c "Testing for direct read hitting hole"
7073
7074 test_119d() # bug 15950
7075 {
7076         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7077         MAX_RPCS_IN_FLIGHT=`$LCTL get_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight`
7078         $LCTL set_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight 1
7079         BSIZE=1048576
7080         $SETSTRIPE $DIR/$tfile -i 0 -c 1 || error "setstripe failed"
7081         $DIRECTIO write $DIR/$tfile 0 1 $BSIZE || error "first directio failed"
7082         #define OBD_FAIL_OSC_DIO_PAUSE           0x40d
7083         lctl set_param fail_loc=0x40d
7084         $DIRECTIO write $DIR/$tfile 1 4 $BSIZE &
7085         pid_dio=$!
7086         sleep 1
7087         cat $DIR/$tfile > /dev/null &
7088         lctl set_param fail_loc=0
7089         pid_reads=$!
7090         wait $pid_dio
7091         log "the DIO writes have completed, now wait for the reads (should not block very long)"
7092         sleep 2
7093         [ -n "`ps h -p $pid_reads -o comm`" ] && \
7094         error "the read rpcs have not completed in 2s"
7095         rm -f $DIR/$tfile
7096         $LCTL set_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight $MAX_RPCS_IN_FLIGHT
7097 }
7098 run_test 119d "The DIO path should try to send a new rpc once one is completed"
7099
7100 test_120a() {
7101         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7102         test_mkdir -p $DIR/$tdir
7103         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7104                skip "no early lock cancel on server" && return 0
7105
7106         lru_resize_disable mdc
7107         lru_resize_disable osc
7108         cancel_lru_locks mdc
7109         # asynchronous object destroy at MDT could cause bl ast to client
7110         cancel_lru_locks osc
7111
7112         stat $DIR/$tdir > /dev/null
7113         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7114         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7115         test_mkdir $DIR/$tdir/d1
7116         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7117         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7118         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
7119         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
7120         lru_resize_enable mdc
7121         lru_resize_enable osc
7122 }
7123 run_test 120a "Early Lock Cancel: mkdir test"
7124
7125 test_120b() {
7126         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7127         test_mkdir -p $DIR/$tdir
7128         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7129                skip "no early lock cancel on server" && return 0
7130         lru_resize_disable mdc
7131         lru_resize_disable osc
7132         cancel_lru_locks mdc
7133         stat $DIR/$tdir > /dev/null
7134         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7135         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7136         touch $DIR/$tdir/f1
7137         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7138         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7139         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
7140         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
7141         lru_resize_enable mdc
7142         lru_resize_enable osc
7143 }
7144 run_test 120b "Early Lock Cancel: create test"
7145
7146 test_120c() {
7147         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7148         test_mkdir -p $DIR/$tdir
7149         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7150                skip "no early lock cancel on server" && return 0
7151         lru_resize_disable mdc
7152         lru_resize_disable osc
7153         test_mkdir -p $DIR/$tdir/d1 $DIR/$tdir/d2
7154         touch $DIR/$tdir/d1/f1
7155         cancel_lru_locks mdc
7156         stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 > /dev/null
7157         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7158         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7159         ln $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2
7160         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7161         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7162         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
7163         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
7164         lru_resize_enable mdc
7165         lru_resize_enable osc
7166 }
7167 run_test 120c "Early Lock Cancel: link test"
7168
7169 test_120d() {
7170         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7171         test_mkdir -p $DIR/$tdir
7172         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7173                skip "no early lock cancel on server" && return 0
7174         lru_resize_disable mdc
7175         lru_resize_disable osc
7176         touch $DIR/$tdir
7177         cancel_lru_locks mdc
7178         stat $DIR/$tdir > /dev/null
7179         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7180         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7181         chmod a+x $DIR/$tdir
7182         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
7183         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
7184         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
7185         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
7186         lru_resize_enable mdc
7187         lru_resize_enable osc
7188 }
7189 run_test 120d "Early Lock Cancel: setattr test"
7190
7191 test_120e() {
7192         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7193         test_mkdir -p $DIR/$tdir
7194         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7195                skip "no early lock cancel on server" && return 0
7196         lru_resize_disable mdc
7197         lru_resize_disable osc
7198         dd if=/dev/zero of=$DIR/$tdir/f1 count=1
7199         cancel_lru_locks mdc
7200         cancel_lru_locks osc
7201         dd if=$DIR/$tdir/f1 of=/dev/null
7202         stat $DIR/$tdir $DIR/$tdir/f1 > /dev/null
7203         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7204               awk '/ldlm_cancel/ {print $2}'`
7205         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7206               awk '/ldlm_bl_callback/ {print $2}'`
7207         unlink $DIR/$tdir/f1
7208         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7209               awk '/ldlm_cancel/ {print $2}'`
7210         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7211               awk '/ldlm_bl_callback/ {print $2}'`
7212         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
7213         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
7214         lru_resize_enable mdc
7215         lru_resize_enable osc
7216 }
7217 run_test 120e "Early Lock Cancel: unlink test"
7218
7219 test_120f() {
7220         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7221         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7222                skip "no early lock cancel on server" && return 0
7223         test_mkdir -p $DIR/$tdir
7224         lru_resize_disable mdc
7225         lru_resize_disable osc
7226         test_mkdir -p $DIR/$tdir/d1 $DIR/$tdir/d2
7227         dd if=/dev/zero of=$DIR/$tdir/d1/f1 count=1
7228         dd if=/dev/zero of=$DIR/$tdir/d2/f2 count=1
7229         cancel_lru_locks mdc
7230         cancel_lru_locks osc
7231         dd if=$DIR/$tdir/d1/f1 of=/dev/null
7232         dd if=$DIR/$tdir/d2/f2 of=/dev/null
7233         stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2 > /dev/null
7234         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7235               awk '/ldlm_cancel/ {print $2}'`
7236         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7237               awk '/ldlm_bl_callback/ {print $2}'`
7238         mv $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2
7239         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7240               awk '/ldlm_cancel/ {print $2}'`
7241         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7242               awk '/ldlm_bl_callback/ {print $2}'`
7243         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
7244         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
7245         lru_resize_enable mdc
7246         lru_resize_enable osc
7247 }
7248 run_test 120f "Early Lock Cancel: rename test"
7249
7250 test_120g() {
7251         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7252         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
7253                skip "no early lock cancel on server" && return 0
7254         lru_resize_disable mdc
7255         lru_resize_disable osc
7256         count=10000
7257         echo create $count files
7258         test_mkdir -p $DIR/$tdir
7259         cancel_lru_locks mdc
7260         cancel_lru_locks osc
7261         t0=`date +%s`
7262
7263         can0=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7264               awk '/ldlm_cancel/ {print $2}'`
7265         blk0=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7266               awk '/ldlm_bl_callback/ {print $2}'`
7267         createmany -o $DIR/$tdir/f $count
7268         sync
7269         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7270               awk '/ldlm_cancel/ {print $2}'`
7271         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7272               awk '/ldlm_bl_callback/ {print $2}'`
7273         t1=`date +%s`
7274         echo total: $((can1-can0)) cancels, $((blk1-blk0)) blockings
7275         echo rm $count files
7276         rm -r $DIR/$tdir
7277         sync
7278         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
7279               awk '/ldlm_cancel/ {print $2}'`
7280         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
7281               awk '/ldlm_bl_callback/ {print $2}'`
7282         t2=`date +%s`
7283         echo total: $count removes in $((t2-t1))
7284         echo total: $((can2-can1)) cancels, $((blk2-blk1)) blockings
7285         sleep 2
7286         # wait for commitment of removal
7287         lru_resize_enable mdc
7288         lru_resize_enable osc
7289 }
7290 run_test 120g "Early Lock Cancel: performance test"
7291
7292 test_121() { #bug #10589
7293         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7294         rm -rf $DIR/$tfile
7295         writes=$(LANG=C dd if=/dev/zero of=$DIR/$tfile count=1 2>&1 | awk -F '+' '/out$/ {print $1}')
7296 #define OBD_FAIL_LDLM_CANCEL_RACE        0x310
7297         lctl set_param fail_loc=0x310
7298         cancel_lru_locks osc > /dev/null
7299         reads=$(LANG=C dd if=$DIR/$tfile of=/dev/null 2>&1 | awk -F '+' '/in$/ {print $1}')
7300         lctl set_param fail_loc=0
7301         [ "$reads" -eq "$writes" ] || error "read" $reads "blocks, must be" $writes
7302 }
7303 run_test 121 "read cancel race ========="
7304
7305 test_123a() { # was test 123, statahead(bug 11401)
7306         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7307         SLOWOK=0
7308         if [ -z "$(grep "processor.*: 1" /proc/cpuinfo)" ]; then
7309             log "testing on UP system. Performance may be not as good as expected."
7310                         SLOWOK=1
7311         fi
7312
7313         rm -rf $DIR/$tdir
7314         test_mkdir -p $DIR/$tdir
7315         NUMFREE=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
7316         [ $NUMFREE -gt 100000 ] && NUMFREE=100000 || NUMFREE=$((NUMFREE-1000))
7317         MULT=10
7318         for ((i=100, j=0; i<=$NUMFREE; j=$i, i=$((i * MULT)) )); do
7319                 createmany -o $DIR/$tdir/$tfile $j $((i - j))
7320
7321                 max=`lctl get_param -n llite.*.statahead_max | head -n 1`
7322                 lctl set_param -n llite.*.statahead_max 0
7323                 lctl get_param llite.*.statahead_max
7324                 cancel_lru_locks mdc
7325                 cancel_lru_locks osc
7326                 stime=`date +%s`
7327                 time ls -l $DIR/$tdir | wc -l
7328                 etime=`date +%s`
7329                 delta=$((etime - stime))
7330                 log "ls $i files without statahead: $delta sec"
7331                 lctl set_param llite.*.statahead_max=$max
7332
7333                 swrong=`lctl get_param -n llite.*.statahead_stats | grep "statahead wrong:" | awk '{print $3}'`
7334                 lctl get_param -n llite.*.statahead_max | grep '[0-9]'
7335                 cancel_lru_locks mdc
7336                 cancel_lru_locks osc
7337                 stime=`date +%s`
7338                 time ls -l $DIR/$tdir | wc -l
7339                 etime=`date +%s`
7340                 delta_sa=$((etime - stime))
7341                 log "ls $i files with statahead: $delta_sa sec"
7342                 lctl get_param -n llite.*.statahead_stats
7343                 ewrong=`lctl get_param -n llite.*.statahead_stats | grep "statahead wrong:" | awk '{print $3}'`
7344
7345                 [ $swrong -lt $ewrong ] && log "statahead was stopped, maybe too many locks held!"
7346                 [ $delta -eq 0 -o $delta_sa -eq 0 ] && continue
7347
7348                 if [ $((delta_sa * 100)) -gt $((delta * 105)) -a $delta_sa -gt $((delta + 2)) ]; then
7349                     max=`lctl get_param -n llite.*.statahead_max | head -n 1`
7350                     lctl set_param -n llite.*.statahead_max 0
7351                     lctl get_param llite.*.statahead_max
7352                     cancel_lru_locks mdc
7353                     cancel_lru_locks osc
7354                     stime=`date +%s`
7355                     time ls -l $DIR/$tdir | wc -l
7356                     etime=`date +%s`
7357                     delta=$((etime - stime))
7358                     log "ls $i files again without statahead: $delta sec"
7359                     lctl set_param llite.*.statahead_max=$max
7360                     if [ $((delta_sa * 100)) -gt $((delta * 105)) -a $delta_sa -gt $((delta + 2)) ]; then
7361                         if [  $SLOWOK -eq 0 ]; then
7362                                 error "ls $i files is slower with statahead!"
7363                         else
7364                                 log "ls $i files is slower with statahead!"
7365                         fi
7366                         break
7367                     fi
7368                 fi
7369
7370                 [ $delta -gt 20 ] && break
7371                 [ $delta -gt 8 ] && MULT=$((50 / delta))
7372                 [ "$SLOW" = "no" -a $delta -gt 5 ] && break
7373         done
7374         log "ls done"
7375
7376         stime=`date +%s`
7377         rm -r $DIR/$tdir
7378         sync
7379         etime=`date +%s`
7380         delta=$((etime - stime))
7381         log "rm -r $DIR/$tdir/: $delta seconds"
7382         log "rm done"
7383         lctl get_param -n llite.*.statahead_stats
7384 }
7385 run_test 123a "verify statahead work"
7386
7387 test_123b () { # statahead(bug 15027)
7388         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7389         test_mkdir -p $DIR/$tdir
7390         createmany -o $DIR/$tdir/$tfile-%d 1000
7391
7392         cancel_lru_locks mdc
7393         cancel_lru_locks osc
7394
7395 #define OBD_FAIL_MDC_GETATTR_ENQUEUE     0x803
7396         lctl set_param fail_loc=0x80000803
7397         ls -lR $DIR/$tdir > /dev/null
7398         log "ls done"
7399         lctl set_param fail_loc=0x0
7400         lctl get_param -n llite.*.statahead_stats
7401         rm -r $DIR/$tdir
7402         sync
7403
7404 }
7405 run_test 123b "not panic with network error in statahead enqueue (bug 15027)"
7406
7407 test_124a() {
7408         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7409         [ -z "`lctl get_param -n mdc.*.connect_flags | grep lru_resize`" ] && \
7410                skip "no lru resize on server" && return 0
7411         local NR=2000
7412         test_mkdir -p $DIR/$tdir || error "failed to create $DIR/$tdir"
7413
7414         log "create $NR files at $DIR/$tdir"
7415         createmany -o $DIR/$tdir/f $NR ||
7416                 error "failed to create $NR files in $DIR/$tdir"
7417
7418         cancel_lru_locks mdc
7419         ls -l $DIR/$tdir > /dev/null
7420
7421         local NSDIR=""
7422         local LRU_SIZE=0
7423         for VALUE in `lctl get_param ldlm.namespaces.*mdc-*.lru_size`; do
7424                 local PARAM=`echo ${VALUE[0]} | cut -d "=" -f1`
7425                 LRU_SIZE=$(lctl get_param -n $PARAM)
7426                 if [ $LRU_SIZE -gt $(default_lru_size) ]; then
7427                         NSDIR=$(echo $PARAM | cut -d "." -f1-3)
7428                                                 log "NSDIR=$NSDIR"
7429                         log "NS=$(basename $NSDIR)"
7430                         break
7431                 fi
7432         done
7433
7434         if [ -z "$NSDIR" -o $LRU_SIZE -lt $(default_lru_size) ]; then
7435                 skip "Not enough cached locks created!"
7436                 return 0
7437         fi
7438         log "LRU=$LRU_SIZE"
7439
7440         local SLEEP=30
7441
7442         # We know that lru resize allows one client to hold $LIMIT locks
7443         # for 10h. After that locks begin to be killed by client.
7444         local MAX_HRS=10
7445         local LIMIT=`lctl get_param -n $NSDIR.pool.limit`
7446                 log "LIMIT=$LIMIT"
7447
7448         # Make LVF so higher that sleeping for $SLEEP is enough to _start_
7449         # killing locks. Some time was spent for creating locks. This means
7450         # that up to the moment of sleep finish we must have killed some of
7451         # them (10-100 locks). This depends on how fast ther were created.
7452         # Many of them were touched in almost the same moment and thus will
7453         # be killed in groups.
7454         local LVF=$(($MAX_HRS * 60 * 60 / $SLEEP * $LIMIT / $LRU_SIZE))
7455
7456         # Use $LRU_SIZE_B here to take into account real number of locks
7457         # created in the case of CMD, LRU_SIZE_B != $NR in most of cases
7458         local LRU_SIZE_B=$LRU_SIZE
7459         log "LVF=$LVF"
7460         local OLD_LVF=`lctl get_param -n $NSDIR.pool.lock_volume_factor`
7461                 log "OLD_LVF=$OLD_LVF"
7462         lctl set_param -n $NSDIR.pool.lock_volume_factor $LVF
7463
7464         # Let's make sure that we really have some margin. Client checks
7465         # cached locks every 10 sec.
7466         SLEEP=$((SLEEP+20))
7467         log "Sleep ${SLEEP} sec"
7468         local SEC=0
7469         while ((SEC<$SLEEP)); do
7470                 echo -n "..."
7471                 sleep 5
7472                 SEC=$((SEC+5))
7473                 LRU_SIZE=`lctl get_param -n $NSDIR/lru_size`
7474                 echo -n "$LRU_SIZE"
7475         done
7476         echo ""
7477         lctl set_param -n $NSDIR.pool.lock_volume_factor $OLD_LVF
7478         local LRU_SIZE_A=`lctl get_param -n $NSDIR.lru_size`
7479
7480         [ $LRU_SIZE_B -gt $LRU_SIZE_A ] || {
7481                 error "No locks dropped in ${SLEEP}s. LRU size: $LRU_SIZE_A"
7482                 unlinkmany $DIR/$tdir/f $NR
7483                 return
7484         }
7485
7486         log "Dropped "$((LRU_SIZE_B-LRU_SIZE_A))" locks in ${SLEEP}s"
7487         log "unlink $NR files at $DIR/$tdir"
7488         unlinkmany $DIR/$tdir/f $NR
7489 }
7490 run_test 124a "lru resize ======================================="
7491
7492 get_max_pool_limit()
7493 {
7494         local limit=`lctl get_param -n ldlm.namespaces.*-MDT0000-mdc-*.pool.limit`
7495         local max=0
7496         for l in $limit; do
7497                 if test $l -gt $max; then
7498                         max=$l
7499                 fi
7500         done
7501         echo $max
7502 }
7503
7504 test_124b() {
7505         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7506         [ -z "`lctl get_param -n mdc.*.connect_flags | grep lru_resize`" ] && \
7507                skip "no lru resize on server" && return 0
7508
7509         LIMIT=`get_max_pool_limit`
7510
7511         NR=$(($(default_lru_size)*20))
7512         if [ $NR -gt $LIMIT ]; then
7513                 log "Limit lock number by $LIMIT locks"
7514                 NR=$LIMIT
7515         fi
7516         lru_resize_disable mdc
7517         test_mkdir -p $DIR/$tdir/disable_lru_resize ||
7518                 error "failed to create $DIR/$tdir/disable_lru_resize"
7519
7520         createmany -o $DIR/$tdir/disable_lru_resize/f $NR
7521         log "doing ls -la $DIR/$tdir/disable_lru_resize 3 times"
7522         cancel_lru_locks mdc
7523         stime=`date +%s`
7524         PID=""
7525         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
7526         PID="$PID $!"
7527         sleep 2
7528         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
7529         PID="$PID $!"
7530         sleep 2
7531         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
7532         PID="$PID $!"
7533         wait $PID
7534         etime=`date +%s`
7535         nolruresize_delta=$((etime-stime))
7536         log "ls -la time: $nolruresize_delta seconds"
7537         log "lru_size = $(lctl get_param -n ldlm.namespaces.*mdc*.lru_size)"
7538         unlinkmany $DIR/$tdir/disable_lru_resize/f $NR
7539
7540         lru_resize_enable mdc
7541         test_mkdir -p $DIR/$tdir/enable_lru_resize ||
7542                 error "failed to create $DIR/$tdir/enable_lru_resize"
7543
7544         createmany -o $DIR/$tdir/enable_lru_resize/f $NR
7545         log "doing ls -la $DIR/$tdir/enable_lru_resize 3 times"
7546         cancel_lru_locks mdc
7547         stime=`date +%s`
7548         PID=""
7549         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
7550         PID="$PID $!"
7551         sleep 2
7552         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
7553         PID="$PID $!"
7554         sleep 2
7555         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
7556         PID="$PID $!"
7557         wait $PID
7558         etime=`date +%s`
7559         lruresize_delta=$((etime-stime))
7560         log "ls -la time: $lruresize_delta seconds"
7561         log "lru_size = $(lctl get_param -n ldlm.namespaces.*mdc*.lru_size)"
7562
7563         if [ $lruresize_delta -gt $nolruresize_delta ]; then
7564                 log "ls -la is $(((lruresize_delta - $nolruresize_delta) * 100 / $nolruresize_delta))% slower with lru resize enabled"
7565         elif [ $nolruresize_delta -gt $lruresize_delta ]; then
7566                 log "ls -la is $(((nolruresize_delta - $lruresize_delta) * 100 / $nolruresize_delta))% faster with lru resize enabled"
7567         else
7568                 log "lru resize performs the same with no lru resize"
7569         fi
7570         unlinkmany $DIR/$tdir/enable_lru_resize/f $NR
7571 }
7572 run_test 124b "lru resize (performance test) ======================="
7573
7574 test_125() { # 13358
7575         [ -z "$(lctl get_param -n llite.*.client_type | grep local)" ] && skip "must run as local client" && return
7576         [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep acl)" ] && skip "must have acl enabled" && return
7577         test_mkdir -p $DIR/d125 || error "mkdir failed"
7578         $SETSTRIPE -S 65536 -c -1 $DIR/d125 || error "setstripe failed"
7579         setfacl -R -m u:bin:rwx $DIR/d125 || error "setfacl $DIR/d125 failed"
7580         ls -ld $DIR/d125 || error "cannot access $DIR/d125"
7581 }
7582 run_test 125 "don't return EPROTO when a dir has a non-default striping and ACLs"
7583
7584 test_126() { # bug 12829/13455
7585         [ -z "$(lctl get_param -n llite.*.client_type | grep local)" ] && skip "must run as local client" && return
7586         [ "$UID" != 0 ] && skip_env "skipping $TESTNAME (must run as root)" && return
7587         $GSS && skip "must run as gss disabled" && return
7588
7589         $RUNAS -u 0 -g 1 touch $DIR/$tfile || error "touch failed"
7590         gid=`ls -n $DIR/$tfile | awk '{print $4}'`
7591         rm -f $DIR/$tfile
7592         [ $gid -eq "1" ] || error "gid is set to" $gid "instead of 1"
7593 }
7594 run_test 126 "check that the fsgid provided by the client is taken into account"
7595
7596 test_127a() { # bug 15521
7597         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7598         $SETSTRIPE -i 0 -c 1 $DIR/$tfile || error "setstripe failed"
7599         $LCTL set_param osc.*.stats=0
7600         FSIZE=$((2048 * 1024))
7601         dd if=/dev/zero of=$DIR/$tfile bs=$FSIZE count=1
7602         cancel_lru_locks osc
7603         dd if=$DIR/$tfile of=/dev/null bs=$FSIZE
7604
7605         $LCTL get_param osc.*0000-osc-*.stats | grep samples > $DIR/${tfile}.tmp
7606         while read NAME COUNT SAMP UNIT MIN MAX SUM SUMSQ; do
7607                 echo "got $COUNT $NAME"
7608                 [ ! $MIN ] && error "Missing min value for $NAME proc entry"
7609                 eval $NAME=$COUNT || error "Wrong proc format"
7610
7611                 case $NAME in
7612                         read_bytes|write_bytes)
7613                         [ $MIN -lt 4096 ] && error "min is too small: $MIN"
7614                         [ $MIN -gt $FSIZE ] && error "min is too big: $MIN"
7615                         [ $MAX -lt 4096 ] && error "max is too small: $MAX"
7616                         [ $MAX -gt $FSIZE ] && error "max is too big: $MAX"
7617                         [ $SUM -ne $FSIZE ] && error "sum is wrong: $SUM"
7618                         [ $SUMSQ -lt $(((FSIZE /4096) * (4096 * 4096))) ] &&
7619                                 error "sumsquare is too small: $SUMSQ"
7620                         [ $SUMSQ -gt $((FSIZE * FSIZE)) ] &&
7621                                 error "sumsquare is too big: $SUMSQ"
7622                         ;;
7623                         *) ;;
7624                 esac
7625         done < $DIR/${tfile}.tmp
7626
7627         #check that we actually got some stats
7628         [ "$read_bytes" ] || error "Missing read_bytes stats"
7629         [ "$write_bytes" ] || error "Missing write_bytes stats"
7630         [ "$read_bytes" != 0 ] || error "no read done"
7631         [ "$write_bytes" != 0 ] || error "no write done"
7632 }
7633 run_test 127a "verify the client stats are sane"
7634
7635 test_127b() { # bug LU-333
7636         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7637         $LCTL set_param llite.*.stats=0
7638         FSIZE=65536 # sized fixed to match PAGE_SIZE for most clients
7639         # perform 2 reads and writes so MAX is different from SUM.
7640         dd if=/dev/zero of=$DIR/$tfile bs=$FSIZE count=1
7641         dd if=/dev/zero of=$DIR/$tfile bs=$FSIZE count=1
7642         cancel_lru_locks osc
7643         dd if=$DIR/$tfile of=/dev/null bs=$FSIZE count=1
7644         dd if=$DIR/$tfile of=/dev/null bs=$FSIZE count=1
7645
7646         $LCTL get_param llite.*.stats | grep samples > $TMP/${tfile}.tmp
7647         while read NAME COUNT SAMP UNIT MIN MAX SUM SUMSQ; do
7648                 echo "got $COUNT $NAME"
7649                 eval $NAME=$COUNT || error "Wrong proc format"
7650
7651         case $NAME in
7652                 read_bytes)
7653                         [ $COUNT -ne 2 ] && error "count is not 2: $COUNT"
7654                         [ $MIN -ne $FSIZE ] && error "min is not $FSIZE: $MIN"
7655                         [ $MAX -ne $FSIZE ] && error "max is incorrect: $MAX"
7656                         [ $SUM -ne $((FSIZE * 2)) ] && error "sum is wrong: $SUM"
7657                         ;;
7658                 write_bytes)
7659                         [ $COUNT -ne 2 ] && error "count is not 2: $COUNT"
7660                         [ $MIN -ne $FSIZE ] && error "min is not $FSIZE: $MIN"
7661                         [ $MAX -ne $FSIZE ] && error "max is incorrect: $MAX"
7662                         [ $SUM -ne $((FSIZE * 2)) ] && error "sum is wrong: $SUM"
7663                         ;;
7664                         *) ;;
7665                 esac
7666         done < $TMP/${tfile}.tmp
7667
7668         #check that we actually got some stats
7669         [ "$read_bytes" ] || error "Missing read_bytes stats"
7670         [ "$write_bytes" ] || error "Missing write_bytes stats"
7671         [ "$read_bytes" != 0 ] || error "no read done"
7672         [ "$write_bytes" != 0 ] || error "no write done"
7673 }
7674 run_test 127b "verify the llite client stats are sane"
7675
7676 test_128() { # bug 15212
7677         touch $DIR/$tfile
7678         $LFS 2>&1 <<-EOF | tee $TMP/$tfile.log
7679                 find $DIR/$tfile
7680                 find $DIR/$tfile
7681         EOF
7682
7683         result=$(grep error $TMP/$tfile.log)
7684         rm -f $DIR/$tfile
7685         [ -z "$result" ] || error "consecutive find's under interactive lfs failed"
7686 }
7687 run_test 128 "interactive lfs for 2 consecutive find's"
7688
7689 set_dir_limits () {
7690         local mntdev
7691         local canondev
7692         local node
7693
7694         local LDPROC=/proc/fs/ldiskfs
7695         local facets=$(get_facets MDS)
7696
7697         for facet in ${facets//,/ }; do
7698                 canondev=$(ldiskfs_canon \
7699                            *.$(convert_facet2label $facet).mntdev $facet)
7700                 do_facet $facet "test -e $LDPROC/$canondev/max_dir_size" ||
7701                                                 LDPROC=/sys/fs/ldiskfs
7702                 do_facet $facet "echo $1 >$LDPROC/$canondev/max_dir_size"
7703         done
7704 }
7705
7706 test_129() {
7707         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
7708         if [ "$(facet_fstype $SINGLEMDS)" != ldiskfs ]; then
7709                 skip "Only applicable to ldiskfs-based MDTs"
7710                 return
7711         fi
7712         remote_mds_nodsh && skip "remote MDS with nodsh" && return
7713
7714         EFBIG=27
7715         MAX=16384
7716
7717         set_dir_limits $MAX
7718         test_mkdir -p $DIR/$tdir
7719
7720         local I=0
7721         local J=0
7722         while [ ! $I -gt $((MAX * MDSCOUNT)) ]; do
7723                 $MULTIOP $DIR/$tdir/$J Oc
7724                 rc=$?
7725                 if [ $rc -eq $EFBIG ]; then
7726                         set_dir_limits 0
7727                         echo "return code $rc received as expected"
7728                         return 0
7729                 elif [ $rc -ne 0 ]; then
7730                         set_dir_limits 0
7731                         error_exit "return code $rc received instead of expected $EFBIG"
7732                 fi
7733                 J=$((J+1))
7734                 I=$(stat -c%s "$DIR/$tdir")
7735         done
7736
7737         set_dir_limits 0
7738         error "exceeded dir size limit $MAX x $MDSCOUNT $((MAX * MDSCOUNT)) : $I bytes"
7739 }
7740 run_test 129 "test directory size limit ========================"
7741
7742 OLDIFS="$IFS"
7743 cleanup_130() {
7744         trap 0
7745         IFS="$OLDIFS"
7746 }
7747
7748 test_130a() {
7749         local filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
7750         [ -n "$filefrag_op" ] && skip_env "filefrag does not support FIEMAP" &&
7751                 return
7752
7753         trap cleanup_130 EXIT RETURN
7754
7755         local fm_file=$DIR/$tfile
7756         $SETSTRIPE -S 65536 -c 1 $fm_file || error "setstripe on $fm_file"
7757         dd if=/dev/zero of=$fm_file bs=65536 count=1 ||
7758                 error "dd failed for $fm_file"
7759
7760         # LU-1795: test filefrag/FIEMAP once, even if unsupported
7761         filefrag -ves $fm_file
7762         RC=$?
7763         [ "$(facet_fstype ost$(($($GETSTRIPE -i $fm_file) + 1)))" = "zfs" ] &&
7764                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS" && return
7765         [ $RC != 0 ] && error "filefrag $fm_file failed"
7766
7767         filefrag_op=$(filefrag -ve $fm_file | grep -A 100 "ext:" |
7768                       grep -v "ext:" | grep -v "found")
7769         lun=$($GETSTRIPE -i $fm_file)
7770
7771         start_blk=`echo $filefrag_op | cut -d: -f2 | cut -d. -f1`
7772         IFS=$'\n'
7773         tot_len=0
7774         for line in $filefrag_op
7775         do
7776                 frag_lun=`echo $line | cut -d: -f5`
7777                 ext_len=`echo $line | cut -d: -f4`
7778                 if (( $frag_lun != $lun )); then
7779                         cleanup_130
7780                         error "FIEMAP on 1-stripe file($fm_file) failed"
7781                         return
7782                 fi
7783                 (( tot_len += ext_len ))
7784         done
7785
7786         if (( lun != frag_lun || start_blk != 0 || tot_len != 64 )); then
7787                 cleanup_130
7788                 error "FIEMAP on 1-stripe file($fm_file) failed;"
7789                 return
7790         fi
7791
7792         cleanup_130
7793
7794         echo "FIEMAP on single striped file succeeded"
7795 }
7796 run_test 130a "FIEMAP (1-stripe file)"
7797
7798 test_130b() {
7799         [ "$OSTCOUNT" -lt "2" ] &&
7800                 skip_env "skipping FIEMAP on 2-stripe file test" && return
7801
7802         [ "$OSTCOUNT" -ge "10" ] &&
7803                 skip_env "skipping FIEMAP with >= 10 OSTs" && return
7804
7805         local filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
7806         [ -n "$filefrag_op" ] && skip_env "filefrag does not support FIEMAP" &&
7807                 return
7808
7809         trap cleanup_130 EXIT RETURN
7810
7811         local fm_file=$DIR/$tfile
7812         $SETSTRIPE -S 65536 -c 2 $fm_file || error "setstripe on $fm_file"
7813         [ "$(facet_fstype ost$(($($GETSTRIPE -i $fm_file) + 1)))" = "zfs" ] &&
7814                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS" && return
7815
7816         dd if=/dev/zero of=$fm_file bs=1M count=2 ||
7817                 error "dd failed on $fm_file"
7818
7819         filefrag -ves $fm_file || error "filefrag $fm_file failed"
7820         filefrag_op=$(filefrag -ve $fm_file | grep -A 100 "ext:" |
7821                       grep -v "ext:" | grep -v "found")
7822
7823         last_lun=$(echo $filefrag_op | cut -d: -f5)
7824
7825         IFS=$'\n'
7826         tot_len=0
7827         num_luns=1
7828         for line in $filefrag_op
7829         do
7830                 frag_lun=`echo $line | cut -d: -f5`
7831                 ext_len=`echo $line | cut -d: -f4`
7832                 if (( $frag_lun != $last_lun )); then
7833                         if (( tot_len != 1024 )); then
7834                                 cleanup_130
7835                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of 256"
7836                                 return
7837                         else
7838                                 (( num_luns += 1 ))
7839                                 tot_len=0
7840                         fi
7841                 fi
7842                 (( tot_len += ext_len ))
7843                 last_lun=$frag_lun
7844         done
7845         if (( num_luns != 2 || tot_len != 1024 )); then
7846                 cleanup_130
7847                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
7848                 return
7849         fi
7850
7851         cleanup_130
7852
7853         echo "FIEMAP on 2-stripe file succeeded"
7854 }
7855 run_test 130b "FIEMAP (2-stripe file)"
7856
7857 test_130c() {
7858         [ "$OSTCOUNT" -lt "2" ] &&
7859                 skip_env "skipping FIEMAP on 2-stripe file" && return
7860
7861         [ "$OSTCOUNT" -ge "10" ] &&
7862                 skip_env "skipping FIEMAP with >= 10 OSTs" && return
7863
7864         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
7865         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" &&
7866                 return
7867
7868         trap cleanup_130 EXIT RETURN
7869
7870         local fm_file=$DIR/$tfile
7871         $SETSTRIPE -S 65536 -c 2 $fm_file || error "setstripe on $fm_file"
7872         [ "$(facet_fstype ost$(($($GETSTRIPE -i $fm_file) + 1)))" = "zfs" ] &&
7873                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS" && return
7874
7875         dd if=/dev/zero of=$fm_file seek=1 bs=1M count=1 || error "dd failed on $fm_file"
7876
7877         filefrag -ves $fm_file || error "filefrag $fm_file failed"
7878         filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" | grep -v "ext:" | grep -v "found"`
7879
7880         last_lun=`echo $filefrag_op | cut -d: -f5`
7881
7882         IFS=$'\n'
7883         tot_len=0
7884         num_luns=1
7885         for line in $filefrag_op
7886         do
7887                 frag_lun=`echo $line | cut -d: -f5`
7888                 ext_len=`echo $line | cut -d: -f4`
7889                 if (( $frag_lun != $last_lun )); then
7890                         logical=`echo $line | cut -d: -f2 | cut -d. -f1`
7891                         if (( logical != 512 )); then
7892                                 cleanup_130
7893                                 error "FIEMAP on $fm_file failed; returned logical start for lun $logical instead of 512"
7894                                 return
7895                         fi
7896                         if (( tot_len != 512 )); then
7897                                 cleanup_130
7898                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of 1024"
7899                                 return
7900                         else
7901                                 (( num_luns += 1 ))
7902                                 tot_len=0
7903                         fi
7904                 fi
7905                 (( tot_len += ext_len ))
7906                 last_lun=$frag_lun
7907         done
7908         if (( num_luns != 2 || tot_len != 512 )); then
7909                 cleanup_130
7910                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
7911                 return
7912         fi
7913
7914         cleanup_130
7915
7916         echo "FIEMAP on 2-stripe file with hole succeeded"
7917 }
7918 run_test 130c "FIEMAP (2-stripe file with hole)"
7919
7920 test_130d() {
7921         [ "$OSTCOUNT" -lt "3" ] && skip_env "skipping FIEMAP on N-stripe file test" && return
7922
7923         [ "$OSTCOUNT" -ge "10" ] &&
7924                 skip_env "skipping FIEMAP with >= 10 OSTs" && return
7925
7926         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
7927         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
7928
7929         trap cleanup_130 EXIT RETURN
7930
7931         local fm_file=$DIR/$tfile
7932         $SETSTRIPE -S 65536 -c $OSTCOUNT $fm_file||error "setstripe on $fm_file"
7933         [ "$(facet_fstype ost$(($($GETSTRIPE -i $fm_file) + 1)))" = "zfs" ] &&
7934                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS" && return
7935         dd if=/dev/zero of=$fm_file bs=1M count=$OSTCOUNT || error "dd failed on $fm_file"
7936
7937         filefrag -ves $fm_file || error "filefrag $fm_file failed"
7938         filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" | grep -v "ext:" | grep -v "found"`
7939
7940         last_lun=`echo $filefrag_op | cut -d: -f5`
7941
7942         IFS=$'\n'
7943         tot_len=0
7944         num_luns=1
7945         for line in $filefrag_op
7946         do
7947                 frag_lun=`echo $line | cut -d: -f5`
7948                 ext_len=`echo $line | cut -d: -f4`
7949                 if (( $frag_lun != $last_lun )); then
7950                         if (( tot_len != 1024 )); then
7951                                 cleanup_130
7952                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of 1024"
7953                                 return
7954                         else
7955                                 (( num_luns += 1 ))
7956                                 tot_len=0
7957                         fi
7958                 fi
7959                 (( tot_len += ext_len ))
7960                 last_lun=$frag_lun
7961         done
7962         if (( num_luns != OSTCOUNT || tot_len != 1024 )); then
7963                 cleanup_130
7964                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
7965                 return
7966         fi
7967
7968         cleanup_130
7969
7970         echo "FIEMAP on N-stripe file succeeded"
7971 }
7972 run_test 130d "FIEMAP (N-stripe file)"
7973
7974 test_130e() {
7975         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping continuation FIEMAP test" && return
7976
7977         [ "$OSTCOUNT" -ge "10" ] &&
7978                 skip_env "skipping FIEMAP with >= 10 OSTs" && return
7979
7980         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
7981         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
7982
7983         trap cleanup_130 EXIT RETURN
7984
7985         local fm_file=$DIR/$tfile
7986         $SETSTRIPE -S 131072 -c 2 $fm_file || error "setstripe on $fm_file"
7987         [ "$(facet_fstype ost$(($($GETSTRIPE -i $fm_file) + 1)))" = "zfs" ] &&
7988                 skip "ORI-366/LU-1941: FIEMAP unimplemented on ZFS" && return
7989
7990         NUM_BLKS=512
7991         EXPECTED_LEN=$(( (NUM_BLKS / 2) * 64 ))
7992         for ((i = 0; i < $NUM_BLKS; i++))
7993         do
7994                 dd if=/dev/zero of=$fm_file count=1 bs=64k seek=$((2*$i)) conv=notrunc > /dev/null 2>&1
7995         done
7996
7997         filefrag -ves $fm_file || error "filefrag $fm_file failed"
7998         filefrag_op=`filefrag -ve $fm_file | grep -A 12000 "ext:" | grep -v "ext:" | grep -v "found"`
7999
8000         last_lun=`echo $filefrag_op | cut -d: -f5`
8001
8002         IFS=$'\n'
8003         tot_len=0
8004         num_luns=1
8005         for line in $filefrag_op
8006         do
8007                 frag_lun=`echo $line | cut -d: -f5`
8008                 ext_len=`echo $line | cut -d: -f4`
8009                 if (( $frag_lun != $last_lun )); then
8010                         if (( tot_len != $EXPECTED_LEN )); then
8011                                 cleanup_130
8012                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of $EXPECTED_LEN"
8013                                 return
8014                         else
8015                                 (( num_luns += 1 ))
8016                                 tot_len=0
8017                         fi
8018                 fi
8019                 (( tot_len += ext_len ))
8020                 last_lun=$frag_lun
8021         done
8022         if (( num_luns != 2 || tot_len != $EXPECTED_LEN )); then
8023                 cleanup_130
8024                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
8025                 return
8026         fi
8027
8028         cleanup_130
8029
8030         echo "FIEMAP with continuation calls succeeded"
8031 }
8032 run_test 130e "FIEMAP (test continuation FIEMAP calls)"
8033
8034 # Test for writev/readv
8035 test_131a() {
8036         rwv -f $DIR/$tfile -w -n 3 524288 1048576 1572864 || \
8037         error "writev test failed"
8038         rwv -f $DIR/$tfile -r -v -n 2 1572864 1048576 || \
8039         error "readv failed"
8040         rm -f $DIR/$tfile
8041 }
8042 run_test 131a "test iov's crossing stripe boundary for writev/readv"
8043
8044 test_131b() {
8045         rwv -f $DIR/$tfile -w -a -n 3 524288 1048576 1572864 || \
8046         error "append writev test failed"
8047         rwv -f $DIR/$tfile -w -a -n 2 1572864 1048576 || \
8048         error "append writev test failed"
8049         rm -f $DIR/$tfile
8050 }
8051 run_test 131b "test append writev"
8052
8053 test_131c() {
8054         rwv -f $DIR/$tfile -w -d -n 1 1048576 || return 0
8055         error "NOT PASS"
8056 }
8057 run_test 131c "test read/write on file w/o objects"
8058
8059 test_131d() {
8060         rwv -f $DIR/$tfile -w -n 1 1572864
8061         NOB=`rwv -f $DIR/$tfile -r -n 3 524288 524288 1048576 | awk '/error/ {print $6}'`
8062         if [ "$NOB" != 1572864 ]; then
8063                 error "Short read filed: read $NOB bytes instead of 1572864"
8064         fi
8065         rm -f $DIR/$tfile
8066 }
8067 run_test 131d "test short read"
8068
8069 test_131e() {
8070         rwv -f $DIR/$tfile -w -s 1048576 -n 1 1048576
8071         rwv -f $DIR/$tfile -r -z -s 0 -n 1 524288 || \
8072         error "read hitting hole failed"
8073         rm -f $DIR/$tfile
8074 }
8075 run_test 131e "test read hitting hole"
8076
8077 get_ost_param() {
8078         local token=$1
8079         local gl_sum=0
8080         for node in $(osts_nodes); do
8081                 gl=$(do_node $node "$LCTL get_param -n ost.OSS.ost.stats" | awk '/'$token'/ {print $2}' | head -n 1)
8082                 [ x$gl = x"" ] && gl=0
8083                 gl_sum=$((gl_sum + gl))
8084         done
8085         echo $gl_sum
8086 }
8087
8088 som_mode_switch() {
8089         local som=$1
8090         local gl1=$2
8091         local gl2=$3
8092
8093         if [ x$som = x"enabled" ]; then
8094                 [ $((gl2 - gl1)) -gt 0 ] && error "no glimpse RPC is expected"
8095                 MOUNTOPT=`echo $MOUNTOPT | sed 's/som_preview//g'`
8096                 do_facet mgs "$LCTL conf_param $FSNAME.mdt.som=disabled"
8097         else
8098                 [ $((gl2 - gl1)) -gt 0 ] || error "some glimpse RPC is expected"
8099                 MOUNTOPT="$MOUNTOPT,som_preview"
8100                 do_facet mgs "$LCTL conf_param $FSNAME.mdt.som=enabled"
8101         fi
8102
8103         # do remount to make new mount-conf parameters actual
8104         echo remounting...
8105         sync
8106         stopall
8107         setupall
8108 }
8109
8110 test_132() { #1028, SOM
8111         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8112         remote_mds_nodsh && skip "remote MDS with nodsh" && return
8113         local num=$(get_mds_dir $DIR)
8114         local mymds=mds${num}
8115         local MOUNTOPT_SAVE=$MOUNTOPT
8116
8117         dd if=/dev/zero of=$DIR/$tfile count=1 2>/dev/null
8118         cancel_lru_locks osc
8119
8120         som1=$(do_facet $mymds "$LCTL get_param mdt.*.som" |  awk -F= ' {print $2}' | head -n 1)
8121
8122         gl1=$(get_ost_param "ldlm_glimpse_enqueue")
8123         stat $DIR/$tfile >/dev/null
8124         gl2=$(get_ost_param "ldlm_glimpse_enqueue")
8125         echo "====> SOM is "$som1", "$((gl2 - gl1))" glimpse RPC occured"
8126         rm $DIR/$tfile
8127         som_mode_switch $som1 $gl1 $gl2
8128
8129         dd if=/dev/zero of=$DIR/$tfile count=1 2>/dev/null
8130         cancel_lru_locks osc
8131
8132         som2=$(do_facet $mymds "$LCTL get_param mdt.*.som" |  awk -F= ' {print $2}' | head -n 1)
8133         if [ $som1 == $som2 ]; then
8134             error "som is still "$som2
8135             if [ x$som2 = x"enabled" ]; then
8136                 som2="disabled"
8137             else
8138                 som2="enabled"
8139             fi
8140         fi
8141
8142         gl1=$(get_ost_param "ldlm_glimpse_enqueue")
8143         stat $DIR/$tfile >/dev/null
8144         gl2=$(get_ost_param "ldlm_glimpse_enqueue")
8145         echo "====> SOM is "$som2", "$((gl2 - gl1))" glimpse RPC occured"
8146         som_mode_switch $som2 $gl1 $gl2
8147         MOUNTOPT=$MOUNTOPT_SAVE
8148 }
8149 run_test 132 "som avoids glimpse rpc"
8150
8151 check_stats() {
8152         local res
8153         local count
8154         case $1 in
8155         $SINGLEMDS) res=`do_facet $SINGLEMDS $LCTL get_param mdt.$FSNAME-MDT0000.md_stats | grep "$2"`
8156                  ;;
8157         ost) res=`do_facet ost1 $LCTL get_param obdfilter.$FSNAME-OST0000.stats | grep "$2"`
8158                  ;;
8159         *) error "Wrong argument $1" ;;
8160         esac
8161         echo $res
8162         count=`echo $res | awk '{print $2}'`
8163         [ -z "$res" ] && error "The counter for $2 on $1 was not incremented"
8164         # if the argument $3 is zero, it means any stat increment is ok.
8165         if [ $3 -gt 0 ] ; then
8166                 [ $count -ne $3 ] && error "The $2 counter on $1 is wrong - expected $3"
8167         fi
8168 }
8169
8170 test_133a() {
8171         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8172         remote_ost_nodsh && skip "remote OST with nodsh" && return
8173         remote_mds_nodsh && skip "remote MDS with nodsh" && return
8174
8175         do_facet $SINGLEMDS $LCTL list_param mdt.*.rename_stats ||
8176                 { skip "MDS doesn't support rename stats"; return; }
8177         local testdir=$DIR/${tdir}/stats_testdir
8178         mkdir -p $DIR/${tdir}
8179
8180         # clear stats.
8181         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
8182         do_facet ost1 $LCTL set_param obdfilter.*.stats=clear
8183
8184         # verify mdt stats first.
8185         mkdir ${testdir} || error "mkdir failed"
8186         check_stats $SINGLEMDS "mkdir" 1
8187         touch ${testdir}/${tfile} || "touch failed"
8188         check_stats $SINGLEMDS "open" 1
8189         check_stats $SINGLEMDS "close" 1
8190         mknod ${testdir}/${tfile}-pipe p || "mknod failed"
8191         check_stats $SINGLEMDS "mknod" 1
8192         rm -f ${testdir}/${tfile}-pipe || "pipe remove failed"
8193         check_stats $SINGLEMDS "unlink" 1
8194         rm -f ${testdir}/${tfile} || error "file remove failed"
8195         check_stats $SINGLEMDS "unlink" 2
8196
8197         # remove working dir and check mdt stats again.
8198         rmdir ${testdir} || error "rmdir failed"
8199         check_stats $SINGLEMDS "rmdir" 1
8200
8201         local testdir1=$DIR/${tdir}/stats_testdir1
8202         mkdir -p ${testdir}
8203         mkdir -p ${testdir1}
8204         touch ${testdir1}/test1
8205         mv ${testdir1}/test1 ${testdir} || error "file crossdir rename"
8206         check_stats $SINGLEMDS "crossdir_rename" 1
8207
8208         mv ${testdir}/test1 ${testdir}/test0 || error "file samedir rename"
8209         check_stats $SINGLEMDS "samedir_rename" 1
8210
8211         rm -rf $DIR/${tdir}
8212 }
8213 run_test 133a "Verifying MDT stats ========================================"
8214
8215 test_133b() {
8216         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8217         remote_ost_nodsh && skip "remote OST with nodsh" && return
8218         remote_mds_nodsh && skip "remote MDS with nodsh" && return
8219         local testdir=$DIR/${tdir}/stats_testdir
8220         mkdir -p ${testdir} || error "mkdir failed"
8221         touch ${testdir}/${tfile} || "touch failed"
8222         cancel_lru_locks mdc
8223
8224         # clear stats.
8225         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
8226         do_facet ost1 $LCTL set_param obdfilter.*.stats=clear
8227
8228         # extra mdt stats verification.
8229         chmod 444 ${testdir}/${tfile} || error "chmod failed"
8230         check_stats $SINGLEMDS "setattr" 1
8231         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
8232         if [ $(lustre_version_code $SINGLEMDS) -ne $(version_code 2.2.0) ]
8233         then            # LU-1740
8234                 ls -l ${testdir}/${tfile} > /dev/null|| error "ls failed"
8235                 check_stats $SINGLEMDS "getattr" 1
8236         fi
8237         $LFS df || error "lfs failed"
8238         check_stats $SINGLEMDS "statfs" 1
8239
8240         rm -rf $DIR/${tdir}
8241 }
8242 run_test 133b "Verifying extra MDT stats =================================="
8243
8244 test_133c() {
8245         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8246         remote_ost_nodsh && skip "remote OST with nodsh" && return
8247         remote_mds_nodsh && skip "remote MDS with nodsh" && return
8248         local testdir=$DIR/${tdir}/stats_testdir
8249         test_mkdir -p ${testdir} || error "mkdir failed"
8250
8251         # verify obdfilter stats.
8252         $SETSTRIPE -c 1 -i 0 ${testdir}/${tfile}
8253         sync
8254         cancel_lru_locks osc
8255         wait_delete_completed
8256
8257         # clear stats.
8258         do_facet $SINGLEMDS $LCTL set_param mdt.*.md_stats=clear
8259         do_facet ost1 $LCTL set_param obdfilter.*.stats=clear
8260
8261         dd if=/dev/zero of=${testdir}/${tfile} conv=notrunc bs=512k count=1 || error "dd failed"
8262         sync
8263         cancel_lru_locks osc
8264         check_stats ost "write" 1
8265
8266         dd if=${testdir}/${tfile} of=/dev/null bs=1k count=1 || error "dd failed"
8267         check_stats ost "read" 1
8268
8269         > ${testdir}/${tfile} || error "truncate failed"
8270         check_stats ost "punch" 1
8271
8272         rm -f ${testdir}/${tfile} || error "file remove failed"
8273         wait_delete_completed
8274         check_stats ost "destroy" 1
8275
8276         rm -rf $DIR/${tdir}
8277 }
8278 run_test 133c "Verifying OST stats ========================================"
8279
8280 order_2() {
8281     local value=$1
8282     local orig=$value
8283     local order=1
8284
8285     while [ $value -ge 2 ]; do
8286         order=$((order*2))
8287         value=$((value/2))
8288     done
8289
8290     if [ $orig -gt $order ]; then
8291         order=$((order*2))
8292     fi
8293     echo $order
8294 }
8295
8296 size_in_KMGT() {
8297     local value=$1
8298     local size=('K' 'M' 'G' 'T');
8299     local i=0
8300     local size_string=$value
8301
8302     while [ $value -ge 1024 ]; do
8303         if [ $i -gt 3 ]; then
8304             #T is the biggest unit we get here, if that is bigger,
8305             #just return XXXT
8306             size_string=${value}T
8307             break
8308         fi
8309         value=$((value >> 10))
8310         if [ $value -lt 1024 ]; then
8311             size_string=${value}${size[$i]}
8312             break
8313         fi
8314         i=$((i + 1))
8315     done
8316
8317     echo $size_string
8318 }
8319
8320 get_rename_size() {
8321     local size=$1
8322     local context=${2:-.}
8323     local sample=$(do_facet $SINGLEMDS $LCTL get_param mdt.*.rename_stats |
8324                 grep -A1 $context |
8325                 awk '/ '${size}'/ {print $4}' | sed -e "s/,//g")
8326     echo $sample
8327 }
8328
8329 test_133d() {
8330         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8331         remote_ost_nodsh && skip "remote OST with nodsh" && return
8332         remote_mds_nodsh && skip "remote MDS with nodsh" && return
8333         do_facet $SINGLEMDS $LCTL list_param mdt.*.rename_stats ||
8334         { skip "MDS doesn't support rename stats"; return; }
8335
8336         local testdir1=$DIR/${tdir}/stats_testdir1
8337         local testdir2=$DIR/${tdir}/stats_testdir2
8338
8339         do_facet $SINGLEMDS $LCTL set_param mdt.*.rename_stats=clear
8340
8341         mkdir -p ${testdir1} || error "mkdir failed"
8342         mkdir -p ${testdir2} || error "mkdir failed"
8343
8344         createmany -o $testdir1/test 512 || error "createmany failed"
8345
8346         # check samedir rename size
8347         mv ${testdir1}/test0 ${testdir1}/test_0
8348
8349         local testdir1_size=$(ls -l $DIR/${tdir} |
8350                 awk '/stats_testdir1/ {print $5}')
8351         local testdir2_size=$(ls -l $DIR/${tdir} |
8352                 awk '/stats_testdir2/ {print $5}')
8353
8354         testdir1_size=$(order_2 $testdir1_size)
8355         testdir2_size=$(order_2 $testdir2_size)
8356
8357         testdir1_size=$(size_in_KMGT $testdir1_size)
8358         testdir2_size=$(size_in_KMGT $testdir2_size)
8359
8360         echo "source rename dir size: ${testdir1_size}"
8361         echo "target rename dir size: ${testdir2_size}"
8362
8363         local cmd="do_facet $SINGLEMDS $LCTL get_param mdt.*.rename_stats"
8364         eval $cmd || error "$cmd failed"
8365         local samedir=$($cmd | grep 'same_dir')
8366         local same_sample=$(get_rename_size $testdir1_size)
8367         [ -z "$samedir" ] && error "samedir_rename_size count error"
8368         [ "$same_sample" -eq 1 ] || error "samedir_rename_size error $same_sample"
8369         echo "Check same dir rename stats success"
8370
8371         do_facet $SINGLEMDS $LCTL set_param mdt.*.rename_stats=clear
8372
8373         # check crossdir rename size
8374         mv ${testdir1}/test_0 ${testdir2}/test_0
8375
8376         testdir1_size=$(ls -l $DIR/${tdir} |
8377                 awk '/stats_testdir1/ {print $5}')
8378         testdir2_size=$(ls -l $DIR/${tdir} |
8379                 awk '/stats_testdir2/ {print $5}')
8380
8381         testdir1_size=$(order_2 $testdir1_size)
8382         testdir2_size=$(order_2 $testdir2_size)
8383
8384         testdir1_size=$(size_in_KMGT $testdir1_size)
8385         testdir2_size=$(size_in_KMGT $testdir2_size)
8386
8387         echo "source rename dir size: ${testdir1_size}"
8388         echo "target rename dir size: ${testdir2_size}"
8389
8390         eval $cmd || error "$cmd failed"
8391         local crossdir=$($cmd | grep 'crossdir')
8392         local src_sample=$(get_rename_size $testdir1_size crossdir_src)
8393         local tgt_sample=$(get_rename_size $testdir2_size crossdir_tgt)
8394         [ -z "$crossdir" ] && error "crossdir_rename_size count error"
8395         [ "$src_sample" -eq 1 ] || error "crossdir_rename_size error $src_sample"
8396         [ "$tgt_sample" -eq 1 ] || error "crossdir_rename_size error $tgt_sample"
8397         echo "Check cross dir rename stats success"
8398         rm -rf $DIR/${tdir}
8399 }
8400 run_test 133d "Verifying rename_stats ========================================"
8401
8402 test_133e() {
8403         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8404         local testdir=$DIR/${tdir}/stats_testdir
8405         local ctr f0 f1 bs=32768 count=42 sum
8406
8407         remote_ost_nodsh && skip "remote OST with nodsh" && return
8408         mkdir -p ${testdir} || error "mkdir failed"
8409
8410         $SETSTRIPE -c 1 -i 0 ${testdir}/${tfile}
8411
8412         for ctr in {write,read}_bytes; do
8413                 sync
8414                 cancel_lru_locks osc
8415
8416                 do_facet ost1 $LCTL set_param -n \
8417                         "obdfilter.*.exports.clear=clear"
8418
8419                 if [ $ctr = write_bytes ]; then
8420                         f0=/dev/zero
8421                         f1=${testdir}/${tfile}
8422                 else
8423                         f0=${testdir}/${tfile}
8424                         f1=/dev/null
8425                 fi
8426
8427                 dd if=$f0 of=$f1 conv=notrunc bs=$bs count=$count || \
8428                         error "dd failed"
8429                 sync
8430                 cancel_lru_locks osc
8431
8432                 sum=$(do_facet ost1 $LCTL get_param \
8433                                 "obdfilter.*.exports.*.stats" | \
8434                           awk -v ctr=$ctr '\
8435                                 BEGIN { sum = 0 }
8436                                 $1 == ctr { sum += $7 }
8437                                 END { print sum }')
8438
8439                 if ((sum != bs * count)); then
8440                         error "Bad $ctr sum, expected $((bs * count)), got $sum"
8441                 fi
8442         done
8443
8444         rm -rf $DIR/${tdir}
8445 }
8446 run_test 133e "Verifying OST {read,write}_bytes nid stats ================="
8447
8448 test_133f() {
8449         local proc_dirs="/proc/fs/lustre/ /proc/sys/lnet/ /proc/sys/lustre/"
8450         local facet
8451
8452         # First without trusting modes.
8453         find $proc_dirs \
8454                 -exec cat '{}' \; &> /dev/null
8455
8456         # Second verifying readability.
8457         find $proc_dirs \
8458                 -type f \
8459                 -readable \
8460                 -exec cat '{}' \; > /dev/null ||
8461                         error "proc file read failed"
8462
8463         for facet in $SINGLEMDS ost1; do
8464                 do_facet $facet find $proc_dirs \
8465                         -not -name req_history \
8466                         -exec cat '{}' \\\; &> /dev/null
8467
8468             do_facet $facet     find $proc_dirs \
8469                         -not -name req_history \
8470                         -type f \
8471                         -readable \
8472                         -exec cat '{}' \\\; > /dev/null ||
8473                                 error "proc file read failed"
8474         done
8475 }
8476 run_test 133f "Check for LBUGs/Oopses/unreadable files in /proc"
8477
8478 test_140() { #bug-17379
8479         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8480         test_mkdir -p $DIR/$tdir || error "Creating dir $DIR/$tdir"
8481         cd $DIR/$tdir || error "Changing to $DIR/$tdir"
8482         cp /usr/bin/stat . || error "Copying stat to $DIR/$tdir"
8483
8484         # VFS limits max symlink depth to 5(4KSTACK) or 7(8KSTACK) or 8
8485         # For kernel > 3.5, bellow only tests consecutive symlink (MAX 40)
8486         local i=0
8487         while i=`expr $i + 1`; do
8488                 test_mkdir -p $i || error "Creating dir $i"
8489                 cd $i || error "Changing to $i"
8490                 ln -s ../stat stat || error "Creating stat symlink"
8491                 # Read the symlink until ELOOP present,
8492                 # not LBUGing the system is considered success,
8493                 # we didn't overrun the stack.
8494                 $OPENFILE -f O_RDONLY stat >/dev/null 2>&1; ret=$?
8495                 [ $ret -ne 0 ] && {
8496                         if [ $ret -eq 40 ]; then
8497                                 break  # -ELOOP
8498                         else
8499                                 error "Open stat symlink"
8500                                 return
8501                         fi
8502                 }
8503         done
8504         i=`expr $i - 1`
8505         echo "The symlink depth = $i"
8506         [ $i -eq 5 -o $i -eq 7 -o $i -eq 8 -o $i -eq 40 ] ||
8507                                         error "Invalid symlink depth"
8508
8509         # Test recursive symlink
8510         ln -s symlink_self symlink_self
8511         $OPENFILE -f O_RDONLY symlink_self >/dev/null 2>&1; ret=$?
8512         echo "open symlink_self returns $ret"
8513         [ $ret -eq 40 ] || error "recursive symlink doesn't return -ELOOP"
8514 }
8515 run_test 140 "Check reasonable stack depth (shouldn't LBUG) ===="
8516
8517 test_150() {
8518         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8519         local TF="$TMP/$tfile"
8520
8521         dd if=/dev/urandom of=$TF bs=6096 count=1 || error "dd failed"
8522         cp $TF $DIR/$tfile
8523         cancel_lru_locks osc
8524         cmp $TF $DIR/$tfile || error "$TMP/$tfile $DIR/$tfile differ"
8525         remount_client $MOUNT
8526         df -P $MOUNT
8527         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (remount)"
8528
8529         $TRUNCATE $TF 6000
8530         $TRUNCATE $DIR/$tfile 6000
8531         cancel_lru_locks osc
8532         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (truncate1)"
8533
8534         echo "12345" >>$TF
8535         echo "12345" >>$DIR/$tfile
8536         cancel_lru_locks osc
8537         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (append1)"
8538
8539         echo "12345" >>$TF
8540         echo "12345" >>$DIR/$tfile
8541         cancel_lru_locks osc
8542         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (append2)"
8543
8544         rm -f $TF
8545         true
8546 }
8547 run_test 150 "truncate/append tests"
8548
8549 function roc_hit() {
8550         local list=$(comma_list $(osts_nodes))
8551         #debug temp debug for LU-2902: lets see what values we get back
8552         echo $(get_osd_param $list '' stats) 1>&2
8553         echo $(get_osd_param $list '' stats |
8554                awk '/'cache_hit'/ {sum+=$2} END {print sum}')
8555 }
8556
8557 function set_cache() {
8558         local on=1
8559
8560         if [ "$2" == "off" ]; then
8561                 on=0;
8562         fi
8563         local list=$(comma_list $(osts_nodes))
8564         set_osd_param $list '' $1_cache_enable $on
8565
8566         cancel_lru_locks osc
8567 }
8568
8569 test_151() {
8570         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8571         remote_ost_nodsh && skip "remote OST with nodsh" && return
8572
8573         local CPAGES=3
8574         local list=$(comma_list $(osts_nodes))
8575
8576         # check whether obdfilter is cache capable at all
8577         if ! get_osd_param $list '' read_cache_enable >/dev/null; then
8578                 echo "not cache-capable obdfilter"
8579                 return 0
8580         fi
8581
8582         # check cache is enabled on all obdfilters
8583         if get_osd_param $list '' read_cache_enable | grep 0; then
8584                 echo "oss cache is disabled"
8585                 return 0
8586         fi
8587
8588         set_osd_param $list '' writethrough_cache_enable 1
8589
8590         # check write cache is enabled on all obdfilters
8591         if get_osd_param $list '' writethrough_cache_enable | grep 0; then
8592                 echo "oss write cache is NOT enabled"
8593                 return 0
8594         fi
8595
8596 #define OBD_FAIL_OBD_NO_LRU  0x609
8597         do_nodes $list $LCTL set_param fail_loc=0x609
8598
8599         # pages should be in the case right after write
8600         dd if=/dev/urandom of=$DIR/$tfile bs=4k count=$CPAGES ||
8601                 error "dd failed"
8602
8603         local BEFORE=`roc_hit`
8604         cancel_lru_locks osc
8605         cat $DIR/$tfile >/dev/null
8606         local AFTER=`roc_hit`
8607
8608         do_nodes $list $LCTL set_param fail_loc=0
8609
8610         if ! let "AFTER - BEFORE == CPAGES"; then
8611                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
8612         fi
8613
8614         # the following read invalidates the cache
8615         cancel_lru_locks osc
8616         set_osd_param $list '' read_cache_enable 0
8617         cat $DIR/$tfile >/dev/null
8618
8619         # now data shouldn't be found in the cache
8620         BEFORE=`roc_hit`
8621         cancel_lru_locks osc
8622         cat $DIR/$tfile >/dev/null
8623         AFTER=`roc_hit`
8624         if let "AFTER - BEFORE != 0"; then
8625                 error "IN CACHE: before: $BEFORE, after: $AFTER"
8626         fi
8627
8628         set_osd_param $list '' read_cache_enable 1
8629         rm -f $DIR/$tfile
8630 }
8631 run_test 151 "test cache on oss and controls ==============================="
8632
8633 test_152() {
8634         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8635         local TF="$TMP/$tfile"
8636
8637         # simulate ENOMEM during write
8638 #define OBD_FAIL_OST_NOMEM      0x226
8639         lctl set_param fail_loc=0x80000226
8640         dd if=/dev/urandom of=$TF bs=6096 count=1 || error "dd failed"
8641         cp $TF $DIR/$tfile
8642         sync || error "sync failed"
8643         lctl set_param fail_loc=0
8644
8645         # discard client's cache
8646         cancel_lru_locks osc
8647
8648         # simulate ENOMEM during read
8649         lctl set_param fail_loc=0x80000226
8650         cmp $TF $DIR/$tfile || error "cmp failed"
8651         lctl set_param fail_loc=0
8652
8653         rm -f $TF
8654 }
8655 run_test 152 "test read/write with enomem ============================"
8656
8657 test_153() {
8658         $MULTIOP $DIR/$tfile Ow4096Ycu || error "multiop failed"
8659 }
8660 run_test 153 "test if fdatasync does not crash ======================="
8661
8662 dot_lustre_fid_permission_check() {
8663         local fid=$1
8664         local ffid=$MOUNT/.lustre/fid/$fid
8665         local test_dir=$2
8666
8667         echo "stat fid $fid"
8668         stat $ffid > /dev/null || error "stat $ffid failed."
8669         echo "touch fid $fid"
8670         touch $ffid || error "touch $ffid failed."
8671         echo "write to fid $fid"
8672         cat /etc/hosts > $ffid || error "write $ffid failed."
8673         echo "read fid $fid"
8674         diff /etc/hosts $ffid || error "read $ffid failed."
8675         echo "append write to fid $fid"
8676         cat /etc/hosts >> $ffid || error "append write $ffid failed."
8677         echo "rename fid $fid"
8678         mv $ffid $test_dir/$tfile.1 &&
8679                 error "rename $ffid to $tfile.1 should fail."
8680         touch $test_dir/$tfile.1
8681         mv $test_dir/$tfile.1 $ffid &&
8682                 error "rename $tfile.1 to $ffid should fail."
8683         rm -f $test_dir/$tfile.1
8684         echo "truncate fid $fid"
8685         $TRUNCATE $ffid 777 || error "truncate $ffid failed."
8686         echo "link fid $fid"
8687         ln -f $ffid $test_dir/tfile.lnk || error "link $ffid failed."
8688         if [ -n $(lctl get_param -n mdc.*-mdc-*.connect_flags | grep acl) ]; then
8689                 echo "setfacl fid $fid"
8690                 setfacl -R -m u:bin:rwx $ffid || error "setfacl $ffid failed."
8691                 echo "getfacl fid $fid"
8692                 getfacl $ffid >/dev/null || error "getfacl $ffid failed."
8693         fi
8694         echo "unlink fid $fid"
8695         unlink $MOUNT/.lustre/fid/$fid && error "unlink $ffid should fail."
8696         echo "mknod fid $fid"
8697         mknod $ffid c 1 3 && error "mknod $ffid should fail."
8698
8699         fid=[0xf00000400:0x1:0x0]
8700         ffid=$MOUNT/.lustre/fid/$fid
8701
8702         echo "stat non-exist fid $fid"
8703         stat $ffid > /dev/null && error "stat non-exist $ffid should fail."
8704         echo "write to non-exist fid $fid"
8705         cat /etc/hosts > $ffid && error "write non-exist $ffid should fail."
8706         echo "link new fid $fid"
8707         ln $test_dir/$tfile $ffid && error "link $ffid should fail."
8708
8709         mkdir -p $test_dir/$tdir
8710         touch $test_dir/$tdir/$tfile
8711         fid=$($LFS path2fid $test_dir/$tdir)
8712         rc=$?
8713         [ $rc -ne 0 ] &&
8714                 error "error: could not get fid for $test_dir/$dir/$tfile."
8715
8716         ffid=$MOUNT/.lustre/fid/$fid
8717
8718         echo "ls $fid"
8719         ls $ffid > /dev/null || error "ls $ffid failed."
8720         echo "touch $fid/$tfile.1"
8721         touch $ffid/$tfile.1 || error "touch $ffid/$tfile.1 failed."
8722
8723         echo "touch $MOUNT/.lustre/fid/$tfile"
8724         touch $MOUNT/.lustre/fid/$tfile && \
8725                 error "touch $MOUNT/.lustre/fid/$tfile should fail."
8726
8727         echo "setxattr to $MOUNT/.lustre/fid"
8728         setfattr -n trusted.name1 -v value1 $MOUNT/.lustre/fid
8729
8730         echo "listxattr for $MOUNT/.lustre/fid"
8731         getfattr -d -m "^trusted" $MOUNT/.lustre/fid
8732
8733         echo "delxattr from $MOUNT/.lustre/fid"
8734         setfattr -x trusted.name1 $MOUNT/.lustre/fid
8735
8736         echo "touch invalid fid: $MOUNT/.lustre/fid/[0x200000400:0x2:0x3]"
8737         touch $MOUNT/.lustre/fid/[0x200000400:0x2:0x3] &&
8738                 error "touch invalid fid should fail."
8739
8740         echo "touch non-normal fid: $MOUNT/.lustre/fid/[0x1:0x2:0x0]"
8741         touch $MOUNT/.lustre/fid/[0x1:0x2:0x0] &&
8742                 error "touch non-normal fid should fail."
8743
8744         echo "rename $tdir to $MOUNT/.lustre/fid"
8745         mrename $test_dir/$tdir $MOUNT/.lustre/fid &&
8746                 error "rename to $MOUNT/.lustre/fid should fail."
8747
8748         echo "rename .lustre to itself"
8749         fid=$($LFS path2fid $MOUNT)
8750         mrename $MOUNT/.lustre $MOUNT/.lustre/fid/$fid/.lustre &&
8751                 error "rename .lustre to itself should fail."
8752
8753         local old_obf_mode=$(stat --format="%a" $DIR/.lustre/fid)
8754         local new_obf_mode=777
8755
8756         echo "change mode of $DIR/.lustre/fid to $new_obf_mode"
8757         chmod $new_obf_mode $DIR/.lustre/fid ||
8758                 error "chmod $new_obf_mode $DIR/.lustre/fid failed"
8759
8760         local obf_mode=$(stat --format=%a $DIR/.lustre/fid)
8761         [ $obf_mode -eq $new_obf_mode ] ||
8762                 error "stat $DIR/.lustre/fid returned wrong mode $obf_mode"
8763
8764         echo "restore mode of $DIR/.lustre/fid to $old_obf_mode"
8765         chmod $old_obf_mode $DIR/.lustre/fid ||
8766                 error "chmod $old_obf_mode $DIR/.lustre/fid failed"
8767
8768         $OPENFILE -f O_LOV_DELAY_CREATE:O_CREAT $test_dir/$tfile-2
8769         fid=$($LFS path2fid $test_dir/$tfile-2)
8770         echo "cp /etc/passwd $MOUNT/.lustre/fid/$fid"
8771         cp /etc/passwd $MOUNT/.lustre/fid/$fid &&
8772                 error "create lov data thru .lustre should fail."
8773         echo "cp /etc/passwd $test_dir/$tfile-2"
8774         cp /etc/passwd $test_dir/$tfile-2 ||
8775                 error "copy to $test_dir/$tfile-2 failed."
8776         echo "diff /etc/passwd $MOUNT/.lustre/fid/$fid"
8777         diff /etc/passwd $MOUNT/.lustre/fid/$fid ||
8778                 error "diff /etc/passwd $MOUNT/.lustre/fid/$fid failed."
8779
8780         rm -rf $test_dir/tfile.lnk
8781         rm -rf $test_dir/$tfile-2
8782 }
8783
8784 test_154a() {
8785         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8786         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.51) ]] ||
8787                 { skip "Need MDS version at least 2.2.51"; return 0; }
8788
8789         cp /etc/hosts $DIR/$tfile
8790
8791         fid=$($LFS path2fid $DIR/$tfile)
8792         rc=$?
8793         [ $rc -ne 0 ] && error "error: could not get fid for $DIR/$tfile."
8794
8795         dot_lustre_fid_permission_check "$fid" $DIR ||
8796                 error "dot lustre permission check $fid failed"
8797
8798         rm -rf $MOUNT/.lustre && error ".lustre is not allowed to be unlinked"
8799
8800         touch $MOUNT/.lustre/file &&
8801                 error "creation is not allowed under .lustre"
8802
8803         mkdir $MOUNT/.lustre/dir &&
8804                 error "mkdir is not allowed under .lustre"
8805
8806         rm -rf $DIR/$tfile
8807 }
8808 run_test 154a "Open-by-FID"
8809
8810 test_154b() {
8811         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8812         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.51) ]] ||
8813                 { skip "Need MDS version at least 2.2.51"; return 0; }
8814
8815         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
8816
8817         local remote_dir=$DIR/$tdir/remote_dir
8818         local MDTIDX=1
8819         local rc=0
8820
8821         mkdir -p $DIR/$tdir
8822         $LFS mkdir -i $MDTIDX $remote_dir ||
8823                 error "create remote directory failed"
8824
8825         cp /etc/hosts $remote_dir/$tfile
8826
8827         fid=$($LFS path2fid $remote_dir/$tfile)
8828         rc=$?
8829         [ $rc -ne 0 ] && error "error: could not get fid for $remote_dir/$tfile"
8830
8831         dot_lustre_fid_permission_check "$fid" $remote_dir ||
8832                 error "dot lustre permission check $fid failed"
8833         rm -rf $DIR/$tdir
8834 }
8835 run_test 154b "Open-by-FID for remote directory"
8836
8837 test_155_small_load() {
8838     local temp=$TMP/$tfile
8839     local file=$DIR/$tfile
8840
8841     dd if=/dev/urandom of=$temp bs=6096 count=1 || \
8842         error "dd of=$temp bs=6096 count=1 failed"
8843     cp $temp $file
8844     cancel_lru_locks osc
8845     cmp $temp $file || error "$temp $file differ"
8846
8847     $TRUNCATE $temp 6000
8848     $TRUNCATE $file 6000
8849     cmp $temp $file || error "$temp $file differ (truncate1)"
8850
8851     echo "12345" >>$temp
8852     echo "12345" >>$file
8853     cmp $temp $file || error "$temp $file differ (append1)"
8854
8855     echo "12345" >>$temp
8856     echo "12345" >>$file
8857     cmp $temp $file || error "$temp $file differ (append2)"
8858
8859     rm -f $temp $file
8860     true
8861 }
8862
8863 test_155_big_load() {
8864     remote_ost_nodsh && skip "remote OST with nodsh" && return
8865     local temp=$TMP/$tfile
8866     local file=$DIR/$tfile
8867
8868     free_min_max
8869     local cache_size=$(do_facet ost$((MAXI+1)) \
8870         "awk '/cache/ {sum+=\\\$4} END {print sum}' /proc/cpuinfo")
8871     local large_file_size=$((cache_size * 2))
8872
8873     echo "OSS cache size: $cache_size KB"
8874     echo "Large file size: $large_file_size KB"
8875
8876     [ $MAXV -le $large_file_size ] && \
8877         skip_env "max available OST size needs > $large_file_size KB" && \
8878         return 0
8879
8880     $SETSTRIPE $file -c 1 -i $MAXI || error "$SETSTRIPE $file failed"
8881
8882     dd if=/dev/urandom of=$temp bs=$large_file_size count=1k || \
8883         error "dd of=$temp bs=$large_file_size count=1k failed"
8884     cp $temp $file
8885     ls -lh $temp $file
8886     cancel_lru_locks osc
8887     cmp $temp $file || error "$temp $file differ"
8888
8889     rm -f $temp $file
8890     true
8891 }
8892
8893 test_155a() {
8894         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8895         set_cache read on
8896         set_cache writethrough on
8897         test_155_small_load
8898 }
8899 run_test 155a "Verify small file correctness: read cache:on write_cache:on"
8900
8901 test_155b() {
8902         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8903         set_cache read on
8904         set_cache writethrough off
8905         test_155_small_load
8906 }
8907 run_test 155b "Verify small file correctness: read cache:on write_cache:off"
8908
8909 test_155c() {
8910         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8911         set_cache read off
8912         set_cache writethrough on
8913         test_155_small_load
8914 }
8915 run_test 155c "Verify small file correctness: read cache:off write_cache:on"
8916
8917 test_155d() {
8918         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8919         set_cache read off
8920         set_cache writethrough off
8921         test_155_small_load
8922 }
8923 run_test 155d "Verify small file correctness: read cache:off write_cache:off"
8924
8925 test_155e() {
8926         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8927         set_cache read on
8928         set_cache writethrough on
8929         test_155_big_load
8930 }
8931 run_test 155e "Verify big file correctness: read cache:on write_cache:on"
8932
8933 test_155f() {
8934         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8935         set_cache read on
8936         set_cache writethrough off
8937         test_155_big_load
8938 }
8939 run_test 155f "Verify big file correctness: read cache:on write_cache:off"
8940
8941 test_155g() {
8942         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8943         set_cache read off
8944         set_cache writethrough on
8945         test_155_big_load
8946 }
8947 run_test 155g "Verify big file correctness: read cache:off write_cache:on"
8948
8949 test_155h() {
8950         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8951         set_cache read off
8952         set_cache writethrough off
8953         test_155_big_load
8954 }
8955 run_test 155h "Verify big file correctness: read cache:off write_cache:off"
8956
8957 test_156() {
8958         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
8959         local CPAGES=3
8960         local BEFORE
8961         local AFTER
8962         local file="$DIR/$tfile"
8963
8964         [ "$(facet_fstype ost1)" = "zfs" ] &&
8965                 skip "LU-1956/LU-2261: stats unimplemented on OSD ZFS" &&
8966                 return
8967
8968     log "Turn on read and write cache"
8969     set_cache read on
8970     set_cache writethrough on
8971
8972     log "Write data and read it back."
8973     log "Read should be satisfied from the cache."
8974     dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
8975     BEFORE=`roc_hit`
8976     cancel_lru_locks osc
8977     cat $file >/dev/null
8978     AFTER=`roc_hit`
8979     if ! let "AFTER - BEFORE == CPAGES"; then
8980         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
8981     else
8982         log "cache hits:: before: $BEFORE, after: $AFTER"
8983     fi
8984
8985     log "Read again; it should be satisfied from the cache."
8986     BEFORE=$AFTER
8987     cancel_lru_locks osc
8988     cat $file >/dev/null
8989     AFTER=`roc_hit`
8990     if ! let "AFTER - BEFORE == CPAGES"; then
8991         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
8992     else
8993         log "cache hits:: before: $BEFORE, after: $AFTER"
8994     fi
8995
8996
8997     log "Turn off the read cache and turn on the write cache"
8998     set_cache read off
8999     set_cache writethrough on
9000
9001     log "Read again; it should be satisfied from the cache."
9002     BEFORE=`roc_hit`
9003     cancel_lru_locks osc
9004     cat $file >/dev/null
9005     AFTER=`roc_hit`
9006     if ! let "AFTER - BEFORE == CPAGES"; then
9007         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
9008     else
9009         log "cache hits:: before: $BEFORE, after: $AFTER"
9010     fi
9011
9012     log "Read again; it should not be satisfied from the cache."
9013     BEFORE=$AFTER
9014     cancel_lru_locks osc
9015     cat $file >/dev/null
9016     AFTER=`roc_hit`
9017     if ! let "AFTER - BEFORE == 0"; then
9018         error "IN CACHE: before: $BEFORE, after: $AFTER"
9019     else
9020         log "cache hits:: before: $BEFORE, after: $AFTER"
9021     fi
9022
9023     log "Write data and read it back."
9024     log "Read should be satisfied from the cache."
9025     dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
9026     BEFORE=`roc_hit`
9027     cancel_lru_locks osc
9028     cat $file >/dev/null
9029     AFTER=`roc_hit`
9030     if ! let "AFTER - BEFORE == CPAGES"; then
9031         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
9032     else
9033         log "cache hits:: before: $BEFORE, after: $AFTER"
9034     fi
9035
9036     log "Read again; it should not be satisfied from the cache."
9037     BEFORE=$AFTER
9038     cancel_lru_locks osc
9039     cat $file >/dev/null
9040     AFTER=`roc_hit`
9041     if ! let "AFTER - BEFORE == 0"; then
9042         error "IN CACHE: before: $BEFORE, after: $AFTER"
9043     else
9044         log "cache hits:: before: $BEFORE, after: $AFTER"
9045     fi
9046
9047
9048     log "Turn off read and write cache"
9049     set_cache read off
9050     set_cache writethrough off
9051
9052     log "Write data and read it back"
9053     log "It should not be satisfied from the cache."
9054     rm -f $file
9055     dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
9056     cancel_lru_locks osc
9057     BEFORE=`roc_hit`
9058     cat $file >/dev/null
9059     AFTER=`roc_hit`
9060     if ! let "AFTER - BEFORE == 0"; then
9061         error_ignore 20762 "IN CACHE: before: $BEFORE, after: $AFTER"
9062     else
9063         log "cache hits:: before: $BEFORE, after: $AFTER"
9064     fi
9065
9066
9067     log "Turn on the read cache and turn off the write cache"
9068     set_cache read on
9069     set_cache writethrough off
9070
9071     log "Write data and read it back"
9072     log "It should not be satisfied from the cache."
9073     rm -f $file
9074     dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
9075     BEFORE=`roc_hit`
9076     cancel_lru_locks osc
9077     cat $file >/dev/null
9078     AFTER=`roc_hit`
9079     if ! let "AFTER - BEFORE == 0"; then
9080         error_ignore 20762 "IN CACHE: before: $BEFORE, after: $AFTER"
9081     else
9082         log "cache hits:: before: $BEFORE, after: $AFTER"
9083     fi
9084
9085     log "Read again; it should be satisfied from the cache."
9086     BEFORE=`roc_hit`
9087     cancel_lru_locks osc
9088     cat $file >/dev/null
9089     AFTER=`roc_hit`
9090     if ! let "AFTER - BEFORE == CPAGES"; then
9091         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
9092     else
9093         log "cache hits:: before: $BEFORE, after: $AFTER"
9094     fi
9095
9096     rm -f $file
9097 }
9098 run_test 156 "Verification of tunables ============================"
9099
9100 #Changelogs
9101 err17935 () {
9102     if [ $MDSCOUNT -gt 1 ]; then
9103         error_ignore 17935 $*
9104     else
9105         error $*
9106     fi
9107 }
9108
9109 changelog_chmask()
9110 {
9111     MASK=$(do_facet $SINGLEMDS $LCTL get_param mdd.$MDT0.changelog_mask |\
9112            grep -c $1)
9113
9114     if [ $MASK -eq 1 ]; then
9115         do_facet $SINGLEMDS $LCTL set_param mdd.$MDT0.changelog_mask="-$1"
9116     else
9117         do_facet $SINGLEMDS $LCTL set_param mdd.$MDT0.changelog_mask="+$1"
9118     fi
9119 }
9120
9121 test_160() {
9122         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9123     remote_mds_nodsh && skip "remote MDS with nodsh" && return
9124     [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.0) ] ||
9125         { skip "Need MDS version at least 2.2.0"; return; }
9126     USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_register -n)
9127     echo "Registered as changelog user $USER"
9128     do_facet $SINGLEMDS $LCTL get_param -n mdd.$MDT0.changelog_users | \
9129         grep -q $USER || error "User $USER not found in changelog_users"
9130
9131     # change something
9132     test_mkdir -p $DIR/$tdir/pics/2008/zachy
9133     touch $DIR/$tdir/pics/2008/zachy/timestamp
9134     cp /etc/hosts $DIR/$tdir/pics/2008/zachy/pic1.jpg
9135     mv $DIR/$tdir/pics/2008/zachy $DIR/$tdir/pics/zach
9136     ln $DIR/$tdir/pics/zach/pic1.jpg $DIR/$tdir/pics/2008/portland.jpg
9137     ln -s $DIR/$tdir/pics/2008/portland.jpg $DIR/$tdir/pics/desktop.jpg
9138     rm $DIR/$tdir/pics/desktop.jpg
9139
9140     $LFS changelog $MDT0 | tail -5
9141
9142     echo "verifying changelog mask"
9143     changelog_chmask "MKDIR"
9144     changelog_chmask "CLOSE"
9145
9146     test_mkdir -p $DIR/$tdir/pics/zach/sofia
9147     echo "zzzzzz" > $DIR/$tdir/pics/zach/file
9148
9149     changelog_chmask "MKDIR"
9150     changelog_chmask "CLOSE"
9151
9152     test_mkdir -p $DIR/$tdir/pics/2008/sofia
9153     echo "zzzzzz" > $DIR/$tdir/pics/zach/file
9154
9155     $LFS changelog $MDT0
9156     MKDIRS=$($LFS changelog $MDT0 | tail -5 | grep -c "MKDIR")
9157     CLOSES=$($LFS changelog $MDT0 | tail -5 | grep -c "CLOSE")
9158     [ $MKDIRS -eq 1 ] || err17935 "MKDIR changelog mask count $DIRS != 1"
9159     [ $CLOSES -eq 1 ] || err17935 "CLOSE changelog mask count $DIRS != 1"
9160
9161     # verify contents
9162     echo "verifying target fid"
9163     fidc=$($LFS changelog $MDT0 | grep timestamp | grep "CREAT" | \
9164         tail -1 | awk '{print $6}')
9165     fidf=$($LFS path2fid $DIR/$tdir/pics/zach/timestamp)
9166     [ "$fidc" == "t=$fidf" ] || \
9167         err17935 "fid in changelog $fidc != file fid $fidf"
9168     echo "verifying parent fid"
9169     fidc=$($LFS changelog $MDT0 | grep timestamp | grep "CREAT" | \
9170         tail -1 | awk '{print $7}')
9171     fidf=$($LFS path2fid $DIR/$tdir/pics/zach)
9172     [ "$fidc" == "p=$fidf" ] || \
9173         err17935 "pfid in changelog $fidc != dir fid $fidf"
9174
9175     USER_REC1=$(do_facet $SINGLEMDS $LCTL get_param -n \
9176         mdd.$MDT0.changelog_users | grep $USER | awk '{print $2}')
9177     $LFS changelog_clear $MDT0 $USER $(($USER_REC1 + 5))
9178     USER_REC2=$(do_facet $SINGLEMDS $LCTL get_param -n \
9179         mdd.$MDT0.changelog_users | grep $USER | awk '{print $2}')
9180     echo "verifying user clear: $(( $USER_REC1 + 5 )) == $USER_REC2"
9181     [ $USER_REC2 == $(($USER_REC1 + 5)) ] || \
9182         err17935 "user index should be $(($USER_REC1 + 5)); is $USER_REC2"
9183
9184     MIN_REC=$(do_facet $SINGLEMDS $LCTL get_param mdd.$MDT0.changelog_users | \
9185         awk 'min == "" || $2 < min {min = $2}; END {print min}')
9186     FIRST_REC=$($LFS changelog $MDT0 | head -1 | awk '{print $1}')
9187     echo "verifying min purge: $(( $MIN_REC + 1 )) == $FIRST_REC"
9188     [ $FIRST_REC == $(($MIN_REC + 1)) ] || \
9189         err17935 "first index should be $(($MIN_REC + 1)); is $FIRST_REC"
9190
9191     echo "verifying user deregister"
9192     do_facet $SINGLEMDS $LCTL --device $MDT0 changelog_deregister $USER
9193     do_facet $SINGLEMDS $LCTL get_param -n mdd.$MDT0.changelog_users | \
9194         grep -q $USER && error "User $USER still found in changelog_users"
9195
9196     USERS=$(( $(do_facet $SINGLEMDS $LCTL get_param -n \
9197         mdd.$MDT0.changelog_users | wc -l) - 2 ))
9198     if [ $USERS -eq 0 ]; then
9199         LAST_REC1=$(do_facet $SINGLEMDS $LCTL get_param -n \
9200             mdd.$MDT0.changelog_users | head -1 | awk '{print $3}')
9201         touch $DIR/$tdir/chloe
9202         LAST_REC2=$(do_facet $SINGLEMDS $LCTL get_param -n \
9203             mdd.$MDT0.changelog_users | head -1 | awk '{print $3}')
9204         echo "verify changelogs are off if we were the only user: $LAST_REC1 == $LAST_REC2"
9205         [ $LAST_REC1 == $LAST_REC2 ] || error "changelogs not off"
9206     else
9207         echo "$USERS other changelog users; can't verify off"
9208     fi
9209 }
9210 run_test 160 "changelog sanity"
9211
9212 test_161a() {
9213         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9214     test_mkdir -p $DIR/$tdir
9215     cp /etc/hosts $DIR/$tdir/$tfile
9216     test_mkdir $DIR/$tdir/foo1
9217     test_mkdir $DIR/$tdir/foo2
9218     ln $DIR/$tdir/$tfile $DIR/$tdir/foo1/sofia
9219     ln $DIR/$tdir/$tfile $DIR/$tdir/foo2/zachary
9220     ln $DIR/$tdir/$tfile $DIR/$tdir/foo1/luna
9221     ln $DIR/$tdir/$tfile $DIR/$tdir/foo2/thor
9222         local FID=$($LFS path2fid $DIR/$tdir/$tfile | tr -d '[]')
9223         if [ "$($LFS fid2path $DIR $FID | wc -l)" != "5" ]; then
9224                 $LFS fid2path $DIR $FID
9225                 err17935 "bad link ea"
9226         fi
9227     # middle
9228     rm $DIR/$tdir/foo2/zachary
9229     # last
9230     rm $DIR/$tdir/foo2/thor
9231     # first
9232     rm $DIR/$tdir/$tfile
9233     # rename
9234     mv $DIR/$tdir/foo1/sofia $DIR/$tdir/foo2/maggie
9235     if [ "$($LFS fid2path $FSNAME --link 1 $FID)" != "$tdir/foo2/maggie" ]
9236         then
9237         $LFS fid2path $DIR $FID
9238         err17935 "bad link rename"
9239     fi
9240     rm $DIR/$tdir/foo2/maggie
9241
9242     # overflow the EA
9243     local longname=filename_avg_len_is_thirty_two_
9244     createmany -l$DIR/$tdir/foo1/luna $DIR/$tdir/foo2/$longname 1000 || \
9245         error "failed to hardlink many files"
9246     links=$($LFS fid2path $DIR $FID | wc -l)
9247     echo -n "${links}/1000 links in link EA"
9248     [ ${links} -gt 60 ] || err17935 "expected at least 60 links in link EA"
9249     unlinkmany $DIR/$tdir/foo2/$longname 1000 || \
9250         error "failed to unlink many hardlinks"
9251 }
9252 run_test 161a "link ea sanity"
9253
9254 test_161b() {
9255         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9256         [ $MDSCOUNT -lt 2 ] &&
9257                 skip "skipping remote directory test" && return
9258         local MDTIDX=1
9259         local remote_dir=$DIR/$tdir/remote_dir
9260
9261         mkdir -p $DIR/$tdir
9262         $LFS mkdir -i $MDTIDX $remote_dir ||
9263                 error "create remote directory failed"
9264
9265         cp /etc/hosts $remote_dir/$tfile
9266         mkdir -p $remote_dir/foo1
9267         mkdir -p $remote_dir/foo2
9268         ln $remote_dir/$tfile $remote_dir/foo1/sofia
9269         ln $remote_dir/$tfile $remote_dir/foo2/zachary
9270         ln $remote_dir/$tfile $remote_dir/foo1/luna
9271         ln $remote_dir/$tfile $remote_dir/foo2/thor
9272
9273         local FID=$($LFS path2fid $remote_dir/$tfile | tr -d '[' |
9274                      tr -d ']')
9275         if [ "$($LFS fid2path $DIR $FID | wc -l)" != "5" ]; then
9276                 $LFS fid2path $DIR $FID
9277                 err17935 "bad link ea"
9278         fi
9279         # middle
9280         rm $remote_dir/foo2/zachary
9281         # last
9282         rm $remote_dir/foo2/thor
9283         # first
9284         rm $remote_dir/$tfile
9285         # rename
9286         mv $remote_dir/foo1/sofia $remote_dir/foo2/maggie
9287         local link_path=$($LFS fid2path $FSNAME --link 1 $FID)
9288         if [ "$DIR/$link_path" != "$remote_dir/foo2/maggie" ]; then
9289                 $LFS fid2path $DIR $FID
9290                 err17935 "bad link rename"
9291         fi
9292         rm $remote_dir/foo2/maggie
9293
9294         # overflow the EA
9295         local longname=filename_avg_len_is_thirty_two_
9296         createmany -l$remote_dir/foo1/luna $remote_dir/foo2/$longname 1000 ||
9297                 error "failed to hardlink many files"
9298         links=$($LFS fid2path $DIR $FID | wc -l)
9299         echo -n "${links}/1000 links in link EA"
9300         [ ${links} -gt 60 ] || err17935 "expected at least 60 links in link EA"
9301         unlinkmany $remote_dir/foo2/$longname 1000 ||
9302         error "failed to unlink many hardlinks"
9303 }
9304 run_test 161b "link ea sanity under remote directory"
9305
9306 check_path() {
9307     local expected=$1
9308     shift
9309     local fid=$2
9310
9311     local path=$(${LFS} fid2path $*)
9312     RC=$?
9313
9314     if [ $RC -ne 0 ]; then
9315         err17935 "path looked up of $expected failed. Error $RC"
9316         return $RC
9317     elif [ "${path}" != "${expected}" ]; then
9318         err17935 "path looked up \"${path}\" instead of \"${expected}\""
9319         return 2
9320     fi
9321     echo "fid $fid resolves to path $path (expected $expected)"
9322 }
9323
9324 test_162() {
9325         # Make changes to filesystem
9326         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9327         test_mkdir -p $DIR/$tdir/d2
9328         touch $DIR/$tdir/d2/$tfile
9329         touch $DIR/$tdir/d2/x1
9330         touch $DIR/$tdir/d2/x2
9331         test_mkdir -p $DIR/$tdir/d2/a/b/c
9332         test_mkdir -p $DIR/$tdir/d2/p/q/r
9333         # regular file
9334         FID=$($LFS path2fid $DIR/$tdir/d2/$tfile | tr -d '[]')
9335         check_path "$tdir/d2/$tfile" $FSNAME $FID --link 0
9336
9337         # softlink
9338         ln -s $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/p/q/r/slink
9339         FID=$($LFS path2fid $DIR/$tdir/d2/p/q/r/slink | tr -d '[]')
9340         check_path "$tdir/d2/p/q/r/slink" $FSNAME $FID --link 0
9341
9342         # softlink to wrong file
9343         ln -s /this/is/garbage $DIR/$tdir/d2/p/q/r/slink.wrong
9344         FID=$($LFS path2fid $DIR/$tdir/d2/p/q/r/slink.wrong | tr -d '[]')
9345         check_path "$tdir/d2/p/q/r/slink.wrong" $FSNAME $FID --link 0
9346
9347         # hardlink
9348         ln $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/p/q/r/hlink
9349         mv $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/a/b/c/new_file
9350         FID=$($LFS path2fid $DIR/$tdir/d2/a/b/c/new_file | tr -d '[]')
9351         # fid2path dir/fsname should both work
9352         check_path "$tdir/d2/a/b/c/new_file" $FSNAME $FID --link 1
9353         check_path "$DIR/$tdir/d2/p/q/r/hlink" $DIR $FID --link 0
9354
9355         # hardlink count: check that there are 2 links
9356         # Doesnt work with CMD yet: 17935
9357         ${LFS} fid2path $DIR $FID | wc -l | grep -q 2 || \
9358                 err17935 "expected 2 links"
9359
9360         # hardlink indexing: remove the first link
9361         rm $DIR/$tdir/d2/p/q/r/hlink
9362         check_path "$tdir/d2/a/b/c/new_file" $FSNAME $FID --link 0
9363
9364         return 0
9365 }
9366 run_test 162 "path lookup sanity"
9367
9368 test_163() {
9369         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9370         remote_mds_nodsh && skip "remote MDS with nodsh" && return
9371         copytool --test $FSNAME || { skip "copytool not runnable: $?" && return; }
9372         copytool $FSNAME &
9373         sleep 1
9374         local uuid=$($LCTL get_param -n mdc.${FSNAME}-MDT0000-mdc-*.uuid)
9375         # this proc file is temporary and linux-only
9376         do_facet $SINGLEMDS lctl set_param mdt.${FSNAME}-MDT0000.mdccomm=$uuid ||\
9377          error "kernel->userspace send failed"
9378         kill -INT $!
9379 }
9380 run_test 163 "kernel <-> userspace comms"
9381
9382 test_169() {
9383         # do directio so as not to populate the page cache
9384         log "creating a 10 Mb file"
9385         $MULTIOP $DIR/$tfile oO_CREAT:O_DIRECT:O_RDWR:w$((10*1048576))c || error "multiop failed while creating a file"
9386         log "starting reads"
9387         dd if=$DIR/$tfile of=/dev/null bs=4096 &
9388         log "truncating the file"
9389         $MULTIOP $DIR/$tfile oO_TRUNC:c || error "multiop failed while truncating the file"
9390         log "killing dd"
9391         kill %+ || true # reads might have finished
9392         echo "wait until dd is finished"
9393         wait
9394         log "removing the temporary file"
9395         rm -rf $DIR/$tfile || error "tmp file removal failed"
9396 }
9397 run_test 169 "parallel read and truncate should not deadlock"
9398
9399 test_170() {
9400         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9401         $LCTL clear     # bug 18514
9402         $LCTL debug_daemon start $TMP/${tfile}_log_good
9403         touch $DIR/$tfile
9404         $LCTL debug_daemon stop
9405         sed -e "s/^...../a/g" $TMP/${tfile}_log_good > $TMP/${tfile}_log_bad ||
9406                error "sed failed to read log_good"
9407
9408         $LCTL debug_daemon start $TMP/${tfile}_log_good
9409         rm -rf $DIR/$tfile
9410         $LCTL debug_daemon stop
9411
9412         $LCTL df $TMP/${tfile}_log_bad > $TMP/${tfile}_log_bad.out 2>&1 ||
9413                error "lctl df log_bad failed"
9414
9415         local bad_line=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $9}')
9416         local good_line1=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $5}')
9417
9418         $LCTL df $TMP/${tfile}_log_good > $TMP/${tfile}_log_good.out 2>&1
9419         local good_line2=$(tail -n 1 $TMP/${tfile}_log_good.out | awk '{print $5}')
9420
9421         [ "$bad_line" ] && [ "$good_line1" ] && [ "$good_line2" ] ||
9422                 error "bad_line good_line1 good_line2 are empty"
9423
9424         cat $TMP/${tfile}_log_good >> $TMP/${tfile}_logs_corrupt
9425         cat $TMP/${tfile}_log_bad >> $TMP/${tfile}_logs_corrupt
9426         cat $TMP/${tfile}_log_good >> $TMP/${tfile}_logs_corrupt
9427
9428         $LCTL df $TMP/${tfile}_logs_corrupt > $TMP/${tfile}_log_bad.out 2>&1
9429         local bad_line_new=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $9}')
9430         local good_line_new=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $5}')
9431
9432         [ "$bad_line_new" ] && [ "$good_line_new" ] ||
9433                 error "bad_line_new good_line_new are empty"
9434
9435         local expected_good=$((good_line1 + good_line2*2))
9436
9437         rm -f $TMP/${tfile}*
9438         # LU-231, short malformed line may not be counted into bad lines
9439         if [ $bad_line -ne $bad_line_new ] &&
9440                    [ $bad_line -ne $((bad_line_new - 1)) ]; then
9441                 error "expected $bad_line bad lines, but got $bad_line_new"
9442                 return 1
9443         fi
9444
9445         if [ $expected_good -ne $good_line_new ]; then
9446                 error "expected $expected_good good lines, but got $good_line_new"
9447                 return 2
9448         fi
9449         true
9450 }
9451 run_test 170 "test lctl df to handle corrupted log ====================="
9452
9453 test_171() { # bug20592
9454         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9455 #define OBD_FAIL_PTLRPC_DUMP_LOG         0x50e
9456         $LCTL set_param fail_loc=0x50e
9457         $LCTL set_param fail_val=3000
9458         multiop_bg_pause $DIR/$tfile O_s || true
9459         local MULTIPID=$!
9460         kill -USR1 $MULTIPID
9461         # cause log dump
9462         sleep 3
9463         wait $MULTIPID
9464         if dmesg | grep "recursive fault"; then
9465                 error "caught a recursive fault"
9466         fi
9467         $LCTL set_param fail_loc=0
9468         true
9469 }
9470 run_test 171 "test libcfs_debug_dumplog_thread stuck in do_exit() ======"
9471
9472 # it would be good to share it with obdfilter-survey/libecho code
9473 setup_obdecho_osc () {
9474         local rc=0
9475         local ost_nid=$1
9476         local obdfilter_name=$2
9477         echo "Creating new osc for $obdfilter_name on $ost_nid"
9478         # make sure we can find loopback nid
9479         $LCTL add_uuid $ost_nid $ost_nid >/dev/null 2>&1
9480
9481         [ $rc -eq 0 ] && { $LCTL attach osc ${obdfilter_name}_osc     \
9482                            ${obdfilter_name}_osc_UUID || rc=2; }
9483         [ $rc -eq 0 ] && { $LCTL --device ${obdfilter_name}_osc setup \
9484                            ${obdfilter_name}_UUID  $ost_nid || rc=3; }
9485         return $rc
9486 }
9487
9488 cleanup_obdecho_osc () {
9489         local obdfilter_name=$1
9490         $LCTL --device ${obdfilter_name}_osc cleanup >/dev/null
9491         $LCTL --device ${obdfilter_name}_osc detach  >/dev/null
9492         return 0
9493 }
9494
9495 obdecho_create_test() {
9496         local OBD=$1
9497         local node=$2
9498         local rc=0
9499         local id
9500         do_facet $node "$LCTL attach echo_client ec ec_uuid" || rc=1
9501         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec setup $OBD" ||
9502                            rc=2; }
9503         if [ $rc -eq 0 ]; then
9504             id=$(do_facet $node "$LCTL --device ec create 1"  | awk '/object id/ {print $6}')
9505             [ ${PIPESTATUS[0]} -eq 0 -a -n "$id" ] || rc=3
9506         fi
9507         echo "New object id is $id"
9508         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec test_brw 10 w v 64 $id" ||
9509                            rc=4; }
9510         [ $rc -eq 0 -o $rc -gt 2 ] && { do_facet $node "$LCTL --device ec "    \
9511                                         "cleanup" || rc=5; }
9512         [ $rc -eq 0 -o $rc -gt 1 ] && { do_facet $node "$LCTL --device ec "    \
9513                                         "detach" || rc=6; }
9514         [ $rc -ne 0 ] && echo "obecho_create_test failed: $rc"
9515         return $rc
9516 }
9517
9518 test_180a() {
9519         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9520         remote_ost_nodsh && skip "remote OST with nodsh" && return
9521         local rc=0
9522         local rmmod_local=0
9523
9524         if ! module_loaded obdecho; then
9525             load_module obdecho/obdecho
9526             rmmod_local=1
9527         fi
9528
9529         local osc=$($LCTL dl | grep -v mdt | awk '$3 == "osc" {print $4; exit}')
9530         local host=$(lctl get_param -n osc.$osc.import |
9531                              awk '/current_connection:/ {print $2}' )
9532         local target=$(lctl get_param -n osc.$osc.import |
9533                              awk '/target:/ {print $2}' )
9534         target=${target%_UUID}
9535
9536         [[ -n $target ]]  && { setup_obdecho_osc $host $target || rc=1; } || rc=1
9537         [ $rc -eq 0 ] && { obdecho_create_test ${target}_osc client || rc=2; }
9538         [[ -n $target ]] && cleanup_obdecho_osc $target
9539         [ $rmmod_local -eq 1 ] && rmmod obdecho
9540         return $rc
9541 }
9542 run_test 180a "test obdecho on osc"
9543
9544 test_180b() {
9545         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9546         remote_ost_nodsh && skip "remote OST with nodsh" && return
9547         local rc=0
9548         local rmmod_remote=0
9549
9550         do_facet ost1 "lsmod | grep -q obdecho || "                      \
9551                       "{ insmod ${LUSTRE}/obdecho/obdecho.ko || "        \
9552                       "modprobe obdecho; }" && rmmod_remote=1
9553         target=$(do_facet ost1 $LCTL dl | awk '/obdfilter/ {print $4;exit}')
9554         [[ -n $target ]] && { obdecho_create_test $target ost1 || rc=1; }
9555         [ $rmmod_remote -eq 1 ] && do_facet ost1 "rmmod obdecho"
9556         return $rc
9557 }
9558 run_test 180b "test obdecho directly on obdfilter"
9559
9560 test_181() { # bug 22177
9561         test_mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
9562         # create enough files to index the directory
9563         createmany -o $DIR/$tdir/foobar 4000
9564         # print attributes for debug purpose
9565         lsattr -d .
9566         # open dir
9567         multiop_bg_pause $DIR/$tdir D_Sc || return 1
9568         MULTIPID=$!
9569         # remove the files & current working dir
9570         unlinkmany $DIR/$tdir/foobar 4000
9571         rmdir $DIR/$tdir
9572         kill -USR1 $MULTIPID
9573         wait $MULTIPID
9574         stat $DIR/$tdir && error "open-unlinked dir was not removed!"
9575         return 0
9576 }
9577 run_test 181 "Test open-unlinked dir ========================"
9578
9579 test_182() {
9580         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9581         # disable MDC RPC lock wouldn't crash client
9582         local fcount=1000
9583         local tcount=4
9584
9585         mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
9586 #define OBD_FAIL_MDC_RPCS_SEM           0x804
9587         $LCTL set_param fail_loc=0x804
9588
9589         for (( i=0; i < $tcount; i++ )) ; do
9590                 mkdir $DIR/$tdir/$i
9591                 createmany -o $DIR/$tdir/$i/f- $fcount &
9592         done
9593         wait
9594
9595         for (( i=0; i < $tcount; i++ )) ; do
9596                 unlinkmany $DIR/$tdir/$i/f- $fcount &
9597         done
9598         wait
9599
9600         rm -rf $DIR/$tdir
9601
9602         $LCTL set_param fail_loc=0
9603 }
9604 run_test 182 "Disable MDC RPCs semaphore wouldn't crash client ================"
9605
9606 test_183() { # LU-2275
9607         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
9608         mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
9609         echo aaa > $DIR/$tdir/$tfile
9610
9611 #define OBD_FAIL_MDS_NEGATIVE_POSITIVE  0x148
9612         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x148
9613
9614         ls -l $DIR/$tdir && error "ls succeeded, should have failed"
9615         cat $DIR/$tdir/$tfile && error "cat succeeded, should have failed"
9616
9617         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
9618
9619         # Flush negative dentry cache
9620         touch $DIR/$tdir/$tfile
9621
9622         # We are not checking for any leaked references here, they'll
9623         # become evident next time we do cleanup with module unload.
9624         rm -rf $DIR/$tdir
9625 }
9626 run_test 183 "No crash or request leak in case of strange dispositions ========"
9627
9628 # test suite 184 is for LU-2016, LU-2017
9629 test_184a() {
9630         check_swap_layouts_support && return 0
9631
9632         dir0=$DIR/$tdir/$testnum
9633         test_mkdir -p $dir0 || error "creating dir $dir0"
9634         ref1=/etc/passwd
9635         ref2=/etc/group
9636         file1=$dir0/f1
9637         file2=$dir0/f2
9638         $SETSTRIPE -c1 $file1
9639         cp $ref1 $file1
9640         $SETSTRIPE -c2 $file2
9641         cp $ref2 $file2
9642         gen1=$($GETSTRIPE -g $file1)
9643         gen2=$($GETSTRIPE -g $file2)
9644
9645         $LFS swap_layouts $file1 $file2 || error "swap of file layout failed"
9646         gen=$($GETSTRIPE -g $file1)
9647         [[ $gen1 != $gen ]] ||
9648                 "Layout generation on $file1 does not change"
9649         gen=$($GETSTRIPE -g $file2)
9650         [[ $gen2 != $gen ]] ||
9651                 "Layout generation on $file2 does not change"
9652
9653         cmp $ref1 $file2 || error "content compare failed ($ref1 != $file2)"
9654         cmp $ref2 $file1 || error "content compare failed ($ref2 != $file1)"
9655 }
9656 run_test 184a "Basic layout swap"
9657
9658 test_184b() {
9659         check_swap_layouts_support && return 0
9660
9661         dir0=$DIR/$tdir/$testnum
9662         mkdir -p $dir0 || error "creating dir $dir0"
9663         file1=$dir0/f1
9664         file2=$dir0/f2
9665         file3=$dir0/f3
9666         dir1=$dir0/d1
9667         dir2=$dir0/d2
9668         mkdir $dir1 $dir2
9669         $SETSTRIPE -c1 $file1
9670         $SETSTRIPE -c2 $file2
9671         $SETSTRIPE -c1 $file3
9672         chown $RUNAS_ID $file3
9673         gen1=$($GETSTRIPE -g $file1)
9674         gen2=$($GETSTRIPE -g $file2)
9675
9676         $LFS swap_layouts $dir1 $dir2 &&
9677                 error "swap of directories layouts should fail"
9678         $LFS swap_layouts $dir1 $file1 &&
9679                 error "swap of directory and file layouts should fail"
9680         $RUNAS $LFS swap_layouts $file1 $file2 &&
9681                 error "swap of file we cannot write should fail"
9682         $LFS swap_layouts $file1 $file3 &&
9683                 error "swap of file with different owner should fail"
9684         /bin/true # to clear error code
9685 }
9686 run_test 184b "Forbidden layout swap (will generate errors)"
9687
9688 test_184c() {
9689         check_swap_layouts_support && return 0
9690
9691         local dir0=$DIR/$tdir/$testnum
9692         mkdir -p $dir0 || error "creating dir $dir0"
9693
9694         local ref1=$dir0/ref1
9695         local ref2=$dir0/ref2
9696         local file1=$dir0/file1
9697         local file2=$dir0/file2
9698         # create a file large enough for the concurent test
9699         dd if=/dev/urandom of=$ref1 bs=1M count=$((RANDOM % 50 + 20))
9700         dd if=/dev/urandom of=$ref2 bs=1M count=$((RANDOM % 50 + 20))
9701         echo "ref file size: ref1(`stat -c %s $ref1`), ref2(`stat -c %s $ref2`)"
9702
9703         cp $ref2 $file2
9704         dd if=$ref1 of=$file1 bs=16k &
9705         local DD_PID=$!
9706
9707         # Make sure dd starts to copy file
9708         while [ ! -f $file1 ]; do sleep 0.1; done
9709
9710         $LFS swap_layouts $file1 $file2
9711         local rc=$?
9712         wait $DD_PID
9713         [[ $? == 0 ]] || error "concurrent write on $file1 failed"
9714         [[ $rc == 0 ]] || error "swap of $file1 and $file2 failed"
9715
9716         # how many bytes copied before swapping layout
9717         local copied=`stat -c %s $file2`
9718         local remaining=`stat -c %s $ref1`
9719         remaining=$((remaining - copied))
9720         echo "Copied $copied bytes before swapping layout..."
9721
9722         cmp -n $copied $file1 $ref2 | grep differ &&
9723                 error "Content mismatch [0, $copied) of ref2 and file1"
9724         cmp -n $copied $file2 $ref1 ||
9725                 error "Content mismatch [0, $copied) of ref1 and file2"
9726         cmp -i $copied:$copied -n $remaining $file1 $ref1 ||
9727                 error "Content mismatch [$copied, EOF) of ref1 and file1"
9728
9729         # clean up
9730         rm -f $ref1 $ref2 $file1 $file2
9731 }
9732 run_test 184c "Concurrent write and layout swap"
9733
9734 test_184d() {
9735         check_swap_layouts_support && return 0
9736
9737         local file1=$DIR/$tdir/$tfile-1
9738         local file2=$DIR/$tdir/$tfile-2
9739         local file3=$DIR/$tdir/$tfile-3
9740         local lovea1
9741         local lovea2
9742
9743         mkdir -p $DIR/$tdir
9744         touch $file1 || error "create $file1 failed"
9745         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE $file2 ||
9746                 error "create $file2 failed"
9747         $OPENFILE -f O_CREAT:O_LOV_DELAY_CREATE $file3 ||
9748                 error "create $file3 failed"
9749         lovea1=$($LFS getstripe $file1 | sed 1d)
9750
9751         $LFS swap_layouts $file2 $file3 ||
9752                 error "swap $file2 $file3 layouts failed"
9753         $LFS swap_layouts $file1 $file2 ||
9754                 error "swap $file1 $file2 layouts failed"
9755
9756         lovea2=$($LFS getstripe $file2 | sed 1d)
9757         [ "$lovea1" == "$lovea2" ] || error "lovea $lovea1 != $lovea2"
9758
9759         lovea1=$(getfattr -n trusted.lov $file1 | grep ^trusted)
9760         [ -z $lovea1 ] || error "$file1 shouldn't have lovea"
9761 }
9762 run_test 184d "allow stripeless layouts swap"
9763
9764
9765 test_185() { # LU-2441
9766         mkdir -p $DIR/$tdir || error "creating dir $DIR/$tdir"
9767         touch $DIR/$tdir/spoo
9768         local mtime1=$(stat -c "%Y" $DIR/$tdir)
9769         local fid=$($MULTIOP $DIR/$tdir VFw4096c) ||
9770                 error "cannot create/write a volatile file"
9771         $CHECKSTAT -t file $MOUNT/.lustre/fid/$fid 2>/dev/null &&
9772                 error "FID is still valid after close"
9773
9774         multiop_bg_pause $DIR/$tdir vVw4096_c
9775         local multi_pid=$!
9776
9777         local OLD_IFS=$IFS
9778         IFS=":"
9779         local fidv=($fid)
9780         IFS=$OLD_IFS
9781         # assume that the next FID for this client is sequential, since stdout
9782         # is unfortunately eaten by multiop_bg_pause
9783         local n=$((${fidv[1]} + 1))
9784         local next_fid="${fidv[0]}:$(printf "0x%x" $n):${fidv[2]}"
9785         $CHECKSTAT -t file $MOUNT/.lustre/fid/$next_fid ||
9786                 error "FID is missing before close"
9787         kill -USR1 $multi_pid
9788         # 1 second delay, so if mtime change we will see it
9789         sleep 1
9790         local mtime2=$(stat -c "%Y" $DIR/$tdir)
9791         [[ $mtime1 == $mtime2 ]] || error "mtime has changed"
9792 }
9793 run_test 185 "Volatile file support"
9794
9795 # OST pools tests
9796 check_file_in_pool()
9797 {
9798         local file=$1
9799         local pool=$2
9800         local tlist="$3"
9801         local res=$($GETSTRIPE $file | grep 0x | cut -f2)
9802         for i in $res
9803         do
9804                 for t in $tlist ; do
9805                         [ "$i" -eq "$t" ] && continue 2
9806                 done
9807
9808                 echo "pool list: $tlist"
9809                 echo "striping: $res"
9810                 error_noexit "$file not allocated in $pool"
9811                 return 1
9812         done
9813         return 0
9814 }
9815
9816 pool_add() {
9817         echo "Creating new pool"
9818         local pool=$1
9819
9820         create_pool $FSNAME.$pool ||
9821                 { error_noexit "No pool created, result code $?"; return 1; }
9822         [ $($LFS pool_list $FSNAME | grep -c $pool) -eq 1 ] ||
9823                 { error_noexit "$pool not in lfs pool_list"; return 2; }
9824 }
9825
9826 pool_add_targets() {
9827         echo "Adding targets to pool"
9828         local pool=$1
9829         local first=$2
9830         local last=$3
9831         local step=${4:-1}
9832
9833         local list=$(seq $first $step $last)
9834
9835         local t=$(for i in $list; do printf "$FSNAME-OST%04x_UUID " $i; done)
9836         do_facet mgs $LCTL pool_add \
9837                         $FSNAME.$pool $FSNAME-OST[$first-$last/$step]
9838         wait_update $HOSTNAME "lctl get_param -n lov.$FSNAME-*.pools.$pool \
9839                         | sort -u | tr '\n' ' ' " "$t" || {
9840                 error_noexit "Add to pool failed"
9841                 return 1
9842         }
9843         local lfscount=$($LFS pool_list $FSNAME.$pool | grep -c "\-OST")
9844         local addcount=$(((last - first) / step + 1))
9845         [ $lfscount -eq $addcount ] || {
9846                 error_noexit "lfs pool_list bad ost count" \
9847                                                 "$lfscount != $addcount"
9848                 return 2
9849         }
9850 }
9851
9852 pool_set_dir() {
9853         local pool=$1
9854         local tdir=$2
9855         echo "Setting pool on directory $tdir"
9856
9857         $SETSTRIPE -c 2 -p $pool $tdir && return 0
9858
9859         error_noexit "Cannot set pool $pool to $tdir"
9860         return 1
9861 }
9862
9863 pool_check_dir() {
9864         local pool=$1
9865         local tdir=$2
9866         echo "Checking pool on directory $tdir"
9867
9868         local res=$($GETSTRIPE --pool $tdir | sed "s/\s*$//")
9869         [ "$res" = "$pool" ] && return 0
9870
9871         error_noexit "Pool on '$tdir' is '$res', not '$pool'"
9872         return 1
9873 }
9874
9875 pool_dir_rel_path() {
9876         echo "Testing relative path works well"
9877         local pool=$1
9878         local tdir=$2
9879         local root=$3
9880
9881         mkdir -p $root/$tdir/$tdir
9882         cd $root/$tdir
9883         pool_set_dir $pool $tdir          || return 1
9884         pool_set_dir $pool ./$tdir        || return 2
9885         pool_set_dir $pool ../$tdir       || return 3
9886         pool_set_dir $pool ../$tdir/$tdir || return 4
9887         rm -rf $tdir; cd - > /dev/null
9888 }
9889
9890 pool_alloc_files() {
9891         echo "Checking files allocation from directory pool"
9892         local pool=$1
9893         local tdir=$2
9894         local count=$3
9895         local tlist="$4"
9896
9897         local failed=0
9898         for i in $(seq -w 1 $count)
9899         do
9900                 local file=$tdir/file-$i
9901                 touch $file
9902                 check_file_in_pool $file $pool "$tlist" || \
9903                         failed=$((failed + 1))
9904         done
9905         [ "$failed" = 0 ] && return 0
9906
9907         error_noexit "$failed files not allocated in $pool"
9908         return 1
9909 }
9910
9911 pool_create_files() {
9912         echo "Creating files in pool"
9913         local pool=$1
9914         local tdir=$2
9915         local count=$3
9916         local tlist="$4"
9917
9918         mkdir -p $tdir
9919         local failed=0
9920         for i in $(seq -w 1 $count)
9921         do
9922                 local file=$tdir/spoo-$i
9923                 $SETSTRIPE -p $pool $file
9924                 check_file_in_pool $file $pool "$tlist" || \
9925                         failed=$((failed + 1))
9926         done
9927         [ "$failed" = 0 ] && return 0
9928
9929         error_noexit "$failed files not allocated in $pool"
9930         return 1
9931 }
9932
9933 pool_lfs_df() {
9934         echo "Checking 'lfs df' output"
9935         local pool=$1
9936
9937         local t=$($LCTL get_param -n lov.$FSNAME-clilov-*.pools.$pool |
9938                         tr '\n' ' ')
9939         local res=$($LFS df --pool $FSNAME.$pool |
9940                         awk '{print $1}' |
9941                         grep "$FSNAME-OST" |
9942                         tr '\n' ' ')
9943         [ "$res" = "$t" ] && return 0
9944
9945         error_noexit "Pools OSTs '$t' is not '$res' that lfs df reports"
9946         return 1
9947 }
9948
9949 pool_file_rel_path() {
9950         echo "Creating files in a pool with relative pathname"
9951         local pool=$1
9952         local tdir=$2
9953
9954         mkdir -p $tdir ||
9955                 { error_noexit "unable to create $tdir"; return 1 ; }
9956         local file="/..$tdir/$tfile-1"
9957         $SETSTRIPE -p $pool $file ||
9958                 { error_noexit "unable to create $file" ; return 2 ; }
9959
9960         cd $tdir
9961         $SETSTRIPE -p $pool $tfile-2 || {
9962                 error_noexit "unable to create $tfile-2 in $tdir"
9963                 return 3
9964         }
9965 }
9966
9967 pool_remove_first_target() {
9968         echo "Removing first target from a pool"
9969         local pool=$1
9970
9971         local pname="lov.$FSNAME-*.pools.$pool"
9972         local t=$($LCTL get_param -n $pname | head -1)
9973         do_facet mgs $LCTL pool_remove $FSNAME.$pool $t
9974         wait_update $HOSTNAME "lctl get_param -n $pname | grep $t" "" || {
9975                 error_noexit "$t not removed from $FSNAME.$pool"
9976                 return 1
9977         }
9978 }
9979
9980 pool_remove_all_targets() {
9981         echo "Removing all targets from pool"
9982         local pool=$1
9983         local file=$2
9984         local pname="lov.$FSNAME-*.pools.$pool"
9985         for t in $($LCTL get_param -n $pname | sort -u)
9986         do
9987                 do_facet mgs $LCTL pool_remove $FSNAME.$pool $t
9988         done
9989         wait_update $HOSTNAME "lctl get_param -n $pname" "" || {
9990                 error_noexit "Pool $FSNAME.$pool cannot be drained"
9991                 return 1
9992         }
9993         # striping on an empty/nonexistant pool should fall back
9994         # to "pool of everything"
9995         touch $file || {
9996                 error_noexit "failed to use fallback striping for empty pool"
9997                 return 2
9998         }
9999         # setstripe on an empty pool should fail
10000         $SETSTRIPE -p $pool $file 2>/dev/null && {
10001                 error_noexit "expected failure when creating file" \
10002                                                         "with empty pool"
10003                 return 3
10004         }
10005         return 0
10006 }
10007
10008 pool_remove() {
10009         echo "Destroying pool"
10010         local pool=$1
10011         local file=$2
10012
10013         do_facet mgs $LCTL pool_destroy $FSNAME.$pool
10014
10015         sleep 2
10016         # striping on an empty/nonexistant pool should fall back
10017         # to "pool of everything"
10018         touch $file || {
10019                 error_noexit "failed to use fallback striping for missing pool"
10020                 return 1
10021         }
10022         # setstripe on an empty pool should fail
10023         $SETSTRIPE -p $pool $file 2>/dev/null && {
10024                 error_noexit "expected failure when creating file" \
10025                                                         "with missing pool"
10026                 return 2
10027         }
10028
10029         # get param should return err once pool is gone
10030         if wait_update $HOSTNAME "lctl get_param -n \
10031                 lov.$FSNAME-*.pools.$pool 2>/dev/null || echo foo" "foo"
10032         then
10033                 remove_pool_from_list $FSNAME.$pool
10034                 return 0
10035         fi
10036         error_noexit "Pool $FSNAME.$pool is not destroyed"
10037         return 3
10038 }
10039
10040 test_200() {
10041         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10042         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
10043
10044         local POOL=${POOL:-cea1}
10045         local POOL_ROOT=${POOL_ROOT:-$DIR/d200.pools}
10046         local POOL_DIR_NAME=${POOL_DIR_NAME:-dir_tst}
10047         # Pool OST targets
10048         local first_ost=0
10049         local last_ost=$(($OSTCOUNT - 1))
10050         local ost_step=2
10051         local ost_list=$(seq $first_ost $ost_step $last_ost)
10052         local ost_range="$first_ost $last_ost $ost_step"
10053         local test_path=$POOL_ROOT/$POOL_DIR_NAME
10054         local file_dir=$POOL_ROOT/file_tst
10055
10056         local rc=0
10057         while : ; do
10058                 # former test_200a test_200b
10059                 pool_add $POOL                          || { rc=$? ; break; }
10060                 pool_add_targets  $POOL $ost_range      || { rc=$? ; break; }
10061                 # former test_200c test_200d
10062                 mkdir -p $test_path
10063                 pool_set_dir      $POOL $test_path      || { rc=$? ; break; }
10064                 pool_check_dir    $POOL $test_path      || { rc=$? ; break; }
10065                 pool_dir_rel_path $POOL $POOL_DIR_NAME $POOL_ROOT \
10066                                                         || { rc=$? ; break; }
10067                 # former test_200e test_200f
10068                 local files=$((OSTCOUNT*3))
10069                 pool_alloc_files  $POOL $test_path $files "$ost_list" \
10070                                                         || { rc=$? ; break; }
10071                 pool_create_files $POOL $file_dir $files "$ost_list" \
10072                                                         || { rc=$? ; break; }
10073                 # former test_200g test_200h
10074                 pool_lfs_df $POOL                       || { rc=$? ; break; }
10075                 pool_file_rel_path $POOL $test_path     || { rc=$? ; break; }
10076
10077                 # former test_201a test_201b test_201c
10078                 pool_remove_first_target $POOL          || { rc=$? ; break; }
10079
10080                 local f=$test_path/$tfile
10081                 pool_remove_all_targets $POOL $f        || { rc=$? ; break; }
10082                 pool_remove $POOL $f                    || { rc=$? ; break; }
10083                 break
10084         done
10085
10086         cleanup_pools
10087         return $rc
10088 }
10089 run_test 200 "OST pools"
10090
10091 # usage: default_attr <count | size | offset>
10092 default_attr() {
10093         $LCTL get_param -n lov.$FSNAME-clilov-\*.stripe${1}
10094 }
10095
10096 # usage: check_default_stripe_attr
10097 check_default_stripe_attr() {
10098         ACTUAL=$($GETSTRIPE $* $DIR/$tdir)
10099         case $1 in
10100         --stripe-count|--count)
10101                 [ -n "$2" ] && EXPECTED=0 || EXPECTED=$(default_attr count);;
10102         --stripe-size|--size)
10103                 [ -n "$2" ] && EXPECTED=0 || EXPECTED=$(default_attr size);;
10104         --stripe-index|--index)
10105                 EXPECTED=-1;;
10106         *)
10107                 error "unknown getstripe attr '$1'"
10108         esac
10109
10110         [ $ACTUAL != $EXPECTED ] &&
10111                 error "$DIR/$tdir has $1 '$ACTUAL', not '$EXPECTED'"
10112 }
10113
10114 test_204a() {
10115         test_mkdir -p $DIR/$tdir
10116         $SETSTRIPE --stripe-count 0 --stripe-size 0 --stripe-index -1 $DIR/$tdir
10117
10118         check_default_stripe_attr --stripe-count
10119         check_default_stripe_attr --stripe-size
10120         check_default_stripe_attr --stripe-index
10121
10122         return 0
10123 }
10124 run_test 204a "Print default stripe attributes ================="
10125
10126 test_204b() {
10127         test_mkdir -p $DIR/$tdir
10128         $SETSTRIPE --stripe-count 1 $DIR/$tdir
10129
10130         check_default_stripe_attr --stripe-size
10131         check_default_stripe_attr --stripe-index
10132
10133         return 0
10134 }
10135 run_test 204b "Print default stripe size and offset  ==========="
10136
10137 test_204c() {
10138         test_mkdir -p $DIR/$tdir
10139         $SETSTRIPE --stripe-size 65536 $DIR/$tdir
10140
10141         check_default_stripe_attr --stripe-count
10142         check_default_stripe_attr --stripe-index
10143
10144         return 0
10145 }
10146 run_test 204c "Print default stripe count and offset ==========="
10147
10148 test_204d() {
10149         test_mkdir -p $DIR/$tdir
10150         $SETSTRIPE --stripe-index 0 $DIR/$tdir
10151
10152         check_default_stripe_attr --stripe-count
10153         check_default_stripe_attr --stripe-size
10154
10155         return 0
10156 }
10157 run_test 204d "Print default stripe count and size ============="
10158
10159 test_204e() {
10160         test_mkdir -p $DIR/$tdir
10161         $SETSTRIPE -d $DIR/$tdir
10162
10163         check_default_stripe_attr --stripe-count --raw
10164         check_default_stripe_attr --stripe-size --raw
10165         check_default_stripe_attr --stripe-index --raw
10166
10167         return 0
10168 }
10169 run_test 204e "Print raw stripe attributes ================="
10170
10171 test_204f() {
10172         test_mkdir -p $DIR/$tdir
10173         $SETSTRIPE --stripe-count 1 $DIR/$tdir
10174
10175         check_default_stripe_attr --stripe-size --raw
10176         check_default_stripe_attr --stripe-index --raw
10177
10178         return 0
10179 }
10180 run_test 204f "Print raw stripe size and offset  ==========="
10181
10182 test_204g() {
10183         test_mkdir -p $DIR/$tdir
10184         $SETSTRIPE --stripe-size 65536 $DIR/$tdir
10185
10186         check_default_stripe_attr --stripe-count --raw
10187         check_default_stripe_attr --stripe-index --raw
10188
10189         return 0
10190 }
10191 run_test 204g "Print raw stripe count and offset ==========="
10192
10193 test_204h() {
10194         test_mkdir -p $DIR/$tdir
10195         $SETSTRIPE --stripe-index 0 $DIR/$tdir
10196
10197         check_default_stripe_attr --stripe-count --raw
10198         check_default_stripe_attr --stripe-size --raw
10199
10200         return 0
10201 }
10202 run_test 204h "Print raw stripe count and size ============="
10203
10204 # Figure out which job scheduler is being used, if any,
10205 # or use a fake one
10206 if [ -n "$SLURM_JOB_ID" ]; then # SLURM
10207         JOBENV=SLURM_JOB_ID
10208 elif [ -n "$LSB_JOBID" ]; then # Load Sharing Facility
10209         JOBENV=LSB_JOBID
10210 elif [ -n "$PBS_JOBID" ]; then # PBS/Maui/Moab
10211         JOBENV=PBS_JOBID
10212 elif [ -n "$LOADL_STEPID" ]; then # LoadLeveller
10213         JOBENV=LOADL_STEP_ID
10214 elif [ -n "$JOB_ID" ]; then # Sun Grid Engine
10215         JOBENV=JOB_ID
10216 else
10217         JOBENV=FAKE_JOBID
10218 fi
10219
10220 verify_jobstats() {
10221         local cmd=$1
10222         local target=$2
10223
10224         # clear old jobstats
10225         do_facet $SINGLEMDS lctl set_param mdt.*.job_stats="clear"
10226         do_facet ost1 lctl set_param obdfilter.*.job_stats="clear"
10227
10228         # use a new JobID for this test, or we might see an old one
10229         [ "$JOBENV" = "FAKE_JOBID" ] && FAKE_JOBID=test_id.$testnum.$RANDOM
10230
10231         JOBVAL=${!JOBENV}
10232         log "Test: $cmd"
10233         log "Using JobID environment variable $JOBENV=$JOBVAL"
10234
10235         if [ $JOBENV = "FAKE_JOBID" ]; then
10236                 FAKE_JOBID=$JOBVAL $cmd
10237         else
10238                 $cmd
10239         fi
10240
10241         if [ "$target" = "mdt" -o "$target" = "both" ]; then
10242                 FACET="$SINGLEMDS" # will need to get MDS number for DNE
10243                 do_facet $FACET lctl get_param mdt.*.job_stats |
10244                         grep $JOBVAL || error "No job stats found on MDT $FACET"
10245         fi
10246         if [ "$target" = "ost" -o "$target" = "both" ]; then
10247                 FACET=ost1
10248                 do_facet $FACET lctl get_param obdfilter.*.job_stats |
10249                         grep $JOBVAL || error "No job stats found on OST $FACET"
10250         fi
10251 }
10252
10253 jobstats_set() {
10254         trap 0
10255         NEW_JOBENV=${1:-$OLD_JOBENV}
10256         do_facet mgs $LCTL conf_param $FSNAME.sys.jobid_var=$NEW_JOBENV
10257         wait_update $HOSTNAME "$LCTL get_param -n jobid_var" $NEW_JOBENV
10258 }
10259
10260 test_205() { # Job stats
10261         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10262         [ -z "$(lctl get_param -n mdc.*.connect_flags | grep jobstats)" ] &&
10263                 skip "Server doesn't support jobstats" && return 0
10264
10265         local cmd
10266         OLD_JOBENV=`$LCTL get_param -n jobid_var`
10267         if [ $OLD_JOBENV != $JOBENV ]; then
10268                 jobstats_set $JOBENV
10269                 trap jobstats_set EXIT
10270         fi
10271
10272         # mkdir
10273         cmd="mkdir $DIR/$tfile"
10274         verify_jobstats "$cmd" "mdt"
10275         # rmdir
10276         cmd="rm -fr $DIR/$tfile"
10277         verify_jobstats "$cmd" "mdt"
10278         # mknod
10279         cmd="mknod $DIR/$tfile c 1 3"
10280         verify_jobstats "$cmd" "mdt"
10281         # unlink
10282         cmd="rm -f $DIR/$tfile"
10283         verify_jobstats "$cmd" "mdt"
10284         # open & close
10285         cmd="$SETSTRIPE -i 0 -c 1 $DIR/$tfile"
10286         verify_jobstats "$cmd" "mdt"
10287         # setattr
10288         cmd="touch $DIR/$tfile"
10289         verify_jobstats "$cmd" "both"
10290         # write
10291         cmd="dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 oflag=sync"
10292         verify_jobstats "$cmd" "ost"
10293         # read
10294         cmd="dd if=$DIR/$tfile of=/dev/null bs=1M count=1 iflag=direct"
10295         verify_jobstats "$cmd" "ost"
10296         # truncate
10297         cmd="$TRUNCATE $DIR/$tfile 0"
10298         verify_jobstats "$cmd" "both"
10299         # rename
10300         cmd="mv -f $DIR/$tfile $DIR/jobstats_test_rename"
10301         verify_jobstats "$cmd" "mdt"
10302
10303         # cleanup
10304         rm -f $DIR/jobstats_test_rename
10305
10306         [ $OLD_JOBENV != $JOBENV ] && jobstats_set $OLD_JOBENV
10307 }
10308 run_test 205 "Verify job stats"
10309
10310 # LU-1480, LU-1773 and LU-1657
10311 test_206() {
10312         mkdir -p $DIR/$tdir
10313         lfs setstripe -c -1 $DIR/$tdir
10314 #define OBD_FAIL_LOV_INIT 0x1403
10315         $LCTL set_param fail_loc=0xa0001403
10316         $LCTL set_param fail_val=1
10317         touch $DIR/$tdir/$tfile || true
10318 }
10319 run_test 206 "fail lov_init_raid0() doesn't lbug"
10320
10321 test_207a() {
10322         dd if=/dev/zero of=$DIR/$tfile bs=4k count=$((RANDOM%10+1))
10323         local fsz=`stat -c %s $DIR/$tfile`
10324         cancel_lru_locks mdc
10325
10326         # do not return layout in getattr intent
10327 #define OBD_FAIL_MDS_NO_LL_GETATTR 0x170
10328         $LCTL set_param fail_loc=0x170
10329         local sz=`stat -c %s $DIR/$tfile`
10330
10331         [ $fsz -eq $sz ] || error "file size expected $fsz, actual $sz"
10332
10333         rm -rf $DIR/$tfile
10334 }
10335 run_test 207a "can refresh layout at glimpse"
10336
10337 test_207b() {
10338         dd if=/dev/zero of=$DIR/$tfile bs=4k count=$((RANDOM%10+1))
10339         local cksum=`md5sum $DIR/$tfile`
10340         local fsz=`stat -c %s $DIR/$tfile`
10341         cancel_lru_locks mdc
10342         cancel_lru_locks osc
10343
10344         # do not return layout in getattr intent
10345 #define OBD_FAIL_MDS_NO_LL_OPEN 0x171
10346         $LCTL set_param fail_loc=0x171
10347
10348         # it will refresh layout after the file is opened but before read issues
10349         echo checksum is "$cksum"
10350         echo "$cksum" |md5sum -c --quiet || error "file differs"
10351
10352         rm -rf $DIR/$tfile
10353 }
10354 run_test 207b "can refresh layout at open"
10355
10356 test_212() {
10357         size=`date +%s`
10358         size=$((size % 8192 + 1))
10359         dd if=/dev/urandom of=$DIR/f212 bs=1k count=$size
10360         sendfile $DIR/f212 $DIR/f212.xyz || error "sendfile wrong"
10361         rm -f $DIR/f212 $DIR/f212.xyz
10362 }
10363 run_test 212 "Sendfile test ============================================"
10364
10365 test_213() {
10366         dd if=/dev/zero of=$DIR/$tfile bs=4k count=4
10367         cancel_lru_locks osc
10368         lctl set_param fail_loc=0x8000040f
10369         # generate a read lock
10370         cat $DIR/$tfile > /dev/null
10371         # write to the file, it will try to cancel the above read lock.
10372         cat /etc/hosts >> $DIR/$tfile
10373 }
10374 run_test 213 "OSC lock completion and cancel race don't crash - bug 18829"
10375
10376 test_214() { # for bug 20133
10377         test_mkdir -p $DIR/d214p/d214c
10378         for (( i=0; i < 340; i++ )) ; do
10379                 touch $DIR/d214p/d214c/a$i
10380         done
10381
10382         ls -l $DIR/d214p || error "ls -l $DIR/d214p failed"
10383         mv $DIR/d214p/d214c $DIR/ || error "mv $DIR/d214p/d214c $DIR/ failed"
10384         ls $DIR/d214c || error "ls $DIR/d214c failed"
10385         rm -rf $DIR/d214* || error "rm -rf $DIR/d214* failed"
10386 }
10387 run_test 214 "hash-indexed directory test - bug 20133"
10388
10389 # having "abc" as 1st arg, creates $TMP/lnet_abc.out and $TMP/lnet_abc.sys
10390 create_lnet_proc_files() {
10391         cat /proc/sys/lnet/$1 >$TMP/lnet_$1.out || error "cannot read /proc/sys/lnet/$1"
10392         sysctl lnet.$1 >$TMP/lnet_$1.sys_tmp || error "cannot read lnet.$1"
10393
10394         sed "s/^lnet.$1\ =\ //g" "$TMP/lnet_$1.sys_tmp" >$TMP/lnet_$1.sys
10395         rm -f "$TMP/lnet_$1.sys_tmp"
10396 }
10397
10398 # counterpart of create_lnet_proc_files
10399 remove_lnet_proc_files() {
10400         rm -f $TMP/lnet_$1.out $TMP/lnet_$1.sys
10401 }
10402
10403 # uses 1st arg as trailing part of filename, 2nd arg as description for reports,
10404 # 3rd arg as regexp for body
10405 check_lnet_proc_stats() {
10406         local l=$(cat "$TMP/lnet_$1" |wc -l)
10407         [ $l = 1 ] || (cat "$TMP/lnet_$1" && error "$2 is not of 1 line: $l")
10408
10409         grep -E "$3" "$TMP/lnet_$1" || (cat "$TMP/lnet_$1" && error "$2 misformatted")
10410 }
10411
10412 # uses 1st arg as trailing part of filename, 2nd arg as description for reports,
10413 # 3rd arg as regexp for body, 4th arg as regexp for 1st line, 5th arg is
10414 # optional and can be regexp for 2nd line (lnet.routes case)
10415 check_lnet_proc_entry() {
10416         local blp=2            # blp stands for 'position of 1st line of body'
10417         [ "$5" = "" ] || blp=3 # lnet.routes case
10418
10419         local l=$(cat "$TMP/lnet_$1" |wc -l)
10420         # subtracting one from $blp because the body can be empty
10421         [ "$l" -ge "$(($blp - 1))" ] || (cat "$TMP/lnet_$1" && error "$2 is too short: $l")
10422
10423         sed -n '1 p' "$TMP/lnet_$1" |grep -E "$4" >/dev/null ||
10424                 (cat "$TMP/lnet_$1" && error "1st line of $2 misformatted")
10425
10426         [ "$5" = "" ] || sed -n '2 p' "$TMP/lnet_$1" |grep -E "$5" >/dev/null ||
10427                 (cat "$TMP/lnet_$1" && error "2nd line of $2 misformatted")
10428
10429         # bail out if any unexpected line happened
10430         sed -n "$blp~1 p" "$TMP/lnet_$1" |grep -Ev "$3"
10431         [ "$?" != 0 ] || error "$2 misformatted"
10432 }
10433
10434 test_215() { # for bugs 18102, 21079, 21517
10435         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10436         local N='(0|[1-9][0-9]*)'       # non-negative numeric
10437         local P='[1-9][0-9]*'           # positive numeric
10438         local I='(0|-?[1-9][0-9]*|NA)'  # any numeric (0 | >0 | <0) or NA if no value
10439         local NET='[a-z][a-z0-9]*'      # LNET net like o2ib2
10440         local ADDR='[0-9.]+'            # LNET addr like 10.0.0.1
10441         local NID="$ADDR@$NET"          # LNET nid like 10.0.0.1@o2ib2
10442
10443         local L1 # regexp for 1st line
10444         local L2 # regexp for 2nd line (optional)
10445         local BR # regexp for the rest (body)
10446
10447         # /proc/sys/lnet/stats should look as 11 space-separated non-negative numerics
10448         BR="^$N $N $N $N $N $N $N $N $N $N $N$"
10449         create_lnet_proc_files "stats"
10450         check_lnet_proc_stats "stats.out" "/proc/sys/lnet/stats" "$BR"
10451         check_lnet_proc_stats "stats.sys" "lnet.stats" "$BR"
10452         remove_lnet_proc_files "stats"
10453
10454         # /proc/sys/lnet/routes should look like this:
10455         # Routing disabled/enabled
10456         # net hops state router
10457         # where net is a string like tcp0, hops >= 0, state is up/down,
10458         # router is a string like 192.168.1.1@tcp2
10459         L1="^Routing (disabled|enabled)$"
10460         L2="^net +hops +state +router$"
10461         BR="^$NET +$N +(up|down) +$NID$"
10462         create_lnet_proc_files "routes"
10463         check_lnet_proc_entry "routes.out" "/proc/sys/lnet/routes" "$BR" "$L1" "$L2"
10464         check_lnet_proc_entry "routes.sys" "lnet.routes" "$BR" "$L1" "$L2"
10465         remove_lnet_proc_files "routes"
10466
10467         # /proc/sys/lnet/routers should look like this:
10468         # ref rtr_ref alive_cnt state last_ping ping_sent deadline down_ni router
10469         # where ref > 0, rtr_ref > 0, alive_cnt >= 0, state is up/down,
10470         # last_ping >= 0, ping_sent is boolean (0/1), deadline and down_ni are
10471         # numeric (0 or >0 or <0), router is a string like 192.168.1.1@tcp2
10472         L1="^ref +rtr_ref +alive_cnt +state +last_ping +ping_sent +deadline +down_ni +router$"
10473         BR="^$P +$P +$N +(up|down) +$N +(0|1) +$I +$I +$NID$"
10474         create_lnet_proc_files "routers"
10475         check_lnet_proc_entry "routers.out" "/proc/sys/lnet/routers" "$BR" "$L1"
10476         check_lnet_proc_entry "routers.sys" "lnet.routers" "$BR" "$L1"
10477         remove_lnet_proc_files "routers"
10478
10479         # /proc/sys/lnet/peers should look like this:
10480         # nid refs state last max rtr min tx min queue
10481         # where nid is a string like 192.168.1.1@tcp2, refs > 0,
10482         # state is up/down/NA, max >= 0. last, rtr, min, tx, min are
10483         # numeric (0 or >0 or <0), queue >= 0.
10484         L1="^nid +refs +state +last +max +rtr +min +tx +min +queue$"
10485         BR="^$NID +$P +(up|down|NA) +$I +$N +$I +$I +$I +$I +$N$"
10486         create_lnet_proc_files "peers"
10487         check_lnet_proc_entry "peers.out" "/proc/sys/lnet/peers" "$BR" "$L1"
10488         check_lnet_proc_entry "peers.sys" "lnet.peers" "$BR" "$L1"
10489         remove_lnet_proc_files "peers"
10490
10491         # /proc/sys/lnet/buffers  should look like this:
10492         # pages count credits min
10493         # where pages >=0, count >=0, credits and min are numeric (0 or >0 or <0)
10494         L1="^pages +count +credits +min$"
10495         BR="^ +$N +$N +$I +$I$"
10496         create_lnet_proc_files "buffers"
10497         check_lnet_proc_entry "buffers.out" "/proc/sys/lnet/buffers" "$BR" "$L1"
10498         check_lnet_proc_entry "buffers.sys" "lnet.buffers" "$BR" "$L1"
10499         remove_lnet_proc_files "buffers"
10500
10501         # /proc/sys/lnet/nis should look like this:
10502         # nid status alive refs peer rtr max tx min
10503         # where nid is a string like 192.168.1.1@tcp2, status is up/down,
10504         # alive is numeric (0 or >0 or <0), refs >= 0, peer >= 0,
10505         # rtr >= 0, max >=0, tx and min are numeric (0 or >0 or <0).
10506         L1="^nid +status +alive +refs +peer +rtr +max +tx +min$"
10507         BR="^$NID +(up|down) +$I +$N +$N +$N +$N +$I +$I$"
10508         create_lnet_proc_files "nis"
10509         check_lnet_proc_entry "nis.out" "/proc/sys/lnet/nis" "$BR" "$L1"
10510         check_lnet_proc_entry "nis.sys" "lnet.nis" "$BR" "$L1"
10511         remove_lnet_proc_files "nis"
10512
10513         # can we successfully write to /proc/sys/lnet/stats?
10514         echo "0" >/proc/sys/lnet/stats || error "cannot write to /proc/sys/lnet/stats"
10515         sysctl -w lnet.stats=0 || error "cannot write to lnet.stats"
10516 }
10517 run_test 215 "/proc/sys/lnet exists and has proper content - bugs 18102, 21079, 21517"
10518
10519 test_216() { # bug 20317
10520         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10521         remote_ost_nodsh && skip "remote OST with nodsh" && return
10522
10523         local node
10524         local facets=$(get_facets OST)
10525         local p="$TMP/$TESTSUITE-$TESTNAME.parameters"
10526
10527         save_lustre_params client "osc.*.contention_seconds" > $p
10528         save_lustre_params $facets \
10529                 "ldlm.namespaces.filter-*.max_nolock_bytes" >> $p
10530         save_lustre_params $facets \
10531                 "ldlm.namespaces.filter-*.contended_locks" >> $p
10532         save_lustre_params $facets \
10533                 "ldlm.namespaces.filter-*.contention_seconds" >> $p
10534         clear_osc_stats
10535
10536         # agressive lockless i/o settings
10537         for node in $(osts_nodes); do
10538                 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'
10539         done
10540         lctl set_param -n osc.*.contention_seconds 60
10541
10542         $DIRECTIO write $DIR/$tfile 0 10 4096
10543         $CHECKSTAT -s 40960 $DIR/$tfile
10544
10545         # disable lockless i/o
10546         for node in $(osts_nodes); do
10547                 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'
10548         done
10549         lctl set_param -n osc.*.contention_seconds 0
10550         clear_osc_stats
10551
10552         dd if=/dev/zero of=$DIR/$tfile count=0
10553         $CHECKSTAT -s 0 $DIR/$tfile
10554
10555         restore_lustre_params <$p
10556         rm -f $p
10557         rm $DIR/$tfile
10558 }
10559 run_test 216 "check lockless direct write works and updates file size and kms correctly"
10560
10561 test_217() { # bug 22430
10562         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10563         local node
10564         local nid
10565
10566         for node in $(nodes_list); do
10567                 nid=$(host_nids_address $node $NETTYPE)
10568                 if [[ $nid = *-* ]] ; then
10569                         echo "lctl ping $nid@$NETTYPE"
10570                         lctl ping $nid@$NETTYPE
10571                 else
10572                         echo "skipping $node (no hyphen detected)"
10573                 fi
10574         done
10575 }
10576 run_test 217 "check lctl ping for hostnames with hiphen ('-')"
10577
10578 test_218() {
10579        # do directio so as not to populate the page cache
10580        log "creating a 10 Mb file"
10581        $MULTIOP $DIR/$tfile oO_CREAT:O_DIRECT:O_RDWR:w$((10*1048576))c || error "multiop failed while creating a file"
10582        log "starting reads"
10583        dd if=$DIR/$tfile of=/dev/null bs=4096 &
10584        log "truncating the file"
10585        $MULTIOP $DIR/$tfile oO_TRUNC:c || error "multiop failed while truncating the file"
10586        log "killing dd"
10587        kill %+ || true # reads might have finished
10588        echo "wait until dd is finished"
10589        wait
10590        log "removing the temporary file"
10591        rm -rf $DIR/$tfile || error "tmp file removal failed"
10592 }
10593 run_test 218 "parallel read and truncate should not deadlock ======================="
10594
10595 test_219() {
10596         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10597         # write one partial page
10598         dd if=/dev/zero of=$DIR/$tfile bs=1024 count=1
10599         # set no grant so vvp_io_commit_write will do sync write
10600         $LCTL set_param fail_loc=0x411
10601         # write a full page at the end of file
10602         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 seek=1 conv=notrunc
10603
10604         $LCTL set_param fail_loc=0
10605         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 seek=3
10606         $LCTL set_param fail_loc=0x411
10607         dd if=/dev/zero of=$DIR/$tfile bs=1024 count=1 seek=2 conv=notrunc
10608 }
10609 run_test 219 "LU-394: Write partial won't cause uncontiguous pages vec at LND"
10610
10611 test_220() { #LU-325
10612         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10613         remote_ost_nodsh && skip "remote OST with nodsh" && return
10614         local OSTIDX=0
10615
10616         test_mkdir -p $DIR/$tdir
10617         local OST=$(lfs osts | grep ${OSTIDX}": " | \
10618                 awk '{print $2}' | sed -e 's/_UUID$//')
10619
10620         # on the mdt's osc
10621         local mdtosc_proc1=$(get_mdtosc_proc_path $SINGLEMDS $OST)
10622         local last_id=$(do_facet $SINGLEMDS lctl get_param -n \
10623                         osc.$mdtosc_proc1.prealloc_last_id)
10624         local next_id=$(do_facet $SINGLEMDS lctl get_param -n \
10625                         osc.$mdtosc_proc1.prealloc_next_id)
10626
10627         $LFS df -i
10628
10629         do_facet ost$((OSTIDX + 1)) lctl set_param fail_val=-1
10630         #define OBD_FAIL_OST_ENOINO              0x229
10631         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=0x229
10632         do_facet mgs $LCTL pool_new $FSNAME.$TESTNAME || return 1
10633         do_facet mgs $LCTL pool_add $FSNAME.$TESTNAME $OST || return 2
10634
10635         $SETSTRIPE $DIR/$tdir -i $OSTIDX -c 1 -p $FSNAME.$TESTNAME
10636
10637         MDSOBJS=$((last_id - next_id))
10638         echo "preallocated objects on MDS is $MDSOBJS" "($last_id - $next_id)"
10639
10640         blocks=$($LFS df $MOUNT | awk '($1 == '$OSTIDX') { print $4 }')
10641         echo "OST still has $count kbytes free"
10642
10643         echo "create $MDSOBJS files @next_id..."
10644         createmany -o $DIR/$tdir/f $MDSOBJS || return 3
10645
10646         local last_id2=$(do_facet mds${MDSIDX} lctl get_param -n \
10647                         osc.$mdtosc_proc1.prealloc_last_id)
10648         local next_id2=$(do_facet mds${MDSIDX} lctl get_param -n \
10649                         osc.$mdtosc_proc1.prealloc_next_id)
10650
10651         echo "after creation, last_id=$last_id2, next_id=$next_id2"
10652         $LFS df -i
10653
10654         echo "cleanup..."
10655
10656         do_facet ost$((OSTIDX + 1)) lctl set_param fail_val=0
10657         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=0
10658
10659         do_facet mgs $LCTL pool_remove $FSNAME.$TESTNAME $OST || return 4
10660         do_facet mgs $LCTL pool_destroy $FSNAME.$TESTNAME || return 5
10661         echo "unlink $MDSOBJS files @$next_id..."
10662         unlinkmany $DIR/$tdir/f $MDSOBJS || return 6
10663 }
10664 run_test 220 "preallocated MDS objects still used if ENOSPC from OST"
10665
10666 test_221() {
10667         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10668         dd if=`which date` of=$MOUNT/date oflag=sync
10669         chmod +x $MOUNT/date
10670
10671         #define OBD_FAIL_LLITE_FAULT_TRUNC_RACE  0x1401
10672         $LCTL set_param fail_loc=0x80001401
10673
10674         $MOUNT/date > /dev/null
10675         rm -f $MOUNT/date
10676 }
10677 run_test 221 "make sure fault and truncate race to not cause OOM"
10678
10679 test_222a () {
10680         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10681        rm -rf $DIR/$tdir
10682        test_mkdir -p $DIR/$tdir
10683        $SETSTRIPE -c 1 -i 0 $DIR/$tdir
10684        createmany -o $DIR/$tdir/$tfile 10
10685        cancel_lru_locks mdc
10686        cancel_lru_locks osc
10687        #define OBD_FAIL_LDLM_AGL_DELAY           0x31a
10688        $LCTL set_param fail_loc=0x31a
10689        ls -l $DIR/$tdir > /dev/null || error "AGL for ls failed"
10690        $LCTL set_param fail_loc=0
10691        rm -r $DIR/$tdir
10692 }
10693 run_test 222a "AGL for ls should not trigger CLIO lock failure ================"
10694
10695 test_222b () {
10696         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10697        rm -rf $DIR/$tdir
10698        test_mkdir -p $DIR/$tdir
10699        $SETSTRIPE -c 1 -i 0 $DIR/$tdir
10700        createmany -o $DIR/$tdir/$tfile 10
10701        cancel_lru_locks mdc
10702        cancel_lru_locks osc
10703        #define OBD_FAIL_LDLM_AGL_DELAY           0x31a
10704        $LCTL set_param fail_loc=0x31a
10705        rm -r $DIR/$tdir || "AGL for rmdir failed"
10706        $LCTL set_param fail_loc=0
10707 }
10708 run_test 222b "AGL for rmdir should not trigger CLIO lock failure ============="
10709
10710 test_223 () {
10711         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10712        rm -rf $DIR/$tdir
10713        test_mkdir -p $DIR/$tdir
10714        $SETSTRIPE -c 1 -i 0 $DIR/$tdir
10715        createmany -o $DIR/$tdir/$tfile 10
10716        cancel_lru_locks mdc
10717        cancel_lru_locks osc
10718        #define OBD_FAIL_LDLM_AGL_NOLOCK          0x31b
10719        $LCTL set_param fail_loc=0x31b
10720        ls -l $DIR/$tdir > /dev/null || error "reenqueue failed"
10721        $LCTL set_param fail_loc=0
10722        rm -r $DIR/$tdir
10723 }
10724 run_test 223 "osc reenqueue if without AGL lock granted ======================="
10725
10726 test_224a() { # LU-1039, MRP-303
10727         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10728         #define OBD_FAIL_PTLRPC_CLIENT_BULK_CB   0x508
10729         $LCTL set_param fail_loc=0x508
10730         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 conv=fsync
10731         $LCTL set_param fail_loc=0
10732         df $DIR
10733 }
10734 run_test 224a "Don't panic on bulk IO failure"
10735
10736 test_224b() { # LU-1039, MRP-303
10737         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10738         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1
10739         cancel_lru_locks osc
10740         #define OBD_FAIL_PTLRPC_CLIENT_BULK_CB2   0x515
10741         $LCTL set_param fail_loc=0x515
10742         dd of=/dev/null if=$DIR/$tfile bs=4096 count=1
10743         $LCTL set_param fail_loc=0
10744         df $DIR
10745 }
10746 run_test 224b "Don't panic on bulk IO failure"
10747
10748 MDSSURVEY=${MDSSURVEY:-$(which mds-survey 2>/dev/null || true)}
10749 test_225a () {
10750         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10751         if [ -z ${MDSSURVEY} ]; then
10752               skip_env "mds-survey not found" && return
10753         fi
10754
10755         [ $MDSCOUNT -ge 2 ] &&
10756                 skip "skipping now for more than one MDT" && return
10757
10758        [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.51) ] ||
10759             { skip "Need MDS version at least 2.2.51"; return; }
10760
10761        local mds=$(facet_host $SINGLEMDS)
10762        local target=$(do_nodes $mds 'lctl dl' | \
10763                       awk "{if (\$2 == \"UP\" && \$3 == \"mdt\") {print \$4}}")
10764
10765        local cmd1="file_count=1000 thrhi=4"
10766        local cmd2="dir_count=2 layer=mdd stripe_count=0"
10767        local cmd3="rslt_loc=${TMP} targets=\"$mds:$target\" $MDSSURVEY"
10768        local cmd="$cmd1 $cmd2 $cmd3"
10769
10770        rm -f ${TMP}/mds_survey*
10771        echo + $cmd
10772        eval $cmd || error "mds-survey with zero-stripe failed"
10773        cat ${TMP}/mds_survey*
10774        rm -f ${TMP}/mds_survey*
10775 }
10776 run_test 225a "Metadata survey sanity with zero-stripe"
10777
10778 test_225b () {
10779         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10780
10781         if [ -z ${MDSSURVEY} ]; then
10782               skip_env "mds-survey not found" && return
10783         fi
10784         [ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.2.51) ] ||
10785             { skip "Need MDS version at least 2.2.51"; return; }
10786
10787         if [ $($LCTL dl | grep -c osc) -eq 0 ]; then
10788               skip_env "Need to mount OST to test" && return
10789         fi
10790
10791         [ $MDSCOUNT -ge 2 ] &&
10792                 skip "skipping now for more than one MDT" && return
10793        local mds=$(facet_host $SINGLEMDS)
10794        local target=$(do_nodes $mds 'lctl dl' | \
10795                       awk "{if (\$2 == \"UP\" && \$3 == \"mdt\") {print \$4}}")
10796
10797        local cmd1="file_count=1000 thrhi=4"
10798        local cmd2="dir_count=2 layer=mdd stripe_count=1"
10799        local cmd3="rslt_loc=${TMP} targets=\"$mds:$target\" $MDSSURVEY"
10800        local cmd="$cmd1 $cmd2 $cmd3"
10801
10802        rm -f ${TMP}/mds_survey*
10803        echo + $cmd
10804        eval $cmd || error "mds-survey with stripe_count failed"
10805        cat ${TMP}/mds_survey*
10806        rm -f ${TMP}/mds_survey*
10807 }
10808 run_test 225b "Metadata survey sanity with stripe_count = 1"
10809
10810 mcreate_path2fid () {
10811         local mode=$1
10812         local major=$2
10813         local minor=$3
10814         local name=$4
10815         local desc=$5
10816         local path=$DIR/$tdir/$name
10817         local fid
10818         local rc
10819         local fid_path
10820
10821         $MCREATE --mode=$1 --major=$2 --minor=$3 $path ||
10822                 error "cannot create $desc"
10823
10824         fid=$($LFS path2fid $path | tr -d '[' | tr -d ']')
10825         rc=$?
10826         [ $rc -ne 0 ] && error "cannot get fid of a $desc"
10827
10828         fid_path=$($LFS fid2path $MOUNT $fid)
10829         rc=$?
10830         [ $rc -ne 0 ] && error "cannot get path of $desc by $DIR $path $fid"
10831
10832         [ "$path" == "$fid_path" ] ||
10833                 error "fid2path returned $fid_path, expected $path"
10834
10835         echo "pass with $path and $fid"
10836 }
10837
10838 test_226a () {
10839         rm -rf $DIR/$tdir
10840         mkdir -p $DIR/$tdir
10841
10842         mcreate_path2fid 0010666 0 0 fifo "FIFO"
10843         mcreate_path2fid 0020666 1 3 null "character special file (null)"
10844         mcreate_path2fid 0020666 1 255 none "character special file (no device)"
10845         mcreate_path2fid 0040666 0 0 dir "directory"
10846         mcreate_path2fid 0060666 7 0 loop0 "block special file (loop)"
10847         mcreate_path2fid 0100666 0 0 file "regular file"
10848         mcreate_path2fid 0120666 0 0 link "symbolic link"
10849         mcreate_path2fid 0140666 0 0 sock "socket"
10850 }
10851 run_test 226a "call path2fid and fid2path on files of all type"
10852
10853 test_226b () {
10854         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
10855         rm -rf $DIR/$tdir
10856         local MDTIDX=1
10857
10858         mkdir -p $DIR/$tdir
10859         $LFS setdirstripe -i $MDTIDX $DIR/$tdir/remote_dir ||
10860                 error "create remote directory failed"
10861         mcreate_path2fid 0010666 0 0 "remote_dir/fifo" "FIFO"
10862         mcreate_path2fid 0020666 1 3 "remote_dir/null" \
10863                                 "character special file (null)"
10864         mcreate_path2fid 0020666 1 255 "remote_dir/none" \
10865                                 "character special file (no device)"
10866         mcreate_path2fid 0040666 0 0 "remote_dir/dir" "directory"
10867         mcreate_path2fid 0060666 7 0 "remote_dir/loop0" \
10868                                 "block special file (loop)"
10869         mcreate_path2fid 0100666 0 0 "remote_dir/file" "regular file"
10870         mcreate_path2fid 0120666 0 0 "remote_dir/link" "symbolic link"
10871         mcreate_path2fid 0140666 0 0 "remote_dir/sock" "socket"
10872 }
10873 run_test 226b "call path2fid and fid2path on files of all type under remote dir"
10874
10875 # LU-1299 Executing or running ldd on a truncated executable does not
10876 # cause an out-of-memory condition.
10877 test_227() {
10878         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10879         dd if=`which date` of=$MOUNT/date bs=1k count=1
10880         chmod +x $MOUNT/date
10881
10882         $MOUNT/date > /dev/null
10883         ldd $MOUNT/date > /dev/null
10884         rm -f $MOUNT/date
10885 }
10886 run_test 227 "running truncated executable does not cause OOM"
10887
10888 # LU-1512 try to reuse idle OI blocks
10889 test_228a() {
10890         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10891         [ "$(facet_fstype $SINGLEMDS)" != "ldiskfs" ] &&
10892                 skip "non-ldiskfs backend" && return
10893
10894         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
10895         local myDIR=$DIR/$tdir
10896
10897         mkdir -p $myDIR
10898         #define OBD_FAIL_SEQ_EXHAUST             0x1002
10899         $LCTL set_param fail_loc=0x80001002
10900         createmany -o $myDIR/t- 10000
10901         $LCTL set_param fail_loc=0
10902         # The guard is current the largest FID holder
10903         touch $myDIR/guard
10904         local SEQ=$($LFS path2fid $myDIR/guard | awk -F ':' '{print $1}' |
10905                     tr -d '[')
10906         local IDX=$(($SEQ % 64))
10907
10908         do_facet $SINGLEMDS sync
10909         # Make sure journal flushed.
10910         sleep 6
10911         local blk1=$(do_facet $SINGLEMDS \
10912                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
10913                      grep Blockcount | awk '{print $4}')
10914
10915         # Remove old files, some OI blocks will become idle.
10916         unlinkmany $myDIR/t- 10000
10917         # Create new files, idle OI blocks should be reused.
10918         createmany -o $myDIR/t- 2000
10919         do_facet $SINGLEMDS sync
10920         # Make sure journal flushed.
10921         sleep 6
10922         local blk2=$(do_facet $SINGLEMDS \
10923                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
10924                      grep Blockcount | awk '{print $4}')
10925
10926         [ $blk1 == $blk2 ] || error "old blk1=$blk1, new blk2=$blk2, unmatched!"
10927 }
10928 run_test 228a "try to reuse idle OI blocks"
10929
10930 test_228b() {
10931         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10932         [ "$(facet_fstype $SINGLEMDS)" != "ldiskfs" ] &&
10933                 skip "non-ldiskfs backend" && return
10934
10935         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
10936         local myDIR=$DIR/$tdir
10937
10938         mkdir -p $myDIR
10939         #define OBD_FAIL_SEQ_EXHAUST             0x1002
10940         $LCTL set_param fail_loc=0x80001002
10941         createmany -o $myDIR/t- 10000
10942         $LCTL set_param fail_loc=0
10943         # The guard is current the largest FID holder
10944         touch $myDIR/guard
10945         local SEQ=$($LFS path2fid $myDIR/guard | awk -F ':' '{print $1}' |
10946                     tr -d '[')
10947         local IDX=$(($SEQ % 64))
10948
10949         do_facet $SINGLEMDS sync
10950         # Make sure journal flushed.
10951         sleep 6
10952         local blk1=$(do_facet $SINGLEMDS \
10953                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
10954                      grep Blockcount | awk '{print $4}')
10955
10956         # Remove old files, some OI blocks will become idle.
10957         unlinkmany $myDIR/t- 10000
10958
10959         # stop the MDT
10960         stop $SINGLEMDS || error "Fail to stop MDT."
10961         # remount the MDT
10962         start $SINGLEMDS $MDT_DEV $MDS_MOUNT_OPTS || error "Fail to start MDT."
10963
10964         df $MOUNT || error "Fail to df."
10965         # Create new files, idle OI blocks should be reused.
10966         createmany -o $myDIR/t- 2000
10967         do_facet $SINGLEMDS sync
10968         # Make sure journal flushed.
10969         sleep 6
10970         local blk2=$(do_facet $SINGLEMDS \
10971                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
10972                      grep Blockcount | awk '{print $4}')
10973
10974         [ $blk1 == $blk2 ] || error "old blk1=$blk1, new blk2=$blk2, unmatched!"
10975 }
10976 run_test 228b "idle OI blocks can be reused after MDT restart"
10977
10978 #LU-1881
10979 test_228c() {
10980         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
10981         [ "$(facet_fstype $SINGLEMDS)" != "ldiskfs" ] &&
10982                 skip "non-ldiskfs backend" && return
10983
10984         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
10985         local myDIR=$DIR/$tdir
10986
10987         mkdir -p $myDIR
10988         #define OBD_FAIL_SEQ_EXHAUST             0x1002
10989         $LCTL set_param fail_loc=0x80001002
10990         # 20000 files can guarantee there are index nodes in the OI file
10991         createmany -o $myDIR/t- 20000
10992         $LCTL set_param fail_loc=0
10993         # The guard is current the largest FID holder
10994         touch $myDIR/guard
10995         local SEQ=$($LFS path2fid $myDIR/guard | awk -F ':' '{print $1}' |
10996                     tr -d '[')
10997         local IDX=$(($SEQ % 64))
10998
10999         do_facet $SINGLEMDS sync
11000         # Make sure journal flushed.
11001         sleep 6
11002         local blk1=$(do_facet $SINGLEMDS \
11003                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
11004                      grep Blockcount | awk '{print $4}')
11005
11006         # Remove old files, some OI blocks will become idle.
11007         unlinkmany $myDIR/t- 20000
11008         rm -f $myDIR/guard
11009         # The OI file should become empty now
11010
11011         # Create new files, idle OI blocks should be reused.
11012         createmany -o $myDIR/t- 2000
11013         do_facet $SINGLEMDS sync
11014         # Make sure journal flushed.
11015         sleep 6
11016         local blk2=$(do_facet $SINGLEMDS \
11017                      "$DEBUGFS -c -R \\\"stat oi.16.${IDX}\\\" $MDT_DEV" |
11018                      grep Blockcount | awk '{print $4}')
11019
11020         [ $blk1 == $blk2 ] || error "old blk1=$blk1, new blk2=$blk2, unmatched!"
11021 }
11022 run_test 228c "NOT shrink the last entry in OI index node to recycle idle leaf"
11023
11024 test_230a() {
11025         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11026         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
11027         local MDTIDX=1
11028
11029         mkdir -p $DIR/$tdir/test_230_local
11030         local mdt_idx=$($GETSTRIPE -M $DIR/$tdir/test_230_local)
11031         [ $mdt_idx -ne 0 ] &&
11032                 error "create local directory on wrong MDT $mdt_idx"
11033
11034         $LFS mkdir -i $MDTIDX $DIR/$tdir/test_230 ||
11035                         error "create remote directory failed"
11036         local mdt_idx=$($GETSTRIPE -M $DIR/$tdir/test_230)
11037         [ $mdt_idx -ne $MDTIDX ] &&
11038                 error "create remote directory on wrong MDT $mdt_idx"
11039
11040         createmany -o $DIR/$tdir/test_230/t- 10 ||
11041                 error "create files on remote directory failed"
11042         mdt_idx=$($GETSTRIPE -M $DIR/$tdir/test_230/t-0)
11043         [ $mdt_idx -ne $MDTIDX ] && error "create files on wrong MDT $mdt_idx"
11044         rm -r $DIR/$tdir || error "unlink remote directory failed"
11045 }
11046 run_test 230a "Create remote directory and files under the remote directory"
11047
11048 test_230b() {
11049         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11050         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
11051         local MDTIDX=1
11052         local remote_dir=$DIR/$tdir/remote_dir
11053         local rc=0
11054
11055         mkdir -p $DIR/$tdir
11056         $LFS mkdir -i $MDTIDX $remote_dir ||
11057                 error "create remote directory failed"
11058
11059         $LFS mkdir -i 0 $remote_dir/new_dir &&
11060                 error "nested remote directory create succeed!"
11061
11062         do_facet mds$((MDTIDX + 1)) lctl set_param mdt.*.enable_remote_dir=1
11063         $LFS mkdir -i 0 $remote_dir/new_dir || rc=$?
11064         do_facet mds$((MDTIDX + 1)) lctl set_param mdt.*.enable_remote_dir=0
11065
11066         [ $rc -ne 0 ] &&
11067            error "create remote directory failed after set enable_remote_dir"
11068
11069         rm -rf $remote_dir || error "first unlink remote directory failed"
11070
11071         $RUNAS -G$RUNAS_GID $LFS mkdir -i $MDTIDX $DIR/$tfile &&
11072                                                         error "chown worked"
11073
11074         do_facet mds$MDTIDX lctl set_param \
11075                                 mdt.*.enable_remote_dir_gid=$RUNAS_GID
11076         $LFS mkdir -i $MDTIDX $remote_dir || rc=$?
11077         do_facet mds$MDTIDX lctl set_param mdt.*.enable_remote_dir_gid=0
11078
11079         [ $rc -ne 0 ] &&
11080            error "create remote dir failed after set enable_remote_dir_gid"
11081
11082         rm -r $DIR/$tdir || error "second unlink remote directory failed"
11083 }
11084 run_test 230b "nested remote directory should be failed"
11085
11086 test_231a()
11087 {
11088         # For simplicity this test assumes that max_pages_per_rpc
11089         # is the same across all OSCs
11090         local max_pages=$($LCTL get_param -n osc.*.max_pages_per_rpc | head -1)
11091         local bulk_size=$((max_pages * 4096))
11092
11093         mkdir -p $DIR/$tdir
11094
11095         # clear the OSC stats
11096         $LCTL set_param osc.*.stats=0 &>/dev/null
11097
11098         # Client writes $bulk_size - there must be 1 rpc for $max_pages.
11099         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=$bulk_size count=1 \
11100                 oflag=direct &>/dev/null || error "dd failed"
11101
11102         local nrpcs=$($LCTL get_param osc.*.stats |awk '/ost_write/ {print $2}')
11103         if [ x$nrpcs != "x1" ]; then
11104                 error "found $nrpc ost_write RPCs, not 1 as expected"
11105         fi
11106
11107         # Drop the OSC cache, otherwise we will read from it
11108         cancel_lru_locks osc
11109
11110         # clear the OSC stats
11111         $LCTL set_param osc.*.stats=0 &>/dev/null
11112
11113         # Client reads $bulk_size.
11114         dd if=$DIR/$tdir/$tfile of=/dev/null bs=$bulk_size count=1 \
11115                 iflag=direct &>/dev/null || error "dd failed"
11116
11117         nrpcs=$($LCTL get_param osc.*.stats | awk '/ost_read/ { print $2 }')
11118         if [ x$nrpcs != "x1" ]; then
11119                 error "found $nrpc ost_read RPCs, not 1 as expected"
11120         fi
11121 }
11122 run_test 231a "checking that reading/writing of BRW RPC size results in one RPC"
11123
11124 test_231b() {
11125         mkdir -p $DIR/$tdir
11126         local i
11127         for i in {0..1023}; do
11128                 dd if=/dev/zero of=$DIR/$tdir/$tfile conv=notrunc \
11129                         seek=$((2 * i)) bs=4096 count=1 &>/dev/null ||
11130                         error "dd of=$DIR/$tdir/$tfile seek=$((2 * i)) failed"
11131         done
11132         sync
11133 }
11134 run_test 231b "must not assert on fully utilized OST request buffer"
11135
11136 test_232() {
11137         mkdir -p $DIR/$tdir
11138         #define OBD_FAIL_LDLM_OST_LVB            0x31c
11139         $LCTL set_param fail_loc=0x31c
11140
11141         # ignore dd failure
11142         dd if=/dev/zero of=$DIR/$tdir/$tfile bs=1M count=1 || true
11143
11144         $LCTL set_param fail_loc=0
11145         umount_client $MOUNT || error "umount failed"
11146         mount_client $MOUNT || error "mount failed"
11147 }
11148 run_test 232 "failed lock should not block umount"
11149
11150 #
11151 # tests that do cleanup/setup should be run at the end
11152 #
11153
11154 test_900() {
11155         [ $PARALLEL == "yes" ] && skip "skip parallel run" && return
11156         local ls
11157         #define OBD_FAIL_MGC_PAUSE_PROCESS_LOG   0x903
11158         $LCTL set_param fail_loc=0x903
11159         # cancel_lru_locks mgc - does not work due to lctl set_param syntax
11160         for ls in /proc/fs/lustre/ldlm/namespaces/MGC*/lru_size; do
11161                 echo "clear" > $ls
11162         done
11163         FAIL_ON_ERROR=true cleanup
11164         FAIL_ON_ERROR=true setup
11165 }
11166 run_test 900 "umount should not race with any mgc requeue thread"
11167
11168 complete $SECONDS
11169 check_and_cleanup_lustre
11170 if [ "$I_MOUNTED" != "yes" ]; then
11171         lctl set_param debug="$OLDDEBUG" 2> /dev/null || true
11172 fi
11173 exit_status