lustre/tests/sanity.sh

   1 #!/bin/bash
   2 # -*- mode: Bash; tab-width: 4; indent-tabs-mode: t; -*-
   3 # vim:autoindent:shiftwidth=4:tabstop=4:
   4 #
   5 # Run select tests by setting ONLY, or as arguments to the script.
   6 # Skip specific tests by setting EXCEPT.
   7 #
   8 # e.g. ONLY="22 23" or ONLY="`seq 32 39`" or EXCEPT="31"
   9 set -e
  10
  11 ONLY=${ONLY:-"$*"}
  12 # bug number for skipped test: 13297 2108 9789 3637 9789 3561 12622 12653 12653 5188 16260 19742
  13 ALWAYS_EXCEPT="                27u   42a  42b  42c  42d  45   51d   65a   65e   68b  $SANITY_EXCEPT"
  14 # bug number for skipped test: 2108 9789 3637 9789 3561 5188/5749 1443
  15 #ALWAYS_EXCEPT=${ALWAYS_EXCEPT:-"27m 42a 42b 42c 42d 45 68 76"}
  16 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  17
  18 # Tests that fail on uml
  19 CPU=`awk '/model/ {print $4}' /proc/cpuinfo`
  20 #                                    buffer i/o errs             sock spc runas
  21 [ "$CPU" = "UML" ] && EXCEPT="$EXCEPT 27m 27n 27o 27p 27q 27r 31d 54a  64b 99a 99b 99c 99d 99e 99f 101"
  22
  23 case `uname -r` in
  24 2.4*) FSTYPE=${FSTYPE:-ext3} ;;
  25 2.6*) FSTYPE=${FSTYPE:-ldiskfs} ;;
  26 *) error "unsupported kernel" ;;
  27 esac
  28
  29 SRCDIR=$(cd $(dirname $0); echo $PWD)
  30 export PATH=$PATH:/sbin
  31
  32 TMP=${TMP:-/tmp}
  33
  34 CHECKSTAT=${CHECKSTAT:-"checkstat -v"}
  35 CREATETEST=${CREATETEST:-createtest}
  36 LFS=${LFS:-lfs}
  37 SETSTRIPE=${SETSTRIPE:-"$LFS setstripe"}
  38 GETSTRIPE=${GETSTRIPE:-"$LFS getstripe"}
  39 LSTRIPE=${LSTRIPE:-"$LFS setstripe"}
  40 LFIND=${LFIND:-"$LFS find"}
  41 LVERIFY=${LVERIFY:-ll_dirstripe_verify}
  42 LCTL=${LCTL:-lctl}
  43 MCREATE=${MCREATE:-mcreate}
  44 OPENFILE=${OPENFILE:-openfile}
  45 OPENUNLINK=${OPENUNLINK:-openunlink}
  46 READS=${READS:-"reads"}
  47 TRUNCATE=${TRUNCATE:-truncate}
  48 MUNLINK=${MUNLINK:-munlink}
  49 SOCKETSERVER=${SOCKETSERVER:-socketserver}
  50 SOCKETCLIENT=${SOCKETCLIENT:-socketclient}
  51 IOPENTEST1=${IOPENTEST1:-iopentest1}
  52 IOPENTEST2=${IOPENTEST2:-iopentest2}
  53 MEMHOG=${MEMHOG:-memhog}
  54 DIRECTIO=${DIRECTIO:-directio}
  55 ACCEPTOR_PORT=${ACCEPTOR_PORT:-988}
  56 UMOUNT=${UMOUNT:-"umount -d"}
  57 STRIPES_PER_OBJ=-1
  58 CHECK_GRANT=${CHECK_GRANT:-"yes"}
  59 GRANT_CHECK_LIST=${GRANT_CHECK_LIST:-""}
  60
  61 export NAME=${NAME:-local}
  62
  63 SAVE_PWD=$PWD
  64
  65 CLEANUP=${CLEANUP:-:}
  66 SETUP=${SETUP:-:}
  67 TRACE=${TRACE:-""}
  68 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
  69 . $LUSTRE/tests/test-framework.sh
  70 init_test_env $@
  71 . ${CONFIG:=$LUSTRE/tests/cfg/${NAME}.sh}
  72 init_logging
  73
  74 [ "$SLOW" = "no" ] && EXCEPT_SLOW="24o 24v 27m 36f 36g 36h 51b 51c 60c 63 64b 68 71 73 77f 78 101 103 115 120g 124b"
  75
  76 SANITYLOG=${TESTSUITELOG:-$TMP/$(basename $0 .sh).log}
  77 FAIL_ON_ERROR=false
  78
  79 cleanup() {
  80         echo -n "cln.."
  81         pgrep ll_sa > /dev/null && { echo "There are ll_sa thread not exit!"; exit 20; }
  82         cleanupall ${FORCE} $* || { echo "FAILed to clean up"; exit 20; }
  83 }
  84 setup() {
  85         echo -n "mnt.."
  86         load_modules
  87         setupall || exit 10
  88         echo "done"
  89 }
  90
  91 check_kernel_version() {
  92         WANT_VER=$1
  93         GOT_VER=$(lctl get_param -n version | awk '/kernel:/ {print $2}')
  94         case $GOT_VER in
  95         patchless|patchless_client) return 0;;
  96         *) [ $GOT_VER -ge $WANT_VER ] && return 0 ;;
  97         esac
  98         log "test needs at least kernel version $WANT_VER, running $GOT_VER"
  99         return 1
 100 }
 101
 102 if [ "$ONLY" == "cleanup" ]; then
 103        sh llmountcleanup.sh
 104        exit 0
 105 fi
 106
 107 [ "$SANITYLOG" ] && rm -f $SANITYLOG || true
 108
 109 check_and_setup_lustre
 110
 111 DIR=${DIR:-$MOUNT}
 112 assert_DIR
 113
 114 MDT0=$($LCTL get_param -n mdc.*.mds_server_uuid | \
 115     awk '{gsub(/_UUID/,""); print $1}' | head -1)
 116 LOVNAME=$($LCTL get_param -n llite.*.lov.common_name | tail -n 1)
 117 OSTCOUNT=$($LCTL get_param -n lov.$LOVNAME.numobd)
 118 STRIPECOUNT=$($LCTL get_param -n lov.$LOVNAME.stripecount)
 119 STRIPESIZE=$($LCTL get_param -n lov.$LOVNAME.stripesize)
 120 ORIGFREE=$($LCTL get_param -n lov.$LOVNAME.kbytesavail)
 121 MAXFREE=${MAXFREE:-$((200000 * $OSTCOUNT))}
 122
 123 [ -f $DIR/d52a/foo ] && chattr -a $DIR/d52a/foo
 124 [ -f $DIR/d52b/foo ] && chattr -i $DIR/d52b/foo
 125 rm -rf $DIR/[Rdfs][0-9]*
 126
 127 # $RUNAS_ID may get set incorrectly somewhere else
 128 [ $UID -eq 0 -a $RUNAS_ID -eq 0 ] && error "\$RUNAS_ID set to 0, but \$UID is also 0!"
 129
 130 check_runas_id $RUNAS_ID $RUNAS_ID $RUNAS
 131
 132 build_test_filter
 133
 134 if [ "${ONLY}" = "MOUNT" ] ; then
 135         echo "Lustre is up, please go on"
 136         exit
 137 fi
 138
 139 echo "preparing for tests involving mounts"
 140 EXT2_DEV=${EXT2_DEV:-$TMP/SANITY.LOOP}
 141 touch $EXT2_DEV
 142 mke2fs -j -F $EXT2_DEV 8000 > /dev/null
 143 echo # add a newline after mke2fs.
 144
 145 umask 077
 146
 147 OLDDEBUG="`lctl get_param -n debug 2> /dev/null`"
 148 lctl set_param debug=-1 2> /dev/null || true
 149 test_0() {
 150         touch $DIR/$tfile
 151         $CHECKSTAT -t file $DIR/$tfile || error
 152         rm $DIR/$tfile
 153         $CHECKSTAT -a $DIR/$tfile || error
 154 }
 155 run_test 0 "touch .../$tfile ; rm .../$tfile ====================="
 156
 157 test_0b() {
 158         chmod 0755 $DIR || error
 159         $CHECKSTAT -p 0755 $DIR || error
 160 }
 161 run_test 0b "chmod 0755 $DIR ============================="
 162
 163 test_0c() {
 164     $LCTL get_param mdc.*.import | grep  "state: FULL" || error "import not FULL"
 165     $LCTL get_param mdc.*.import | grep  "target: $FSNAME-MDT" || error "bad target"
 166 }
 167 run_test 0c "check import proc ============================="
 168
 169 test_1a() {
 170         mkdir $DIR/d1
 171         mkdir $DIR/d1/d2
 172         mkdir $DIR/d1/d2 && error "we expect EEXIST, but not returned"
 173         $CHECKSTAT -t dir $DIR/d1/d2 || error
 174 }
 175 run_test 1a "mkdir .../d1; mkdir .../d1/d2 ====================="
 176
 177 test_1b() {
 178         rmdir $DIR/d1/d2
 179         rmdir $DIR/d1
 180         $CHECKSTAT -a $DIR/d1 || error
 181 }
 182 run_test 1b "rmdir .../d1/d2; rmdir .../d1 ====================="
 183
 184 test_2a() {
 185         mkdir $DIR/d2
 186         touch $DIR/d2/f
 187         $CHECKSTAT -t file $DIR/d2/f || error
 188 }
 189 run_test 2a "mkdir .../d2; touch .../d2/f ======================"
 190
 191 test_2b() {
 192         rm -r $DIR/d2
 193         $CHECKSTAT -a $DIR/d2 || error
 194 }
 195 run_test 2b "rm -r .../d2; checkstat .../d2/f ======================"
 196
 197 test_3a() {
 198         mkdir $DIR/d3
 199         $CHECKSTAT -t dir $DIR/d3 || error
 200 }
 201 run_test 3a "mkdir .../d3 ======================================"
 202
 203 test_3b() {
 204         if [ ! -d $DIR/d3 ]; then
 205                 mkdir $DIR/d3
 206         fi
 207         touch $DIR/d3/f
 208         $CHECKSTAT -t file $DIR/d3/f || error
 209 }
 210 run_test 3b "touch .../d3/f ===================================="
 211
 212 test_3c() {
 213         rm -r $DIR/d3
 214         $CHECKSTAT -a $DIR/d3 || error
 215 }
 216 run_test 3c "rm -r .../d3 ======================================"
 217
 218 test_4a() {
 219         mkdir $DIR/d4
 220         $CHECKSTAT -t dir $DIR/d4 || error
 221 }
 222 run_test 4a "mkdir .../d4 ======================================"
 223
 224 test_4b() {
 225         if [ ! -d $DIR/d4 ]; then
 226                 mkdir $DIR/d4
 227         fi
 228         mkdir $DIR/d4/d2
 229         $CHECKSTAT -t dir $DIR/d4/d2 || error
 230 }
 231 run_test 4b "mkdir .../d4/d2 ==================================="
 232
 233 test_5() {
 234         mkdir $DIR/d5
 235         mkdir $DIR/d5/d2
 236         chmod 0707 $DIR/d5/d2
 237         $CHECKSTAT -t dir -p 0707 $DIR/d5/d2 || error
 238 }
 239 run_test 5 "mkdir .../d5 .../d5/d2; chmod .../d5/d2 ============"
 240
 241 test_6a() {
 242         touch $DIR/f6a
 243         chmod 0666 $DIR/f6a || error
 244         $CHECKSTAT -t file -p 0666 -u \#$UID $DIR/f6a || error
 245 }
 246 run_test 6a "touch .../f6a; chmod .../f6a ======================"
 247
 248 test_6b() {
 249         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
 250         if [ ! -f $DIR/f6a ]; then
 251                 touch $DIR/f6a
 252                 chmod 0666 $DIR/f6a
 253         fi
 254         $RUNAS chmod 0444 $DIR/f6a && error
 255         $CHECKSTAT -t file -p 0666 -u \#$UID $DIR/f6a || error
 256 }
 257 run_test 6b "$RUNAS chmod .../f6a (should return error) =="
 258
 259 test_6c() {
 260         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
 261         touch $DIR/f6c
 262         chown $RUNAS_ID $DIR/f6c || error
 263         $CHECKSTAT -t file -u \#$RUNAS_ID $DIR/f6c || error
 264 }
 265 run_test 6c "touch .../f6c; chown .../f6c ======================"
 266
 267 test_6d() {
 268         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
 269         if [ ! -f $DIR/f6c ]; then
 270                 touch $DIR/f6c
 271                 chown $RUNAS_ID $DIR/f6c
 272         fi
 273         $RUNAS chown $UID $DIR/f6c && error
 274         $CHECKSTAT -t file -u \#$RUNAS_ID $DIR/f6c || error
 275 }
 276 run_test 6d "$RUNAS chown .../f6c (should return error) =="
 277
 278 test_6e() {
 279         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
 280         touch $DIR/f6e
 281         chgrp $RUNAS_ID $DIR/f6e || error
 282         $CHECKSTAT -t file -u \#$UID -g \#$RUNAS_ID $DIR/f6e || error
 283 }
 284 run_test 6e "touch .../f6e; chgrp .../f6e ======================"
 285
 286 test_6f() {
 287         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
 288         if [ ! -f $DIR/f6e ]; then
 289                 touch $DIR/f6e
 290                 chgrp $RUNAS_ID $DIR/f6e
 291         fi
 292         $RUNAS chgrp $UID $DIR/f6e && error
 293         $CHECKSTAT -t file -u \#$UID -g \#$RUNAS_ID $DIR/f6e || error
 294 }
 295 run_test 6f "$RUNAS chgrp .../f6e (should return error) =="
 296
 297 test_6g() {
 298         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
 299         mkdir $DIR/d6g || error
 300         chmod 777 $DIR/d6g || error
 301         $RUNAS mkdir $DIR/d6g/d || error
 302         chmod g+s $DIR/d6g/d || error
 303         mkdir $DIR/d6g/d/subdir
 304         $CHECKSTAT -g \#$RUNAS_ID $DIR/d6g/d/subdir || error
 305 }
 306 run_test 6g "Is new dir in sgid dir inheriting group?"
 307
 308 test_6h() { # bug 7331
 309         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
 310         touch $DIR/f6h || error "touch failed"
 311         chown $RUNAS_ID:$RUNAS_ID $DIR/f6h || error "initial chown failed"
 312         $RUNAS -G$RUNAS_ID chown $RUNAS_ID:0 $DIR/f6h && error "chown worked"
 313         $CHECKSTAT -t file -u \#$RUNAS_ID -g \#$RUNAS_ID $DIR/f6h || error
 314 }
 315 run_test 6h "$RUNAS chown RUNAS_ID.0 .../f6h (should return error)"
 316
 317 test_7a() {
 318         mkdir $DIR/d7
 319         $MCREATE $DIR/d7/f
 320         chmod 0666 $DIR/d7/f
 321         $CHECKSTAT -t file -p 0666 $DIR/d7/f || error
 322 }
 323 run_test 7a "mkdir .../d7; mcreate .../d7/f; chmod .../d7/f ===="
 324
 325 test_7b() {
 326         if [ ! -d $DIR/d7 ]; then
 327                 mkdir $DIR/d7
 328         fi
 329         $MCREATE $DIR/d7/f2
 330         echo -n foo > $DIR/d7/f2
 331         [ "`cat $DIR/d7/f2`" = "foo" ] || error
 332         $CHECKSTAT -t file -s 3 $DIR/d7/f2 || error
 333 }
 334 run_test 7b "mkdir .../d7; mcreate d7/f2; echo foo > d7/f2 ====="
 335
 336 test_8() {
 337         mkdir $DIR/d8
 338         touch $DIR/d8/f
 339         chmod 0666 $DIR/d8/f
 340         $CHECKSTAT -t file -p 0666 $DIR/d8/f || error
 341 }
 342 run_test 8 "mkdir .../d8; touch .../d8/f; chmod .../d8/f ======="
 343
 344 test_9() {
 345         mkdir $DIR/d9
 346         mkdir $DIR/d9/d2
 347         mkdir $DIR/d9/d2/d3
 348         $CHECKSTAT -t dir $DIR/d9/d2/d3 || error
 349 }
 350 run_test 9 "mkdir .../d9 .../d9/d2 .../d9/d2/d3 ================"
 351
 352 test_10() {
 353         mkdir $DIR/d10
 354         mkdir $DIR/d10/d2
 355         touch $DIR/d10/d2/f
 356         $CHECKSTAT -t file $DIR/d10/d2/f || error
 357 }
 358 run_test 10 "mkdir .../d10 .../d10/d2; touch .../d10/d2/f ======"
 359
 360 test_11() {
 361         mkdir $DIR/d11
 362         mkdir $DIR/d11/d2
 363         chmod 0666 $DIR/d11/d2
 364         chmod 0705 $DIR/d11/d2
 365         $CHECKSTAT -t dir -p 0705 $DIR/d11/d2 || error
 366 }
 367 run_test 11 "mkdir .../d11 d11/d2; chmod .../d11/d2 ============"
 368
 369 test_12() {
 370         mkdir $DIR/d12
 371         touch $DIR/d12/f
 372         chmod 0666 $DIR/d12/f
 373         chmod 0654 $DIR/d12/f
 374         $CHECKSTAT -t file -p 0654 $DIR/d12/f || error
 375 }
 376 run_test 12 "touch .../d12/f; chmod .../d12/f .../d12/f ========"
 377
 378 test_13() {
 379         mkdir $DIR/d13
 380         dd if=/dev/zero of=$DIR/d13/f count=10
 381         >  $DIR/d13/f
 382         $CHECKSTAT -t file -s 0 $DIR/d13/f || error
 383 }
 384 run_test 13 "creat .../d13/f; dd .../d13/f; > .../d13/f ========"
 385
 386 test_14() {
 387         mkdir $DIR/d14
 388         touch $DIR/d14/f
 389         rm $DIR/d14/f
 390         $CHECKSTAT -a $DIR/d14/f || error
 391 }
 392 run_test 14 "touch .../d14/f; rm .../d14/f; rm .../d14/f ======="
 393
 394 test_15() {
 395         mkdir $DIR/d15
 396         touch $DIR/d15/f
 397         mv $DIR/d15/f $DIR/d15/f2
 398         $CHECKSTAT -t file $DIR/d15/f2 || error
 399 }
 400 run_test 15 "touch .../d15/f; mv .../d15/f .../d15/f2 =========="
 401
 402 test_16() {
 403         mkdir $DIR/d16
 404         touch $DIR/d16/f
 405         rm -rf $DIR/d16/f
 406         $CHECKSTAT -a $DIR/d16/f || error
 407 }
 408 run_test 16 "touch .../d16/f; rm -rf .../d16/f ================="
 409
 410 test_17a() {
 411         mkdir -p $DIR/d17
 412         touch $DIR/d17/f
 413         ln -s $DIR/d17/f $DIR/d17/l-exist
 414         ls -l $DIR/d17
 415         $CHECKSTAT -l $DIR/d17/f $DIR/d17/l-exist || error
 416         $CHECKSTAT -f -t f $DIR/d17/l-exist || error
 417         rm -f $DIR/d17/l-exist
 418         $CHECKSTAT -a $DIR/d17/l-exist || error
 419 }
 420 run_test 17a "symlinks: create, remove (real) =================="
 421
 422 test_17b() {
 423         mkdir -p $DIR/d17
 424         ln -s no-such-file $DIR/d17/l-dangle
 425         ls -l $DIR/d17
 426         $CHECKSTAT -l no-such-file $DIR/d17/l-dangle || error
 427         $CHECKSTAT -fa $DIR/d17/l-dangle || error
 428         rm -f $DIR/d17/l-dangle
 429         $CHECKSTAT -a $DIR/d17/l-dangle || error
 430 }
 431 run_test 17b "symlinks: create, remove (dangling) =============="
 432
 433 test_17c() { # bug 3440 - don't save failed open RPC for replay
 434         mkdir -p $DIR/d17
 435         ln -s foo $DIR/d17/f17c
 436         cat $DIR/d17/f17c && error "opened non-existent symlink" || true
 437 }
 438 run_test 17c "symlinks: open dangling (should return error) ===="
 439
 440 test_17d() {
 441         mkdir -p $DIR/d17
 442         ln -s foo $DIR/d17/f17d
 443         touch $DIR/d17/f17d || error "creating to new symlink"
 444 }
 445 run_test 17d "symlinks: create dangling ========================"
 446
 447 test_17e() {
 448         mkdir -p $DIR/$tdir
 449         local foo=$DIR/$tdir/$tfile
 450         ln -s $foo $foo || error "create symlink failed"
 451         ls -l $foo || error "ls -l failed"
 452         ls $foo && error "ls not failed" || true
 453 }
 454 run_test 17e "symlinks: create recursive symlink (should return error) ===="
 455
 456 test_17f() {
 457         mkdir -p $DIR/d17f
 458         ln -s 1234567890/2234567890/3234567890/4234567890 $DIR/d17f/111
 459         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890 $DIR/d17f/222
 460         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890 $DIR/d17f/333
 461         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890 $DIR/d17f/444
 462         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890/c234567890/d234567890/f234567890 $DIR/d17f/555
 463         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
 464         ls -l  $DIR/d17f
 465 }
 466 run_test 17f "symlinks: long and very long symlink name ========================"
 467
 468 test_17g() {
 469         mkdir -p $DIR/$tdir
 470         LONGSYMLINK="$(dd if=/dev/zero bs=4095 count=1 | tr '\0' 'x')"
 471         ln -s $LONGSYMLINK $DIR/$tdir/$tfile
 472         ls -l $DIR/$tdir
 473 }
 474 run_test 17g "symlinks: really long symlink name ==============================="
 475
 476 test_17h() { #bug 17378
 477         mkdir -p $DIR/$tdir
 478         $SETSTRIPE $DIR/$tdir -c -1
 479 #define OBD_FAIL_MDS_LOV_PREP_CREATE 0x141
 480         do_facet mds lctl set_param fail_loc=0x80000141
 481         touch $DIR/$tdir/$tfile || true
 482 }
 483 run_test 17h "create objects: lov_free_memmd() doesn't lbug"
 484
 485 test_17i() { #bug 20018
 486         mkdir -p $DIR/$tdir
 487         local foo=$DIR/$tdir/$tfile
 488         ln -s $foo $foo || error "create symlink failed"
 489 #define OBD_FAIL_MDS_READLINK_EPROTO     0x143
 490         do_facet mds lctl set_param fail_loc=0x80000143
 491         ls -l $foo && error "error not detected"
 492         return 0
 493 }
 494 run_test 17i "don't panic on short symlink"
 495
 496 test_18() {
 497         touch $DIR/f
 498         ls $DIR || error
 499 }
 500 run_test 18 "touch .../f ; ls ... =============================="
 501
 502 test_19a() {
 503         touch $DIR/f19
 504         ls -l $DIR
 505         rm $DIR/f19
 506         $CHECKSTAT -a $DIR/f19 || error
 507 }
 508 run_test 19a "touch .../f19 ; ls -l ... ; rm .../f19 ==========="
 509
 510 test_19b() {
 511         ls -l $DIR/f19 && error || true
 512 }
 513 run_test 19b "ls -l .../f19 (should return error) =============="
 514
 515 test_19c() {
 516         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
 517         $RUNAS touch $DIR/f19 && error || true
 518 }
 519 run_test 19c "$RUNAS touch .../f19 (should return error) =="
 520
 521 test_19d() {
 522         cat $DIR/f19 && error || true
 523 }
 524 run_test 19d "cat .../f19 (should return error) =============="
 525
 526 test_20() {
 527         touch $DIR/f
 528         rm $DIR/f
 529         log "1 done"
 530         touch $DIR/f
 531         rm $DIR/f
 532         log "2 done"
 533         touch $DIR/f
 534         rm $DIR/f
 535         log "3 done"
 536         $CHECKSTAT -a $DIR/f || error
 537 }
 538 run_test 20 "touch .../f ; ls -l ... ==========================="
 539
 540 test_21() {
 541         mkdir $DIR/d21
 542         [ -f $DIR/d21/dangle ] && rm -f $DIR/d21/dangle
 543         ln -s dangle $DIR/d21/link
 544         echo foo >> $DIR/d21/link
 545         cat $DIR/d21/dangle
 546         $CHECKSTAT -t link $DIR/d21/link || error
 547         $CHECKSTAT -f -t file $DIR/d21/link || error
 548 }
 549 run_test 21 "write to dangling link ============================"
 550
 551 test_22() {
 552         WDIR=$DIR/$tdir
 553         mkdir -p $WDIR
 554         chown $RUNAS_ID $WDIR
 555         (cd $WDIR || error "cd $WDIR failed";
 556         $RUNAS tar cf - /etc/hosts /etc/sysconfig/network | \
 557         $RUNAS tar xf -)
 558         ls -lR $WDIR/etc || error "ls -lR $WDIR/etc failed"
 559         $CHECKSTAT -t dir $WDIR/etc || error "checkstat -t dir failed"
 560         $CHECKSTAT -u \#$RUNAS_ID $WDIR/etc || error "checkstat -u failed"
 561 }
 562 run_test 22 "unpack tar archive as non-root user ==============="
 563
 564 # was test_23
 565 test_23a() {
 566         mkdir -p $DIR/$tdir
 567         local file=$DIR/$tdir/$tfile
 568
 569         openfile -f O_CREAT:O_EXCL $file || error "$file create failed"
 570         openfile -f O_CREAT:O_EXCL $file &&
 571                 error "$file recreate succeeded" || true
 572 }
 573 run_test 23a "O_CREAT|O_EXCL in subdir =========================="
 574
 575 test_23b() { # bug 18988
 576         mkdir -p $DIR/$tdir
 577         local file=$DIR/$tdir/$tfile
 578
 579         rm -f $file
 580         echo foo > $file || error "write filed"
 581         echo bar >> $file || error "append filed"
 582         $CHECKSTAT -s 8 $file || error "wrong size"
 583         rm $file
 584 }
 585 run_test 23b "O_APPEND check =========================="
 586
 587 test_24a() {
 588         echo '== rename sanity =============================================='
 589         echo '-- same directory rename'
 590         mkdir $DIR/R1
 591         touch $DIR/R1/f
 592         mv $DIR/R1/f $DIR/R1/g
 593         $CHECKSTAT -t file $DIR/R1/g || error
 594 }
 595 run_test 24a "touch .../R1/f; rename .../R1/f .../R1/g ========="
 596
 597 test_24b() {
 598         mkdir $DIR/R2
 599         touch $DIR/R2/{f,g}
 600         mv $DIR/R2/f $DIR/R2/g
 601         $CHECKSTAT -a $DIR/R2/f || error
 602         $CHECKSTAT -t file $DIR/R2/g || error
 603 }
 604 run_test 24b "touch .../R2/{f,g}; rename .../R2/f .../R2/g ====="
 605
 606 test_24c() {
 607         mkdir $DIR/R3
 608         mkdir $DIR/R3/f
 609         mv $DIR/R3/f $DIR/R3/g
 610         $CHECKSTAT -a $DIR/R3/f || error
 611         $CHECKSTAT -t dir $DIR/R3/g || error
 612 }
 613 run_test 24c "mkdir .../R3/f; rename .../R3/f .../R3/g ========="
 614
 615 test_24d() {
 616         mkdir $DIR/R4
 617         mkdir $DIR/R4/{f,g}
 618         mrename $DIR/R4/f $DIR/R4/g
 619         $CHECKSTAT -a $DIR/R4/f || error
 620         $CHECKSTAT -t dir $DIR/R4/g || error
 621 }
 622 run_test 24d "mkdir .../R4/{f,g}; rename .../R4/f .../R4/g ====="
 623
 624 test_24e() {
 625         echo '-- cross directory renames --'
 626         mkdir $DIR/R5{a,b}
 627         touch $DIR/R5a/f
 628         mv $DIR/R5a/f $DIR/R5b/g
 629         $CHECKSTAT -a $DIR/R5a/f || error
 630         $CHECKSTAT -t file $DIR/R5b/g || error
 631 }
 632 run_test 24e "touch .../R5a/f; rename .../R5a/f .../R5b/g ======"
 633
 634 test_24f() {
 635         mkdir $DIR/R6{a,b}
 636         touch $DIR/R6a/f $DIR/R6b/g
 637         mv $DIR/R6a/f $DIR/R6b/g
 638         $CHECKSTAT -a $DIR/R6a/f || error
 639         $CHECKSTAT -t file $DIR/R6b/g || error
 640 }
 641 run_test 24f "touch .../R6a/f R6b/g; mv .../R6a/f .../R6b/g ===="
 642
 643 test_24g() {
 644         mkdir $DIR/R7{a,b}
 645         mkdir $DIR/R7a/d
 646         mv $DIR/R7a/d $DIR/R7b/e
 647         $CHECKSTAT -a $DIR/R7a/d || error
 648         $CHECKSTAT -t dir $DIR/R7b/e || error
 649 }
 650 run_test 24g "mkdir .../R7{a,b}/d; mv .../R7a/d .../R7b/e ======"
 651
 652 test_24h() {
 653         mkdir $DIR/R8{a,b}
 654         mkdir $DIR/R8a/d $DIR/R8b/e
 655         mrename $DIR/R8a/d $DIR/R8b/e
 656         $CHECKSTAT -a $DIR/R8a/d || error
 657         $CHECKSTAT -t dir $DIR/R8b/e || error
 658 }
 659 run_test 24h "mkdir .../R8{a,b}/{d,e}; rename .../R8a/d .../R8b/e"
 660
 661 test_24i() {
 662         echo "-- rename error cases"
 663         mkdir $DIR/R9
 664         mkdir $DIR/R9/a
 665         touch $DIR/R9/f
 666         mrename $DIR/R9/f $DIR/R9/a
 667         $CHECKSTAT -t file $DIR/R9/f || error
 668         $CHECKSTAT -t dir  $DIR/R9/a || error
 669         $CHECKSTAT -a $DIR/R9/a/f || error
 670 }
 671 run_test 24i "rename file to dir error: touch f ; mkdir a ; rename f a"
 672
 673 test_24j() {
 674         mkdir $DIR/R10
 675         mrename $DIR/R10/f $DIR/R10/g
 676         $CHECKSTAT -t dir $DIR/R10 || error
 677         $CHECKSTAT -a $DIR/R10/f || error
 678         $CHECKSTAT -a $DIR/R10/g || error
 679 }
 680 run_test 24j "source does not exist ============================"
 681
 682 test_24k() {
 683         mkdir $DIR/R11a $DIR/R11a/d
 684         touch $DIR/R11a/f
 685         mv $DIR/R11a/f $DIR/R11a/d
 686         $CHECKSTAT -a $DIR/R11a/f || error
 687         $CHECKSTAT -t file $DIR/R11a/d/f || error
 688 }
 689 run_test 24k "touch .../R11a/f; mv .../R11a/f .../R11a/d ======="
 690
 691 # bug 2429 - rename foo foo foo creates invalid file
 692 test_24l() {
 693         f="$DIR/f24l"
 694         multiop $f OcNs || error
 695 }
 696 run_test 24l "Renaming a file to itself ========================"
 697
 698 test_24m() {
 699         f="$DIR/f24m"
 700         multiop $f OcLN ${f}2 ${f}2 || error "link ${f}2 ${f}2 failed"
 701         # on ext3 this does not remove either the source or target files
 702         # though the "expected" operation would be to remove the source
 703         $CHECKSTAT -t file ${f} || error "${f} missing"
 704         $CHECKSTAT -t file ${f}2 || error "${f}2 missing"
 705 }
 706 run_test 24m "Renaming a file to a hard link to itself ========="
 707
 708 test_24n() {
 709     f="$DIR/f24n"
 710     # this stats the old file after it was renamed, so it should fail
 711     touch ${f}
 712     $CHECKSTAT ${f}
 713     mv ${f} ${f}.rename
 714     $CHECKSTAT ${f}.rename
 715     $CHECKSTAT -a ${f}
 716 }
 717 run_test 24n "Statting the old file after renaming (Posix rename 2)"
 718
 719 test_24o() {
 720         check_kernel_version 37 || return 0
 721         mkdir -p $DIR/d24o
 722         rename_many -s random -v -n 10 $DIR/d24o
 723 }
 724 run_test 24o "rename of files during htree split ==============="
 725
 726 test_24p() {
 727         mkdir $DIR/R12{a,b}
 728         DIRINO=`ls -lid $DIR/R12a | awk '{ print $1 }'`
 729         mrename $DIR/R12a $DIR/R12b
 730         $CHECKSTAT -a $DIR/R12a || error
 731         $CHECKSTAT -t dir $DIR/R12b || error
 732         DIRINO2=`ls -lid $DIR/R12b | awk '{ print $1 }'`
 733         [ "$DIRINO" = "$DIRINO2" ] || error "R12a $DIRINO != R12b $DIRINO2"
 734 }
 735 run_test 24p "mkdir .../R12{a,b}; rename .../R12a .../R12b"
 736
 737 test_24q() {
 738         mkdir $DIR/R13{a,b}
 739         DIRINO=`ls -lid $DIR/R13a | awk '{ print $1 }'`
 740         multiop_bg_pause $DIR/R13b D_c || return 1
 741         MULTIPID=$!
 742
 743         mrename $DIR/R13a $DIR/R13b
 744         $CHECKSTAT -a $DIR/R13a || error
 745         $CHECKSTAT -t dir $DIR/R13b || error
 746         DIRINO2=`ls -lid $DIR/R13b | awk '{ print $1 }'`
 747         [ "$DIRINO" = "$DIRINO2" ] || error "R13a $DIRINO != R13b $DIRINO2"
 748         kill -USR1 $MULTIPID
 749         wait $MULTIPID || error "multiop close failed"
 750 }
 751 run_test 24q "mkdir .../R13{a,b}; open R13b rename R13a R13b ==="
 752
 753 test_24r() { #bug 3789
 754         mkdir $DIR/R14a $DIR/R14a/b
 755         mrename $DIR/R14a $DIR/R14a/b && error "rename to subdir worked!"
 756         $CHECKSTAT -t dir $DIR/R14a || error "$DIR/R14a missing"
 757         $CHECKSTAT -t dir $DIR/R14a/b || error "$DIR/R14a/b missing"
 758 }
 759 run_test 24r "mkdir .../R14a/b; rename .../R14a .../R14a/b ====="
 760
 761 test_24s() {
 762         mkdir $DIR/R15a $DIR/R15a/b $DIR/R15a/b/c
 763         mrename $DIR/R15a $DIR/R15a/b/c && error "rename to sub-subdir worked!"
 764         $CHECKSTAT -t dir $DIR/R15a || error "$DIR/R15a missing"
 765         $CHECKSTAT -t dir $DIR/R15a/b/c || error "$DIR/R15a/b/c missing"
 766 }
 767 run_test 24s "mkdir .../R15a/b/c; rename .../R15a .../R15a/b/c ="
 768 test_24t() {
 769         mkdir $DIR/R16a $DIR/R16a/b $DIR/R16a/b/c
 770         mrename $DIR/R16a/b/c $DIR/R16a && error "rename to sub-subdir worked!"
 771         $CHECKSTAT -t dir $DIR/R16a || error "$DIR/R16a missing"
 772         $CHECKSTAT -t dir $DIR/R16a/b/c || error "$DIR/R16a/b/c missing"
 773 }
 774 run_test 24t "mkdir .../R16a/b/c; rename .../R16a/b/c .../R16a ="
 775
 776 test_24u() { # bug12192
 777         multiop $DIR/$tfile C2w$((2048 * 1024))c || error
 778         $CHECKSTAT -s $((2048 * 1024)) $DIR/$tfile || error "wrong file size"
 779 }
 780 run_test 24u "create stripe file"
 781
 782 test_24v() {
 783         local NRFILES=100000
 784         local FREE_INODES=`lfs df -i|grep "filesystem summary" | awk '{print $5}'`
 785         [ $FREE_INODES -lt $NRFILES ] && \
 786                 skip "not enough free inodes $FREE_INODES required $NRFILES" && \
 787                 return
 788
 789         mkdir -p $DIR/d24v
 790         createmany -m $DIR/d24v/$tfile $NRFILES
 791         ls $DIR/d24v >/dev/null || error "error in listing large dir"
 792
 793         rm $DIR/d24v -rf
 794 }
 795 run_test 24v "list directory with large files (handle hash collision, bug: 17560)"
 796
 797 test_25a() {
 798         echo '== symlink sanity ============================================='
 799
 800         mkdir $DIR/d25
 801         ln -s d25 $DIR/s25
 802         touch $DIR/s25/foo || error
 803 }
 804 run_test 25a "create file in symlinked directory ==============="
 805
 806 test_25b() {
 807         [ ! -d $DIR/d25 ] && test_25a
 808         $CHECKSTAT -t file $DIR/s25/foo || error
 809 }
 810 run_test 25b "lookup file in symlinked directory ==============="
 811
 812 test_26a() {
 813         mkdir $DIR/d26
 814         mkdir $DIR/d26/d26-2
 815         ln -s d26/d26-2 $DIR/s26
 816         touch $DIR/s26/foo || error
 817 }
 818 run_test 26a "multiple component symlink ======================="
 819
 820 test_26b() {
 821         mkdir -p $DIR/d26b/d26-2
 822         ln -s d26b/d26-2/foo $DIR/s26-2
 823         touch $DIR/s26-2 || error
 824 }
 825 run_test 26b "multiple component symlink at end of lookup ======"
 826
 827 test_26c() {
 828         mkdir $DIR/d26.2
 829         touch $DIR/d26.2/foo
 830         ln -s d26.2 $DIR/s26.2-1
 831         ln -s s26.2-1 $DIR/s26.2-2
 832         ln -s s26.2-2 $DIR/s26.2-3
 833         chmod 0666 $DIR/s26.2-3/foo
 834 }
 835 run_test 26c "chain of symlinks ================================"
 836
 837 # recursive symlinks (bug 439)
 838 test_26d() {
 839         ln -s d26-3/foo $DIR/d26-3
 840 }
 841 run_test 26d "create multiple component recursive symlink ======"
 842
 843 test_26e() {
 844         [ ! -h $DIR/d26-3 ] && test_26d
 845         rm $DIR/d26-3
 846 }
 847 run_test 26e "unlink multiple component recursive symlink ======"
 848
 849 # recursive symlinks (bug 7022)
 850 test_26f() {
 851         mkdir -p $DIR/$tdir
 852         mkdir $DIR/$tdir/$tfile        || error "mkdir $DIR/$tdir/$tfile failed"
 853         cd $DIR/$tdir/$tfile           || error "cd $DIR/$tdir/$tfile failed"
 854         mkdir -p lndir/bar1      || error "mkdir lndir/bar1 failed"
 855         mkdir $tfile             || error "mkdir $tfile failed"
 856         cd $tfile                || error "cd $tfile failed"
 857         ln -s .. dotdot          || error "ln dotdot failed"
 858         ln -s dotdot/lndir lndir || error "ln lndir failed"
 859         cd $DIR/$tdir                 || error "cd $DIR/$tdir failed"
 860         output=`ls $tfile/$tfile/lndir/bar1`
 861         [ "$output" = bar1 ] && error "unexpected output"
 862         rm -r $tfile             || error "rm $tfile failed"
 863         $CHECKSTAT -a $DIR/$tfile || error "$tfile not gone"
 864 }
 865 run_test 26f "rm -r of a directory which has recursive symlink ="
 866
 867 test_27a() {
 868         echo '== stripe sanity =============================================='
 869         mkdir -p $DIR/d27 || error "mkdir failed"
 870         $GETSTRIPE $DIR/d27
 871         $SETSTRIPE $DIR/d27/f0 -c 1 || error "lstripe failed"
 872         $CHECKSTAT -t file $DIR/d27/f0 || error "checkstat failed"
 873         pass
 874         log "== test_27a: write to one stripe file ========================="
 875         cp /etc/hosts $DIR/d27/f0 || error
 876 }
 877 run_test 27a "one stripe file =================================="
 878
 879 test_27c() {
 880         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
 881         mkdir -p $DIR/d27
 882         $SETSTRIPE $DIR/d27/f01 -c 2 || error "lstripe failed"
 883         [ `$GETSTRIPE $DIR/d27/f01 | grep -A 10 obdidx | wc -l` -eq 4 ] ||
 884                 error "two-stripe file doesn't have two stripes"
 885         pass
 886         log "== test_27c: write to two stripe file file f01 ================"
 887         dd if=/dev/zero of=$DIR/d27/f01 bs=4k count=4 || error "dd failed"
 888 }
 889 run_test 27c "create two stripe file f01 ======================="
 890
 891 test_27d() {
 892         mkdir -p $DIR/d27
 893         $SETSTRIPE -c0 -i-1 -s0 $DIR/d27/fdef || error "lstripe failed"
 894         $CHECKSTAT -t file $DIR/d27/fdef || error "checkstat failed"
 895         dd if=/dev/zero of=$DIR/d27/fdef bs=4k count=4 || error
 896 }
 897 run_test 27d "create file with default settings ================"
 898
 899 test_27e() {
 900         mkdir -p $DIR/d27
 901         $SETSTRIPE $DIR/d27/f12 -c 2 || error "lstripe failed"
 902         $SETSTRIPE $DIR/d27/f12 -c 2 && error "lstripe succeeded twice"
 903         $CHECKSTAT -t file $DIR/d27/f12 || error "checkstat failed"
 904 }
 905 run_test 27e "setstripe existing file (should return error) ======"
 906
 907 test_27f() {
 908         mkdir -p $DIR/d27
 909         $SETSTRIPE $DIR/d27/fbad -s 100 -i 0 -c 1 && error "lstripe failed"
 910         dd if=/dev/zero of=$DIR/d27/f12 bs=4k count=4 || error "dd failed"
 911         $GETSTRIPE $DIR/d27/fbad || error "lfs getstripe failed"
 912 }
 913 run_test 27f "setstripe with bad stripe size (should return error)"
 914
 915 test_27g() {
 916         mkdir -p $DIR/d27
 917         $MCREATE $DIR/d27/fnone || error "mcreate failed"
 918         pass
 919         log "== test 27h: lfs getstripe with no objects ===================="
 920         $GETSTRIPE $DIR/d27/fnone 2>&1 | grep "no stripe info" || error "has object"
 921         pass
 922         log "== test 27i: lfs getstripe with some objects =================="
 923         touch $DIR/d27/fsome || error "touch failed"
 924         $GETSTRIPE $DIR/d27/fsome | grep obdidx || error "missing objects"
 925 }
 926 run_test 27g "test lfs getstripe ==========================================="
 927
 928 test_27j() {
 929         mkdir -p $DIR/d27
 930         $SETSTRIPE $DIR/d27/f27j -i $OSTCOUNT && error "lstripe failed"||true
 931 }
 932 run_test 27j "setstripe with bad stripe offset (should return error)"
 933
 934 test_27k() { # bug 2844
 935         mkdir -p $DIR/d27
 936         FILE=$DIR/d27/f27k
 937         LL_MAX_BLKSIZE=$((4 * 1024 * 1024))
 938         [ ! -d $DIR/d27 ] && mkdir -p $DIR/d27
 939         $SETSTRIPE $FILE -s 67108864 || error "lstripe failed"
 940         BLKSIZE=`stat $FILE | awk '/IO Block:/ { print $7 }'`
 941         [ $BLKSIZE -le $LL_MAX_BLKSIZE ] || error "$BLKSIZE > $LL_MAX_BLKSIZE"
 942         dd if=/dev/zero of=$FILE bs=4k count=1
 943         BLKSIZE=`stat $FILE | awk '/IO Block:/ { print $7 }'`
 944         [ $BLKSIZE -le $LL_MAX_BLKSIZE ] || error "$BLKSIZE > $LL_MAX_BLKSIZE"
 945 }
 946 run_test 27k "limit i_blksize for broken user apps ============="
 947
 948 test_27l() {
 949         mkdir -p $DIR/d27
 950         mcreate $DIR/f27l || error "creating file"
 951         $RUNAS $SETSTRIPE $DIR/f27l -c 1 && \
 952                 error "lstripe should have failed" || true
 953 }
 954 run_test 27l "check setstripe permissions (should return error)"
 955
 956 test_27m() {
 957         [ "$OSTCOUNT" -lt "2" ] && skip_env "$OSTCOUNT < 2 OSTs -- skipping" && return
 958         if [ $ORIGFREE -gt $MAXFREE ]; then
 959                 skip "$ORIGFREE > $MAXFREE skipping out-of-space test on OST0"
 960                 return
 961         fi
 962         mkdir -p $DIR/d27
 963         $SETSTRIPE $DIR/d27/f27m_1 -i 0 -c 1
 964         dd if=/dev/zero of=$DIR/d27/f27m_1 bs=1024 count=$MAXFREE && \
 965                 error "dd should fill OST0"
 966         i=2
 967         while $SETSTRIPE $DIR/d27/f27m_$i -i 0 -c 1 ; do
 968                 i=`expr $i + 1`
 969                 [ $i -gt 256 ] && break
 970         done
 971         i=`expr $i + 1`
 972         touch $DIR/d27/f27m_$i
 973         [ `$GETSTRIPE $DIR/d27/f27m_$i | grep -A 10 obdidx | awk '{print $1}'| grep -w "0"` ] && \
 974                 error "OST0 was full but new created file still use it"
 975         i=`expr $i + 1`
 976         touch $DIR/d27/f27m_$i
 977         [ `$GETSTRIPE $DIR/d27/f27m_$i | grep -A 10 obdidx | awk '{print $1}'| grep -w "0"` ] && \
 978                 error "OST0 was full but new created file still use it"
 979         rm -r $DIR/d27
 980         sleep 15
 981 }
 982 run_test 27m "create file while OST0 was full =================="
 983
 984 sleep_maxage() {
 985         local DELAY=$(do_facet mds lctl get_param -n lov.*.qos_maxage | head -n 1 | awk '{print $1 * 2}')
 986         sleep $DELAY
 987 }
 988
 989 # OSCs keep a NOSPC flag that will be reset after ~5s (qos_maxage)
 990 # if the OST isn't full anymore.
 991 reset_enospc() {
 992         local OSTIDX=${1:-""}
 993
 994         local list=$(comma_list $(osts_nodes))
 995         [ "$OSTIDX" ] && list=$(facet_host ost$((OSTIDX + 1)))
 996
 997         do_nodes $list lctl set_param fail_loc=0
 998         sleep_maxage
 999 }
1000
1001 exhaust_precreations() {
1002         local OSTIDX=$1
1003         local FAILLOC=$2
1004         local FAILIDX=${3:-$OSTIDX}
1005
1006         mkdir -p $DIR/$tdir
1007         local MDSIDX=$(get_mds_dir "$DIR/$tdir")
1008         echo OSTIDX=$OSTIDX MDSIDX=$MDSIDX
1009
1010         local OST=$(lfs osts | grep ${OSTIDX}": " | \
1011                 awk '{print $2}' | sed -e 's/_UUID$//')
1012         local MDT_INDEX=$(lfs df | grep "\[MDT:$((MDSIDX - 1))\]" | awk '{print $1}' | \
1013                           sed -e 's/_UUID$//;s/^.*-//')
1014
1015         # on the mdt's osc
1016         local last_id=$(do_facet mds${MDSIDX} lctl get_param -n osc.*${OST}-osc-${MDT_INDEX}.prealloc_last_id)
1017         local next_id=$(do_facet mds${MDSIDX} lctl get_param -n osc.*${OST}-osc-${MDT_INDEX}.prealloc_next_id)
1018
1019         do_facet mds${MDSIDX} lctl get_param osc.*OST*-osc-${MDT_INDEX}.prealloc*
1020
1021         mkdir -p $DIR/$tdir/${OST}
1022         $SETSTRIPE $DIR/$tdir/${OST} -i $OSTIDX -c 1
1023 #define OBD_FAIL_OST_ENOSPC              0x215
1024         do_facet ost$((OSTIDX + 1)) lctl set_param fail_val=$FAILIDX
1025         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=0x215
1026         echo "Creating to objid $last_id on ost $OST..."
1027         createmany -o $DIR/$tdir/${OST}/f $next_id $((last_id - next_id + 2))
1028         do_facet mds${MDSIDX} lctl get_param osc.*OST*-osc-${MDT_INDEX}.prealloc*
1029         do_facet ost$((OSTIDX + 1)) lctl set_param fail_loc=$FAILLOC
1030         sleep_maxage
1031 }
1032
1033 exhaust_all_precreations() {
1034         local i
1035         for (( i=0; i < OSTCOUNT; i++ )) ; do
1036                 exhaust_precreations $i $1 -1
1037         done
1038 }
1039
1040 test_27n() {
1041         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1042         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1043         remote_ost_nodsh && skip "remote OST with nodsh" && return
1044
1045         reset_enospc
1046         rm -f $DIR/$tdir/$tfile
1047         exhaust_precreations 0 0x80000215
1048         $SETSTRIPE -c -1 $DIR/$tdir
1049         touch $DIR/$tdir/$tfile || error
1050         $GETSTRIPE $DIR/$tdir/$tfile
1051         reset_enospc
1052 }
1053 run_test 27n "create file with some full OSTs =================="
1054
1055 test_27o() {
1056         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1057         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1058         remote_ost_nodsh && skip "remote OST with nodsh" && return
1059
1060         reset_enospc
1061         rm -f $DIR/$tdir/$tfile
1062         exhaust_all_precreations 0x215
1063
1064         touch $DIR/$tdir/$tfile && error "able to create $DIR/$tdir/$tfile"
1065
1066         reset_enospc
1067         rm -rf $DIR/$tdir/*
1068 }
1069 run_test 27o "create file with all full OSTs (should error) ===="
1070
1071 test_27p() {
1072         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1073         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1074         remote_ost_nodsh && skip "remote OST with nodsh" && return
1075
1076         reset_enospc
1077         rm -f $DIR/$tdir/$tfile
1078         mkdir -p $DIR/$tdir
1079
1080         $MCREATE $DIR/$tdir/$tfile || error "mcreate failed"
1081         $TRUNCATE $DIR/$tdir/$tfile 80000000 || error "truncate failed"
1082         $CHECKSTAT -s 80000000 $DIR/$tdir/$tfile || error "checkstat failed"
1083
1084         exhaust_precreations 0 0x80000215
1085         echo foo >> $DIR/$tdir/$tfile || error "append failed"
1086         $CHECKSTAT -s 80000004 $DIR/$tdir/$tfile || error "checkstat failed"
1087         $LFS getstripe $DIR/$tdir/$tfile
1088
1089         reset_enospc
1090 }
1091 run_test 27p "append to a truncated file with some full OSTs ==="
1092
1093 test_27q() {
1094         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1095         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1096         remote_ost_nodsh && skip "remote OST with nodsh" && return
1097
1098         reset_enospc
1099         rm -f $DIR/$tdir/$tfile
1100
1101         $MCREATE $DIR/$tdir/$tfile || error "mcreate $DIR/$tdir/$tfile failed"
1102         $TRUNCATE $DIR/$tdir/$tfile 80000000 ||error "truncate $DIR/$tdir/$tfile failed"
1103         $CHECKSTAT -s 80000000 $DIR/$tdir/$tfile || error "checkstat failed"
1104
1105         exhaust_all_precreations 0x215
1106
1107         echo foo >> $DIR/$tdir/$tfile && error "append succeeded"
1108         $CHECKSTAT -s 80000000 $DIR/$tdir/$tfile || error "checkstat 2 failed"
1109
1110         reset_enospc
1111 }
1112 run_test 27q "append to truncated file with all OSTs full (should error) ==="
1113
1114 test_27r() {
1115         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1116         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1117         remote_ost_nodsh && skip "remote OST with nodsh" && return
1118
1119         reset_enospc
1120         rm -f $DIR/$tdir/$tfile
1121         exhaust_precreations 0 0x80000215
1122
1123         $SETSTRIPE $DIR/$tdir/$tfile -i 0 -c 2 # && error
1124
1125         reset_enospc
1126 }
1127 run_test 27r "stripe file with some full OSTs (shouldn't LBUG) ="
1128
1129 test_27s() { # bug 10725
1130         mkdir -p $DIR/$tdir
1131         local stripe_size=$((4096 * 1024 * 1024))       # 2^32
1132         local stripe_count=0
1133         [ $OSTCOUNT -eq 1 ] || stripe_count=2
1134         $SETSTRIPE $DIR/$tdir -s $stripe_size -c $stripe_count && \
1135                 error "stripe width >= 2^32 succeeded" || true
1136
1137 }
1138 run_test 27s "lsm_xfersize overflow (should error) (bug 10725)"
1139
1140 test_27t() { # bug 10864
1141         WDIR=`pwd`
1142         WLFS=`which lfs`
1143         cd $DIR
1144         touch $tfile
1145         $WLFS getstripe $tfile
1146         cd $WDIR
1147 }
1148 run_test 27t "check that utils parse path correctly"
1149
1150 test_27u() { # bug 4900
1151         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1152         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1153
1154 #define OBD_FAIL_MDS_OSC_PRECREATE      0x139
1155         do_facet $SINGLEMDS lctl set_param fail_loc=0x139
1156         mkdir -p $DIR/$tdir
1157         createmany -o $DIR/$tdir/t- 1000
1158         do_facet $SINGLEMDS lctl set_param fail_loc=0
1159
1160         TLOG=$DIR/$tfile.getstripe
1161         $GETSTRIPE $DIR/$tdir > $TLOG
1162         OBJS=`awk -vobj=0 '($1 == 0) { obj += 1 } END { print obj;}' $TLOG`
1163         unlinkmany $DIR/$tdir/t- 1000
1164         [ $OBJS -gt 0 ] && \
1165                 error "$OBJS objects created on OST-0.  See $TLOG" || pass
1166 }
1167 run_test 27u "skip object creation on OSC w/o objects =========="
1168
1169 test_27v() { # bug 4900
1170         [ "$OSTCOUNT" -lt "2" ] && skip_env "too few OSTs" && return
1171         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1172         remote_ost_nodsh && skip "remote OST with nodsh" && return
1173
1174         exhaust_all_precreations 0x215
1175         reset_enospc
1176
1177         mkdir -p $DIR/$tdir
1178         $SETSTRIPE $DIR/$tdir -c 1         # 1 stripe / file
1179
1180         touch $DIR/$tdir/$tfile
1181         #define OBD_FAIL_TGT_DELAY_PRECREATE     0x705
1182         # all except ost1
1183         for (( i=0; i < OSTCOUNT; i++ )) ; do
1184                 do_facet ost$i lctl set_param fail_loc=0x705
1185         done
1186         local START=`date +%s`
1187         createmany -o $DIR/$tdir/$tfile 32
1188
1189         local FINISH=`date +%s`
1190         local TIMEOUT=`lctl get_param -n timeout`
1191         [ $((FINISH - START)) -ge $((TIMEOUT / 2)) ] && \
1192                error "$FINISH - $START >= $TIMEOUT / 2"
1193
1194         reset_enospc
1195 }
1196 run_test 27v "skip object creation on slow OST ================="
1197
1198 test_27w() { # bug 10997
1199         mkdir -p $DIR/$tdir || error "mkdir failed"
1200         $LSTRIPE $DIR/$tdir/f0 -s 65536 || error "lstripe failed"
1201         size=`$GETSTRIPE $DIR/$tdir/f0 -s`
1202         [ $size -ne 65536 ] && error "stripe size $size != 65536" || true
1203         gsdir=$($LFS getstripe -d $DIR/$tdir)
1204         [ $(echo $gsdir | grep -c stripe_count) -ne 1 ] && error "$LFS getstripe -d $DIR/$tdir failed"
1205
1206         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping multiple stripe count/offset test" && return
1207         for i in `seq 1 $OSTCOUNT`; do
1208                 offset=$(($i-1))
1209                 $LSTRIPE $DIR/$tdir/f$i -c $i -i $offset || error "lstripe -c $i -i $offset failed"
1210                 count=`$GETSTRIPE -c $DIR/$tdir/f$i`
1211                 index=`$GETSTRIPE -o $DIR/$tdir/f$i`
1212                 [ $count -ne $i ] && error "stripe count $count != $i" || true
1213                 [ $index -ne $offset ] && error "stripe offset $index != $offset" || true
1214         done
1215 }
1216 run_test 27w "check lfs setstripe -c -s -i options ============="
1217
1218 test_27x() {
1219         [ "$OSTCOUNT" -lt "2" ] && skip_env "$OSTCOUNT < 2 OSTs" && return
1220         OFFSET=$(($OSTCOUNT - 1))
1221         OSTIDX=0
1222         local OST=$(lfs osts | awk '/'${OSTIDX}': / { print $2 }' | sed -e 's/_UUID$//')
1223
1224         mkdir -p $DIR/$tdir
1225         $SETSTRIPE $DIR/$tdir -c 1      # 1 stripe per file
1226         do_facet ost$((OSTIDX + 1)) lctl set_param -n obdfilter.$OST.degraded 1
1227         sleep_maxage
1228         createmany -o $DIR/$tdir/$tfile $OSTCOUNT
1229         for i in `seq 0 $OFFSET`; do
1230                 [ `$GETSTRIPE $DIR/$tdir/$tfile$i | grep -A 10 obdidx | awk '{print $1}' | grep -w "$OSTIDX"` ] &&
1231                 error "OST0 was degraded but new created file still use it"
1232         done
1233         do_facet ost$((OSTIDX + 1)) lctl set_param -n obdfilter.$OST.degraded 0
1234 }
1235 run_test 27x "create files while OST0 is degraded"
1236
1237 test_27y() {
1238         [ "$OSTCOUNT" -lt "2" ] && skip_env "$OSTCOUNT < 2 OSTs -- skipping" && return
1239         remote_mds_nodsh && skip "remote MDS with nodsh" && return
1240
1241         local last_id=$(do_facet $SINGLEMDS lctl get_param -n osc.*0000-osc-MDT0000.prealloc_last_id)
1242         local next_id=$(do_facet $SINGLEMDS lctl get_param -n osc.*0000-osc-MDT0000.prealloc_next_id)
1243         local fcount=$((last_id - next_id))
1244         [ $fcount -eq 0 ] && skip "not enough space on OST0" && return
1245         [ $fcount -gt $OSTCOUNT ] && fcount=$OSTCOUNT
1246
1247         MDS_OSCS=`do_facet mds lctl dl | awk '/[oO][sS][cC].*md[ts]/ { print $4 }'`
1248         OFFSET=$(($OSTCOUNT-1))
1249         OST=-1
1250         for OSC in $MDS_OSCS; do
1251                 if [ $OST == -1 ]; then {
1252                         OST=`osc_to_ost $OSC`
1253                 } else {
1254                         echo $OSC "is Deactivate:"
1255                         do_facet mds lctl --device  %$OSC deactivate
1256                 } fi
1257         done
1258
1259         OSTIDX=$(lfs osts | grep ${OST} | awk '{print $1}' | sed -e 's/://')
1260         mkdir -p $DIR/$tdir
1261         $SETSTRIPE $DIR/$tdir -c 1      # 1 stripe / file
1262
1263         do_facet ost$OSTIDX lctl set_param -n obdfilter.$OST.degraded 1
1264         sleep_maxage
1265         createmany -o $DIR/$tdir/$tfile $fcount
1266         do_facet ost$OSTIDX lctl set_param -n obdfilter.$OST.degraded 0
1267
1268         for i in `seq 0 $OFFSET`; do
1269                 [ `$GETSTRIPE $DIR/$tdir/$tfile$i | grep -A 10 obdidx | awk '{print $1}'| grep -w "$OSTIDX"` ] || \
1270                       error "files created on deactivated OSTs instead of degraded OST"
1271         done
1272         for OSC in $MDS_OSCS; do
1273                 [ `osc_to_ost $OSC` != $OST  ] && {
1274                         echo $OSC "is activate"
1275                         do_facet mds lctl --device %$OSC activate
1276                 }
1277         done
1278 }
1279 run_test 27y "create files while OST0 is degraded and the rest inactive"
1280
1281 # createtest also checks that device nodes are created and
1282 # then visible correctly (#2091)
1283 test_28() { # bug 2091
1284         mkdir $DIR/d28
1285         $CREATETEST $DIR/d28/ct || error
1286 }
1287 run_test 28 "create/mknod/mkdir with bad file types ============"
1288
1289 test_29() {
1290         cancel_lru_locks mdc
1291         mkdir $DIR/d29
1292         touch $DIR/d29/foo
1293         log 'first d29'
1294         ls -l $DIR/d29
1295
1296         declare -i LOCKCOUNTORIG=0
1297         for lock_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_count); do
1298                 let LOCKCOUNTORIG=$LOCKCOUNTORIG+$lock_count
1299         done
1300         [ $LOCKCOUNTORIG -eq 0 ] && echo "No mdc lock count" && return 1
1301
1302         declare -i LOCKUNUSEDCOUNTORIG=0
1303         for unused_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_unused_count); do
1304                 let LOCKUNUSEDCOUNTORIG=$LOCKUNUSEDCOUNTORIG+$unused_count
1305         done
1306
1307         log 'second d29'
1308         ls -l $DIR/d29
1309         log 'done'
1310
1311         declare -i LOCKCOUNTCURRENT=0
1312         for lock_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_count); do
1313                 let LOCKCOUNTCURRENT=$LOCKCOUNTCURRENT+$lock_count
1314         done
1315
1316         declare -i LOCKUNUSEDCOUNTCURRENT=0
1317         for unused_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_unused_count); do
1318                 let LOCKUNUSEDCOUNTCURRENT=$LOCKUNUSEDCOUNTCURRENT+$unused_count
1319         done
1320
1321         if [ "$LOCKCOUNTCURRENT" -gt "$LOCKCOUNTORIG" ]; then
1322                 lctl set_param -n ldlm.dump_namespaces ""
1323                 error "CURRENT: $LOCKCOUNTCURRENT > $LOCKCOUNTORIG"
1324                 $LCTL dk | sort -k4 -t: > $TMP/test_29.dk
1325                 log "dumped log to $TMP/test_29.dk (bug 5793)"
1326                 return 2
1327         fi
1328         if [ "$LOCKUNUSEDCOUNTCURRENT" -gt "$LOCKUNUSEDCOUNTORIG" ]; then
1329                 error "UNUSED: $LOCKUNUSEDCOUNTCURRENT > $LOCKUNUSEDCOUNTORIG"
1330                 $LCTL dk | sort -k4 -t: > $TMP/test_29.dk
1331                 log "dumped log to $TMP/test_29.dk (bug 5793)"
1332                 return 3
1333         fi
1334 }
1335 run_test 29 "IT_GETATTR regression  ============================"
1336
1337 test_30() {
1338         cp `which ls` $DIR || cp /bin/ls $DIR
1339         $DIR/ls /
1340         rm $DIR/ls
1341 }
1342 run_test 30 "run binary from Lustre (execve) ==================="
1343
1344 test_31a() {
1345         $OPENUNLINK $DIR/f31 $DIR/f31 || error
1346         $CHECKSTAT -a $DIR/f31 || error
1347 }
1348 run_test 31a "open-unlink file =================================="
1349
1350 test_31b() {
1351         touch $DIR/f31 || error
1352         ln $DIR/f31 $DIR/f31b || error
1353         multiop $DIR/f31b Ouc || error
1354         $CHECKSTAT -t file $DIR/f31 || error
1355 }
1356 run_test 31b "unlink file with multiple links while open ======="
1357
1358 test_31c() {
1359         touch $DIR/f31 || error
1360         ln $DIR/f31 $DIR/f31c || error
1361         multiop_bg_pause $DIR/f31 O_uc || return 1
1362         MULTIPID=$!
1363         multiop $DIR/f31c Ouc
1364         kill -USR1 $MULTIPID
1365         wait $MULTIPID
1366 }
1367 run_test 31c "open-unlink file with multiple links ============="
1368
1369 test_31d() {
1370         opendirunlink $DIR/d31d $DIR/d31d || error
1371         $CHECKSTAT -a $DIR/d31d || error
1372 }
1373 run_test 31d "remove of open directory ========================="
1374
1375 test_31e() { # bug 2904
1376         check_kernel_version 34 || return 0
1377         openfilleddirunlink $DIR/d31e || error
1378 }
1379 run_test 31e "remove of open non-empty directory ==============="
1380
1381 test_31f() { # bug 4554
1382         set -vx
1383         mkdir $DIR/d31f
1384         $SETSTRIPE $DIR/d31f -s 1048576 -c 1
1385         cp /etc/hosts $DIR/d31f
1386         ls -l $DIR/d31f
1387         $GETSTRIPE $DIR/d31f/hosts
1388         multiop_bg_pause $DIR/d31f D_c || return 1
1389         MULTIPID=$!
1390
1391         rm -rv $DIR/d31f || error "first of $DIR/d31f"
1392         mkdir $DIR/d31f
1393         $SETSTRIPE $DIR/d31f -s 1048576 -c 1
1394         cp /etc/hosts $DIR/d31f
1395         ls -l $DIR/d31f
1396         $DIR/d31f/hosts
1397         multiop_bg_pause $DIR/d31f D_c || return 1
1398         MULTIPID2=$!
1399
1400         kill -USR1 $MULTIPID || error "first opendir $MULTIPID not running"
1401         wait $MULTIPID || error "first opendir $MULTIPID failed"
1402
1403         sleep 6
1404
1405         kill -USR1 $MULTIPID2 || error "second opendir $MULTIPID not running"
1406         wait $MULTIPID2 || error "second opendir $MULTIPID2 failed"
1407         set +vx
1408 }
1409 run_test 31f "remove of open directory with open-unlink file ==="
1410
1411 test_31g() {
1412         echo "-- cross directory link --"
1413         mkdir $DIR/d31g{a,b}
1414         touch $DIR/d31ga/f
1415         ln $DIR/d31ga/f $DIR/d31gb/g
1416         $CHECKSTAT -t file $DIR/d31ga/f || error "source"
1417         [ `stat -c%h $DIR/d31ga/f` == '2' ] || error "source nlink"
1418         $CHECKSTAT -t file $DIR/d31gb/g || error "target"
1419         [ `stat -c%h $DIR/d31gb/g` == '2' ] || error "target nlink"
1420 }
1421 run_test 31g "cross directory link==============="
1422
1423 test_31h() {
1424         echo "-- cross directory link --"
1425         mkdir $DIR/d31h
1426         mkdir $DIR/d31h/dir
1427         touch $DIR/d31h/f
1428         ln $DIR/d31h/f $DIR/d31h/dir/g
1429         $CHECKSTAT -t file $DIR/d31h/f || error "source"
1430         [ `stat -c%h $DIR/d31h/f` == '2' ] || error "source nlink"
1431         $CHECKSTAT -t file $DIR/d31h/dir/g || error "target"
1432         [ `stat -c%h $DIR/d31h/dir/g` == '2' ] || error "target nlink"
1433 }
1434 run_test 31h "cross directory link under child==============="
1435
1436 test_31i() {
1437         echo "-- cross directory link --"
1438         mkdir $DIR/d31i
1439         mkdir $DIR/d31i/dir
1440         touch $DIR/d31i/dir/f
1441         ln $DIR/d31i/dir/f $DIR/d31i/g
1442         $CHECKSTAT -t file $DIR/d31i/dir/f || error "source"
1443         [ `stat -c%h $DIR/d31i/dir/f` == '2' ] || error "source nlink"
1444         $CHECKSTAT -t file $DIR/d31i/g || error "target"
1445         [ `stat -c%h $DIR/d31i/g` == '2' ] || error "target nlink"
1446 }
1447 run_test 31i "cross directory link under parent==============="
1448
1449
1450 test_31j() {
1451         mkdir $DIR/d31j
1452         mkdir $DIR/d31j/dir1
1453         ln $DIR/d31j/dir1 $DIR/d31j/dir2 && error "ln for dir"
1454         link $DIR/d31j/dir1 $DIR/d31j/dir3 && error "link for dir"
1455         mlink $DIR/d31j/dir1 $DIR/d31j/dir4 && error "mlink for dir"
1456         mlink $DIR/d31j/dir1 $DIR/d31j/dir1 && error "mlink to the same dir"
1457         return 0
1458 }
1459 run_test 31j "link for directory==============="
1460
1461
1462 test_31k() {
1463         mkdir $DIR/d31k
1464         touch $DIR/d31k/s
1465         touch $DIR/d31k/exist
1466         mlink $DIR/d31k/s $DIR/d31k/t || error "mlink"
1467         mlink $DIR/d31k/s $DIR/d31k/exist && error "mlink to exist file"
1468         mlink $DIR/d31k/s $DIR/d31k/s && error "mlink to the same file"
1469         mlink $DIR/d31k/s $DIR/d31k && error "mlink to parent dir"
1470         mlink $DIR/d31k $DIR/d31k/s && error "mlink parent dir to target"
1471         mlink $DIR/d31k/not-exist $DIR/d31k/foo && error "mlink non-existing to new"
1472         mlink $DIR/d31k/not-exist $DIR/d31k/s && error "mlink non-existing to exist"
1473         return 0
1474 }
1475 run_test 31k "link to file: the same, non-existing, dir==============="
1476
1477 test_31m() {
1478         mkdir $DIR/d31m
1479         touch $DIR/d31m/s
1480         mkdir $DIR/d31m2
1481         touch $DIR/d31m2/exist
1482         mlink $DIR/d31m/s $DIR/d31m2/t || error "mlink"
1483         mlink $DIR/d31m/s $DIR/d31m2/exist && error "mlink to exist file"
1484         mlink $DIR/d31m/s $DIR/d31m2 && error "mlink to parent dir"
1485         mlink $DIR/d31m2 $DIR/d31m/s && error "mlink parent dir to target"
1486         mlink $DIR/d31m/not-exist $DIR/d31m2/foo && error "mlink non-existing to new"
1487         mlink $DIR/d31m/not-exist $DIR/d31m2/s && error "mlink non-existing to exist"
1488         return 0
1489 }
1490 run_test 31m "link to file: the same, non-existing, dir==============="
1491
1492 test_32a() {
1493         echo "== more mountpoints and symlinks ================="
1494         [ -e $DIR/d32a ] && rm -fr $DIR/d32a
1495         mkdir -p $DIR/d32a/ext2-mountpoint
1496         mount -t ext2 -o loop $EXT2_DEV $DIR/d32a/ext2-mountpoint || error
1497         $CHECKSTAT -t dir $DIR/d32a/ext2-mountpoint/.. || error
1498         $UMOUNT $DIR/d32a/ext2-mountpoint || error
1499 }
1500 run_test 32a "stat d32a/ext2-mountpoint/.. ====================="
1501
1502 test_32b() {
1503         [ -e $DIR/d32b ] && rm -fr $DIR/d32b
1504         mkdir -p $DIR/d32b/ext2-mountpoint
1505         mount -t ext2 -o loop $EXT2_DEV $DIR/d32b/ext2-mountpoint || error
1506         ls -al $DIR/d32b/ext2-mountpoint/.. || error
1507         $UMOUNT $DIR/d32b/ext2-mountpoint || error
1508 }
1509 run_test 32b "open d32b/ext2-mountpoint/.. ====================="
1510
1511 test_32c() {
1512         [ -e $DIR/d32c ] && rm -fr $DIR/d32c
1513         mkdir -p $DIR/d32c/ext2-mountpoint
1514         mount -t ext2 -o loop $EXT2_DEV $DIR/d32c/ext2-mountpoint || error
1515         mkdir -p $DIR/d32c/d2/test_dir
1516         $CHECKSTAT -t dir $DIR/d32c/ext2-mountpoint/../d2/test_dir || error
1517         $UMOUNT $DIR/d32c/ext2-mountpoint || error
1518 }
1519 run_test 32c "stat d32c/ext2-mountpoint/../d2/test_dir ========="
1520
1521 test_32d() {
1522         [ -e $DIR/d32d ] && rm -fr $DIR/d32d
1523         mkdir -p $DIR/d32d/ext2-mountpoint
1524         mount -t ext2 -o loop $EXT2_DEV $DIR/d32d/ext2-mountpoint || error
1525         mkdir -p $DIR/d32d/d2/test_dir
1526         ls -al $DIR/d32d/ext2-mountpoint/../d2/test_dir || error
1527         $UMOUNT $DIR/d32d/ext2-mountpoint || error
1528 }
1529 run_test 32d "open d32d/ext2-mountpoint/../d2/test_dir ========="
1530
1531 test_32e() {
1532         [ -e $DIR/d32e ] && rm -fr $DIR/d32e
1533         mkdir -p $DIR/d32e/tmp
1534         TMP_DIR=$DIR/d32e/tmp
1535         ln -s $DIR/d32e $TMP_DIR/symlink11
1536         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
1537         $CHECKSTAT -t link $DIR/d32e/tmp/symlink11 || error
1538         $CHECKSTAT -t link $DIR/d32e/symlink01 || error
1539 }
1540 run_test 32e "stat d32e/symlink->tmp/symlink->lustre-subdir ===="
1541
1542 test_32f() {
1543         [ -e $DIR/d32f ] && rm -fr $DIR/d32f
1544         mkdir -p $DIR/d32f/tmp
1545         TMP_DIR=$DIR/d32f/tmp
1546         ln -s $DIR/d32f $TMP_DIR/symlink11
1547         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
1548         ls $DIR/d32f/tmp/symlink11  || error
1549         ls $DIR/d32f/symlink01 || error
1550 }
1551 run_test 32f "open d32f/symlink->tmp/symlink->lustre-subdir ===="
1552
1553 test_32g() {
1554         TMP_DIR=$DIR/$tdir/tmp
1555         mkdir -p $TMP_DIR $DIR/${tdir}2
1556         ln -s $DIR/${tdir}2 $TMP_DIR/symlink12
1557         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
1558         $CHECKSTAT -t link $TMP_DIR/symlink12 || error
1559         $CHECKSTAT -t link $DIR/$tdir/symlink02 || error
1560         $CHECKSTAT -t dir -f $TMP_DIR/symlink12 || error
1561         $CHECKSTAT -t dir -f $DIR/$tdir/symlink02 || error
1562 }
1563 run_test 32g "stat d32g/symlink->tmp/symlink->lustre-subdir/${tdir}2"
1564
1565 test_32h() {
1566         rm -fr $DIR/$tdir $DIR/${tdir}2
1567         TMP_DIR=$DIR/$tdir/tmp
1568         mkdir -p $TMP_DIR $DIR/${tdir}2
1569         ln -s $DIR/${tdir}2 $TMP_DIR/symlink12
1570         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
1571         ls $TMP_DIR/symlink12 || error
1572         ls $DIR/$tdir/symlink02  || error
1573 }
1574 run_test 32h "open d32h/symlink->tmp/symlink->lustre-subdir/${tdir}2"
1575
1576 test_32i() {
1577         [ -e $DIR/d32i ] && rm -fr $DIR/d32i
1578         mkdir -p $DIR/d32i/ext2-mountpoint
1579         mount -t ext2 -o loop $EXT2_DEV $DIR/d32i/ext2-mountpoint || error
1580         touch $DIR/d32i/test_file
1581         $CHECKSTAT -t file $DIR/d32i/ext2-mountpoint/../test_file || error
1582         $UMOUNT $DIR/d32i/ext2-mountpoint || error
1583 }
1584 run_test 32i "stat d32i/ext2-mountpoint/../test_file ==========="
1585
1586 test_32j() {
1587         [ -e $DIR/d32j ] && rm -fr $DIR/d32j
1588         mkdir -p $DIR/d32j/ext2-mountpoint
1589         mount -t ext2 -o loop $EXT2_DEV $DIR/d32j/ext2-mountpoint || error
1590         touch $DIR/d32j/test_file
1591         cat $DIR/d32j/ext2-mountpoint/../test_file || error
1592         $UMOUNT $DIR/d32j/ext2-mountpoint || error
1593 }
1594 run_test 32j "open d32j/ext2-mountpoint/../test_file ==========="
1595
1596 test_32k() {
1597         rm -fr $DIR/d32k
1598         mkdir -p $DIR/d32k/ext2-mountpoint
1599         mount -t ext2 -o loop $EXT2_DEV $DIR/d32k/ext2-mountpoint
1600         mkdir -p $DIR/d32k/d2
1601         touch $DIR/d32k/d2/test_file || error
1602         $CHECKSTAT -t file $DIR/d32k/ext2-mountpoint/../d2/test_file || error
1603         $UMOUNT $DIR/d32k/ext2-mountpoint || error
1604 }
1605 run_test 32k "stat d32k/ext2-mountpoint/../d2/test_file ========"
1606
1607 test_32l() {
1608         rm -fr $DIR/d32l
1609         mkdir -p $DIR/d32l/ext2-mountpoint
1610         mount -t ext2 -o loop $EXT2_DEV $DIR/d32l/ext2-mountpoint || error
1611         mkdir -p $DIR/d32l/d2
1612         touch $DIR/d32l/d2/test_file
1613         cat  $DIR/d32l/ext2-mountpoint/../d2/test_file || error
1614         $UMOUNT $DIR/d32l/ext2-mountpoint || error
1615 }
1616 run_test 32l "open d32l/ext2-mountpoint/../d2/test_file ========"
1617
1618 test_32m() {
1619         rm -fr $DIR/d32m
1620         mkdir -p $DIR/d32m/tmp
1621         TMP_DIR=$DIR/d32m/tmp
1622         ln -s $DIR $TMP_DIR/symlink11
1623         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
1624         $CHECKSTAT -t link $DIR/d32m/tmp/symlink11 || error
1625         $CHECKSTAT -t link $DIR/d32m/symlink01 || error
1626 }
1627 run_test 32m "stat d32m/symlink->tmp/symlink->lustre-root ======"
1628
1629 test_32n() {
1630         rm -fr $DIR/d32n
1631         mkdir -p $DIR/d32n/tmp
1632         TMP_DIR=$DIR/d32n/tmp
1633         ln -s $DIR $TMP_DIR/symlink11
1634         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
1635         ls -l $DIR/d32n/tmp/symlink11  || error
1636         ls -l $DIR/d32n/symlink01 || error
1637 }
1638 run_test 32n "open d32n/symlink->tmp/symlink->lustre-root ======"
1639
1640 test_32o() {
1641         rm -fr $DIR/d32o $DIR/$tfile
1642         touch $DIR/$tfile
1643         mkdir -p $DIR/d32o/tmp
1644         TMP_DIR=$DIR/d32o/tmp
1645         ln -s $DIR/$tfile $TMP_DIR/symlink12
1646         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
1647         $CHECKSTAT -t link $DIR/d32o/tmp/symlink12 || error
1648         $CHECKSTAT -t link $DIR/d32o/symlink02 || error
1649         $CHECKSTAT -t file -f $DIR/d32o/tmp/symlink12 || error
1650         $CHECKSTAT -t file -f $DIR/d32o/symlink02 || error
1651 }
1652 run_test 32o "stat d32o/symlink->tmp/symlink->lustre-root/$tfile"
1653
1654 test_32p() {
1655     log 32p_1
1656         rm -fr $DIR/d32p
1657     log 32p_2
1658         rm -f $DIR/$tfile
1659     log 32p_3
1660         touch $DIR/$tfile
1661     log 32p_4
1662         mkdir -p $DIR/d32p/tmp
1663     log 32p_5
1664         TMP_DIR=$DIR/d32p/tmp
1665     log 32p_6
1666         ln -s $DIR/$tfile $TMP_DIR/symlink12
1667     log 32p_7
1668         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
1669     log 32p_8
1670         cat $DIR/d32p/tmp/symlink12 || error
1671     log 32p_9
1672         cat $DIR/d32p/symlink02 || error
1673     log 32p_10
1674 }
1675 run_test 32p "open d32p/symlink->tmp/symlink->lustre-root/$tfile"
1676
1677 test_32q() {
1678         [ -e $DIR/d32q ] && rm -fr $DIR/d32q
1679         mkdir -p $DIR/d32q
1680         touch $DIR/d32q/under_the_mount
1681         mount -t ext2 -o loop $EXT2_DEV $DIR/d32q
1682         ls $DIR/d32q/under_the_mount && error || true
1683         $UMOUNT $DIR/d32q || error
1684 }
1685 run_test 32q "stat follows mountpoints in Lustre (should return error)"
1686
1687 test_32r() {
1688         [ -e $DIR/d32r ] && rm -fr $DIR/d32r
1689         mkdir -p $DIR/d32r
1690         touch $DIR/d32r/under_the_mount
1691         mount -t ext2 -o loop $EXT2_DEV $DIR/d32r
1692         ls $DIR/d32r | grep -q under_the_mount && error || true
1693         $UMOUNT $DIR/d32r || error
1694 }
1695 run_test 32r "opendir follows mountpoints in Lustre (should return error)"
1696
1697 test_33() {
1698         rm -f $DIR/$tfile
1699         touch $DIR/$tfile
1700         chmod 444 $DIR/$tfile
1701         chown $RUNAS_ID $DIR/$tfile
1702         log 33_1
1703         $RUNAS $OPENFILE -f O_RDWR $DIR/$tfile && error || true
1704         log 33_2
1705 }
1706 run_test 33 "write file with mode 444 (should return error) ===="
1707
1708 test_33a() {
1709         rm -fr $DIR/d33
1710         mkdir -p $DIR/d33
1711         chown $RUNAS_ID $DIR/d33
1712         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/d33/f33|| error "create"
1713         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/d33/f33 && \
1714                 error "open RDWR" || true
1715 }
1716 run_test 33a "test open file(mode=0444) with O_RDWR (should return error)"
1717
1718 test_33b() {
1719         rm -fr $DIR/d33
1720         mkdir -p $DIR/d33
1721         chown $RUNAS_ID $DIR/d33
1722         $RUNAS $OPENFILE -f 1286739555 $DIR/d33/f33 && error "create" || true
1723 }
1724 run_test 33b "test open file with malformed flags (No panic and return error)"
1725
1726 TEST_34_SIZE=${TEST_34_SIZE:-2000000000000}
1727 test_34a() {
1728         rm -f $DIR/f34
1729         $MCREATE $DIR/f34 || error
1730         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" || error
1731         $TRUNCATE $DIR/f34 $TEST_34_SIZE || error
1732         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" || error
1733         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
1734 }
1735 run_test 34a "truncate file that has not been opened ==========="
1736
1737 test_34b() {
1738         [ ! -f $DIR/f34 ] && test_34a
1739         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
1740         $OPENFILE -f O_RDONLY $DIR/f34
1741         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" || error
1742         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
1743 }
1744 run_test 34b "O_RDONLY opening file doesn't create objects ====="
1745
1746 test_34c() {
1747         [ ! -f $DIR/f34 ] && test_34a
1748         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
1749         $OPENFILE -f O_RDWR $DIR/f34
1750         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" && error
1751         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
1752 }
1753 run_test 34c "O_RDWR opening file-with-size works =============="
1754
1755 test_34d() {
1756         [ ! -f $DIR/f34 ] && test_34a
1757         dd if=/dev/zero of=$DIR/f34 conv=notrunc bs=4k count=1 || error
1758         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
1759         rm $DIR/f34
1760 }
1761 run_test 34d "write to sparse file ============================="
1762
1763 test_34e() {
1764         rm -f $DIR/f34e
1765         $MCREATE $DIR/f34e || error
1766         $TRUNCATE $DIR/f34e 1000 || error
1767         $CHECKSTAT -s 1000 $DIR/f34e || error
1768         $OPENFILE -f O_RDWR $DIR/f34e
1769         $CHECKSTAT -s 1000 $DIR/f34e || error
1770 }
1771 run_test 34e "create objects, some with size and some without =="
1772
1773 test_34f() { # bug 6242, 6243
1774         SIZE34F=48000
1775         rm -f $DIR/f34f
1776         $MCREATE $DIR/f34f || error
1777         $TRUNCATE $DIR/f34f $SIZE34F || error "truncating $DIR/f3f to $SIZE34F"
1778         dd if=$DIR/f34f of=$TMP/f34f
1779         $CHECKSTAT -s $SIZE34F $TMP/f34f || error "$TMP/f34f not $SIZE34F bytes"
1780         dd if=/dev/zero of=$TMP/f34fzero bs=$SIZE34F count=1
1781         cmp $DIR/f34f $TMP/f34fzero || error "$DIR/f34f not all zero"
1782         cmp $TMP/f34f $TMP/f34fzero || error "$TMP/f34f not all zero"
1783         rm $TMP/f34f $TMP/f34fzero $DIR/f34f
1784 }
1785 run_test 34f "read from a file with no objects until EOF ======="
1786
1787 test_34g() {
1788         dd if=/dev/zero of=$DIR/$tfile bs=1 count=100 seek=$TEST_34_SIZE || error
1789         $TRUNCATE $DIR/$tfile $((TEST_34_SIZE / 2))|| error
1790         $CHECKSTAT -s $((TEST_34_SIZE / 2)) $DIR/$tfile || error "truncate failed"
1791         cancel_lru_locks osc
1792         $CHECKSTAT -s $((TEST_34_SIZE / 2)) $DIR/$tfile || \
1793                 error "wrong size after lock cancel"
1794
1795         $TRUNCATE $DIR/$tfile $TEST_34_SIZE || error
1796         $CHECKSTAT -s $TEST_34_SIZE $DIR/$tfile || \
1797                 error "expanding truncate failed"
1798         cancel_lru_locks osc
1799         $CHECKSTAT -s $TEST_34_SIZE $DIR/$tfile || \
1800                 error "wrong expanded size after lock cancel"
1801 }
1802 run_test 34g "truncate long file ==============================="
1803
1804 test_35a() {
1805         cp /bin/sh $DIR/f35a
1806         chmod 444 $DIR/f35a
1807         chown $RUNAS_ID $DIR/f35a
1808         $RUNAS $DIR/f35a && error || true
1809         rm $DIR/f35a
1810 }
1811 run_test 35a "exec file with mode 444 (should return and not leak) ====="
1812
1813 test_36a() {
1814         rm -f $DIR/f36
1815         utime $DIR/f36 || error
1816 }
1817 run_test 36a "MDS utime check (mknod, utime) ==================="
1818
1819 test_36b() {
1820         echo "" > $DIR/f36
1821         utime $DIR/f36 || error
1822 }
1823 run_test 36b "OST utime check (open, utime) ===================="
1824
1825 test_36c() {
1826         rm -f $DIR/d36/f36
1827         mkdir $DIR/d36
1828         chown $RUNAS_ID $DIR/d36
1829         $RUNAS utime $DIR/d36/f36 || error
1830 }
1831 run_test 36c "non-root MDS utime check (mknod, utime) =========="
1832
1833 test_36d() {
1834         [ ! -d $DIR/d36 ] && test_36c
1835         echo "" > $DIR/d36/f36
1836         $RUNAS utime $DIR/d36/f36 || error
1837 }
1838 run_test 36d "non-root OST utime check (open, utime) ==========="
1839
1840 test_36e() {
1841         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
1842         mkdir -p $DIR/$tdir
1843         touch $DIR/$tdir/$tfile
1844         $RUNAS utime $DIR/$tdir/$tfile && \
1845                 error "utime worked, expected failure" || true
1846 }
1847 run_test 36e "utime on non-owned file (should return error) ===="
1848
1849 subr_36fh() {
1850         local fl="$1"
1851         local LANG_SAVE=$LANG
1852         local LC_LANG_SAVE=$LC_LANG
1853         export LANG=C LC_LANG=C # for date language
1854
1855         DATESTR="Dec 20  2000"
1856         mkdir -p $DIR/$tdir
1857         lctl set_param fail_loc=$fl
1858         date; date +%s
1859         cp /etc/hosts $DIR/$tdir/$tfile
1860         sync & # write RPC generated with "current" inode timestamp, but delayed
1861         sleep 1
1862         touch --date="$DATESTR" $DIR/$tdir/$tfile # setattr timestamp in past
1863         LS_BEFORE="`ls -l $DIR/$tdir/$tfile`" # old timestamp from client cache
1864         cancel_lru_locks osc
1865         LS_AFTER="`ls -l $DIR/$tdir/$tfile`"  # timestamp from OST object
1866         date; date +%s
1867         [ "$LS_BEFORE" != "$LS_AFTER" ] && \
1868                 echo "BEFORE: $LS_BEFORE" && \
1869                 echo "AFTER : $LS_AFTER" && \
1870                 echo "WANT  : $DATESTR" && \
1871                 error "$DIR/$tdir/$tfile timestamps changed" || true
1872
1873         export LANG=$LANG_SAVE LC_LANG=$LC_LANG_SAVE
1874 }
1875
1876 test_36f() {
1877         #define OBD_FAIL_OST_BRW_PAUSE_BULK 0x214
1878         subr_36fh "0x80000214"
1879 }
1880 run_test 36f "utime on file racing with OST BRW write =========="
1881
1882 test_36g() {
1883         remote_ost_nodsh && skip "remote OST with nodsh" && return
1884
1885         mkdir -p $DIR/$tdir
1886         export FMD_MAX_AGE=`do_facet ost1 lctl get_param -n obdfilter.*.client_cache_seconds 2> /dev/null | head -n 1`
1887         FMD_BEFORE="`awk '/ll_fmd_cache/ { print $2 }' /proc/slabinfo`"
1888         touch $DIR/$tdir/$tfile
1889         sleep $((FMD_MAX_AGE + 12))
1890         FMD_AFTER="`awk '/ll_fmd_cache/ { print $2 }' /proc/slabinfo`"
1891         [ "$FMD_AFTER" -gt "$FMD_BEFORE" ] && \
1892                 echo "AFTER : $FMD_AFTER > BEFORE $FMD_BEFORE" && \
1893                 error "fmd didn't expire after ping" || true
1894 }
1895 run_test 36g "filter mod data cache expiry ====================="
1896
1897 test_36h() {
1898         #define OBD_FAIL_OST_BRW_PAUSE_BULK2 0x227
1899         subr_36fh "0x80000227"
1900 }
1901 run_test 36h "utime on file racing with OST BRW write =========="
1902
1903 test_37() {
1904         mkdir -p $DIR/$tdir
1905         echo f > $DIR/$tdir/fbugfile
1906         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir
1907         ls $DIR/$tdir | grep "\<fbugfile\>" && error
1908         $UMOUNT $DIR/$tdir || error
1909         rm -f $DIR/$tdir/fbugfile || error
1910 }
1911 run_test 37 "ls a mounted file system to check old content ====="
1912
1913 test_38() {
1914         local file=$DIR/$tfile
1915         touch $file
1916         openfile -f O_DIRECTORY $file
1917         local RC=$?
1918         local ENOTDIR=20
1919         [ $RC -eq 0 ] && error "opened file $file with O_DIRECTORY" || true
1920         [ $RC -eq $ENOTDIR ] || error "error $RC should be ENOTDIR ($ENOTDIR)"
1921 }
1922 run_test 38 "open a regular file with O_DIRECTORY should return -ENOTDIR ==="
1923
1924 test_39() {
1925         touch $DIR/$tfile
1926         touch $DIR/${tfile}2
1927 #       ls -l  $DIR/$tfile $DIR/${tfile}2
1928 #       ls -lu  $DIR/$tfile $DIR/${tfile}2
1929 #       ls -lc  $DIR/$tfile $DIR/${tfile}2
1930         sleep 2
1931         $OPENFILE -f O_CREAT:O_TRUNC:O_WRONLY $DIR/${tfile}2
1932         if [ ! $DIR/${tfile}2 -nt $DIR/$tfile ]; then
1933                 echo "mtime"
1934                 ls -l  $DIR/$tfile $DIR/${tfile}2
1935                 echo "atime"
1936                 ls -lu  $DIR/$tfile $DIR/${tfile}2
1937                 echo "ctime"
1938                 ls -lc  $DIR/$tfile $DIR/${tfile}2
1939                 error "O_TRUNC didn't change timestamps"
1940         fi
1941 }
1942 run_test 39 "mtime changed on create ==========================="
1943
1944 test_40() {
1945         dd if=/dev/zero of=$DIR/f40 bs=4096 count=1
1946         $RUNAS $OPENFILE -f O_WRONLY:O_TRUNC $DIR/f40 && error
1947         $CHECKSTAT -t file -s 4096 $DIR/f40 || error
1948 }
1949 run_test 40 "failed open(O_TRUNC) doesn't truncate ============="
1950
1951 test_41() {
1952         # bug 1553
1953         small_write $DIR/f41 18
1954 }
1955 run_test 41 "test small file write + fstat ====================="
1956
1957 count_ost_writes() {
1958         lctl get_param -n osc.*.stats |
1959             awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }'
1960 }
1961
1962 # decent default
1963 WRITEBACK_SAVE=500
1964 DIRTY_RATIO_SAVE=40
1965 MAX_DIRTY_RATIO=50
1966 BG_DIRTY_RATIO_SAVE=10
1967 MAX_BG_DIRTY_RATIO=25
1968
1969 start_writeback() {
1970         trap 0
1971         # in 2.6, restore /proc/sys/vm/dirty_writeback_centisecs,
1972         # dirty_ratio, dirty_background_ratio
1973         if [ -f /proc/sys/vm/dirty_writeback_centisecs ]; then
1974                 sysctl -w vm.dirty_writeback_centisecs=$WRITEBACK_SAVE
1975                 sysctl -w vm.dirty_background_ratio=$BG_DIRTY_RATIO_SAVE
1976                 sysctl -w vm.dirty_ratio=$DIRTY_RATIO_SAVE
1977         else
1978                 # if file not here, we are a 2.4 kernel
1979                 kill -CONT `pidof kupdated`
1980         fi
1981 }
1982
1983 stop_writeback() {
1984         # setup the trap first, so someone cannot exit the test at the
1985         # exact wrong time and mess up a machine
1986         trap start_writeback EXIT
1987         # in 2.6, save and 0 /proc/sys/vm/dirty_writeback_centisecs
1988         if [ -f /proc/sys/vm/dirty_writeback_centisecs ]; then
1989                 WRITEBACK_SAVE=`sysctl -n vm.dirty_writeback_centisecs`
1990                 sysctl -w vm.dirty_writeback_centisecs=0
1991                 sysctl -w vm.dirty_writeback_centisecs=0
1992                 # save and increase /proc/sys/vm/dirty_ratio
1993                 DIRTY_RATIO_SAVE=`sysctl -n vm.dirty_ratio`
1994                 sysctl -w vm.dirty_ratio=$MAX_DIRTY_RATIO
1995                 # save and increase /proc/sys/vm/dirty_background_ratio
1996                 BG_DIRTY_RATIO_SAVE=`sysctl -n vm.dirty_background_ratio`
1997                 sysctl -w vm.dirty_background_ratio=$MAX_BG_DIRTY_RATIO
1998         else
1999                 # if file not here, we are a 2.4 kernel
2000                 kill -STOP `pidof kupdated`
2001         fi
2002 }
2003
2004 # ensure that all stripes have some grant before we test client-side cache
2005 setup_test42() {
2006         [ "$SETUP_TEST42" ] && return
2007         for i in `seq -f $DIR/f42-%g 1 $OSTCOUNT`; do
2008                 dd if=/dev/zero of=$i bs=4k count=1
2009                 rm $i
2010         done
2011         SETUP_TEST42=DONE
2012 }
2013
2014 # Tests 42* verify that our behaviour is correct WRT caching, file closure,
2015 # file truncation, and file removal.
2016 test_42a() {
2017         setup_test42
2018         cancel_lru_locks osc
2019         stop_writeback
2020         sync; sleep 1; sync # just to be safe
2021         BEFOREWRITES=`count_ost_writes`
2022         lctl get_param -n osc.*[oO][sS][cC][_-]*.cur_grant_bytes | grep "[0-9]"
2023         dd if=/dev/zero of=$DIR/f42a bs=1024 count=100
2024         AFTERWRITES=`count_ost_writes`
2025         [ $BEFOREWRITES -eq $AFTERWRITES ] || \
2026                 error "$BEFOREWRITES < $AFTERWRITES"
2027         start_writeback
2028 }
2029 run_test 42a "ensure that we don't flush on close =============="
2030
2031 test_42b() {
2032         setup_test42
2033         cancel_lru_locks osc
2034         stop_writeback
2035         sync
2036         dd if=/dev/zero of=$DIR/f42b bs=1024 count=100
2037         BEFOREWRITES=`count_ost_writes`
2038         $MUNLINK $DIR/f42b || error "$MUNLINK $DIR/f42b: $?"
2039         AFTERWRITES=`count_ost_writes`
2040         if [ $BEFOREWRITES -lt $AFTERWRITES ]; then
2041                 error "$BEFOREWRITES < $AFTERWRITES on unlink"
2042         fi
2043         BEFOREWRITES=`count_ost_writes`
2044         sync || error "sync: $?"
2045         AFTERWRITES=`count_ost_writes`
2046         if [ $BEFOREWRITES -lt $AFTERWRITES ]; then
2047                 error "$BEFOREWRITES < $AFTERWRITES on sync"
2048         fi
2049         dmesg | grep 'error from obd_brw_async' && error 'error writing back'
2050         start_writeback
2051         return 0
2052 }
2053 run_test 42b "test destroy of file with cached dirty data ======"
2054
2055 # if these tests just want to test the effect of truncation,
2056 # they have to be very careful.  consider:
2057 # - the first open gets a {0,EOF}PR lock
2058 # - the first write conflicts and gets a {0, count-1}PW
2059 # - the rest of the writes are under {count,EOF}PW
2060 # - the open for truncate tries to match a {0,EOF}PR
2061 #   for the filesize and cancels the PWs.
2062 # any number of fixes (don't get {0,EOF} on open, match
2063 # composite locks, do smarter file size management) fix
2064 # this, but for now we want these tests to verify that
2065 # the cancellation with truncate intent works, so we
2066 # start the file with a full-file pw lock to match against
2067 # until the truncate.
2068 trunc_test() {
2069         test=$1
2070         file=$DIR/$test
2071         offset=$2
2072         cancel_lru_locks osc
2073         stop_writeback
2074         # prime the file with 0,EOF PW to match
2075         touch $file
2076         $TRUNCATE $file 0
2077         sync; sync
2078         # now the real test..
2079         dd if=/dev/zero of=$file bs=1024 count=100
2080         BEFOREWRITES=`count_ost_writes`
2081         $TRUNCATE $file $offset
2082         cancel_lru_locks osc
2083         AFTERWRITES=`count_ost_writes`
2084         start_writeback
2085 }
2086
2087 test_42c() {
2088         trunc_test 42c 1024
2089         [ $BEFOREWRITES -eq $AFTERWRITES ] && \
2090             error "beforewrites $BEFOREWRITES == afterwrites $AFTERWRITES on truncate"
2091         rm $file
2092 }
2093 run_test 42c "test partial truncate of file with cached dirty data"
2094
2095 test_42d() {
2096         trunc_test 42d 0
2097         [ $BEFOREWRITES -eq $AFTERWRITES ] || \
2098             error "beforewrites $BEFOREWRITES != afterwrites $AFTERWRITES on truncate"
2099         rm $file
2100 }
2101 run_test 42d "test complete truncate of file with cached dirty data"
2102
2103 page_size() {
2104         getconf PAGE_SIZE
2105 }
2106
2107 test_42e() { # bug22074
2108         local TDIR=$DIR/${tdir}e
2109         local pagesz=$(page_size)
2110         local pages=16
2111         local files=$((OSTCOUNT * 500)) # hopefully 500 files on each OST
2112         local proc_osc0="osc.${FSNAME}-OST0000-osc-[^MDT]*"
2113         local max_dirty_mb
2114         local warmup_files
2115
2116         mkdir -p $TDIR
2117         $LFS setstripe -c 1 $TDIR
2118         createmany -o $TDIR/f $files
2119
2120         max_dirty_mb=$($LCTL get_param -n $proc_osc0/max_dirty_mb)
2121
2122         # we assume that with $OSTCOUNT files, at least one of them will
2123         # be allocated on OST0.
2124         warmup_files=$((OSTCOUNT * max_dirty_mb))
2125         createmany -o $TDIR/w $warmup_files
2126
2127         # write a large amount of data into one file and sync, to get good
2128         # avail_grant number from OST.
2129         for ((i=0; i<$warmup_files; i++)); do
2130                 idx=$($LFS getstripe -i $TDIR/w$i)
2131                 [ $idx -ne 0 ] && continue
2132                 dd if=/dev/zero of=$TDIR/w$i bs="$max_dirty_mb"M count=1
2133                 break
2134         done
2135         [ $i -gt $warmup_files ] && error "OST0 is still cold"
2136         sync
2137         $LCTL get_param $proc_osc0/cur_dirty_bytes
2138         $LCTL get_param $proc_osc0/cur_grant_bytes
2139
2140         # create as much dirty pages as we can while not to trigger the actual
2141         # RPCs directly. but depends on the env, VFS may trigger flush during this
2142         # period, hopefully we are good.
2143         for ((i=0; i<$warmup_files; i++)); do
2144                 idx=$($LFS getstripe -i $TDIR/w$i)
2145                 [ $idx -ne 0 ] && continue
2146                 dd if=/dev/zero of=$TDIR/w$i bs=1M count=1 2>/dev/null
2147         done
2148         $LCTL get_param $proc_osc0/cur_dirty_bytes
2149         $LCTL get_param $proc_osc0/cur_grant_bytes
2150
2151         # perform the real test
2152         $LCTL set_param $proc_osc0/rpc_stats 0
2153         for ((;i<$files; i++)); do
2154                 [ $($LFS getstripe -i $TDIR/f$i) -eq 0 ] || continue
2155                 dd if=/dev/zero of=$TDIR/f$i bs=$pagesz count=$pages 2>/dev/null
2156         done
2157         sync
2158         $LCTL get_param $proc_osc0/rpc_stats
2159
2160         $LCTL get_param $proc_osc0/rpc_stats |
2161                 while read PPR RRPC RPCT RCUM BAR WRPC WPCT WCUM; do
2162                         [ "$PPR" != "16:" ] && continue
2163                         [ $WPCT -lt 85 ] && error "$pages-page write RPCs only $WPCT% < 85%"
2164                         break # we only want the "pages per rpc" stat
2165                 done
2166         rm -rf $TDIR
2167 }
2168 run_test 42e "verify sub-RPC writes are not done synchronously"
2169
2170 test_43() {
2171         mkdir -p $DIR/$tdir
2172         cp -p /bin/ls $DIR/$tdir/$tfile
2173         multiop $DIR/$tdir/$tfile Ow_c &
2174         pid=$!
2175         # give multiop a chance to open
2176         sleep 1
2177
2178         $DIR/$tdir/$tfile && error || true
2179         kill -USR1 $pid
2180 }
2181 run_test 43 "execution of file opened for write should return -ETXTBSY"
2182
2183 test_43a() {
2184         mkdir -p $DIR/d43
2185         cp -p `which multiop` $DIR/d43/multiop || cp -p multiop $DIR/d43/multiop
2186         MULTIOP_PROG=$DIR/d43/multiop multiop_bg_pause $TMP/test43.junk O_c || return 1
2187         MULTIOP_PID=$!
2188         multiop $DIR/d43/multiop Oc && error "expected error, got success"
2189         kill -USR1 $MULTIOP_PID || return 2
2190         wait $MULTIOP_PID || return 3
2191         rm $TMP/test43.junk
2192 }
2193 run_test 43a "open(RDWR) of file being executed should return -ETXTBSY"
2194
2195 test_43b() {
2196         mkdir -p $DIR/d43
2197         cp -p `which multiop` $DIR/d43/multiop || cp -p multiop $DIR/d43/multiop
2198         MULTIOP_PROG=$DIR/d43/multiop multiop_bg_pause $TMP/test43.junk O_c || return 1
2199         MULTIOP_PID=$!
2200         truncate $DIR/d43/multiop 0 && error "expected error, got success"
2201         kill -USR1 $MULTIOP_PID || return 2
2202         wait $MULTIOP_PID || return 3
2203         rm $TMP/test43.junk
2204 }
2205 run_test 43b "truncate of file being executed should return -ETXTBSY"
2206
2207 test_43c() {
2208         local testdir="$DIR/d43c"
2209         mkdir -p $testdir
2210         cp $SHELL $testdir/
2211         ( cd $(dirname $SHELL) && md5sum $(basename $SHELL) ) | \
2212                 ( cd $testdir && md5sum -c)
2213 }
2214 run_test 43c "md5sum of copy into lustre========================"
2215
2216 test_44() {
2217         [  "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
2218         dd if=/dev/zero of=$DIR/f1 bs=4k count=1 seek=1023
2219         dd if=$DIR/f1 bs=4k count=1 > /dev/null
2220 }
2221 run_test 44 "zero length read from a sparse stripe ============="
2222
2223 test_44a() {
2224     local nstripe=`$LCTL lov_getconfig $DIR | grep default_stripe_count: | \
2225                          awk '{print $2}'`
2226     [ -z "$nstripe" ] && skip "can't get stripe info" && return
2227     [ "$nstripe" -gt "$OSTCOUNT" ] && skip "Wrong default_stripe_count: $nstripe (OSTCOUNT: $OSTCOUNT)" && return
2228     local stride=`$LCTL lov_getconfig $DIR | grep default_stripe_size: | \
2229                       awk '{print $2}'`
2230     if [ $nstripe -eq 0 -o $nstripe -eq -1 ] ; then
2231         nstripe=`$LCTL lov_getconfig $DIR | grep obd_count: | awk '{print $2}'`
2232     fi
2233
2234     OFFSETS="0 $((stride/2)) $((stride-1))"
2235     for offset in $OFFSETS ; do
2236       for i in `seq 0 $((nstripe-1))`; do
2237         local GLOBALOFFSETS=""
2238         local size=$((((i + 2 * $nstripe )*$stride + $offset)))  # Bytes
2239         local myfn=$DIR/d44a-$size
2240         echo "--------writing $myfn at $size"
2241         ll_sparseness_write $myfn $size  || error "ll_sparseness_write"
2242         GLOBALOFFSETS="$GLOBALOFFSETS $size"
2243         ll_sparseness_verify $myfn $GLOBALOFFSETS \
2244                             || error "ll_sparseness_verify $GLOBALOFFSETS"
2245
2246         for j in `seq 0 $((nstripe-1))`; do
2247             size=$((((j + $nstripe )*$stride + $offset)))  # Bytes
2248             ll_sparseness_write $myfn $size || error "ll_sparseness_write"
2249             GLOBALOFFSETS="$GLOBALOFFSETS $size"
2250         done
2251         ll_sparseness_verify $myfn $GLOBALOFFSETS \
2252                             || error "ll_sparseness_verify $GLOBALOFFSETS"
2253         rm -f $myfn
2254       done
2255     done
2256 }
2257 run_test 44a "test sparse pwrite ==============================="
2258
2259 dirty_osc_total() {
2260         tot=0
2261         for d in `lctl get_param -n osc.*.cur_dirty_bytes`; do
2262                 tot=$(($tot + $d))
2263         done
2264         echo $tot
2265 }
2266 do_dirty_record() {
2267         before=`dirty_osc_total`
2268         echo executing "\"$*\""
2269         eval $*
2270         after=`dirty_osc_total`
2271         echo before $before, after $after
2272 }
2273 test_45() {
2274         f="$DIR/f45"
2275         # Obtain grants from OST if it supports it
2276         echo blah > ${f}_grant
2277         stop_writeback
2278         sync
2279         do_dirty_record "echo blah > $f"
2280         [ $before -eq $after ] && error "write wasn't cached"
2281         do_dirty_record "> $f"
2282         [ $before -gt $after ] || error "truncate didn't lower dirty count"
2283         do_dirty_record "echo blah > $f"
2284         [ $before -eq $after ] && error "write wasn't cached"
2285         do_dirty_record "sync"
2286         [ $before -gt $after ] || error "writeback didn't lower dirty count"
2287         do_dirty_record "echo blah > $f"
2288         [ $before -eq $after ] && error "write wasn't cached"
2289         do_dirty_record "cancel_lru_locks osc"
2290         [ $before -gt $after ] || error "lock cancellation didn't lower dirty count"
2291         start_writeback
2292 }
2293 run_test 45 "osc io page accounting ============================"
2294
2295 # in a 2 stripe file (lov.sh), page 1023 maps to page 511 in its object.  this
2296 # test tickles a bug where re-dirtying a page was failing to be mapped to the
2297 # objects offset and an assert hit when an rpc was built with 1023's mapped
2298 # offset 511 and 511's raw 511 offset. it also found general redirtying bugs.
2299 test_46() {
2300         f="$DIR/f46"
2301         stop_writeback
2302         sync
2303         dd if=/dev/zero of=$f bs=`page_size` seek=511 count=1
2304         sync
2305         dd conv=notrunc if=/dev/zero of=$f bs=`page_size` seek=1023 count=1
2306         dd conv=notrunc if=/dev/zero of=$f bs=`page_size` seek=511 count=1
2307         sync
2308         start_writeback
2309 }
2310 run_test 46 "dirtying a previously written page ================"
2311
2312 # test_47 is removed "Device nodes check" is moved to test_28
2313
2314 test_48a() { # bug 2399
2315         check_kernel_version 34 || return 0
2316         mkdir -p $DIR/d48a
2317         cd $DIR/d48a
2318         mv $DIR/d48a $DIR/d48.new || error "move directory failed"
2319         mkdir $DIR/d48a || error "recreate directory failed"
2320         touch foo || error "'touch foo' failed after recreating cwd"
2321         mkdir bar || error "'mkdir foo' failed after recreating cwd"
2322         if check_kernel_version 44; then
2323                 touch .foo || error "'touch .foo' failed after recreating cwd"
2324                 mkdir .bar || error "'mkdir .foo' failed after recreating cwd"
2325         fi
2326         ls . > /dev/null || error "'ls .' failed after recreating cwd"
2327         ls .. > /dev/null || error "'ls ..' failed after removing cwd"
2328         cd . || error "'cd .' failed after recreating cwd"
2329         mkdir . && error "'mkdir .' worked after recreating cwd"
2330         rmdir . && error "'rmdir .' worked after recreating cwd"
2331         ln -s . baz || error "'ln -s .' failed after recreating cwd"
2332         cd .. || error "'cd ..' failed after recreating cwd"
2333 }
2334 run_test 48a "Access renamed working dir (should return errors)="
2335
2336 test_48b() { # bug 2399
2337         check_kernel_version 34 || return 0
2338         mkdir -p $DIR/d48b
2339         cd $DIR/d48b
2340         rmdir $DIR/d48b || error "remove cwd $DIR/d48b failed"
2341         touch foo && error "'touch foo' worked after removing cwd"
2342         mkdir foo && error "'mkdir foo' worked after removing cwd"
2343         if check_kernel_version 44; then
2344                 touch .foo && error "'touch .foo' worked after removing cwd"
2345                 mkdir .foo && error "'mkdir .foo' worked after removing cwd"
2346         fi
2347         ls . > /dev/null && error "'ls .' worked after removing cwd"
2348         ls .. > /dev/null || error "'ls ..' failed after removing cwd"
2349         is_patchless || ( cd . && error "'cd .' worked after removing cwd" )
2350         mkdir . && error "'mkdir .' worked after removing cwd"
2351         rmdir . && error "'rmdir .' worked after removing cwd"
2352         ln -s . foo && error "'ln -s .' worked after removing cwd"
2353         cd .. || echo "'cd ..' failed after removing cwd `pwd`"  #bug 3517
2354 }
2355 run_test 48b "Access removed working dir (should return errors)="
2356
2357 test_48c() { # bug 2350
2358         check_kernel_version 36 || return 0
2359         #lctl set_param debug=-1
2360         #set -vx
2361         mkdir -p $DIR/d48c/dir
2362         cd $DIR/d48c/dir
2363         $TRACE rmdir $DIR/d48c/dir || error "remove cwd $DIR/d48c/dir failed"
2364         $TRACE touch foo && error "'touch foo' worked after removing cwd"
2365         $TRACE mkdir foo && error "'mkdir foo' worked after removing cwd"
2366         if check_kernel_version 44; then
2367                 touch .foo && error "'touch .foo' worked after removing cwd"
2368                 mkdir .foo && error "'mkdir .foo' worked after removing cwd"
2369         fi
2370         $TRACE ls . && error "'ls .' worked after removing cwd"
2371         $TRACE ls .. || error "'ls ..' failed after removing cwd"
2372         is_patchless || ( $TRACE cd . && error "'cd .' worked after removing cwd" )
2373         $TRACE mkdir . && error "'mkdir .' worked after removing cwd"
2374         $TRACE rmdir . && error "'rmdir .' worked after removing cwd"
2375         $TRACE ln -s . foo && error "'ln -s .' worked after removing cwd"
2376         $TRACE cd .. || echo "'cd ..' failed after removing cwd `pwd`" #bug 3415
2377 }
2378 run_test 48c "Access removed working subdir (should return errors)"
2379
2380 test_48d() { # bug 2350
2381         check_kernel_version 36 || return 0
2382         #lctl set_param debug=-1
2383         #set -vx
2384         mkdir -p $DIR/d48d/dir
2385         cd $DIR/d48d/dir
2386         $TRACE rmdir $DIR/d48d/dir || error "remove cwd $DIR/d48d/dir failed"
2387         $TRACE rmdir $DIR/d48d || error "remove parent $DIR/d48d failed"
2388         $TRACE touch foo && error "'touch foo' worked after removing parent"
2389         $TRACE mkdir foo && error "'mkdir foo' worked after removing parent"
2390         if check_kernel_version 44; then
2391                 touch .foo && error "'touch .foo' worked after removing parent"
2392                 mkdir .foo && error "'mkdir .foo' worked after removing parent"
2393         fi
2394         $TRACE ls . && error "'ls .' worked after removing parent"
2395         $TRACE ls .. && error "'ls ..' worked after removing parent"
2396         is_patchless || ( $TRACE cd . && error "'cd .' worked after recreate parent" )
2397         $TRACE mkdir . && error "'mkdir .' worked after removing parent"
2398         $TRACE rmdir . && error "'rmdir .' worked after removing parent"
2399         $TRACE ln -s . foo && error "'ln -s .' worked after removing parent"
2400         is_patchless || ( $TRACE cd .. && error "'cd ..' worked after removing parent" || true )
2401 }
2402 run_test 48d "Access removed parent subdir (should return errors)"
2403
2404 test_48e() { # bug 4134
2405         check_kernel_version 41 || return 0
2406         #lctl set_param debug=-1
2407         #set -vx
2408         mkdir -p $DIR/d48e/dir
2409         cd $DIR/d48e/dir
2410         $TRACE rmdir $DIR/d48e/dir || error "remove cwd $DIR/d48e/dir failed"
2411         $TRACE rmdir $DIR/d48e || error "remove parent $DIR/d48e failed"
2412         $TRACE touch $DIR/d48e || error "'touch $DIR/d48e' failed"
2413         $TRACE chmod +x $DIR/d48e || error "'chmod +x $DIR/d48e' failed"
2414         # On a buggy kernel addition of "touch foo" after cd .. will
2415         # produce kernel oops in lookup_hash_it
2416         touch ../foo && error "'cd ..' worked after recreate parent"
2417         cd $DIR
2418         $TRACE rm $DIR/d48e || error "rm '$DIR/d48e' failed"
2419 }
2420 run_test 48e "Access to recreated parent subdir (should return errors)"
2421
2422 test_50() {
2423         # bug 1485
2424         mkdir $DIR/d50
2425         cd $DIR/d50
2426         ls /proc/$$/cwd || error
2427 }
2428 run_test 50 "special situations: /proc symlinks  ==============="
2429
2430 test_51a() {    # was test_51
2431         # bug 1516 - create an empty entry right after ".." then split dir
2432         mkdir $DIR/d51
2433         touch $DIR/d51/foo
2434         $MCREATE $DIR/d51/bar
2435         rm $DIR/d51/foo
2436         createmany -m $DIR/d51/longfile 201
2437         FNUM=202
2438         while [ `ls -sd $DIR/d51 | awk '{ print $1 }'` -eq 4 ]; do
2439                 $MCREATE $DIR/d51/longfile$FNUM
2440                 FNUM=$(($FNUM + 1))
2441                 echo -n "+"
2442         done
2443         echo
2444         ls -l $DIR/d51 > /dev/null || error
2445 }
2446 run_test 51a "special situations: split htree with empty entry =="
2447
2448 #export NUMTEST=70000
2449 # FIXME: I select a relatively small number to do basic test.
2450 # large number may give panic(). debugging on this is going on.
2451 export NUMTEST=70
2452 test_51b() {
2453         NUMFREE=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
2454         [ $NUMFREE -lt 21000 ] && \
2455                 skip "not enough free inodes ($NUMFREE)" && \
2456                 return
2457
2458         check_kernel_version 40 || NUMTEST=31000
2459         [ $NUMFREE -lt $NUMTEST ] && NUMTEST=$(($NUMFREE - 50))
2460
2461         mkdir -p $DIR/d51b
2462         createmany -d $DIR/d51b/t- $NUMTEST
2463 }
2464 run_test 51b "mkdir .../t-0 --- .../t-$NUMTEST ===================="
2465
2466 test_51bb() {
2467         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2468
2469         local ndirs=${TEST51BB_NDIRS:-10}
2470         local nfiles=${TEST51BB_NFILES:-100}
2471
2472         local numfree=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
2473
2474         [ $numfree -lt $(( ndirs * nfiles)) ] && \
2475                 nfiles=$(( numfree / ndirs - 10 ))
2476
2477         local dir=$DIR/d51bb
2478         mkdir -p $dir
2479         local savePOLICY=$(lctl get_param -n lmv.*.placement)
2480         lctl set_param -n lmv.*.placement=CHAR
2481
2482         lfs df -i $dir
2483         local IUSED=$(lfs df -i $dir | grep MDT | awk '{print $3}')
2484         OLDUSED=($IUSED)
2485
2486         declare -a dirs
2487         for ((i=0; i < $ndirs; i++)); do
2488                 dirs[i]=$dir/$RANDOM
2489                 echo Creating directory ${dirs[i]}
2490                 mkdir -p ${dirs[i]}
2491                 ls $dir
2492                 echo Creating $nfiles in dir ${dirs[i]} ...
2493                 echo "createmany -o ${dirs[i]}/$tfile- $nfiles"
2494                 createmany -o ${dirs[i]}/$tfile- $nfiles
2495         done
2496         ls $dir
2497
2498         sleep 1
2499
2500         IUSED=$(lfs df -i $dir | grep MDT | awk '{print $3}')
2501         NEWUSED=($IUSED)
2502
2503         local rc=0
2504         for ((i=0; i<${#NEWUSED[@]}; i++)); do
2505                 echo "mds $i: inodes count OLD ${OLDUSED[$i]} NEW ${NEWUSED[$i]}"
2506                 [ ${OLDUSED[$i]} -lt ${NEWUSED[$i]} ] || rc=$((rc + 1))
2507         done
2508
2509         lctl set_param -n lmv.*.placement=$savePOLICY
2510
2511         [ $rc -ne $MDSCOUNT ] || \
2512                 error "Objects/inodes are not distributed over all mds servers"
2513 }
2514 run_test 51bb "mkdir createmany CMD $MDSCOUNT  ===================="
2515
2516
2517 test_51c() {
2518         [ ! -d $DIR/d51b ] && skip "$DIR/51b missing" && \
2519                 return
2520
2521         unlinkmany -d $DIR/d51b/t- $NUMTEST
2522 }
2523 run_test 51c "rmdir .../t-0 --- .../t-$NUMTEST ===================="
2524
2525 test_51d() {
2526         [  "$OSTCOUNT" -lt "3" ] && skip_env "skipping test with few OSTs" && return
2527         mkdir -p $DIR/d51d
2528         createmany -o $DIR/d51d/t- 1000
2529         $LFS getstripe $DIR/d51d > $TMP/files
2530         for N in `seq 0 $((OSTCOUNT - 1))`; do
2531             OBJS[$N]=`awk -vobjs=0 '($1 == '$N') { objs += 1 } END { print objs;}' $TMP/files`
2532             OBJS0[$N]=`grep -A 1 idx $TMP/files | awk -vobjs=0 '($1 == '$N') { objs += 1 } END { print objs;}'`
2533             log "OST$N has ${OBJS[$N]} objects, ${OBJS0[$N]} are index 0"
2534         done
2535         unlinkmany $DIR/d51d/t- 1000
2536
2537         NLAST=0
2538         for N in `seq 1 $((OSTCOUNT - 1))`; do
2539             [ ${OBJS[$N]} -lt $((${OBJS[$NLAST]} - 20)) ] && \
2540                 error "OST $N has less objects vs OST $NLAST (${OBJS[$N]} < ${OBJS[$NLAST]}"
2541             [ ${OBJS[$N]} -gt $((${OBJS[$NLAST]} + 20)) ] && \
2542                 error "OST $N has less objects vs OST $NLAST (${OBJS[$N]} < ${OBJS[$NLAST]}"
2543
2544             [ ${OBJS0[$N]} -lt $((${OBJS0[$NLAST]} - 20)) ] && \
2545                 error "OST $N has less #0 objects vs OST $NLAST (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
2546             [ ${OBJS0[$N]} -gt $((${OBJS0[$NLAST]} + 20)) ] && \
2547                 error "OST $N has less #0 objects vs OST $NLAST (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
2548             NLAST=$N
2549         done
2550 }
2551 run_test 51d "check object distribution ===================="
2552
2553 test_52a() {
2554         [ -f $DIR/d52a/foo ] && chattr -a $DIR/d52a/foo
2555         mkdir -p $DIR/d52a
2556         touch $DIR/d52a/foo
2557         chattr +a $DIR/d52a/foo || error "chattr +a failed"
2558         echo bar >> $DIR/d52a/foo || error "append bar failed"
2559         cp /etc/hosts $DIR/d52a/foo && error "cp worked"
2560         rm -f $DIR/d52a/foo 2>/dev/null && error "rm worked"
2561         link $DIR/d52a/foo $DIR/d52a/foo_link 2>/dev/null && error "link worked"
2562         echo foo >> $DIR/d52a/foo || error "append foo failed"
2563         mrename $DIR/d52a/foo $DIR/d52a/foo_ren && error "rename worked"
2564         lsattr $DIR/d52a/foo | egrep -q "^-+a[-e]+ $DIR/d52a/foo" || error "lsattr"
2565         chattr -a $DIR/d52a/foo || error "chattr -a failed"
2566         cp -r $DIR/d52a /tmp/
2567         rm -fr $DIR/d52a || error "cleanup rm failed"
2568 }
2569 run_test 52a "append-only flag test (should return errors) ====="
2570
2571 test_52b() {
2572         [ -f $DIR/d52b/foo ] && chattr -i $DIR/d52b/foo
2573         mkdir -p $DIR/d52b
2574         touch $DIR/d52b/foo
2575         chattr +i $DIR/d52b/foo || error "chattr +i failed"
2576         cat test > $DIR/d52b/foo && error "cat test worked"
2577         cp /etc/hosts $DIR/d52b/foo && error "cp worked"
2578         rm -f $DIR/d52b/foo 2>/dev/null && error "rm worked"
2579         link $DIR/d52b/foo $DIR/d52b/foo_link 2>/dev/null && error  "link worked"
2580         echo foo >> $DIR/d52b/foo && error "echo worked"
2581         mrename $DIR/d52b/foo $DIR/d52b/foo_ren && error "rename worked"
2582         [ -f $DIR/d52b/foo ] || error
2583         [ -f $DIR/d52b/foo_ren ] && error
2584         lsattr $DIR/d52b/foo | egrep -q "^-+i[-e]+ $DIR/d52b/foo" || error "lsattr"
2585         chattr -i $DIR/d52b/foo || error "chattr failed"
2586
2587         rm -fr $DIR/d52b || error
2588 }
2589 run_test 52b "immutable flag test (should return errors) ======="
2590
2591 test_53() {
2592         remote_mds_nodsh && skip "remote MDS with nodsh" && return
2593         remote_ost_nodsh && skip "remote OST with nodsh" && return
2594
2595         local param
2596         local ostname
2597         local mds_last
2598         local ost_last
2599         local ostnum
2600
2601         # only test MDT0000
2602         for value in $(do_facet $SINGLEMDS lctl get_param osc.*-osc-MDT0000.prealloc_last_id) ; do
2603                 param=`echo ${value[0]} | cut -d "=" -f1`
2604                 ostname=`echo $param | cut -d "." -f2 | cut -d - -f 1-2`
2605                 mds_last=$(do_facet $SINGLEMDS lctl get_param -n $param)
2606                 ostnum=$(echo $ostname | sed "s/${FSNAME}-OST//g" | awk '{print ($1+1)}' )
2607                 ost_last=$(do_facet ost$ostnum lctl get_param -n obdfilter.$ostname.last_id | head -n 1)
2608                 echo "$ostname.last_id=$ost_last ; MDS.last_id=$mds_last"
2609                 if [ $ost_last != $mds_last ]; then
2610                     error "$ostname.last_id=$ost_last ; MDS.last_id=$mds_last"
2611                 fi
2612         done
2613 }
2614 run_test 53 "verify that MDS and OSTs agree on pre-creation ===="
2615
2616 test_54a() {
2617         [ ! -f "$SOCKETSERVER" ] && skip_env "no socketserver, skipping" && return
2618         [ ! -f "$SOCKETCLIENT" ] && skip_env "no socketclient, skipping" && return
2619         $SOCKETSERVER $DIR/socket
2620         $SOCKETCLIENT $DIR/socket || error
2621         $MUNLINK $DIR/socket
2622 }
2623 run_test 54a "unix domain socket test =========================="
2624
2625 test_54b() {
2626         f="$DIR/f54b"
2627         mknod $f c 1 3
2628         chmod 0666 $f
2629         dd if=/dev/zero of=$f bs=`page_size` count=1
2630 }
2631 run_test 54b "char device works in lustre ======================"
2632
2633 find_loop_dev() {
2634         [ -b /dev/loop/0 ] && LOOPBASE=/dev/loop/
2635         [ -b /dev/loop0 ] && LOOPBASE=/dev/loop
2636         [ -z "$LOOPBASE" ] && echo "/dev/loop/0 and /dev/loop0 gone?" && return
2637
2638         for i in `seq 3 7`; do
2639                 losetup $LOOPBASE$i > /dev/null 2>&1 && continue
2640                 LOOPDEV=$LOOPBASE$i
2641                 LOOPNUM=$i
2642                 break
2643         done
2644 }
2645
2646 test_54c() {
2647         tfile="$DIR/f54c"
2648         tdir="$DIR/d54c"
2649         loopdev="$DIR/loop54c"
2650
2651         find_loop_dev
2652         [ -z "$LOOPNUM" ] && echo "couldn't find empty loop device" && return
2653         mknod $loopdev b 7 $LOOPNUM
2654         echo "make a loop file system with $tfile on $loopdev ($LOOPNUM)..."
2655         dd if=/dev/zero of=$tfile bs=`page_size` seek=1024 count=1 > /dev/null
2656         losetup $loopdev $tfile || error "can't set up $loopdev for $tfile"
2657         mkfs.ext2 $loopdev || error "mke2fs on $loopdev"
2658         mkdir -p $tdir
2659         mount -t ext2 $loopdev $tdir || error "error mounting $loopdev on $tdir"
2660         dd if=/dev/zero of=$tdir/tmp bs=`page_size` count=30 || error "dd write"
2661         df $tdir
2662         dd if=$tdir/tmp of=/dev/zero bs=`page_size` count=30 || error "dd read"
2663         $UMOUNT $tdir
2664         losetup -d $loopdev
2665         rm $loopdev
2666 }
2667 run_test 54c "block device works in lustre ====================="
2668
2669 test_54d() {
2670         f="$DIR/f54d"
2671         string="aaaaaa"
2672         mknod $f p
2673         [ "$string" = `echo $string > $f | cat $f` ] || error
2674 }
2675 run_test 54d "fifo device works in lustre ======================"
2676
2677 test_54e() {
2678         check_kernel_version 46 || return 0
2679         f="$DIR/f54e"
2680         string="aaaaaa"
2681         cp -aL /dev/console $f
2682         echo $string > $f || error
2683 }
2684 run_test 54e "console/tty device works in lustre ======================"
2685
2686 check_fstype() {
2687         grep -q $FSTYPE /proc/filesystems && return 1
2688         modprobe $FSTYPE
2689         grep -q $FSTYPE /proc/filesystems && return 1
2690         insmod ../$FSTYPE/$FSTYPE.o
2691         grep -q $FSTYPE /proc/filesystems && return 1
2692         insmod ../$FSTYPE/$FSTYPE.ko
2693         grep -q $FSTYPE /proc/filesystems && return 1
2694         return 0
2695 }
2696
2697 test_55() {
2698         rm -rf $DIR/d55
2699         mkdir $DIR/d55
2700         client_only && skip "Not a server" && return
2701         mount -t $FSTYPE -o loop,iopen $EXT2_DEV $DIR/d55 || error "mounting"
2702         touch $DIR/d55/foo
2703         $IOPENTEST1 $DIR/d55/foo $DIR/d55 || error "running $IOPENTEST1"
2704         $IOPENTEST2 $DIR/d55 || error "running $IOPENTEST2"
2705         echo "check for $EXT2_DEV. Please wait..."
2706         rm -rf $DIR/d55/*
2707         $UMOUNT $DIR/d55 || error "unmounting"
2708 }
2709 run_test 55 "check iopen_connect_dentry() ======================"
2710
2711 test_56a() {    # was test_56
2712         rm -rf $DIR/d56
2713         $SETSTRIPE -d $DIR
2714         mkdir $DIR/d56
2715         mkdir $DIR/d56/dir
2716         NUMFILES=3
2717         NUMFILESx2=$(($NUMFILES * 2))
2718         for i in `seq 1 $NUMFILES` ; do
2719                 touch $DIR/d56/file$i
2720                 touch $DIR/d56/dir/file$i
2721         done
2722
2723         # test lfs getstripe with --recursive
2724         FILENUM=`$GETSTRIPE --recursive $DIR/d56 | grep -c obdidx`
2725         [ $FILENUM -eq $NUMFILESx2 ] || error \
2726                 "lfs getstripe --recursive $DIR/d56 wrong: found $FILENUM, expected $NUMFILESx2"
2727         FILENUM=`$GETSTRIPE $DIR/d56 | grep -c obdidx`
2728         [ $FILENUM -eq $NUMFILES ] || error \
2729                 "lfs getstripe $DIR/d56 without --recursive wrong: found $FILENUM, expected $NUMFILES"
2730         echo "lfs getstripe --recursive passed."
2731
2732         # test lfs getstripe with file instead of dir
2733         FILENUM=`$GETSTRIPE $DIR/d56/file1 | grep -c obdidx`
2734         [ $FILENUM  -eq 1 ] || error \
2735                  "lfs getstripe $DIR/d56/file1 wrong:found $FILENUM, expected 1"
2736         echo "lfs getstripe file passed."
2737
2738         #test lfs getstripe with --verbose
2739         [ `$GETSTRIPE --verbose $DIR/d56 | grep -c lmm_magic` -eq $NUMFILES ] ||\
2740                 error "lfs getstripe --verbose $DIR/d56 wrong: should find $NUMFILES lmm_magic info"
2741         [ `$GETSTRIPE $DIR/d56 | grep -c lmm_magic` -eq 0 ] || error \
2742                 "lfs getstripe $DIR/d56 without --verbose wrong: should not show lmm_magic info"
2743         echo "lfs getstripe --verbose passed."
2744
2745         #test lfs getstripe with --obd
2746         $GETSTRIPE --obd wrong_uuid $DIR/d56 2>&1 | grep -q "unknown obduuid" || \
2747                 error "lfs getstripe --obd wrong_uuid should return error message"
2748
2749         [  "$OSTCOUNT" -lt 2 ] && \
2750                 skip_env "skipping other lfs getstripe --obd test" && return
2751         OSTIDX=1
2752         OBDUUID=$(lfs osts | grep ${OSTIDX}": " | awk '{print $2}')
2753         FILENUM=`$GETSTRIPE -ir $DIR/d56 | grep -x $OSTIDX | wc -l`
2754         FOUND=`$GETSTRIPE -r --obd $OBDUUID $DIR/d56 | grep obdidx | wc -l`
2755         [ $FOUND -eq $FILENUM ] || \
2756                 error "lfs getstripe --obd wrong: found $FOUND, expected $FILENUM"
2757         [ `$GETSTRIPE -r -v --obd $OBDUUID $DIR/d56 | \
2758                 sed '/^[         ]*'${OSTIDX}'[  ]/d' |\
2759                 sed -n '/^[      ]*[0-9][0-9]*[  ]/p' | wc -l` -eq 0 ] || \
2760                 error "lfs getstripe --obd wrong: should not show file on other obd"
2761         echo "lfs getstripe --obd passed."
2762 }
2763 run_test 56a "check lfs getstripe ===================================="
2764
2765 NUMFILES=3
2766 NUMDIRS=3
2767 setup_56() {
2768         LOCAL_NUMFILES=$1
2769         LOCAL_NUMDIRS=$2
2770         if [ ! -d "$DIR/${tdir}g" ] ; then
2771                 mkdir -p $DIR/${tdir}g
2772                 for i in `seq 1 $LOCAL_NUMFILES` ; do
2773                         touch $DIR/${tdir}g/file$i
2774                 done
2775                 for i in `seq 1 $LOCAL_NUMDIRS` ; do
2776                         mkdir $DIR/${tdir}g/dir$i
2777                         for j in `seq 1 $LOCAL_NUMFILES` ; do
2778                                 touch $DIR/${tdir}g/dir$i/file$j
2779                         done
2780                 done
2781         fi
2782 }
2783
2784 setup_56_special() {
2785         LOCAL_NUMFILES=$1
2786         LOCAL_NUMDIRS=$2
2787         TDIR=$DIR/${tdir}g
2788         setup_56 $1 $2
2789         if [ ! -e "$TDIR/loop1b" ] ; then
2790                 for i in `seq 1 $LOCAL_NUMFILES` ; do
2791                         mknod $TDIR/loop${i}b b 7 $i
2792                         mknod $TDIR/null${i}c c 1 3
2793                         ln -s $TDIR/file1 $TDIR/link${i}l
2794                 done
2795                 for i in `seq 1 $LOCAL_NUMDIRS` ; do
2796                         mknod $TDIR/dir$i/loop${i}b b 7 $i
2797                         mknod $TDIR/dir$i/null${i}c c 1 3
2798                         ln -s $TDIR/dir$i/file1 $TDIR/dir$i/link${i}l
2799                 done
2800         fi
2801 }
2802
2803 test_56g() {
2804         $LSTRIPE -d $DIR
2805
2806         setup_56 $NUMFILES $NUMDIRS
2807
2808         EXPECTED=$(($NUMDIRS + 2))
2809         # test lfs find with -name
2810         for i in `seq 1 $NUMFILES` ; do
2811                 NUMS=`$LFIND -name "*$i" $DIR/${tdir}g | wc -l`
2812                 [ $NUMS -eq $EXPECTED ] || error \
2813                         "lfs find -name \"*$i\" $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2814         done
2815         echo "lfs find -name passed."
2816 }
2817 run_test 56g "check lfs find -name ============================="
2818
2819 test_56h() {
2820         $LSTRIPE -d $DIR
2821
2822         setup_56 $NUMFILES $NUMDIRS
2823
2824         EXPECTED=$((($NUMDIRS+1)*($NUMFILES-1)+$NUMFILES))
2825         # test lfs find with ! -name
2826         for i in `seq 1 $NUMFILES` ; do
2827                 NUMS=`$LFIND ! -name "*$i" $DIR/${tdir}g | wc -l`
2828                 [ $NUMS -eq $EXPECTED ] || error \
2829                         "lfs find ! -name \"*$i\" $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2830         done
2831         echo "lfs find ! -name passed."
2832 }
2833 run_test 56h "check lfs find ! -name ============================="
2834
2835 test_56i() {
2836        tdir=${tdir}i
2837        mkdir -p $DIR/$tdir
2838        UUID=`$LFS osts | awk '/0: / { print $2 }'`
2839        OUT="`$LFIND -ost $UUID $DIR/$tdir`"
2840        [ "$OUT" ] && error "$LFIND returned directory '$OUT'" || true
2841 }
2842 run_test 56i "check 'lfs find -ost UUID' skips directories ======="
2843
2844 test_56j() {
2845         setup_56_special $NUMFILES $NUMDIRS
2846
2847         EXPECTED=$((NUMDIRS+1))
2848         NUMS=`$LFIND -type d $DIR/${tdir}g | wc -l`
2849         [ $NUMS -eq $EXPECTED ] || \
2850                 error "lfs find -type d $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2851 }
2852 run_test 56j "check lfs find -type d ============================="
2853
2854 test_56k() {
2855         setup_56_special $NUMFILES $NUMDIRS
2856
2857         EXPECTED=$(((NUMDIRS+1) * NUMFILES))
2858         NUMS=`$LFIND -type f $DIR/${tdir}g | wc -l`
2859         [ $NUMS -eq $EXPECTED ] || \
2860                 error "lfs find -type f $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2861 }
2862 run_test 56k "check lfs find -type f ============================="
2863
2864 test_56l() {
2865         setup_56_special $NUMFILES $NUMDIRS
2866
2867         EXPECTED=$((NUMDIRS + NUMFILES))
2868         NUMS=`$LFIND -type b $DIR/${tdir}g | wc -l`
2869         [ $NUMS -eq $EXPECTED ] || \
2870                 error "lfs find -type b $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2871 }
2872 run_test 56l "check lfs find -type b ============================="
2873
2874 test_56m() {
2875         setup_56_special $NUMFILES $NUMDIRS
2876
2877         EXPECTED=$((NUMDIRS + NUMFILES))
2878         NUMS=`$LFIND -type c $DIR/${tdir}g | wc -l`
2879         [ $NUMS -eq $EXPECTED ] || \
2880                 error "lfs find -type c $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2881 }
2882 run_test 56m "check lfs find -type c ============================="
2883
2884 test_56n() {
2885         setup_56_special $NUMFILES $NUMDIRS
2886
2887         EXPECTED=$((NUMDIRS + NUMFILES))
2888         NUMS=`$LFIND -type l $DIR/${tdir}g | wc -l`
2889         [ $NUMS -eq $EXPECTED ] || \
2890                 error "lfs find -type l $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2891 }
2892 run_test 56n "check lfs find -type l ============================="
2893
2894 test_56o() {
2895         setup_56 $NUMFILES $NUMDIRS
2896         TDIR=$DIR/${tdir}g
2897
2898         utime $TDIR/file1 > /dev/null || error "utime (1)"
2899         utime $TDIR/file2 > /dev/null || error "utime (2)"
2900         utime $TDIR/dir1 > /dev/null || error "utime (3)"
2901         utime $TDIR/dir2 > /dev/null || error "utime (4)"
2902         utime $TDIR/dir1/file1 > /dev/null || error "utime (5)"
2903
2904         EXPECTED=5
2905         NUMS=`$LFIND -mtime +1 $TDIR | wc -l`
2906         [ $NUMS -eq $EXPECTED ] || \
2907                 error "lfs find -mtime $TDIR wrong: found $NUMS, expected $EXPECTED"
2908 }
2909 run_test 56o "check lfs find -mtime for old files =========================="
2910
2911 test_56p() {
2912         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
2913
2914         TDIR=$DIR/${tdir}g
2915         rm -rf $TDIR
2916
2917         setup_56 $NUMFILES $NUMDIRS
2918
2919         chown $RUNAS_ID $TDIR/file* || error "chown $DIR/${tdir}g/file$i failed"
2920         EXPECTED=$NUMFILES
2921         NUMS="`$LFIND -uid $RUNAS_ID $TDIR | wc -l`"
2922         [ $NUMS -eq $EXPECTED ] || \
2923                 error "lfs find -uid $TDIR wrong: found $NUMS, expected $EXPECTED"
2924
2925         EXPECTED=$(( ($NUMFILES+1) * $NUMDIRS + 1))
2926         NUMS="`$LFIND ! -uid $RUNAS_ID $TDIR | wc -l`"
2927         [ $NUMS -eq $EXPECTED ] || \
2928                 error "lfs find ! -uid $TDIR wrong: found $NUMS, expected $EXPECTED"
2929
2930         echo "lfs find -uid and ! -uid passed."
2931 }
2932 run_test 56p "check lfs find -uid and ! -uid ==============================="
2933
2934 test_56q() {
2935         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
2936
2937         TDIR=$DIR/${tdir}g
2938         rm -rf $TDIR
2939
2940         setup_56 $NUMFILES $NUMDIRS
2941
2942         chgrp $RUNAS_ID $TDIR/file* || error "chown $DIR/${tdir}g/file$i failed"
2943         EXPECTED=$NUMFILES
2944         NUMS="`$LFIND -gid $RUNAS_ID $TDIR | wc -l`"
2945         [ $NUMS -eq $EXPECTED ] || \
2946                 error "lfs find -gid $TDIR wrong: found $NUMS, expected $EXPECTED"
2947
2948         EXPECTED=$(( ($NUMFILES+1) * $NUMDIRS + 1))
2949         NUMS="`$LFIND ! -gid $RUNAS_ID $TDIR | wc -l`"
2950         [ $NUMS -eq $EXPECTED ] || \
2951                 error "lfs find ! -gid $TDIR wrong: found $NUMS, expected $EXPECTED"
2952
2953         echo "lfs find -gid and ! -gid passed."
2954 }
2955 run_test 56q "check lfs find -gid and ! -gid ==============================="
2956
2957 test_57a() {
2958         # note test will not do anything if MDS is not local
2959         remote_mds_nodsh && skip "remote MDS with nodsh" && return
2960
2961         local MNTDEV="osd.*MDT*.mntdev"
2962         DEV=$(do_facet $SINGLEMDS lctl get_param -n $MNTDEV)
2963         [ -z "$DEV" ] && error "can't access $MNTDEV"
2964         for DEV in $(do_facet $SINGLEMDS lctl get_param -n $MNTDEV); do
2965                 do_facet $SINGLEMDS $DUMPE2FS -h $DEV > $TMP/t57a.dump || error "can't access $DEV"
2966                 DEVISIZE=`awk '/Inode size:/ { print $3 }' $TMP/t57a.dump`
2967                 [ "$DEVISIZE" -gt 128 ] || error "inode size $DEVISIZE"
2968                 rm $TMP/t57a.dump
2969         done
2970 }
2971 run_test 57a "verify MDS filesystem created with large inodes =="
2972
2973 test_57b() {
2974         local dir=$DIR/d57b
2975
2976         local FILECOUNT=100
2977         local FILE1=$dir/f1
2978         local FILEN=$dir/f$FILECOUNT
2979
2980         rm -rf $dir || error "removing $dir"
2981         mkdir -p $dir || error "creating $dir"
2982         local num=$(get_mds_dir $dir)
2983         local mymds=mds$num
2984
2985         echo "mcreating $FILECOUNT files"
2986         createmany -m $dir/f 1 $FILECOUNT || \
2987                 error "creating files in $dir"
2988
2989         # verify that files do not have EAs yet
2990         $GETSTRIPE $FILE1 2>&1 | grep -q "no stripe" || error "$FILE1 has an EA"
2991         $GETSTRIPE $FILEN 2>&1 | grep -q "no stripe" || error "$FILEN has an EA"
2992
2993         sync
2994         sleep 1
2995         df $dir  #make sure we get new statfs data
2996         local MDSFREE=$(do_facet $mymds lctl get_param -n osd.*MDT000$((num -1)).kbytesfree)
2997         local MDCFREE=$(lctl get_param -n mdc.*MDT000$((num -1))-mdc-*.kbytesfree)
2998         echo "opening files to create objects/EAs"
2999         local FILE
3000         for FILE in `seq -f $dir/f%g 1 $FILECOUNT`; do
3001                 $OPENFILE -f O_RDWR $FILE > /dev/null 2>&1 || error "opening $FILE"
3002         done
3003
3004         # verify that files have EAs now
3005         $GETSTRIPE $FILE1 | grep -q "obdidx" || error "$FILE1 missing EA"
3006         $GETSTRIPE $FILEN | grep -q "obdidx" || error "$FILEN missing EA"
3007
3008         sleep 1  #make sure we get new statfs data
3009         df $dir
3010         local MDSFREE2=$(do_facet $mymds lctl get_param -n osd.*MDT000$((num -1)).kbytesfree)
3011         local MDCFREE2=$(lctl get_param -n mdc.*MDT000$((num -1))-mdc-*.kbytesfree)
3012         if [ "$MDCFREE2" -lt "$((MDCFREE - 8))" ]; then
3013                 if [ "$MDSFREE" != "$MDSFREE2" ]; then
3014                         error "MDC before $MDCFREE != after $MDCFREE2"
3015                 else
3016                         echo "MDC before $MDCFREE != after $MDCFREE2"
3017                         echo "unable to confirm if MDS has large inodes"
3018                 fi
3019         fi
3020         rm -rf $dir
3021 }
3022 run_test 57b "default LOV EAs are stored inside large inodes ==="
3023
3024 test_58() {
3025     [ -z "$(which wiretest 2>/dev/null)" ] && skip_env "could not find wiretest" && return
3026     wiretest
3027 }
3028 run_test 58 "verify cross-platform wire constants =============="
3029
3030 test_59() {
3031         echo "touch 130 files"
3032         createmany -o $DIR/f59- 130
3033         echo "rm 130 files"
3034         unlinkmany $DIR/f59- 130
3035         sync
3036         sleep 2
3037         # wait for commitment of removal
3038 }
3039 run_test 59 "verify cancellation of llog records async ========="
3040
3041 TEST60_HEAD="test_60 run $RANDOM"
3042 test_60a() {
3043         [ ! -f run-llog.sh ] && skip_env "missing subtest run-llog.sh" && return
3044         log "$TEST60_HEAD - from kernel mode"
3045         sh run-llog.sh
3046 }
3047 run_test 60a "llog sanity tests run from kernel module =========="
3048
3049 test_60b() { # bug 6411
3050         dmesg > $DIR/$tfile
3051         LLOG_COUNT=`dmesg | awk "/$TEST60_HEAD/{marker = 1; from_marker = 0;}
3052                                  /llog.test/ {
3053                                          if (marker)
3054                                                  from_marker++
3055                                          from_begin++
3056                                  }
3057                                  END {
3058                                          if (marker)
3059                                                  print from_marker
3060                                          else
3061                                                  print from_begin
3062                                  }"`
3063         [ $LLOG_COUNT -gt 50 ] && error "CDEBUG_LIMIT not limiting messages ($LLOG_COUNT)"|| true
3064 }
3065 run_test 60b "limit repeated messages from CERROR/CWARN ========"
3066
3067 test_60c() {
3068         echo "create 5000 files"
3069         createmany -o $DIR/f60c- 5000
3070 #define OBD_FAIL_MDS_LLOG_CREATE_FAILED  0x137
3071         lctl set_param fail_loc=0x80000137
3072         unlinkmany $DIR/f60c- 5000
3073         lctl set_param fail_loc=0
3074 }
3075 run_test 60c "unlink file when mds full"
3076
3077 test_60d() {
3078         SAVEPRINTK=$(lctl get_param -n printk)
3079
3080         # verify "lctl mark" is even working"
3081         MESSAGE="test message ID $RANDOM $$"
3082         $LCTL mark "$MESSAGE" || error "$LCTL mark failed"
3083         dmesg | grep -q "$MESSAGE" || error "didn't find debug marker in log"
3084
3085         lctl set_param printk=0 || error "set lnet.printk failed"
3086         lctl get_param -n printk | grep emerg || error "lnet.printk dropped emerg"
3087         MESSAGE="new test message ID $RANDOM $$"
3088         # Assume here that libcfs_debug_mark_buffer() uses D_WARNING
3089         $LCTL mark "$MESSAGE" || error "$LCTL mark failed"
3090         dmesg | grep -q "$MESSAGE" && error "D_WARNING wasn't masked" || true
3091
3092         lctl set_param -n printk="$SAVEPRINTK"
3093 }
3094 run_test 60d "test printk console message masking"
3095
3096 test_61() {
3097         f="$DIR/f61"
3098         dd if=/dev/zero of=$f bs=`page_size` count=1
3099         cancel_lru_locks osc
3100         multiop $f OSMWUc || error
3101         sync
3102 }
3103 run_test 61 "mmap() writes don't make sync hang ================"
3104
3105 # bug 2330 - insufficient obd_match error checking causes LBUG
3106 test_62() {
3107         f="$DIR/f62"
3108         echo foo > $f
3109         cancel_lru_locks osc
3110         lctl set_param fail_loc=0x405
3111         cat $f && error "cat succeeded, expect -EIO"
3112         lctl set_param fail_loc=0
3113 }
3114 # This test is now irrelevant (as of bug 10718 inclusion), we no longer
3115 # match every page all of the time.
3116 #run_test 62 "verify obd_match failure doesn't LBUG (should -EIO)"
3117
3118 # bug 2319 - oig_wait() interrupted causes crash because of invalid waitq.
3119 test_63a() {    # was test_63
3120         MAX_DIRTY_MB=`lctl get_param -n osc.*.max_dirty_mb | head -n 1`
3121         lctl set_param -n osc.*.max_dirty_mb 0
3122         for i in `seq 10` ; do
3123                 dd if=/dev/zero of=$DIR/f63 bs=8k &
3124                 sleep 5
3125                 kill $!
3126                 sleep 1
3127         done
3128
3129         lctl set_param -n osc.*.max_dirty_mb $MAX_DIRTY_MB
3130         rm -f $DIR/f63 || true
3131 }
3132 run_test 63a "Verify oig_wait interruption does not crash ======="
3133
3134 # bug 2248 - async write errors didn't return to application on sync
3135 # bug 3677 - async write errors left page locked
3136 test_63b() {
3137         debugsave
3138         lctl set_param debug=-1
3139
3140         # ensure we have a grant to do async writes
3141         dd if=/dev/zero of=$DIR/$tfile bs=4k count=1
3142         rm $DIR/$tfile
3143
3144         #define OBD_FAIL_OSC_BRW_PREP_REQ        0x406
3145         lctl set_param fail_loc=0x80000406
3146         multiop $DIR/$tfile Owy && \
3147                 error "sync didn't return ENOMEM"
3148         sync; sleep 2; sync     # do a real sync this time to flush page
3149         lctl get_param -n llite.*.dump_page_cache | grep locked && \
3150                 error "locked page left in cache after async error" || true
3151         debugrestore
3152 }
3153 run_test 63b "async write errors should be returned to fsync ==="
3154
3155 test_64a () {
3156         df $DIR
3157         lctl get_param -n osc.*[oO][sS][cC][_-]*.cur* | grep "[0-9]"
3158 }
3159 run_test 64a "verify filter grant calculations (in kernel) ====="
3160
3161 test_64b () {
3162         [ ! -f oos.sh ] && skip_env "missing subtest oos.sh" && return
3163         sh oos.sh $MOUNT
3164 }
3165 run_test 64b "check out-of-space detection on client ==========="
3166
3167 # bug 1414 - set/get directories' stripe info
3168 test_65a() {
3169         mkdir -p $DIR/d65
3170         touch $DIR/d65/f1
3171         $LVERIFY $DIR/d65 $DIR/d65/f1 || error "lverify failed"
3172 }
3173 run_test 65a "directory with no stripe info ===================="
3174
3175 test_65b() {
3176         mkdir -p $DIR/d65
3177         $SETSTRIPE $DIR/d65 -s $(($STRIPESIZE * 2)) -i 0 -c 1 || error "setstripe"
3178         touch $DIR/d65/f2
3179         $LVERIFY $DIR/d65 $DIR/d65/f2 || error "lverify failed"
3180 }
3181 run_test 65b "directory setstripe $(($STRIPESIZE * 2)) 0 1 ==============="
3182
3183 test_65c() {
3184         if [ $OSTCOUNT -gt 1 ]; then
3185                 mkdir -p $DIR/d65
3186                 $SETSTRIPE $DIR/d65 -s $(($STRIPESIZE * 4)) -i 1 \
3187                         -c $(($OSTCOUNT - 1)) || error "setstripe"
3188                 touch $DIR/d65/f3
3189                 $LVERIFY $DIR/d65 $DIR/d65/f3 || error "lverify failed"
3190         fi
3191 }
3192 run_test 65c "directory setstripe $(($STRIPESIZE * 4)) 1 $(($OSTCOUNT - 1))"
3193
3194 test_65d() {
3195         mkdir -p $DIR/d65
3196         if [ $STRIPECOUNT -le 0 ]; then
3197                 sc=1
3198         elif [ $STRIPECOUNT -gt 160 ]; then
3199 #LOV_MAX_STRIPE_COUNT is 160
3200                 [ $OSTCOUNT -gt 160 ] && sc=160 || sc=$(($OSTCOUNT - 1))
3201         else
3202                 sc=$(($STRIPECOUNT - 1))
3203         fi
3204         $SETSTRIPE $DIR/d65 -s $STRIPESIZE -c $sc || error "setstripe"
3205         touch $DIR/d65/f4 $DIR/d65/f5
3206         $LVERIFY $DIR/d65 $DIR/d65/f4 $DIR/d65/f5 || error "lverify failed"
3207 }
3208 run_test 65d "directory setstripe $STRIPESIZE -1 stripe_count =============="
3209
3210 test_65e() {
3211         mkdir -p $DIR/d65
3212
3213         $SETSTRIPE $DIR/d65 || error "setstripe"
3214         $GETSTRIPE -v $DIR/d65 | grep "Default" || error "no stripe info failed"
3215         touch $DIR/d65/f6
3216         $LVERIFY $DIR/d65 $DIR/d65/f6 || error "lverify failed"
3217 }
3218 run_test 65e "directory setstripe defaults ======================="
3219
3220 test_65f() {
3221         mkdir -p $DIR/d65f
3222         $RUNAS $SETSTRIPE $DIR/d65f && error "setstripe succeeded" || true
3223 }
3224 run_test 65f "dir setstripe permission (should return error) ==="
3225
3226 test_65g() {
3227         mkdir -p $DIR/d65
3228         $SETSTRIPE $DIR/d65 -s $(($STRIPESIZE * 2)) -i 0 -c 1 || error "setstripe"
3229         $SETSTRIPE -d $DIR/d65 || error "setstripe"
3230         $GETSTRIPE -v $DIR/d65 | grep "Default" || \
3231                 error "delete default stripe failed"
3232 }
3233 run_test 65g "directory setstripe -d ==========================="
3234
3235 test_65h() {
3236         mkdir -p $DIR/d65
3237         $SETSTRIPE $DIR/d65 -s $(($STRIPESIZE * 2)) -i 0 -c 1 || error "setstripe"
3238         mkdir -p $DIR/d65/dd1
3239         [ "`$GETSTRIPE -v $DIR/d65 | grep "^count"`" == \
3240           "`$GETSTRIPE -v $DIR/d65/dd1 | grep "^count"`" ] || error "stripe info inherit failed"
3241 }
3242 run_test 65h "directory stripe info inherit ===================="
3243
3244 test_65i() { # bug6367
3245         $SETSTRIPE $MOUNT -s 65536 -c -1
3246 }
3247 run_test 65i "set non-default striping on root directory (bug 6367)="
3248
3249 test_65ia() { # bug12836
3250         $LFS getstripe $MOUNT || error "getstripe $MOUNT failed"
3251 }
3252 run_test 65ia "getstripe on -1 default directory striping"
3253
3254 test_65ib() { # bug12836
3255         $LFS getstripe -v $MOUNT || error "getstripe -v $MOUNT failed"
3256 }
3257 run_test 65ib "getstripe -v on -1 default directory striping"
3258
3259 test_65ic() { # bug12836
3260         $LFS find -mtime -1 $MOUNT || error "find $MOUNT failed"
3261 }
3262 run_test 65ic "new find on -1 default directory striping"
3263
3264 test_65j() { # bug6367
3265         sync; sleep 1
3266         # if we aren't already remounting for each test, do so for this test
3267         if [ "$CLEANUP" = ":" -a "$I_MOUNTED" = "yes" ]; then
3268                 cleanup || error "failed to unmount"
3269                 setup
3270         fi
3271         $SETSTRIPE -d $MOUNT || error "setstripe failed"
3272 }
3273 run_test 65j "set default striping on root directory (bug 6367)="
3274
3275 test_65k() { # bug11679
3276         [ "$OSTCOUNT" -lt 2 ] && skip_env "too few OSTs" && return
3277         remote_mds_nodsh && skip "remote MDS with nodsh" && return
3278
3279         echo "Check OST status: "
3280         MDS_OSCS=`do_facet $SINGLEMDS lctl dl | awk '/[oO][sS][cC].*md[ts]/ { print $4 }'`
3281         for OSC in $MDS_OSCS; do
3282                 echo $OSC "is activate"
3283                 do_facet $SINGLEMDS lctl --device %$OSC activate
3284         done
3285         do_facet client mkdir -p $DIR/$tdir
3286         for INACTIVE_OSC in $MDS_OSCS; do
3287                 echo $INACTIVE_OSC "is Deactivate:"
3288                 do_facet $SINGLEMDS lctl --device  %$INACTIVE_OSC deactivate
3289                 for STRIPE_OSC in $MDS_OSCS; do
3290                         STRIPE_OST=`osc_to_ost $STRIPE_OSC`
3291                         STRIPE_INDEX=`do_facet $SINGLEMDS lctl get_param -n lov.*md*.target_obd |
3292                                       grep $STRIPE_OST | awk -F: '{print $1}' | head -n 1`
3293
3294                         [ -f $DIR/$tdir/${STRIPE_INDEX} ] && continue
3295                         echo "$SETSTRIPE $DIR/$tdir/${STRIPE_INDEX} -i ${STRIPE_INDEX} -c 1"
3296                         do_facet client $SETSTRIPE $DIR/$tdir/${STRIPE_INDEX} -i ${STRIPE_INDEX} -c 1
3297                         RC=$?
3298                         [ $RC -ne 0 ] && error "setstripe should have succeeded"
3299                 done
3300                 do_facet client rm -f $DIR/$tdir/*
3301                 echo $INACTIVE_OSC "is Activate."
3302                 do_facet $SINGLEMDS lctl --device  %$INACTIVE_OSC activate
3303         done
3304 }
3305 run_test 65k "validate manual striping works properly with deactivated OSCs"
3306
3307 test_65l() { # bug 12836
3308         mkdir -p $DIR/$tdir/test_dir
3309         $SETSTRIPE $DIR/$tdir/test_dir -c -1
3310         $LFS find -mtime -1 $DIR/$tdir >/dev/null
3311 }
3312 run_test 65l "lfs find on -1 stripe dir ========================"
3313
3314 # bug 2543 - update blocks count on client
3315 test_66() {
3316         COUNT=${COUNT:-8}
3317         dd if=/dev/zero of=$DIR/f66 bs=1k count=$COUNT
3318         sync; sleep 1; sync
3319         BLOCKS=`ls -s $DIR/f66 | awk '{ print $1 }'`
3320         [ $BLOCKS -ge $COUNT ] || error "$DIR/f66 blocks $BLOCKS < $COUNT"
3321 }
3322 run_test 66 "update inode blocks count on client ==============="
3323
3324 LLOOP=
3325 LLITELOOPLOAD=
3326 cleanup_68() {
3327         trap 0
3328         if [ ! -z "$LLOOP" ]; then
3329                 if swapon -s | grep -q $LLOOP; then
3330                         swapoff $LLOOP || error "swapoff failed"
3331                 fi
3332
3333                 $LCTL blockdev_detach $LLOOP || error "detach failed"
3334                 rm -f $LLOOP
3335                 unset LLOOP
3336         fi
3337         if [ ! -z "$LLITELOOPLOAD" ]; then
3338                 rmmod llite_lloop
3339                 unset LLITELOOPLOAD
3340         fi
3341         rm -f $DIR/f68*
3342 }
3343
3344 meminfo() {
3345         awk '($1 == "'$1':") { print $2 }' /proc/meminfo
3346 }
3347
3348 swap_used() {
3349         swapon -s | awk '($1 == "'$1'") { print $4 }'
3350 }
3351
3352 # test case for lloop driver, basic function
3353 test_68a() {
3354         [ "$UID" != 0 ] && skip_env "must run as root" && return
3355
3356         trap cleanup_68 EXIT
3357
3358         if ! module_loaded llite_lloop; then
3359                 if load_module llite/llite_lloop; then
3360                         LLITELOOPLOAD=yes
3361                 else
3362                         skip_env "can't find module llite_lloop"
3363                         return
3364                 fi
3365         fi
3366
3367         LLOOP=$TMP/lloop.`date +%s`.`date +%N`
3368         dd if=/dev/zero of=$DIR/f68a bs=4k count=1024
3369         $LCTL blockdev_attach $DIR/f68a $LLOOP || error "attach failed"
3370
3371         directio rdwr $LLOOP 0 1024 4096 || error "direct write failed"
3372         directio rdwr $LLOOP 0 1025 4096 && error "direct write should fail"
3373
3374         cleanup_68
3375 }
3376 run_test 68a "lloop driver - basic test ========================"
3377
3378 # excercise swapping to lustre by adding a high priority swapfile entry
3379 # and then consuming memory until it is used.
3380 test_68b() {  # was test_68
3381         [ "$UID" != 0 ] && skip_env "must run as root" && return
3382         lctl get_param -n devices | grep -q obdfilter && \
3383                 skip "local OST" && return
3384
3385         grep -q llite_lloop /proc/modules
3386         [ $? -ne 0 ] && skip "can't find module llite_lloop" && return
3387
3388         [ -z "`$LCTL list_nids | grep -v tcp`" ] && \
3389                 skip "can't reliably test swap with TCP" && return
3390
3391         MEMTOTAL=`meminfo MemTotal`
3392         NR_BLOCKS=$((MEMTOTAL>>8))
3393         [[ $NR_BLOCKS -le 2048 ]] && NR_BLOCKS=2048
3394
3395         LLOOP=$TMP/lloop.`date +%s`.`date +%N`
3396         dd if=/dev/zero of=$DIR/f68b bs=64k seek=$NR_BLOCKS count=1
3397         mkswap $DIR/f68b
3398
3399         $LCTL blockdev_attach $DIR/f68b $LLOOP || error "attach failed"
3400
3401         trap cleanup_68 EXIT
3402
3403         swapon -p 32767 $LLOOP || error "swapon $LLOOP failed"
3404
3405         echo "before: `swapon -s | grep $LLOOP`"
3406         $MEMHOG $MEMTOTAL || error "error allocating $MEMTOTAL kB"
3407         echo "after: `swapon -s | grep $LLOOP`"
3408         SWAPUSED=`swap_used $LLOOP`
3409
3410         cleanup_68
3411
3412         [ $SWAPUSED -eq 0 ] && echo "no swap used???" || true
3413 }
3414 run_test 68b "support swapping to Lustre ========================"
3415
3416 # bug5265, obdfilter oa2dentry return -ENOENT
3417 # #define OBD_FAIL_OST_ENOENT 0x217
3418 test_69() {
3419         remote_ost_nodsh && skip "remote OST with nodsh" && return
3420
3421         f="$DIR/$tfile"
3422         $SETSTRIPE $f -c 1 -i 0
3423
3424         $DIRECTIO write ${f}.2 0 1 || error "directio write error"
3425
3426         do_facet ost1 lctl set_param fail_loc=0x217
3427         truncate $f 1 # vmtruncate() will ignore truncate() error.
3428         $DIRECTIO write $f 0 2 && error "write succeeded, expect -ENOENT"
3429
3430         do_facet ost1 lctl set_param fail_loc=0
3431         $DIRECTIO write $f 0 2 || error "write error"
3432
3433         cancel_lru_locks osc
3434         $DIRECTIO read $f 0 1 || error "read error"
3435
3436         do_facet ost1 lctl set_param fail_loc=0x217
3437         $DIRECTIO read $f 1 1 && error "read succeeded, expect -ENOENT"
3438
3439         do_facet ost1 lctl set_param fail_loc=0
3440         rm -f $f
3441 }
3442 run_test 69 "verify oa2dentry return -ENOENT doesn't LBUG ======"
3443
3444 test_71() {
3445     mkdir -p $DIR/$tdir
3446     sh rundbench -C -D $DIR/$tdir 2 || error "dbench failed!"
3447 }
3448 run_test 71 "Running dbench on lustre (don't segment fault) ===="
3449
3450 test_72() { # bug 5695 - Test that on 2.6 remove_suid works properly
3451         check_kernel_version 43 || return 0
3452         [ "$RUNAS_ID" = "$UID" ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
3453
3454         # Check that testing environment is properly set up. Skip if not
3455         FAIL_ON_ERROR=false check_runas_id_ret $RUNAS_ID $RUNAS_ID $RUNAS || {
3456                 skip_env "User $RUNAS_ID does not exist - skipping"
3457                 return 0
3458         }
3459         # We had better clear the $DIR to get enough space for dd
3460         rm -rf $DIR/*
3461         touch $DIR/f72
3462         chmod 777 $DIR/f72
3463         chmod ug+s $DIR/f72
3464         $RUNAS dd if=/dev/zero of=$DIR/f72 bs=512 count=1 || error
3465         # See if we are still setuid/sgid
3466         test -u $DIR/f72 -o -g $DIR/f72 && error "S/gid is not dropped on write"
3467         # Now test that MDS is updated too
3468         cancel_lru_locks mdc
3469         test -u $DIR/f72 -o -g $DIR/f72 && error "S/gid is not dropped on MDS"
3470         true
3471         rm -f $DIR/f72
3472 }
3473 run_test 72 "Test that remove suid works properly (bug5695) ===="
3474
3475 # bug 3462 - multiple simultaneous MDC requests
3476 test_73() {
3477         mkdir $DIR/d73-1
3478         mkdir $DIR/d73-2
3479         multiop_bg_pause $DIR/d73-1/f73-1 O_c || return 1
3480         pid1=$!
3481
3482         lctl set_param fail_loc=0x80000129
3483         multiop $DIR/d73-1/f73-2 Oc &
3484         sleep 1
3485         lctl set_param fail_loc=0
3486
3487         multiop $DIR/d73-2/f73-3 Oc &
3488         pid3=$!
3489
3490         kill -USR1 $pid1
3491         wait $pid1 || return 1
3492
3493         sleep 25
3494
3495         $CHECKSTAT -t file $DIR/d73-1/f73-1 || return 4
3496         $CHECKSTAT -t file $DIR/d73-1/f73-2 || return 5
3497         $CHECKSTAT -t file $DIR/d73-2/f73-3 || return 6
3498
3499         rm -rf $DIR/d73-*
3500 }
3501 run_test 73 "multiple MDC requests (should not deadlock)"
3502
3503 test_74a() { # bug 6149, 6184
3504         #define OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT 0x30e
3505         #
3506         # very important to OR with OBD_FAIL_ONCE (0x80000000) -- otherwise it
3507         # will spin in a tight reconnection loop
3508         touch $DIR/f74a
3509         lctl set_param fail_loc=0x8000030e
3510         # get any lock that won't be difficult - lookup works.
3511         ls $DIR/f74a
3512         lctl set_param fail_loc=0
3513         true
3514         rm -f $DIR/f74a
3515 }
3516 run_test 74a "ldlm_enqueue freed-export error path, ls (shouldn't LBUG)"
3517
3518 test_74b() { # bug 13310
3519         #define OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT 0x30e
3520         #
3521         # very important to OR with OBD_FAIL_ONCE (0x80000000) -- otherwise it
3522         # will spin in a tight reconnection loop
3523         lctl set_param fail_loc=0x8000030e
3524         # get a "difficult" lock
3525         touch $DIR/f74b
3526         lctl set_param fail_loc=0
3527         true
3528         rm -f $DIR/f74b
3529 }
3530 run_test 74b "ldlm_enqueue freed-export error path, touch (shouldn't LBUG)"
3531
3532 num_inodes() {
3533         awk '/lustre_inode_cache/ {print $2; exit}' /proc/slabinfo
3534 }
3535
3536 test_76() { # Now for bug 20433, added originally in bug 1443
3537         cancel_lru_locks osc
3538         BEFORE_INODES=`num_inodes`
3539         echo "before inodes: $BEFORE_INODES"
3540         local COUNT=1000
3541         [ "$SLOW" = "no" ] && COUNT=100
3542         for i in `seq $COUNT`; do
3543                 touch $DIR/$tfile
3544                 rm -f $DIR/$tfile
3545         done
3546         cancel_lru_locks osc
3547         AFTER_INODES=`num_inodes`
3548         echo "after inodes: $AFTER_INODES"
3549         local wait=0
3550         while [ $AFTER_INODES -gt $BEFORE_INODES ]; do
3551                 sleep 2
3552                 AFTER_INODES=`num_inodes`
3553                 wait=$((wait+2))
3554                 echo "wait $wait seconds inodes: $AFTER_INODES"
3555                 if [ $wait -gt 30 ]; then
3556                         error "inode slab grew from $BEFORE_INODES to $AFTER_INODES"
3557                 fi
3558         done
3559 }
3560 run_test 76 "confirm clients recycle inodes properly ===="
3561
3562
3563 export ORIG_CSUM=""
3564 set_checksums()
3565 {
3566         # Note: in sptlrpc modes which enable its own bulk checksum, the
3567         # original crc32_le bulk checksum will be automatically disabled,
3568         # and the OBD_FAIL_OSC_CHECKSUM_SEND/OBD_FAIL_OSC_CHECKSUM_RECEIVE
3569         # will be checked by sptlrpc code against sptlrpc bulk checksum.
3570         # In this case set_checksums() will not be no-op, because sptlrpc
3571         # bulk checksum will be enabled all through the test.
3572
3573         [ "$ORIG_CSUM" ] || ORIG_CSUM=`lctl get_param -n osc.*.checksums | head -n1`
3574         lctl set_param -n osc.*.checksums $1
3575         return 0
3576 }
3577
3578 export ORIG_CSUM_TYPE=""
3579 CKSUM_TYPES=${CKSUM_TYPES:-"crc32 adler"}
3580 set_checksum_type()
3581 {
3582         [ "$ORIG_CSUM_TYPE" ] || \
3583                 ORIG_CSUM_TYPE=`lctl get_param -n osc/*osc-[^mM]*/checksum_type |
3584                                 sed 's/.*\[\(.*\)\].*/\1/g' | head -n1`
3585         lctl set_param -n osc.*osc-[^mM]*.checksum_type $1
3586         log "set checksum type to $1"
3587         return 0
3588 }
3589 F77_TMP=$TMP/f77-temp
3590 F77SZ=8
3591 setup_f77() {
3592         dd if=/dev/urandom of=$F77_TMP bs=1M count=$F77SZ || \
3593                 error "error writing to $F77_TMP"
3594 }
3595
3596 test_77a() { # bug 10889
3597         $GSS && skip "could not run with gss" && return
3598         [ ! -f $F77_TMP ] && setup_f77
3599         set_checksums 1
3600         dd if=$F77_TMP of=$DIR/$tfile bs=1M count=$F77SZ || error "dd error"
3601         set_checksums 0
3602         rm -f $DIR/$tfile
3603 }
3604 run_test 77a "normal checksum read/write operation ============="
3605
3606 test_77b() { # bug 10889
3607         $GSS && skip "could not run with gss" && return
3608         [ ! -f $F77_TMP ] && setup_f77
3609         #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
3610         lctl set_param fail_loc=0x80000409
3611         set_checksums 1
3612         dd if=$F77_TMP of=$DIR/f77b bs=1M count=$F77SZ conv=sync || \
3613                 error "dd error: $?"
3614         lctl set_param fail_loc=0
3615         set_checksums 0
3616 }
3617 run_test 77b "checksum error on client write ===================="
3618
3619 test_77c() { # bug 10889
3620         $GSS && skip "could not run with gss" && return
3621         [ ! -f $DIR/f77b ] && skip "requires 77b - skipping" && return
3622         set_checksums 1
3623         for algo in $CKSUM_TYPES; do
3624                 cancel_lru_locks osc
3625                 set_checksum_type $algo
3626                 #define OBD_FAIL_OSC_CHECKSUM_RECEIVE    0x408
3627                 lctl set_param fail_loc=0x80000408
3628                 cmp $F77_TMP $DIR/f77b || error "file compare failed"
3629                 lctl set_param fail_loc=0
3630         done
3631         set_checksums 0
3632         set_checksum_type $ORIG_CSUM_TYPE
3633         rm -f $DIR/f77b
3634 }
3635 run_test 77c "checksum error on client read ==================="
3636
3637 test_77d() { # bug 10889
3638         $GSS && skip "could not run with gss" && return
3639         #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
3640         lctl set_param fail_loc=0x80000409
3641         set_checksums 1
3642         directio write $DIR/f77 0 $F77SZ $((1024 * 1024)) || \
3643                 error "direct write: rc=$?"
3644         lctl set_param fail_loc=0
3645         set_checksums 0
3646 }
3647 run_test 77d "checksum error on OST direct write ==============="
3648
3649 test_77e() { # bug 10889
3650         $GSS && skip "could not run with gss" && return
3651         [ ! -f $DIR/f77 ] && skip "requires 77d - skipping" && return
3652         #define OBD_FAIL_OSC_CHECKSUM_RECEIVE    0x408
3653         lctl set_param fail_loc=0x80000408
3654         set_checksums 1
3655         cancel_lru_locks osc
3656         directio read $DIR/f77 0 $F77SZ $((1024 * 1024)) || \
3657                 error "direct read: rc=$?"
3658         lctl set_param fail_loc=0
3659         set_checksums 0
3660 }
3661 run_test 77e "checksum error on OST direct read ================"
3662
3663 test_77f() { # bug 10889
3664         $GSS && skip "could not run with gss" && return
3665         set_checksums 1
3666         for algo in $CKSUM_TYPES; do
3667                 cancel_lru_locks osc
3668                 set_checksum_type $algo
3669                 #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
3670                 lctl set_param fail_loc=0x409
3671                 directio write $DIR/f77 0 $F77SZ $((1024 * 1024)) && \
3672                         error "direct write succeeded"
3673                 lctl set_param fail_loc=0
3674         done
3675         set_checksum_type $ORIG_CSUM_TYPE
3676         set_checksums 0
3677 }
3678 run_test 77f "repeat checksum error on write (expect error) ===="
3679
3680 test_77g() { # bug 10889
3681         $GSS && skip "could not run with gss" && return
3682         remote_ost_nodsh && skip "remote OST with nodsh" && return
3683
3684         [ ! -f $F77_TMP ] && setup_f77
3685
3686         $SETSTRIPE $DIR/f77g -c 1 -i 0
3687         #define OBD_FAIL_OST_CHECKSUM_RECEIVE       0x21a
3688         do_facet ost1 lctl set_param fail_loc=0x8000021a
3689         set_checksums 1
3690         dd if=$F77_TMP of=$DIR/f77g bs=1M count=$F77SZ || \
3691                 error "write error: rc=$?"
3692         do_facet ost1 lctl set_param fail_loc=0
3693         set_checksums 0
3694 }
3695 run_test 77g "checksum error on OST write ======================"
3696
3697 test_77h() { # bug 10889
3698         $GSS && skip "could not run with gss" && return
3699         remote_ost_nodsh && skip "remote OST with nodsh" && return
3700
3701         [ ! -f $DIR/f77g ] && skip "requires 77g - skipping" && return
3702         cancel_lru_locks osc
3703         #define OBD_FAIL_OST_CHECKSUM_SEND          0x21b
3704         do_facet ost1 lctl set_param fail_loc=0x8000021b
3705         set_checksums 1
3706         cmp $F77_TMP $DIR/f77g || error "file compare failed"
3707         do_facet ost1 lctl set_param fail_loc=0
3708         set_checksums 0
3709 }
3710 run_test 77h "checksum error on OST read ======================="
3711
3712 test_77i() { # bug 13805
3713         $GSS && skip "could not run with gss" && return
3714         #define OBD_FAIL_OSC_CONNECT_CKSUM       0x40b
3715         lctl set_param fail_loc=0x40b
3716         remount_client $MOUNT
3717         lctl set_param fail_loc=0
3718         for VALUE in `lctl get_param osc.*osc-[^mM]*.checksum_type`; do
3719                 PARAM=`echo ${VALUE[0]} | cut -d "=" -f1`
3720                 algo=`lctl get_param -n $PARAM | sed 's/.*\[\(.*\)\].*/\1/g'`
3721                 [ "$algo" = "crc32" ] || error "algo set to $algo instead of crc32"
3722         done
3723         remount_client $MOUNT
3724 }
3725 run_test 77i "client not supporting OSD_CONNECT_CKSUM =========="
3726
3727 test_77j() { # bug 13805
3728         $GSS && skip "could not run with gss" && return
3729         #define OBD_FAIL_OSC_CKSUM_ADLER_ONLY    0x40c
3730         lctl set_param fail_loc=0x40c
3731         remount_client $MOUNT
3732         lctl set_param fail_loc=0
3733         sleep 2 # wait async osc connect to finish
3734         for VALUE in `lctl get_param osc.*osc-[^mM]*.checksum_type`; do
3735                 PARAM=`echo ${VALUE[0]} | cut -d "=" -f1`
3736                 algo=`lctl get_param -n $PARAM | sed 's/.*\[\(.*\)\].*/\1/g'`
3737                 [ "$algo" = "adler" ] || error "algo set to $algo instead of adler"
3738         done
3739         remount_client $MOUNT
3740 }
3741 run_test 77j "client only supporting ADLER32 ===================="
3742
3743 [ "$ORIG_CSUM" ] && set_checksums $ORIG_CSUM || true
3744 rm -f $F77_TMP
3745 unset F77_TMP
3746
3747 test_78() { # bug 10901
3748         remote_ost || { skip_env "local OST" && return; }
3749
3750         NSEQ=5
3751         F78SIZE=$(($(awk '/MemFree:/ { print $2 }' /proc/meminfo) / 1024))
3752         echo "MemFree: $F78SIZE, Max file size: $MAXFREE"
3753         MEMTOTAL=$(($(awk '/MemTotal:/ { print $2 }' /proc/meminfo) / 1024))
3754         echo "MemTotal: $MEMTOTAL"
3755 # reserve 256MB of memory for the kernel and other running processes,
3756 # and then take 1/2 of the remaining memory for the read/write buffers.
3757     if [ $MEMTOTAL -gt 512 ] ;then
3758         MEMTOTAL=$(((MEMTOTAL - 256 ) / 2))
3759     else
3760         # for those poor memory-starved high-end clusters...
3761         MEMTOTAL=$((MEMTOTAL / 2))
3762     fi
3763         echo "Mem to use for directio: $MEMTOTAL"
3764         [ $F78SIZE -gt $MEMTOTAL ] && F78SIZE=$MEMTOTAL
3765         [ $F78SIZE -gt 512 ] && F78SIZE=512
3766         [ $F78SIZE -gt $((MAXFREE / 1024)) ] && F78SIZE=$((MAXFREE / 1024))
3767         SMALLESTOST=`lfs df $DIR |grep OST | awk '{print $4}' |sort -n |head -1`
3768         echo "Smallest OST: $SMALLESTOST"
3769         [ $SMALLESTOST -lt 10240 ] && \
3770                 skip "too small OSTSIZE, useless to run large O_DIRECT test" && return 0
3771
3772         [ $F78SIZE -gt $((SMALLESTOST * $OSTCOUNT / 1024 - 80)) ] && \
3773                 F78SIZE=$((SMALLESTOST * $OSTCOUNT / 1024 - 80))
3774
3775         [ "$SLOW" = "no" ] && NSEQ=1 && [ $F78SIZE -gt 32 ] && F78SIZE=32
3776         echo "File size: $F78SIZE"
3777         $SETSTRIPE $DIR/$tfile -c $OSTCOUNT || error "setstripe failed"
3778         for i in `seq 1 $NSEQ`
3779         do
3780                 FSIZE=$(($F78SIZE / ($NSEQ - $i + 1)))
3781                 echo directIO rdwr round $i of $NSEQ
3782                 $DIRECTIO rdwr $DIR/$tfile 0 $FSIZE 1048576||error "rdwr failed"
3783         done
3784
3785         rm -f $DIR/$tfile
3786 }
3787 run_test 78 "handle large O_DIRECT writes correctly ============"
3788
3789 test_79() { # bug 12743
3790         wait_delete_completed
3791
3792         BKTOTAL=$(calc_osc_kbytes kbytestotal)
3793         BKFREE=$(calc_osc_kbytes kbytesfree)
3794         BKAVAIL=$(calc_osc_kbytes kbytesavail)
3795
3796         STRING=`df -P $MOUNT | tail -n 1 | awk '{print $2","$3","$4}'`
3797         DFTOTAL=`echo $STRING | cut -d, -f1`
3798         DFUSED=`echo $STRING  | cut -d, -f2`
3799         DFAVAIL=`echo $STRING | cut -d, -f3`
3800         DFFREE=$(($DFTOTAL - $DFUSED))
3801
3802         ALLOWANCE=$((64 * $OSTCOUNT))
3803
3804         if [ $DFTOTAL -lt $(($BKTOTAL - $ALLOWANCE)) ] ||
3805            [ $DFTOTAL -gt $(($BKTOTAL + $ALLOWANCE)) ] ; then
3806                 error "df total($DFTOTAL) mismatch OST total($BKTOTAL)"
3807         fi
3808         if [ $DFFREE -lt $(($BKFREE - $ALLOWANCE)) ] ||
3809            [ $DFFREE -gt $(($BKFREE + $ALLOWANCE)) ] ; then
3810                 error "df free($DFFREE) mismatch OST free($BKFREE)"
3811         fi
3812         if [ $DFAVAIL -lt $(($BKAVAIL - $ALLOWANCE)) ] ||
3813            [ $DFAVAIL -gt $(($BKAVAIL + $ALLOWANCE)) ] ; then
3814                 error "df avail($DFAVAIL) mismatch OST avail($BKAVAIL)"
3815         fi
3816 }
3817 run_test 79 "df report consistency check ======================="
3818
3819 test_80() { # bug 10718
3820         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1M
3821         sync; sleep 1; sync
3822         local BEFORE=`date +%s`
3823         cancel_lru_locks osc
3824         local AFTER=`date +%s`
3825         local DIFF=$((AFTER-BEFORE))
3826         if [ $DIFF -gt 1 ] ; then
3827                 error "elapsed for 1M@1T = $DIFF"
3828         fi
3829         true
3830         rm -f $DIR/$tfile
3831 }
3832 run_test 80 "Page eviction is equally fast at high offsets too  ===="
3833
3834 test_99a() {
3835         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && \
3836             return
3837         mkdir -p $DIR/d99cvsroot
3838         chown $RUNAS_ID $DIR/d99cvsroot
3839         local oldPWD=$PWD       # bug 13584, use $TMP as working dir
3840         cd $TMP
3841
3842         $RUNAS cvs -d $DIR/d99cvsroot init || error
3843         cd $oldPWD
3844 }
3845 run_test 99a "cvs init ========================================="
3846
3847 test_99b() {
3848         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
3849         [ ! -d $DIR/d99cvsroot ] && test_99a
3850         cd /etc/init.d
3851         # some versions of cvs import exit(1) when asked to import links or
3852         # files they can't read.  ignore those files.
3853         TOIGNORE=$(find . -type l -printf '-I %f\n' -o \
3854                         ! -perm +4 -printf '-I %f\n')
3855         $RUNAS cvs -d $DIR/d99cvsroot import -m "nomesg" $TOIGNORE \
3856                 d99reposname vtag rtag
3857 }
3858 run_test 99b "cvs import ======================================="
3859
3860 test_99c() {
3861         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
3862         [ ! -d $DIR/d99cvsroot ] && test_99b
3863         cd $DIR
3864         mkdir -p $DIR/d99reposname
3865         chown $RUNAS_ID $DIR/d99reposname
3866         $RUNAS cvs -d $DIR/d99cvsroot co d99reposname
3867 }
3868 run_test 99c "cvs checkout ====================================="
3869
3870 test_99d() {
3871         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
3872         [ ! -d $DIR/d99cvsroot ] && test_99c
3873         cd $DIR/d99reposname
3874         $RUNAS touch foo99
3875         $RUNAS cvs add -m 'addmsg' foo99
3876 }
3877 run_test 99d "cvs add =========================================="
3878
3879 test_99e() {
3880         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
3881         [ ! -d $DIR/d99cvsroot ] && test_99c
3882         cd $DIR/d99reposname
3883         $RUNAS cvs update
3884 }
3885 run_test 99e "cvs update ======================================="
3886
3887 test_99f() {
3888         [ -z "$(which cvs 2>/dev/null)" ] && skip_env "could not find cvs" && return
3889         [ ! -d $DIR/d99cvsroot ] && test_99d
3890         cd $DIR/d99reposname
3891         $RUNAS cvs commit -m 'nomsg' foo99
3892     rm -fr $DIR/d99cvsroot
3893 }
3894 run_test 99f "cvs commit ======================================="
3895
3896 test_100() {
3897         [ "$NETTYPE" = tcp ] || \
3898                 { skip "TCP secure port test, not useful for NETTYPE=$NETTYPE" && \
3899                         return ; }
3900
3901         remote_ost_nodsh && skip "remote OST with nodsh" && return
3902         remote_mds_nodsh && skip "remote MDS with nodsh" && return
3903         remote_servers || \
3904                 { skip "useless for local single node setup" && return; }
3905
3906         netstat -tna | ( rc=1; while read PROT SND RCV LOCAL REMOTE STAT; do
3907                 [ "$PROT" != "tcp" ] && continue
3908                 RPORT=$(echo $REMOTE | cut -d: -f2)
3909                 [ "$RPORT" != "$ACCEPTOR_PORT" ] && continue
3910
3911                 rc=0
3912                 LPORT=`echo $LOCAL | cut -d: -f2`
3913                 if [ $LPORT -ge 1024 ]; then
3914                         echo "bad: $PROT $SND $RCV $LOCAL $REMOTE $STAT"
3915                         netstat -tna
3916                         error_exit "local: $LPORT > 1024, remote: $RPORT"
3917                 fi
3918         done
3919         [ "$rc" = 0 ] || error_exit "privileged port not found" )
3920 }
3921 run_test 100 "check local port using privileged port ==========="
3922
3923 function get_named_value()
3924 {
3925     local tag
3926
3927     tag=$1
3928     while read ;do
3929         line=$REPLY
3930         case $line in
3931         $tag*)
3932             echo $line | sed "s/^$tag//"
3933             break
3934             ;;
3935         esac
3936     done
3937 }
3938
3939 export CACHE_MAX=`lctl get_param -n llite.*.max_cached_mb | head -n 1`
3940 cleanup_101() {
3941         lctl set_param -n llite.*.max_cached_mb $CACHE_MAX
3942         trap 0
3943 }
3944
3945 test_101() {
3946         local s
3947         local discard
3948         local nreads=10000
3949         [ "$CPU" = "UML" ] && nreads=1000
3950         local cache_limit=32
3951
3952         lctl set_param -n osc.*-osc*.rpc_stats 0
3953         trap cleanup_101 EXIT
3954         lctl set_param -n llite.*.read_ahead_stats 0
3955         lctl set_param -n llite.*.max_cached_mb $cache_limit
3956
3957         #
3958         # randomly read 10000 of 64K chunks from file 3x 32MB in size
3959         #
3960         echo "nreads: $nreads file size: $((cache_limit * 3))MB"
3961         $READS -f $DIR/$tfile -s$((cache_limit * 3192 * 1024)) -b65536 -C -n$nreads -t 180
3962
3963         discard=0
3964         for s in `lctl get_param -n llite.*.read_ahead_stats | \
3965                 get_named_value 'read but discarded' | cut -d" " -f1`; do
3966                         discard=$(($discard + $s))
3967         done
3968         cleanup_101
3969
3970         if [ $(($discard * 10)) -gt $nreads ] ;then
3971                 lctl get_param osc.*-osc*.rpc_stats
3972                 lctl get_param llite.*.read_ahead_stats
3973                 error "too many ($discard) discarded pages"
3974         fi
3975         rm -f $DIR/$tfile || true
3976 }
3977 run_test 101 "check read-ahead for random reads ================"
3978
3979 export SETUP_TEST101=no
3980 setup_test101() {
3981         [ "$SETUP_TEST101" = "yes" ] && return
3982         mkdir -p $DIR/$tdir
3983         STRIPE_SIZE=1048576
3984         STRIPE_COUNT=$OSTCOUNT
3985         STRIPE_OFFSET=0
3986
3987         trap cleanup_test101 EXIT
3988         # prepare the read-ahead file
3989         $SETSTRIPE $DIR/$tfile -s $STRIPE_SIZE -i $STRIPE_OFFSET -c $OSTCOUNT
3990
3991         dd if=/dev/zero of=$DIR/$tfile bs=1024k count=100 2> /dev/null
3992         SETUP_TEST101=yes
3993 }
3994
3995 cleanup_test101() {
3996         [ "$SETUP_TEST101" = "yes" ] || return
3997         trap 0
3998         rm -rf $DIR/$tdir
3999         rm -f $DIR/$tfile
4000         SETUP_TEST101=no
4001 }
4002
4003 calc_total() {
4004         awk 'BEGIN{total=0}; {total+=$1}; END{print total}'
4005 }
4006
4007 ra_check_101() {
4008         local READ_SIZE=$1
4009         local STRIPE_SIZE=1048576
4010         local RA_INC=1048576
4011         local STRIDE_LENGTH=$((STRIPE_SIZE/READ_SIZE))
4012         local FILE_LENGTH=$((64*100))
4013         local discard_limit=$((((STRIDE_LENGTH - 1)*3/(STRIDE_LENGTH*OSTCOUNT))* \
4014                              (STRIDE_LENGTH*OSTCOUNT - STRIDE_LENGTH)))
4015         DISCARD=`$LCTL get_param -n llite.*.read_ahead_stats | \
4016                         get_named_value 'read but discarded' | \
4017                         cut -d" " -f1 | calc_total`
4018
4019         if [ $DISCARD -gt $discard_limit ]; then
4020                 lctl get_param llite.*.read_ahead_stats
4021                 error "Too many ($DISCARD) discarded pages with size (${READ_SIZE})"
4022         else
4023                 echo "Read-ahead success for size ${READ_SIZE}"
4024         fi
4025 }
4026
4027 test_101b() {
4028         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping stride IO stride-ahead test" && return
4029         local STRIPE_SIZE=1048576
4030         local STRIDE_SIZE=$((STRIPE_SIZE*OSTCOUNT))
4031         local FILE_LENGTH=$((STRIPE_SIZE*100))
4032         local ITERATION=$((FILE_LENGTH/STRIDE_SIZE))
4033         # prepare the read-ahead file
4034         setup_test101
4035         cancel_lru_locks osc
4036         for BIDX in 2 4 8 16 32 64 128 256
4037         do
4038                 local BSIZE=$((BIDX*4096))
4039                 local READ_COUNT=$((STRIPE_SIZE/BSIZE))
4040                 local STRIDE_LENGTH=$((STRIDE_SIZE/BSIZE))
4041                 local OFFSET=$((STRIPE_SIZE/BSIZE*(OSTCOUNT - 1)))
4042                 $LCTL set_param -n llite.*.read_ahead_stats 0
4043                 $READS -f $DIR/$tfile  -l $STRIDE_LENGTH -o $OFFSET \
4044                               -s $FILE_LENGTH -b $STRIPE_SIZE -a $READ_COUNT -n $ITERATION
4045                 cancel_lru_locks osc
4046                 ra_check_101 $BSIZE
4047         done
4048         cleanup_test101
4049         true
4050 }
4051 run_test 101b "check stride-io mode read-ahead ================="
4052
4053 set_read_ahead() {
4054    lctl get_param -n llite.*.max_read_ahead_mb | head -n 1
4055    lctl set_param -n llite.*.max_read_ahead_mb $1 > /dev/null 2>&1
4056 }
4057
4058 test_101d() {
4059     local file=$DIR/$tfile
4060     local size=${FILESIZE_101c:-500}
4061     local ra_MB=${READAHEAD_MB:-40}
4062
4063     local space=$(df -P $DIR | tail -n 1 | awk '{ print $4 }')
4064     [ $space -gt $((size / 1024)) ] ||
4065         { skip "Need free space ${size}M, have $space" && return; }
4066
4067     echo Creating ${size}M test file $file
4068     dd if=/dev/zero of=$file bs=1M count=$size
4069     echo Cancel LRU locks on lustre client to flush the client cache
4070     cancel_lru_locks osc
4071
4072     echo Disable read-ahead
4073     local old_READAHEAD=$(set_read_ahead 0)
4074
4075     echo Reading the test file $file with read-ahead disabled
4076     time_ra_OFF=$(do_and_time "dd if=$file of=/dev/null bs=1M count=$size")
4077
4078     echo Cancel LRU locks on lustre client to flush the client cache
4079     cancel_lru_locks osc
4080     echo Enable read-ahead with ${ra_MB}MB
4081     set_read_ahead $ra_MB
4082
4083     echo Reading the test file $file with read-ahead enabled
4084     time_ra_ON=$(do_and_time "dd if=$file of=/dev/null bs=1M count=$size")
4085
4086     echo read-ahead disabled time read $time_ra_OFF
4087     echo read-ahead enabled  time read $time_ra_ON
4088
4089     set_read_ahead $old_READAHEAD
4090     rm -f $file
4091
4092     [ $time_ra_ON -lt $time_ra_OFF ] ||
4093         error "read-ahead enabled  time read (${time_ra_ON}s) is more than
4094                read-ahead disabled time read (${time_ra_OFF}s) filesize ${size}M"
4095 }
4096 run_test 101d "file read with and without read-ahead enabled  ================="
4097
4098 export SETUP_TEST102=no
4099 setup_test102() {
4100         [ "$SETUP_TEST102" = "yes" ] && return
4101         mkdir -p $DIR/$tdir
4102         chown $RUNAS_ID $DIR/$tdir
4103         STRIPE_SIZE=65536
4104         STRIPE_OFFSET=1
4105         STRIPE_COUNT=$OSTCOUNT
4106         [ $OSTCOUNT -gt 4 ] && STRIPE_COUNT=4
4107
4108         trap cleanup_test102 EXIT
4109         cd $DIR
4110         $1 $SETSTRIPE $tdir -s $STRIPE_SIZE -i $STRIPE_OFFSET -c $STRIPE_COUNT
4111         cd $DIR/$tdir
4112         for num in 1 2 3 4
4113         do
4114                 for count in `seq 1 $STRIPE_COUNT`
4115                 do
4116                         for offset in `seq 0 $[$STRIPE_COUNT - 1]`
4117                         do
4118                                 local stripe_size=`expr $STRIPE_SIZE \* $num`
4119                                 local file=file"$num-$offset-$count"
4120                                 $1 $SETSTRIPE $file -s $stripe_size -i $offset -c $count
4121                         done
4122                 done
4123         done
4124
4125         cd $DIR
4126         $1 $TAR cf $TMP/f102.tar $tdir --xattrs
4127         SETUP_TEST102=yes
4128 }
4129
4130 cleanup_test102() {
4131         trap 0
4132         [ "$SETUP_TEST102" = "yes" ] || return 0
4133         rm -f $TMP/f102.tar
4134         SETUP_TEST102=no
4135 }
4136
4137 test_102a() {
4138         local testfile=$DIR/xattr_testfile
4139
4140         rm -f $testfile
4141         touch $testfile
4142
4143         [ "$UID" != 0 ] && skip_env "must run as root" && return
4144         [ -z "`lctl get_param -n mdc.*-mdc-*.connect_flags | grep xattr`" ] && skip_env "must have user_xattr" && return
4145
4146         [ -z "$(which setfattr 2>/dev/null)" ] && skip_env "could not find setfattr" && return
4147
4148         echo "set/get xattr..."
4149         setfattr -n trusted.name1 -v value1 $testfile || error
4150         [ "`getfattr -n trusted.name1 $testfile 2> /dev/null | \
4151         grep "trusted.name1"`" == "trusted.name1=\"value1\"" ] || error
4152
4153         setfattr -n user.author1 -v author1 $testfile || error
4154         [ "`getfattr -n user.author1 $testfile 2> /dev/null | \
4155         grep "user.author1"`" == "user.author1=\"author1\"" ] || error
4156
4157         echo "listxattr..."
4158         setfattr -n trusted.name2 -v value2 $testfile || error
4159         setfattr -n trusted.name3 -v value3 $testfile || error
4160         [ `getfattr -d -m "^trusted" $testfile 2> /dev/null | \
4161         grep "trusted.name" | wc -l` -eq 3 ] || error
4162
4163
4164         setfattr -n user.author2 -v author2 $testfile || error
4165         setfattr -n user.author3 -v author3 $testfile || error
4166         [ `getfattr -d -m "^user" $testfile 2> /dev/null | \
4167         grep "user" | wc -l` -eq 3 ] || error
4168
4169         echo "remove xattr..."
4170         setfattr -x trusted.name1 $testfile || error
4171         getfattr -d -m trusted $testfile 2> /dev/null | \
4172         grep "trusted.name1" && error || true
4173
4174         setfattr -x user.author1 $testfile || error
4175         getfattr -d -m user $testfile 2> /dev/null | \
4176         grep "user.author1" && error || true
4177
4178         # b10667: setting lustre special xattr be silently discarded
4179         echo "set lustre special xattr ..."
4180         setfattr -n "trusted.lov" -v "invalid value" $testfile || error
4181
4182         rm -f $testfile
4183 }
4184 run_test 102a "user xattr test =================================="
4185
4186 test_102b() {
4187         # b10930: get/set/list trusted.lov xattr
4188         echo "get/set/list trusted.lov xattr ..."
4189         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
4190         local testfile=$DIR/$tfile
4191         $SETSTRIPE -s 65536 -i 1 -c 2 $testfile || error "setstripe failed"
4192         getfattr -d -m "^trusted" $testfile 2> /dev/null | \
4193         grep "trusted.lov" || error "can't get trusted.lov from $testfile"
4194
4195         local testfile2=${testfile}2
4196         local value=`getfattr -n trusted.lov $testfile 2> /dev/null | \
4197                      grep "trusted.lov" |sed -e 's/[^=]\+=//'`
4198
4199         $MCREATE $testfile2
4200         setfattr -n trusted.lov -v $value $testfile2
4201         local tmp_file=${testfile}3
4202         $GETSTRIPE -v $testfile2 > $tmp_file
4203         local stripe_size=`grep "size"  $tmp_file| awk '{print $2}'`
4204         local stripe_count=`grep "count"  $tmp_file| awk '{print $2}'`
4205         [ "$stripe_size" -eq 65536 ] || error "stripe size $stripe_size != 65536"
4206         [ "$stripe_count" -eq 2 ] || error "stripe count $stripe_count != 2"
4207         rm -f $DIR/$tfile
4208 }
4209 run_test 102b "getfattr/setfattr for trusted.lov EAs ============"
4210
4211 test_102c() {
4212         # b10930: get/set/list lustre.lov xattr
4213         echo "get/set/list lustre.lov xattr ..."
4214         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
4215         mkdir -p $DIR/$tdir
4216         chown $RUNAS_ID $DIR/$tdir
4217         local testfile=$DIR/$tdir/$tfile
4218         $RUNAS $SETSTRIPE -s 65536 -i 1 -c 2 $testfile||error "setstripe failed"
4219         $RUNAS getfattr -d -m "^lustre" $testfile 2> /dev/null | \
4220         grep "lustre.lov" || error "can't get lustre.lov from $testfile"
4221
4222         local testfile2=${testfile}2
4223         local value=`getfattr -n lustre.lov $testfile 2> /dev/null | \
4224                      grep "lustre.lov" |sed -e 's/[^=]\+=//'  `
4225
4226         $RUNAS $MCREATE $testfile2
4227         $RUNAS setfattr -n lustre.lov -v $value $testfile2
4228         local tmp_file=${testfile}3
4229         $RUNAS $GETSTRIPE -v $testfile2 > $tmp_file
4230         local stripe_size=`grep "size"  $tmp_file| awk '{print $2}'`
4231         local stripe_count=`grep "count"  $tmp_file| awk '{print $2}'`
4232         [ $stripe_size -eq 65536 ] || error "stripe size $stripe_size != 65536"
4233         [ $stripe_count -eq 2 ] || error "stripe count $stripe_count != 2"
4234 }
4235 run_test 102c "non-root getfattr/setfattr for lustre.lov EAs ==========="
4236
4237 compare_stripe_info1() {
4238         local stripe_index_all_zero=1
4239
4240         for num in 1 2 3 4
4241         do
4242                 for count in `seq 1 $STRIPE_COUNT`
4243                 do
4244                         for offset in `seq 0 $[$STRIPE_COUNT - 1]`
4245                         do
4246                                 local size=`expr $STRIPE_SIZE \* $num`
4247                                 local file=file"$num-$offset-$count"
4248                                 get_stripe_info client $PWD/$file "$1"
4249                                 if [ $stripe_size -ne $size ]; then
4250                                         error "$file: different stripe size $stripe_size, expected $size" && return
4251                                 fi
4252                                 if [ $stripe_count -ne $count ]; then
4253                                         error "$file: different stripe count $stripe_count, expected $count" && return
4254                                 fi
4255                                 if [ $stripe_index -ne 0 ]; then
4256                                        stripe_index_all_zero=0
4257                                 fi
4258                         done
4259                 done
4260         done
4261         [ $stripe_index_all_zero -eq 1 ] && error "all files are being extracted starting from OST index 0"
4262         return 0
4263 }
4264
4265 compare_stripe_info2() {
4266         for num in 1 2 3 4
4267         do
4268                 for count in `seq 1 $STRIPE_COUNT`
4269                 do
4270                         for offset in `seq 0 $[$STRIPE_COUNT - 1]`
4271                         do
4272                                 local size=`expr $STRIPE_SIZE \* $num`
4273                                 local file=file"$num-$offset-$count"
4274                                 get_stripe_info client $PWD/$file
4275                                 if [ $stripe_size -ne $size ]; then
4276                                         error "$file: different stripe size $stripe_size, expected $size" && return
4277                                 fi
4278                                 if [ $stripe_count -ne $count ]; then
4279                                         error "$file: different stripe count $stripe_count, expected $count" && return
4280                                 fi
4281                                 if [ $stripe_index -ne $offset ]; then
4282                                         error "$file: different stripe offset $stripe_index, expected $offset" && return
4283                                 fi
4284                         done
4285                 done
4286         done
4287 }
4288
4289 find_lustre_tar() {
4290         [ -n "$(which tar 2>/dev/null)" ] && strings $(which tar) | grep -q lustre && echo tar
4291 }
4292
4293 test_102d() {
4294         # b10930: tar test for trusted.lov xattr
4295         TAR=$(find_lustre_tar)
4296         [ -z "$TAR" ] && skip_env "lustre-aware tar is not installed" && return
4297         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping N-stripe test" && return
4298         setup_test102
4299         mkdir -p $DIR/d102d
4300         $TAR xf $TMP/f102.tar -C $DIR/d102d --xattrs
4301         cd $DIR/d102d/$tdir
4302         compare_stripe_info1
4303 }
4304 run_test 102d "tar restore stripe info from tarfile,not keep osts ==========="
4305
4306 test_102f() {
4307         # b10930: tar test for trusted.lov xattr
4308         TAR=$(find_lustre_tar)
4309         [ -z "$TAR" ] && skip_env "lustre-aware tar is not installed" && return
4310         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping N-stripe test" && return
4311         setup_test102
4312         mkdir -p $DIR/d102f
4313         cd $DIR
4314         $TAR cf - --xattrs $tdir | $TAR xf - --xattrs -C $DIR/d102f
4315         cd $DIR/d102f/$tdir
4316         compare_stripe_info1
4317 }
4318 run_test 102f "tar copy files, not keep osts ==========="
4319
4320 test_102h() { # bug 15777
4321         [ -z $(lctl get_param -n mdc.*.connect_flags | grep xattr) ] &&
4322                 skip "must have user_xattr" && return
4323         [ -z "$(which setfattr 2>/dev/null)" ] &&
4324                 skip_env "could not find setfattr" && return
4325
4326         XBIG=trusted.big
4327         XSIZE=1024
4328         touch $DIR/$tfile
4329         VALUE=datadatadatadatadatadatadatadata
4330         while [ $(echo $VALUE | wc -c) -lt $XSIZE ]; do
4331                 VALUE="$VALUE$VALUE"
4332         done
4333         log "save $XBIG on $DIR/$tfile"
4334         setfattr -n $XBIG -v "$VALUE" $DIR/$tfile ||
4335                 error "saving $XBIG on $DIR/$tfile failed"
4336         ORIG=$(getfattr -n $XBIG $DIR/$tfile 2> /dev/null | grep $XBIG)
4337         OSIZE=$(echo $ORIG | wc -c)
4338         [ $OSIZE -lt $XSIZE ] && error "set $XBIG too small ($OSIZE < $XSIZE)"
4339
4340         XSML=trusted.sml
4341         log "save $XSML on $DIR/$tfile"
4342         setfattr -n $XSML -v val $DIR/$tfile ||
4343                 error "saving $XSML on $DIR/$tfile failed"
4344         NEW=$(getfattr -n $XBIG $DIR/$tfile 2> /dev/null | grep $XBIG)
4345         if [ "$NEW" != "$ORIG" ]; then
4346                 log "orig: $ORIG"
4347                 log "new: $NEW"
4348                 error "$XBIG different after saving $XSML"
4349         fi
4350
4351         log "grow $XSML on $DIR/$tfile"
4352         setfattr -n $XSML -v "$VALUE" $DIR/$tfile ||
4353                 error "growing $XSML on $DIR/$tfile failed"
4354         NEW=$(getfattr -n $XBIG $DIR/$tfile 2> /dev/null | grep $XBIG)
4355         if [ "$NEW" != "$ORIG" ]; then
4356                 log "orig: $ORIG"
4357                 log "new: $NEW"
4358                 error "$XBIG different after growing $XSML"
4359         fi
4360         log "$XBIG still valid after growing $XSML"
4361         rm -f $file
4362 }
4363 run_test 102h "grow xattr from inside inode to external block"
4364
4365 test_102i() { # bug 17038
4366         touch $DIR/$tfile
4367         ln -s $DIR/$tfile $DIR/${tfile}link
4368         getfattr -n trusted.lov $DIR/$tfile || error "lgetxattr on $DIR/$tfile failed"
4369         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"
4370         rm -f $DIR/$tfile $DIR/${tfile}link
4371 }
4372 run_test 102i "lgetxattr test on symbolic link ============"
4373
4374 test_102j() {
4375         TAR=$(find_lustre_tar)
4376         [ -z "$TAR" ] && skip_env "lustre-aware tar is not installed" && return
4377         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping N-stripe test" && return
4378         setup_test102 "$RUNAS"
4379         mkdir -p $DIR/d102j
4380         chown $RUNAS_ID $DIR/d102j
4381         $RUNAS $TAR xf $TMP/f102.tar -C $DIR/d102j --xattrs
4382         cd $DIR/d102j/$tdir
4383         compare_stripe_info1 "$RUNAS"
4384 }
4385 run_test 102j "non-root tar restore stripe info from tarfile, not keep osts ==="
4386
4387 test_102k() {
4388         touch $DIR/$tfile
4389         # b22187 just check that does not crash for regular file.
4390         setfattr -n trusted.lov $DIR/$tfile
4391         # b22187 'setfattr -n trusted.lov' should work as remove LOV EA for directories
4392         local test_kdir=$DIR/d102k
4393         mkdir $test_kdir
4394         local default_size=`$GETSTRIPE -s $test_kdir`
4395         local default_count=`$GETSTRIPE -c $test_kdir`
4396         local default_offset=`$GETSTRIPE -o $test_kdir`
4397         $SETSTRIPE -s 65536 -i 1 -c 2 $test_kdir || error 'dir setstripe failed'
4398         setfattr -n trusted.lov $test_kdir
4399         local stripe_size=`$GETSTRIPE -s $test_kdir`
4400         local stripe_count=`$GETSTRIPE -c $test_kdir`
4401         local stripe_offset=`$GETSTRIPE -o $test_kdir`
4402         [ $stripe_size -eq $default_size ] || error "stripe size $stripe_size != $default_size"
4403         [ $stripe_count -eq $default_count ] || error "stripe count $stripe_count != $default_count"
4404         [ $stripe_offset -eq $default_offset ] || error "stripe offset $stripe_offset != $default_offset"
4405         rm -rf $DIR/$tfile $test_kdir
4406 }
4407 run_test 102k "setfattr without parameter of value shouldn't cause a crash"
4408
4409 cleanup_test102
4410
4411 run_acl_subtest()
4412 {
4413     $LUSTRE/tests/acl/run $LUSTRE/tests/acl/$1.test
4414     return $?
4415 }
4416
4417 test_103 () {
4418     [ "$UID" != 0 ] && skip_env "must run as root" && return
4419     [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep acl)" ] && skip "must have acl enabled" && return
4420     [ -z "$(which setfacl 2>/dev/null)" ] && skip_env "could not find setfacl" && return
4421     $GSS && skip "could not run under gss" && return
4422
4423     declare -a identity_old
4424
4425     for num in `seq $MDSCOUNT`; do
4426         switch_identity $num true || identity_old[$num]=$?
4427     done
4428
4429     SAVE_UMASK=`umask`
4430     umask 0022
4431     cd $DIR
4432
4433     echo "performing cp ..."
4434     run_acl_subtest cp || error
4435     echo "performing getfacl-noacl..."
4436     run_acl_subtest getfacl-noacl || error "getfacl-noacl test failed"
4437     echo "performing misc..."
4438     run_acl_subtest misc || error  "misc test failed"
4439     echo "performing permissions..."
4440     run_acl_subtest permissions || error "permissions failed"
4441     echo "performing setfacl..."
4442     run_acl_subtest setfacl || error  "setfacl test failed"
4443
4444     # inheritance test got from HP
4445     echo "performing inheritance..."
4446     cp $LUSTRE/tests/acl/make-tree . || error "cannot copy make-tree"
4447     chmod +x make-tree || error "chmod +x failed"
4448     run_acl_subtest inheritance || error "inheritance test failed"
4449     rm -f make-tree
4450
4451     cd $SAVE_PWD
4452     umask $SAVE_UMASK
4453
4454     for num in `seq $MDSCOUNT`; do
4455         if [ "${identity_old[$num]}" = 1 ]; then
4456             switch_identity $num false || identity_old[$num]=$?
4457         fi
4458     done
4459 }
4460 run_test 103 "acl test ========================================="
4461
4462 test_104a() {
4463         touch $DIR/$tfile
4464         lfs df || error "lfs df failed"
4465         lfs df -ih || error "lfs df -ih failed"
4466         lfs df -h $DIR || error "lfs df -h $DIR failed"
4467         lfs df -i $DIR || error "lfs df -i $DIR failed"
4468         lfs df $DIR/$tfile || error "lfs df $DIR/$tfile failed"
4469         lfs df -ih $DIR/$tfile || error "lfs df -ih $DIR/$tfile failed"
4470
4471         OSC=`lctl get_param -n devices | awk '/-osc-/ {print $4}' | head -n 1`
4472         lctl --device %$OSC deactivate
4473         lfs df || error "lfs df with deactivated OSC failed"
4474         lctl --device %$OSC recover
4475         lfs df || error "lfs df with reactivated OSC failed"
4476         rm -f $DIR/$tfile
4477 }
4478 run_test 104a "lfs df [-ih] [path] test ========================="
4479
4480 test_104b() {
4481         [ $RUNAS_ID -eq $UID ] && skip_env "RUNAS_ID = UID = $UID -- skipping" && return
4482         chmod 666 /dev/obd
4483         denied_cnt=$((`$RUNAS $LFS check servers 2>&1 | grep "Permission denied" | wc -l`))
4484         if [ $denied_cnt -ne 0 ];
4485         then
4486                     error "lfs check servers test failed"
4487         fi
4488 }
4489 run_test 104b "$RUNAS lfs check servers test ===================="
4490
4491 test_105a() {
4492         # doesn't work on 2.4 kernels
4493         touch $DIR/$tfile
4494         if [ -n "`mount | grep \"$DIR.*flock\" | grep -v noflock`" ];
4495         then
4496                 flocks_test 1 on -f $DIR/$tfile || error "fail flock on"
4497         else
4498                 flocks_test 1 off -f $DIR/$tfile || error "fail flock off"
4499         fi
4500         rm -f $DIR/$tfile
4501 }
4502 run_test 105a "flock when mounted without -o flock test ========"
4503
4504 test_105b() {
4505         touch $DIR/$tfile
4506         if [ -n "`mount | grep \"$DIR.*flock\" | grep -v noflock`" ];
4507         then
4508                 flocks_test 1 on -c $DIR/$tfile || error "fail flock on"
4509         else
4510                 flocks_test 1 off -c $DIR/$tfile || error "fail flock off"
4511         fi
4512         rm -f $DIR/$tfile
4513 }
4514 run_test 105b "fcntl when mounted without -o flock test ========"
4515
4516 test_105c() {
4517         touch $DIR/$tfile
4518         if [ -n "`mount | grep \"$DIR.*flock\" | grep -v noflock`" ];
4519         then
4520                 flocks_test 1 on -l $DIR/$tfile || error "fail flock on"
4521         else
4522                 flocks_test 1 off -l $DIR/$tfile || error "fail flock off"
4523         fi
4524         rm -f $DIR/$tfile
4525 }
4526 run_test 105c "lockf when mounted without -o flock test ========"
4527
4528 test_105d() { # bug 15924
4529         mkdir -p $DIR/$tdir
4530         [ -z "`mount | grep \"$DIR.*flock\" | grep -v noflock`" ] && \
4531                 skip "mount w/o flock enabled" && return
4532         #define OBD_FAIL_LDLM_CP_CB_WAIT  0x315
4533         $LCTL set_param fail_loc=0x80000315
4534         flocks_test 2 $DIR/$tdir
4535 }
4536 run_test 105d "flock race (should not freeze) ========"
4537
4538 test_106() { #bug 10921
4539         mkdir -p $DIR/$tdir
4540         $DIR/$tdir && error "exec $DIR/$tdir succeeded"
4541         chmod 777 $DIR/$tdir || error "chmod $DIR/$tdir failed"
4542 }
4543 run_test 106 "attempt exec of dir followed by chown of that dir"
4544
4545 test_107() {
4546         CDIR=`pwd`
4547         cd $DIR
4548
4549         local file=core
4550         rm -f $file
4551
4552         local save_pattern=$(sysctl -n kernel.core_pattern)
4553         local save_uses_pid=$(sysctl -n kernel.core_uses_pid)
4554         sysctl -w kernel.core_pattern=$file
4555         sysctl -w kernel.core_uses_pid=0
4556
4557         ulimit -c unlimited
4558         sleep 60 &
4559         SLEEPPID=$!
4560
4561         sleep 1
4562
4563         kill -s 11 $SLEEPPID
4564         wait $SLEEPPID
4565         if [ -e $file ]; then
4566                 size=`stat -c%s $file`
4567                 [ $size -eq 0 ] && error "Fail to create core file $file"
4568         else
4569                 error "Fail to create core file $file"
4570         fi
4571         rm -f $file
4572         sysctl -w kernel.core_pattern=$save_pattern
4573         sysctl -w kernel.core_uses_pid=$save_uses_pid
4574         cd $CDIR
4575 }
4576 run_test 107 "Coredump on SIG"
4577
4578 test_110() {
4579         mkdir -p $DIR/d110
4580         mkdir $DIR/d110/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || error "mkdir with 255 char fail"
4581         mkdir $DIR/d110/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && error "mkdir with 256 char should fail, but not"
4582         touch $DIR/d110/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx || error "create with 255 char fail"
4583         touch $DIR/d110/yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy && error ""create with 256 char should fail, but not
4584
4585         ls -l $DIR/d110
4586     rm -fr $DIR/d110
4587 }
4588 run_test 110 "filename length checking"
4589
4590 test_115() {
4591         OSTIO_pre=$(ps -e|grep ll_ost_io|awk '{print $4}'|sort -n|tail -1|\
4592             cut -c11-20)
4593         [ -z "$OSTIO_pre" ] && skip "no OSS threads" && \
4594             return
4595         echo "Starting with $OSTIO_pre threads"
4596
4597         NUMTEST=20000
4598         NUMFREE=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
4599         [ $NUMFREE -lt $NUMTEST ] && NUMTEST=$(($NUMFREE - 1000))
4600         echo "$NUMTEST creates/unlinks"
4601         mkdir -p $DIR/$tdir
4602         createmany -o $DIR/$tdir/$tfile $NUMTEST
4603         unlinkmany $DIR/$tdir/$tfile $NUMTEST
4604
4605         OSTIO_post=$(ps -e|grep ll_ost_io|awk '{print $4}'|sort -n|tail -1|\
4606             cut -c11-20)
4607
4608         # don't return an error
4609         [ $OSTIO_post -eq $OSTIO_pre ] && echo \
4610             "WARNING: No new ll_ost_io threads were created ($OSTIO_pre)" &&\
4611             echo "This may be fine, depending on what ran before this test" &&\
4612             echo "and how fast this system is." && return
4613
4614         echo "Started with $OSTIO_pre threads, ended with $OSTIO_post"
4615 }
4616 run_test 115 "verify dynamic thread creation===================="
4617
4618 free_min_max () {
4619         wait_delete_completed
4620         AVAIL=($(lctl get_param -n osc.*[oO][sS][cC]-[^M]*.kbytesavail))
4621         echo OST kbytes available: ${AVAIL[@]}
4622         MAXI=0; MAXV=${AVAIL[0]}
4623         MINI=0; MINV=${AVAIL[0]}
4624         for ((i = 0; i < ${#AVAIL[@]}; i++)); do
4625             #echo OST $i: ${AVAIL[i]}kb
4626             if [ ${AVAIL[i]} -gt $MAXV ]; then
4627                 MAXV=${AVAIL[i]}; MAXI=$i
4628             fi
4629             if [ ${AVAIL[i]} -lt $MINV ]; then
4630                 MINV=${AVAIL[i]}; MINI=$i
4631             fi
4632         done
4633         echo Min free space: OST $MINI: $MINV
4634         echo Max free space: OST $MAXI: $MAXV
4635 }
4636
4637 test_116() {
4638         [ "$OSTCOUNT" -lt "2" ] && skip_env "$OSTCOUNT < 2 OSTs" && return
4639
4640         echo -n "Free space priority "
4641         lctl get_param -n lov.*-clilov-*.qos_prio_free
4642         declare -a AVAIL
4643         free_min_max
4644         [ $MINV -gt 960000 ] && skip "too much free space in OST$MINI, skip" &&\
4645                 return
4646
4647         # generate uneven OSTs
4648         mkdir -p $DIR/$tdir/OST${MINI}
4649         declare -i FILL
4650         FILL=$(($MINV / 4))
4651         echo "Filling 25% remaining space in OST${MINI} with ${FILL}Kb"
4652         $SETSTRIPE -i $MINI -c 1 $DIR/$tdir/OST${MINI}||error "setstripe failed"
4653         i=0
4654         while [ $FILL -gt 0 ]; do
4655             i=$(($i + 1))
4656             dd if=/dev/zero of=$DIR/$tdir/OST${MINI}/$tfile-$i bs=2M count=1 2>/dev/null
4657             FILL=$(($FILL - 2048))
4658             echo -n .
4659         done
4660         FILL=$(($MINV / 4))
4661         sync
4662         sleep_maxage
4663
4664         free_min_max
4665         DIFF=$(($MAXV - $MINV))
4666         DIFF2=$(($DIFF * 100 / $MINV))
4667         echo -n "diff=${DIFF}=${DIFF2}% must be > 20% for QOS mode..."
4668         if [ $DIFF2 -gt 20 ]; then
4669             echo "ok"
4670         else
4671             echo "failed - QOS mode won't be used"
4672             error_ignore "QOS imbalance criteria not met"
4673             return
4674         fi
4675
4676         MINI1=$MINI; MINV1=$MINV
4677         MAXI1=$MAXI; MAXV1=$MAXV
4678
4679         # now fill using QOS
4680         echo writing a bunch of files to QOS-assigned OSTs
4681         $SETSTRIPE $DIR/$tdir -c 1
4682         i=0
4683         while [ $FILL -gt 0 ]; do
4684             i=$(($i + 1))
4685             dd if=/dev/zero of=$DIR/$tdir/$tfile-$i bs=1024 count=200 2>/dev/null
4686             FILL=$(($FILL - 200))
4687             echo -n .
4688         done
4689         echo "wrote $i 200k files"
4690         sync
4691         sleep_maxage
4692
4693         echo "Note: free space may not be updated, so measurements might be off"
4694         free_min_max
4695         DIFF2=$(($MAXV - $MINV))
4696         echo "free space delta: orig $DIFF final $DIFF2"
4697         [ $DIFF2 -gt $DIFF ] && echo "delta got worse!"
4698         DIFF=$(($MINV1 - ${AVAIL[$MINI1]}))
4699         echo "Wrote $DIFF to smaller OST $MINI1"
4700         DIFF2=$(($MAXV1 - ${AVAIL[$MAXI1]}))
4701         echo "Wrote $DIFF2 to larger OST $MAXI1"
4702         [ $DIFF -gt 0 ] && echo "Wrote $(($DIFF2 * 100 / $DIFF - 100))% more data to larger OST $MAXI1"
4703
4704         # Figure out which files were written where
4705         UUID=$(lctl get_param -n lov.${FSNAME}-clilov-*.target_obd |
4706                awk '/'$MINI1': / {print $2; exit}')
4707         echo $UUID
4708         MINC=$($GETSTRIPE --obd $UUID $DIR/$tdir | wc -l)
4709         echo "$MINC files created on smaller OST $MINI1"
4710         UUID=$(lctl get_param -n lov.${FSNAME}-clilov-*.target_obd |
4711                awk '/'$MAXI1': / {print $2; exit}')
4712         echo $UUID
4713         MAXC=$($GETSTRIPE --obd $UUID $DIR/$tdir | wc -l)
4714         echo "$MAXC files created on larger OST $MAXI1"
4715         [ $MINC -gt 0 ] && echo "Wrote $(($MAXC * 100 / $MINC - 100))% more files to larger OST $MAXI1"
4716         [ $MAXC -gt $MINC ] || error_ignore "stripe QOS didn't balance free space"
4717
4718         rm -rf $DIR/$tdir/OST${MINI}
4719 }
4720 run_test 116 "stripe QOS: free space balance ==================="
4721
4722 test_117() # bug 10891
4723 {
4724         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1
4725         #define OBD_FAIL_OST_SETATTR_CREDITS 0x21e
4726         lctl set_param fail_loc=0x21e
4727         > $DIR/$tfile || error "truncate failed"
4728         lctl set_param fail_loc=0
4729         echo "Truncate succeeded."
4730         rm -f $DIR/$tfile
4731 }
4732 run_test 117 "verify fsfilt_extend =========="
4733
4734 export OLD_RESENDCOUNT=""
4735 set_resend_count () {
4736         local PROC_RESENDCOUNT="osc.${FSNAME}-OST*-osc-*.resend_count"
4737         OLD_RESENDCOUNT=$(lctl get_param -n $PROC_RESENDCOUNT | head -1)
4738         lctl set_param -n $PROC_RESENDCOUNT $1
4739         echo resend_count is set to $(lctl get_param -n $PROC_RESENDCOUNT)
4740 }
4741
4742 [ "$SLOW" = "no" ] && set_resend_count 4 # for reduce test_118* time (bug 14842)
4743
4744 # Reset async IO behavior after error case
4745 reset_async() {
4746         FILE=$DIR/reset_async
4747
4748         # Ensure all OSCs are cleared
4749         $LSTRIPE -c -1 $FILE
4750         dd if=/dev/zero of=$FILE bs=64k count=$OSTCOUNT
4751         sync
4752         rm $FILE
4753 }
4754
4755 test_118a() #bug 11710
4756 {
4757         reset_async
4758
4759         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
4760         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4761         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
4762
4763         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4764                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4765                 return 1;
4766         fi
4767         rm -f $DIR/$tfile
4768 }
4769 run_test 118a "verify O_SYNC works =========="
4770
4771 test_118b()
4772 {
4773         remote_ost_nodsh && skip "remote OST with nodsh" && return
4774
4775         reset_async
4776
4777         #define OBD_FAIL_OST_ENOENT 0x217
4778         set_nodes_failloc "$(osts_nodes)" 0x217
4779         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
4780         RC=$?
4781         set_nodes_failloc "$(osts_nodes)" 0
4782         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4783         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4784                     grep -c writeback)
4785
4786         if [[ $RC -eq 0 ]]; then
4787                 error "Must return error due to dropped pages, rc=$RC"
4788                 return 1;
4789         fi
4790
4791         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4792                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4793                 return 1;
4794         fi
4795
4796         echo "Dirty pages not leaked on ENOENT"
4797
4798         # Due to the above error the OSC will issue all RPCs syncronously
4799         # until a subsequent RPC completes successfully without error.
4800         multiop $DIR/$tfile Ow4096yc
4801         rm -f $DIR/$tfile
4802
4803         return 0
4804 }
4805 run_test 118b "Reclaim dirty pages on fatal error =========="
4806
4807 test_118c()
4808 {
4809         remote_ost_nodsh && skip "remote OST with nodsh" && return
4810
4811         reset_async
4812
4813         #define OBD_FAIL_OST_EROFS               0x216
4814         set_nodes_failloc "$(osts_nodes)" 0x216
4815
4816         # multiop should block due to fsync until pages are written
4817         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
4818         MULTIPID=$!
4819         sleep 1
4820
4821         if [[ `ps h -o comm -p $MULTIPID` != "multiop" ]]; then
4822                 error "Multiop failed to block on fsync, pid=$MULTIPID"
4823         fi
4824
4825         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4826                     grep -c writeback)
4827         if [[ $WRITEBACK -eq 0 ]]; then
4828                 error "No page in writeback, writeback=$WRITEBACK"
4829         fi
4830
4831         set_nodes_failloc "$(osts_nodes)" 0
4832         wait $MULTIPID
4833         RC=$?
4834         if [[ $RC -ne 0 ]]; then
4835                 error "Multiop fsync failed, rc=$RC"
4836         fi
4837
4838         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4839         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4840                     grep -c writeback)
4841         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4842                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4843         fi
4844
4845         rm -f $DIR/$tfile
4846         echo "Dirty pages flushed via fsync on EROFS"
4847         return 0
4848 }
4849 run_test 118c "Fsync blocks on EROFS until dirty pages are flushed =========="
4850
4851 test_118d()
4852 {
4853         remote_ost_nodsh && skip "remote OST with nodsh" && return
4854
4855         reset_async
4856
4857         #define OBD_FAIL_OST_BRW_PAUSE_BULK
4858         set_nodes_failloc "$(osts_nodes)" 0x214
4859         # multiop should block due to fsync until pages are written
4860         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
4861         MULTIPID=$!
4862         sleep 1
4863
4864         if [[ `ps h -o comm -p $MULTIPID` != "multiop" ]]; then
4865                 error "Multiop failed to block on fsync, pid=$MULTIPID"
4866         fi
4867
4868         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4869                     grep -c writeback)
4870         if [[ $WRITEBACK -eq 0 ]]; then
4871                 error "No page in writeback, writeback=$WRITEBACK"
4872         fi
4873
4874         wait $MULTIPID || error "Multiop fsync failed, rc=$?"
4875         set_nodes_failloc "$(osts_nodes)" 0
4876
4877         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4878         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4879                     grep -c writeback)
4880         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4881                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4882         fi
4883
4884         rm -f $DIR/$tfile
4885         echo "Dirty pages gaurenteed flushed via fsync"
4886         return 0
4887 }
4888 run_test 118d "Fsync validation inject a delay of the bulk =========="
4889
4890 test_118f() {
4891         reset_async
4892
4893         #define OBD_FAIL_OSC_BRW_PREP_REQ2        0x40a
4894         lctl set_param fail_loc=0x8000040a
4895
4896         # Should simulate EINVAL error which is fatal
4897         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
4898         RC=$?
4899         if [[ $RC -eq 0 ]]; then
4900                 error "Must return error due to dropped pages, rc=$RC"
4901         fi
4902
4903         lctl set_param fail_loc=0x0
4904
4905         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
4906         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4907         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4908                     grep -c writeback)
4909         if [[ $LOCKED -ne 0 ]]; then
4910                 error "Locked pages remain in cache, locked=$LOCKED"
4911         fi
4912
4913         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4914                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4915         fi
4916
4917         rm -f $DIR/$tfile
4918         echo "No pages locked after fsync"
4919
4920         reset_async
4921         return 0
4922 }
4923 run_test 118f "Simulate unrecoverable OSC side error =========="
4924
4925 test_118g() {
4926         reset_async
4927
4928         #define OBD_FAIL_OSC_BRW_PREP_REQ        0x406
4929         lctl set_param fail_loc=0x406
4930
4931         # simulate local -ENOMEM
4932         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
4933         RC=$?
4934
4935         lctl set_param fail_loc=0
4936         if [[ $RC -eq 0 ]]; then
4937                 error "Must return error due to dropped pages, rc=$RC"
4938         fi
4939
4940         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
4941         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4942         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4943                         grep -c writeback)
4944         if [[ $LOCKED -ne 0 ]]; then
4945                 error "Locked pages remain in cache, locked=$LOCKED"
4946         fi
4947
4948         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4949                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4950         fi
4951
4952         rm -f $DIR/$tfile
4953         echo "No pages locked after fsync"
4954
4955         reset_async
4956         return 0
4957 }
4958 run_test 118g "Don't stay in wait if we got local -ENOMEM  =========="
4959
4960 test_118h() {
4961         remote_ost_nodsh && skip "remote OST with nodsh" && return
4962
4963         reset_async
4964
4965         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
4966         set_nodes_failloc "$(osts_nodes)" 0x20e
4967         # Should simulate ENOMEM error which is recoverable and should be handled by timeout
4968         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
4969         RC=$?
4970
4971         set_nodes_failloc "$(osts_nodes)" 0
4972         if [[ $RC -eq 0 ]]; then
4973                 error "Must return error due to dropped pages, rc=$RC"
4974         fi
4975
4976         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
4977         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4978         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4979                     grep -c writeback)
4980         if [[ $LOCKED -ne 0 ]]; then
4981                 error "Locked pages remain in cache, locked=$LOCKED"
4982         fi
4983
4984         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4985                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4986         fi
4987
4988         rm -f $DIR/$tfile
4989         echo "No pages locked after fsync"
4990
4991         return 0
4992 }
4993 run_test 118h "Verify timeout in handling recoverables errors  =========="
4994
4995 test_118i() {
4996         remote_ost_nodsh && skip "remote OST with nodsh" && return
4997
4998         reset_async
4999
5000         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
5001         set_nodes_failloc "$(osts_nodes)" 0x20e
5002
5003         # Should simulate ENOMEM error which is recoverable and should be handled by timeout
5004         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
5005         PID=$!
5006         sleep 5
5007         set_nodes_failloc "$(osts_nodes)" 0
5008
5009         wait $PID
5010         RC=$?
5011         if [[ $RC -ne 0 ]]; then
5012                 error "got error, but should be not, rc=$RC"
5013         fi
5014
5015         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
5016         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
5017         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
5018         if [[ $LOCKED -ne 0 ]]; then
5019                 error "Locked pages remain in cache, locked=$LOCKED"
5020         fi
5021
5022         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
5023                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
5024         fi
5025
5026         rm -f $DIR/$tfile
5027         echo "No pages locked after fsync"
5028
5029         return 0
5030 }
5031 run_test 118i "Fix error before timeout in recoverable error  =========="
5032
5033 test_118j() {
5034         remote_ost_nodsh && skip "remote OST with nodsh" && return
5035
5036         reset_async
5037
5038         #define OBD_FAIL_OST_BRW_WRITE_BULK2     0x220
5039         set_nodes_failloc "$(osts_nodes)" 0x220
5040
5041         # return -EIO from OST
5042         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
5043         RC=$?
5044         set_nodes_failloc "$(osts_nodes)" 0x0
5045         if [[ $RC -eq 0 ]]; then
5046                 error "Must return error due to dropped pages, rc=$RC"
5047         fi
5048
5049         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
5050         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
5051         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
5052         if [[ $LOCKED -ne 0 ]]; then
5053                 error "Locked pages remain in cache, locked=$LOCKED"
5054         fi
5055
5056         # in recoverable error on OST we want resend and stay until it finished
5057         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
5058                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
5059         fi
5060
5061         rm -f $DIR/$tfile
5062         echo "No pages locked after fsync"
5063
5064         return 0
5065 }
5066 run_test 118j "Simulate unrecoverable OST side error =========="
5067
5068 test_118k()
5069 {
5070         remote_ost_nodsh && skip "remote OSTs with nodsh" && return
5071
5072         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
5073         set_nodes_failloc "$(osts_nodes)" 0x20e
5074         mkdir -p $DIR/$tdir
5075
5076         for ((i=0;i<10;i++)); do
5077                 (dd if=/dev/zero of=$DIR/$tdir/$tfile-$i bs=1M count=10 || \
5078                         error "dd to $DIR/$tdir/$tfile-$i failed" )&
5079                 SLEEPPID=$!
5080                 sleep 0.500s
5081                 kill $SLEEPPID
5082                 wait $SLEEPPID
5083         done
5084
5085         set_nodes_failloc "$(osts_nodes)" 0
5086 }
5087 run_test 118k "bio alloc -ENOMEM and IO TERM handling ========="
5088
5089 [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] && set_resend_count $OLD_RESENDCOUNT
5090
5091 test_119a() # bug 11737
5092 {
5093         BSIZE=$((512 * 1024))
5094         directio write $DIR/$tfile 0 1 $BSIZE
5095         # We ask to read two blocks, which is more than a file size.
5096         # directio will indicate an error when requested and actual
5097         # sizes aren't equeal (a normal situation in this case) and
5098         # print actual read amount.
5099         NOB=`directio read $DIR/$tfile 0 2 $BSIZE | awk '/error/ {print $6}'`
5100         if [ "$NOB" != "$BSIZE" ]; then
5101                 error "read $NOB bytes instead of $BSIZE"
5102         fi
5103         rm -f $DIR/$tfile
5104 }
5105 run_test 119a "Short directIO read must return actual read amount"
5106
5107 test_119b() # bug 11737
5108 {
5109         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
5110
5111         $SETSTRIPE -c 2 $DIR/$tfile || error "setstripe failed"
5112         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1 || error "dd failed"
5113         sync
5114         multiop $DIR/$tfile oO_RDONLY:O_DIRECT:r$((2048 * 1024)) || \
5115                 error "direct read failed"
5116         rm -f $DIR/$tfile
5117 }
5118 run_test 119b "Sparse directIO read must return actual read amount"
5119
5120 test_119c() # bug 13099
5121 {
5122         BSIZE=1048576
5123         directio write $DIR/$tfile 3 1 $BSIZE || error "direct write failed"
5124         directio readhole $DIR/$tfile 0 2 $BSIZE || error "reading hole failed"
5125         rm -f $DIR/$tfile
5126 }
5127 run_test 119c "Testing for direct read hitting hole"
5128
5129 test_119d() # bug 15950
5130 {
5131         MAX_RPCS_IN_FLIGHT=`$LCTL get_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight`
5132         $LCTL set_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight 1
5133         BSIZE=1048576
5134         $SETSTRIPE $DIR/$tfile -i 0 -c 1 || error "setstripe failed"
5135         $DIRECTIO write $DIR/$tfile 0 1 $BSIZE || error "first directio failed"
5136         #define OBD_FAIL_OSC_DIO_PAUSE           0x40d
5137         lctl set_param fail_loc=0x40d
5138         $DIRECTIO write $DIR/$tfile 1 4 $BSIZE &
5139         pid_dio=$!
5140         sleep 1
5141         cat $DIR/$tfile > /dev/null &
5142         lctl set_param fail_loc=0
5143         pid_reads=$!
5144         wait $pid_dio
5145         log "the DIO writes have completed, now wait for the reads (should not block very long)"
5146         sleep 2
5147         [ -n "`ps h -p $pid_reads -o comm`" ] && \
5148         error "the read rpcs have not completed in 2s"
5149         rm -f $DIR/$tfile
5150         $LCTL set_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight $MAX_RPCS_IN_FLIGHT
5151 }
5152 run_test 119d "The DIO path should try to send a new rpc once one is completed"
5153
5154 test_120a() {
5155         mkdir -p $DIR/$tdir
5156         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
5157                skip "no early lock cancel on server" && return 0
5158         lru_resize_disable mdc
5159         lru_resize_disable osc
5160         cancel_lru_locks mdc
5161         stat $DIR/$tdir > /dev/null
5162         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
5163         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
5164         mkdir $DIR/$tdir/d1
5165         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
5166         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
5167         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
5168         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
5169         lru_resize_enable mdc
5170         lru_resize_enable osc
5171 }
5172 run_test 120a "Early Lock Cancel: mkdir test"
5173
5174 test_120b() {
5175         mkdir -p $DIR/$tdir
5176         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
5177                skip "no early lock cancel on server" && return 0
5178         lru_resize_disable mdc
5179         lru_resize_disable osc
5180         cancel_lru_locks mdc
5181         stat $DIR/$tdir > /dev/null
5182         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
5183         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
5184         touch $DIR/$tdir/f1
5185         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
5186         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
5187         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
5188         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
5189         lru_resize_enable mdc
5190         lru_resize_enable osc
5191 }
5192 run_test 120b "Early Lock Cancel: create test"
5193
5194 test_120c() {
5195         mkdir -p $DIR/$tdir
5196         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
5197                skip "no early lock cancel on server" && return 0
5198         lru_resize_disable mdc
5199         lru_resize_disable osc
5200         mkdir -p $DIR/$tdir/d1 $DIR/$tdir/d2
5201         touch $DIR/$tdir/d1/f1
5202         cancel_lru_locks mdc
5203         stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 > /dev/null
5204         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
5205         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
5206         ln $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2
5207         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
5208         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
5209         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
5210         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
5211         lru_resize_enable mdc
5212         lru_resize_enable osc
5213 }
5214 run_test 120c "Early Lock Cancel: link test"
5215
5216 test_120d() {
5217         mkdir -p $DIR/$tdir
5218         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
5219                skip "no early lock cancel on server" && return 0
5220         lru_resize_disable mdc
5221         lru_resize_disable osc
5222         touch $DIR/$tdir
5223         cancel_lru_locks mdc
5224         stat $DIR/$tdir > /dev/null
5225         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
5226         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
5227         chmod a+x $DIR/$tdir
5228         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
5229         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
5230         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
5231         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
5232         lru_resize_enable mdc
5233         lru_resize_enable osc
5234 }
5235 run_test 120d "Early Lock Cancel: setattr test"
5236
5237 test_120e() {
5238         mkdir -p $DIR/$tdir
5239         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
5240                skip "no early lock cancel on server" && return 0
5241         lru_resize_disable mdc
5242         lru_resize_disable osc
5243         dd if=/dev/zero of=$DIR/$tdir/f1 count=1
5244         cancel_lru_locks mdc
5245         cancel_lru_locks osc
5246         dd if=$DIR/$tdir/f1 of=/dev/null
5247         stat $DIR/$tdir $DIR/$tdir/f1 > /dev/null
5248         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
5249               awk '/ldlm_cancel/ {print $2}'`
5250         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
5251               awk '/ldlm_bl_callback/ {print $2}'`
5252         unlink $DIR/$tdir/f1
5253         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
5254               awk '/ldlm_cancel/ {print $2}'`
5255         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
5256               awk '/ldlm_bl_callback/ {print $2}'`
5257         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
5258         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
5259         lru_resize_enable mdc
5260         lru_resize_enable osc
5261 }
5262 run_test 120e "Early Lock Cancel: unlink test"
5263
5264 test_120f() {
5265         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
5266                skip "no early lock cancel on server" && return 0
5267         mkdir -p $DIR/$tdir
5268         lru_resize_disable mdc
5269         lru_resize_disable osc
5270         mkdir -p $DIR/$tdir/d1 $DIR/$tdir/d2
5271         dd if=/dev/zero of=$DIR/$tdir/d1/f1 count=1
5272         dd if=/dev/zero of=$DIR/$tdir/d2/f2 count=1
5273         cancel_lru_locks mdc
5274         cancel_lru_locks osc
5275         dd if=$DIR/$tdir/d1/f1 of=/dev/null
5276         dd if=$DIR/$tdir/d2/f2 of=/dev/null
5277         stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2 > /dev/null
5278         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
5279               awk '/ldlm_cancel/ {print $2}'`
5280         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
5281               awk '/ldlm_bl_callback/ {print $2}'`
5282         mv $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2
5283         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
5284               awk '/ldlm_cancel/ {print $2}'`
5285         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
5286               awk '/ldlm_bl_callback/ {print $2}'`
5287         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
5288         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
5289         lru_resize_enable mdc
5290         lru_resize_enable osc
5291 }
5292 run_test 120f "Early Lock Cancel: rename test"
5293
5294 test_120g() {
5295         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
5296                skip "no early lock cancel on server" && return 0
5297         lru_resize_disable mdc
5298         lru_resize_disable osc
5299         count=10000
5300         echo create $count files
5301         mkdir -p $DIR/$tdir
5302         cancel_lru_locks mdc
5303         cancel_lru_locks osc
5304         t0=`date +%s`
5305
5306         can0=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
5307               awk '/ldlm_cancel/ {print $2}'`
5308         blk0=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
5309               awk '/ldlm_bl_callback/ {print $2}'`
5310         createmany -o $DIR/$tdir/f $count
5311         sync
5312         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
5313               awk '/ldlm_cancel/ {print $2}'`
5314         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
5315               awk '/ldlm_bl_callback/ {print $2}'`
5316         t1=`date +%s`
5317         echo total: $((can1-can0)) cancels, $((blk1-blk0)) blockings
5318         echo rm $count files
5319         rm -r $DIR/$tdir
5320         sync
5321         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
5322               awk '/ldlm_cancel/ {print $2}'`
5323         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
5324               awk '/ldlm_bl_callback/ {print $2}'`
5325         t2=`date +%s`
5326         echo total: $count removes in $((t2-t1))
5327         echo total: $((can2-can1)) cancels, $((blk2-blk1)) blockings
5328         sleep 2
5329         # wait for commitment of removal
5330         lru_resize_enable mdc
5331         lru_resize_enable osc
5332 }
5333 run_test 120g "Early Lock Cancel: performance test"
5334
5335 test_121() { #bug #10589
5336         rm -rf $DIR/$tfile
5337         writes=$(LANG=C dd if=/dev/zero of=$DIR/$tfile count=1 2>&1 | awk -F '+' '/out$/ {print $1}')
5338 #define OBD_FAIL_LDLM_CANCEL_RACE        0x310
5339         lctl set_param fail_loc=0x310
5340         cancel_lru_locks osc > /dev/null
5341         reads=$(LANG=C dd if=$DIR/$tfile of=/dev/null 2>&1 | awk -F '+' '/in$/ {print $1}')
5342         lctl set_param fail_loc=0
5343         [ "$reads" -eq "$writes" ] || error "read" $reads "blocks, must be" $writes
5344 }
5345 run_test 121 "read cancel race ========="
5346
5347 test_123a() { # was test 123, statahead(bug 11401)
5348         SLOWOK=0
5349         if [ -z "$(grep "processor.*: 1" /proc/cpuinfo)" ]; then
5350             log "testing on UP system. Performance may be not as good as expected."
5351                         SLOWOK=1
5352         fi
5353
5354         rm -rf $DIR/$tdir
5355         mkdir -p $DIR/$tdir
5356         NUMFREE=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
5357         [ $NUMFREE -gt 100000 ] && NUMFREE=100000 || NUMFREE=$((NUMFREE-1000))
5358         MULT=10
5359         for ((i=100, j=0; i<=$NUMFREE; j=$i, i=$((i * MULT)) )); do
5360                 createmany -o $DIR/$tdir/$tfile $j $((i - j))
5361
5362                 max=`lctl get_param -n llite.*.statahead_max | head -n 1`
5363                 lctl set_param -n llite.*.statahead_max 0
5364                 lctl get_param llite.*.statahead_max
5365                 cancel_lru_locks mdc
5366                 cancel_lru_locks osc
5367                 stime=`date +%s`
5368                 time ls -l $DIR/$tdir | wc -l
5369                 etime=`date +%s`
5370                 delta=$((etime - stime))
5371                 log "ls $i files without statahead: $delta sec"
5372                 lctl set_param llite.*.statahead_max=$max
5373
5374                 swrong=`lctl get_param -n llite.*.statahead_stats | grep "statahead wrong:" | awk '{print $3}'`
5375                 lctl get_param -n llite.*.statahead_max | grep '[0-9]'
5376                 cancel_lru_locks mdc
5377                 cancel_lru_locks osc
5378                 stime=`date +%s`
5379                 time ls -l $DIR/$tdir | wc -l
5380                 etime=`date +%s`
5381                 delta_sa=$((etime - stime))
5382                 log "ls $i files with statahead: $delta_sa sec"
5383                 lctl get_param -n llite.*.statahead_stats
5384                 ewrong=`lctl get_param -n llite.*.statahead_stats | grep "statahead wrong:" | awk '{print $3}'`
5385
5386                 [ $swrong -lt $ewrong ] && log "statahead was stopped, maybe too many locks held!"
5387                 [ $delta -eq 0 -o $delta_sa -eq 0 ] && continue
5388
5389                 if [ $((delta_sa * 100)) -gt $((delta * 105)) -a $delta_sa -gt $((delta + 2)) ]; then
5390                     max=`lctl get_param -n llite.*.statahead_max | head -n 1`
5391                     lctl set_param -n llite.*.statahead_max 0
5392                     lctl get_param llite.*.statahead_max
5393                     cancel_lru_locks mdc
5394                     cancel_lru_locks osc
5395                     stime=`date +%s`
5396                     time ls -l $DIR/$tdir | wc -l
5397                     etime=`date +%s`
5398                     delta=$((etime - stime))
5399                     log "ls $i files again without statahead: $delta sec"
5400                     lctl set_param llite.*.statahead_max=$max
5401                     if [ $((delta_sa * 100)) -gt $((delta * 105)) -a $delta_sa -gt $((delta + 2)) ]; then
5402                         if [  $SLOWOK -eq 0 ]; then
5403                                 error "ls $i files is slower with statahead!"
5404                         else
5405                                 log "ls $i files is slower with statahead!"
5406                         fi
5407                         break
5408                     fi
5409                 fi
5410
5411                 [ $delta -gt 20 ] && break
5412                 [ $delta -gt 8 ] && MULT=$((50 / delta))
5413                 [ "$SLOW" = "no" -a $delta -gt 5 ] && break
5414         done
5415         log "ls done"
5416
5417         stime=`date +%s`
5418         rm -r $DIR/$tdir
5419         sync
5420         etime=`date +%s`
5421         delta=$((etime - stime))
5422         log "rm -r $DIR/$tdir/: $delta seconds"
5423         log "rm done"
5424         lctl get_param -n llite.*.statahead_stats
5425 }
5426 run_test 123a "verify statahead work"
5427
5428 test_123b () { # statahead(bug 15027)
5429         mkdir -p $DIR/$tdir
5430         createmany -o $DIR/$tdir/$tfile-%d 1000
5431
5432         cancel_lru_locks mdc
5433         cancel_lru_locks osc
5434
5435 #define OBD_FAIL_MDC_GETATTR_ENQUEUE     0x803
5436         lctl set_param fail_loc=0x80000803
5437         ls -lR $DIR/$tdir > /dev/null
5438         log "ls done"
5439         lctl set_param fail_loc=0x0
5440         lctl get_param -n llite.*.statahead_stats
5441         rm -r $DIR/$tdir
5442         sync
5443
5444 }
5445 run_test 123b "not panic with network error in statahead enqueue (bug 15027)"
5446
5447 test_124a() {
5448         [ -z "`lctl get_param -n mdc.*.connect_flags | grep lru_resize`" ] && \
5449                skip "no lru resize on server" && return 0
5450         local NR=2000
5451         mkdir -p $DIR/$tdir || error "failed to create $DIR/$tdir"
5452
5453         log "create $NR files at $DIR/$tdir"
5454         createmany -o $DIR/$tdir/f $NR ||
5455                 error "failed to create $NR files in $DIR/$tdir"
5456
5457         cancel_lru_locks mdc
5458         ls -l $DIR/$tdir > /dev/null
5459
5460         local NSDIR=""
5461         local LRU_SIZE=0
5462         for VALUE in `lctl get_param ldlm.namespaces.*mdc-*.lru_size`; do
5463                 local PARAM=`echo ${VALUE[0]} | cut -d "=" -f1`
5464                 LRU_SIZE=$(lctl get_param -n $PARAM)
5465                 if [ $LRU_SIZE -gt $(default_lru_size) ]; then
5466                         NSDIR=$(echo $PARAM | cut -d "." -f1-3)
5467                         log "NS=$(basename $NSDIR)"
5468                         break
5469                 fi
5470         done
5471
5472         if [ -z "$NSDIR" -o $LRU_SIZE -lt $(default_lru_size) ]; then
5473                 skip "Not enough cached locks created!"
5474                 return 0
5475         fi
5476         log "LRU=$LRU_SIZE"
5477
5478         local SLEEP=30
5479
5480         # We know that lru resize allows one client to hold $LIMIT locks
5481         # for 10h. After that locks begin to be killed by client.
5482         local MAX_HRS=10
5483         local LIMIT=`lctl get_param -n $NSDIR.pool.limit`
5484
5485         # Make LVF so higher that sleeping for $SLEEP is enough to _start_
5486         # killing locks. Some time was spent for creating locks. This means
5487         # that up to the moment of sleep finish we must have killed some of
5488         # them (10-100 locks). This depends on how fast ther were created.
5489         # Many of them were touched in almost the same moment and thus will
5490         # be killed in groups.
5491         local LVF=$(($MAX_HRS * 60 * 60 / $SLEEP * $LIMIT / $LRU_SIZE))
5492
5493         # Use $LRU_SIZE_B here to take into account real number of locks
5494         # created in the case of CMD, LRU_SIZE_B != $NR in most of cases
5495         local LRU_SIZE_B=$LRU_SIZE
5496         log "LVF=$LVF"
5497         local OLD_LVF=`lctl get_param -n $NSDIR.pool.lock_volume_factor`
5498         lctl set_param -n $NSDIR.pool.lock_volume_factor $LVF
5499
5500         # Let's make sure that we really have some margin. Client checks
5501         # cached locks every 10 sec.
5502         SLEEP=$((SLEEP+20))
5503         log "Sleep ${SLEEP} sec"
5504         local SEC=0
5505         while ((SEC<$SLEEP)); do
5506                 echo -n "..."
5507                 sleep 5
5508                 SEC=$((SEC+5))
5509                 LRU_SIZE=`lctl get_param -n $NSDIR/lru_size`
5510                 echo -n "$LRU_SIZE"
5511         done
5512         echo ""
5513         lctl set_param -n $NSDIR.pool.lock_volume_factor $OLD_LVF
5514         local LRU_SIZE_A=`lctl get_param -n $NSDIR/lru_size`
5515
5516         [ $LRU_SIZE_B -gt $LRU_SIZE_A ] || {
5517                 error "No locks dropped in ${SLEEP}s. LRU size: $LRU_SIZE_A"
5518                 unlinkmany $DIR/$tdir/f $NR
5519                 return
5520         }
5521
5522         log "Dropped "$((LRU_SIZE_B-LRU_SIZE_A))" locks in ${SLEEP}s"
5523         log "unlink $NR files at $DIR/$tdir"
5524         unlinkmany $DIR/$tdir/f $NR
5525 }
5526 run_test 124a "lru resize ======================================="
5527
5528 get_max_pool_limit()
5529 {
5530         local limit=`lctl get_param -n ldlm.namespaces.*-MDT0000-mdc-*.pool.limit`
5531         local max=0
5532         for l in $limit; do
5533                 if test $l -gt $max; then
5534                         max=$l
5535                 fi
5536         done
5537         echo $max
5538 }
5539
5540 test_124b() {
5541         [ -z "`lctl get_param -n mdc.*.connect_flags | grep lru_resize`" ] && \
5542                skip "no lru resize on server" && return 0
5543
5544         LIMIT=`get_max_pool_limit`
5545
5546         NR=$(($(default_lru_size)*20))
5547         if [ $NR -gt $LIMIT ]; then
5548                 log "Limit lock number by $LIMIT locks"
5549                 NR=$LIMIT
5550         fi
5551         lru_resize_disable mdc
5552         mkdir -p $DIR/$tdir/disable_lru_resize ||
5553                 error "failed to create $DIR/$tdir/disable_lru_resize"
5554
5555         createmany -o $DIR/$tdir/disable_lru_resize/f $NR
5556         log "doing ls -la $DIR/$tdir/disable_lru_resize 3 times"
5557         cancel_lru_locks mdc
5558         stime=`date +%s`
5559         PID=""
5560         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
5561         PID="$PID $!"
5562         sleep 2
5563         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
5564         PID="$PID $!"
5565         sleep 2
5566         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
5567         PID="$PID $!"
5568         wait $PID
5569         etime=`date +%s`
5570         nolruresize_delta=$((etime-stime))
5571         log "ls -la time: $nolruresize_delta seconds"
5572         log "lru_size = $(lctl get_param -n ldlm.namespaces.*mdc*.lru_size)"
5573         unlinkmany $DIR/$tdir/disable_lru_resize/f $NR
5574
5575         lru_resize_enable mdc
5576         mkdir -p $DIR/$tdir/enable_lru_resize ||
5577                 error "failed to create $DIR/$tdir/enable_lru_resize"
5578
5579         createmany -o $DIR/$tdir/enable_lru_resize/f $NR
5580         log "doing ls -la $DIR/$tdir/enable_lru_resize 3 times"
5581         cancel_lru_locks mdc
5582         stime=`date +%s`
5583         PID=""
5584         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
5585         PID="$PID $!"
5586         sleep 2
5587         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
5588         PID="$PID $!"
5589         sleep 2
5590         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
5591         PID="$PID $!"
5592         wait $PID
5593         etime=`date +%s`
5594         lruresize_delta=$((etime-stime))
5595         log "ls -la time: $lruresize_delta seconds"
5596         log "lru_size = $(lctl get_param -n ldlm.namespaces.*mdc*.lru_size)"
5597
5598         if [ $lruresize_delta -gt $nolruresize_delta ]; then
5599                 log "ls -la is $(((lruresize_delta - $nolruresize_delta) * 100 / $nolruresize_delta))% slower with lru resize enabled"
5600         elif [ $nolruresize_delta -gt $lruresize_delta ]; then
5601                 log "ls -la is $(((nolruresize_delta - $lruresize_delta) * 100 / $nolruresize_delta))% faster with lru resize enabled"
5602         else
5603                 log "lru resize performs the same with no lru resize"
5604         fi
5605         unlinkmany $DIR/$tdir/enable_lru_resize/f $NR
5606 }
5607 run_test 124b "lru resize (performance test) ======================="
5608
5609 test_125() { # 13358
5610         [ -z "$(lctl get_param -n llite.*.client_type | grep local)" ] && skip "must run as local client" && return
5611         [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep acl)" ] && skip "must have acl enabled" && return
5612         mkdir -p $DIR/d125 || error "mkdir failed"
5613         $SETSTRIPE $DIR/d125 -s 65536 -c -1 || error "setstripe failed"
5614         setfacl -R -m u:bin:rwx $DIR/d125 || error "setfacl $DIR/d125 failed"
5615         ls -ld $DIR/d125 || error "cannot access $DIR/d125"
5616 }
5617 run_test 125 "don't return EPROTO when a dir has a non-default striping and ACLs"
5618
5619 test_126() { # bug 12829/13455
5620         [ -z "$(lctl get_param -n llite.*.client_type | grep local)" ] && skip "must run as local client" && return
5621         [ "$UID" != 0 ] && skip_env "skipping $TESTNAME (must run as root)" && return
5622         $GSS && skip "must run as gss disabled" && return
5623
5624         $RUNAS -u 0 -g 1 touch $DIR/$tfile || error "touch failed"
5625         gid=`ls -n $DIR/$tfile | awk '{print $4}'`
5626         rm -f $DIR/$tfile
5627         [ $gid -eq "1" ] || error "gid is set to" $gid "instead of 1"
5628 }
5629 run_test 126 "check that the fsgid provided by the client is taken into account"
5630
5631 test_127() { # bug 15521
5632         $SETSTRIPE -i 0 -c 1 $DIR/$tfile || error "setstripe failed"
5633         $LCTL set_param osc.*.stats=0
5634         FSIZE=$((2048 * 1024))
5635         dd if=/dev/zero of=$DIR/$tfile bs=$FSIZE count=1
5636         cancel_lru_locks osc
5637         dd if=$DIR/$tfile of=/dev/null bs=$FSIZE
5638
5639         $LCTL get_param osc.*0000-osc-*.stats | grep samples > $DIR/${tfile}.tmp
5640         while read NAME COUNT SAMP UNIT MIN MAX SUM SUMSQ; do
5641                 echo "got $COUNT $NAME"
5642                 [ ! $MIN ] && error "Missing min value for $NAME proc entry"
5643                 eval $NAME=$COUNT || error "Wrong proc format"
5644
5645                 case $NAME in
5646                         read_bytes|write_bytes)
5647                         [ $MIN -lt 4096 ] && error "min is too small: $MIN"
5648                         [ $MIN -gt $FSIZE ] && error "min is too big: $MIN"
5649                         [ $MAX -lt 4096 ] && error "max is too small: $MAX"
5650                         [ $MAX -gt $FSIZE ] && error "max is too big: $MAX"
5651                         [ $SUM -ne $FSIZE ] && error "sum is wrong: $SUM"
5652                         [ $SUMSQ -lt $(((FSIZE /4096) * (4096 * 4096))) ] &&
5653                                 error "sumsquare is too small: $SUMSQ"
5654                         [ $SUMSQ -gt $((FSIZE * FSIZE)) ] &&
5655                                 error "sumsquare is too big: $SUMSQ"
5656                         ;;
5657                         *) ;;
5658                 esac
5659         done < $DIR/${tfile}.tmp
5660
5661         #check that we actually got some stats
5662         [ "$read_bytes" ] || error "Missing read_bytes stats"
5663         [ "$write_bytes" ] || error "Missing write_bytes stats"
5664         [ "$read_bytes" != 0 ] || error "no read done"
5665         [ "$write_bytes" != 0 ] || error "no write done"
5666 }
5667 run_test 127 "verify the client stats are sane"
5668
5669 test_128() { # bug 15212
5670         touch $DIR/$tfile
5671         $LFS 2>&1 <<-EOF | tee $TMP/$tfile.log
5672                 find $DIR/$tfile
5673                 find $DIR/$tfile
5674         EOF
5675
5676         result=$(grep error $TMP/$tfile.log)
5677         rm -f $DIR/$tfile
5678         [ -z "$result" ] || error "consecutive find's under interactive lfs failed"
5679 }
5680 run_test 128 "interactive lfs for 2 consecutive find's"
5681
5682 set_dir_limits () {
5683         local mntdev
5684         local node
5685
5686         local LDPROC=/proc/fs/ldiskfs
5687
5688         for node in $(mdts_nodes); do
5689                 devs=$(do_node $node "lctl get_param -n devices" | awk '($3 ~ "mdt" && $4 ~ "MDT") { print $4 }')
5690                 for dev in $devs; do
5691                         mntdev=$(do_node $node "lctl get_param -n osd.$dev.mntdev")
5692                         do_node $node "echo $1 >$LDPROC/\\\$(basename $mntdev)/max_dir_size"
5693                 done
5694         done
5695 }
5696 test_129() {
5697         [ "$FSTYPE" != "ldiskfs" ] && skip "not needed for FSTYPE=$FSTYPE" && return 0
5698         remote_mds_nodsh && skip "remote MDS with nodsh" && return
5699
5700         EFBIG=27
5701         MAX=16384
5702
5703         set_dir_limits $MAX
5704
5705         mkdir -p $DIR/$tdir
5706
5707         I=0
5708         J=0
5709         while [ ! $I -gt $((MAX * MDSCOUNT)) ]; do
5710                 multiop $DIR/$tdir/$J Oc
5711                 rc=$?
5712                 if [ $rc -eq $EFBIG ]; then
5713                         set_dir_limits 0
5714                         echo "return code $rc received as expected"
5715                         return 0
5716                 elif [ $rc -ne 0 ]; then
5717                         set_dir_limits 0
5718                         error_exit "return code $rc received instead of expected $EFBIG"
5719                 fi
5720                 J=$((J+1))
5721                 I=$(stat -c%s "$DIR/$tdir")
5722         done
5723
5724         error "exceeded dir size limit $MAX x $MDSCOUNT $((MAX * MDSCOUNT)) : $I bytes"
5725         do_facet $SINGLEMDS "echo 0 >$LDPROC"
5726 }
5727 run_test 129 "test directory size limit ========================"
5728
5729 OLDIFS="$IFS"
5730 cleanup_130() {
5731         trap 0
5732         IFS="$OLDIFS"
5733 }
5734
5735 test_130a() {
5736         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
5737         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
5738
5739         trap cleanup_130 EXIT RETURN
5740
5741         local fm_file=$DIR/$tfile
5742         lfs setstripe -s 65536 -c 1 $fm_file || error "setstripe failed on $fm_file"
5743         dd if=/dev/zero of=$fm_file bs=65536 count=1 || error "dd failed for $fm_file"
5744
5745         filefrag -ves $fm_file || error "filefrag $fm_file failed"
5746         filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" | grep -v "ext:" | grep -v "found"`
5747
5748         lun=`$GETSTRIPE $fm_file  | grep -A 10 obdidx | awk '{print $1}' | grep -v "obdidx"`
5749
5750         start_blk=`echo $filefrag_op | cut -d: -f2 | cut -d. -f1`
5751         IFS=$'\n'
5752         tot_len=0
5753         for line in $filefrag_op
5754         do
5755                 frag_lun=`echo $line | cut -d: -f5`
5756                 ext_len=`echo $line | cut -d: -f4`
5757                 if (( $frag_lun != $lun )); then
5758                         cleanup_130
5759                         error "FIEMAP on 1-stripe file($fm_file) failed"
5760                         return
5761                 fi
5762                 (( tot_len += ext_len ))
5763         done
5764
5765         if (( lun != frag_lun || start_blk != 0 || tot_len != 64 )); then
5766                 cleanup_130
5767                 error "FIEMAP on 1-stripe file($fm_file) failed;"
5768                 return
5769         fi
5770
5771         cleanup_130
5772
5773         echo "FIEMAP on single striped file succeeded"
5774 }
5775 run_test 130a "FIEMAP (1-stripe file)"
5776
5777 test_130b() {
5778         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping FIEMAP on 2-stripe file test" && return
5779
5780         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
5781         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
5782
5783         trap cleanup_130 EXIT RETURN
5784
5785         local fm_file=$DIR/$tfile
5786         lfs setstripe -s 65536 -c 2 $fm_file || error "setstripe failed on $fm_file"
5787         dd if=/dev/zero of=$fm_file bs=1M count=2 || error "dd failed on $fm_file"
5788
5789         filefrag -ves $fm_file || error "filefrag $fm_file failed"
5790         filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" | grep -v "ext:" | grep -v "found"`
5791
5792         last_lun=`echo $filefrag_op | cut -d: -f5`
5793
5794         IFS=$'\n'
5795         tot_len=0
5796         num_luns=1
5797         for line in $filefrag_op
5798         do
5799                 frag_lun=`echo $line | cut -d: -f5`
5800                 ext_len=`echo $line | cut -d: -f4`
5801                 if (( $frag_lun != $last_lun )); then
5802                         if (( tot_len != 1024 )); then
5803                                 cleanup_130
5804                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of 256"
5805                                 return
5806                         else
5807                                 (( num_luns += 1 ))
5808                                 tot_len=0
5809                         fi
5810                 fi
5811                 (( tot_len += ext_len ))
5812                 last_lun=$frag_lun
5813         done
5814         if (( num_luns != 2 || tot_len != 1024 )); then
5815                 cleanup_130
5816                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
5817                 return
5818         fi
5819
5820         cleanup_130
5821
5822         echo "FIEMAP on 2-stripe file succeeded"
5823 }
5824 run_test 130b "FIEMAP (2-stripe file)"
5825
5826 test_130c() {
5827         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping FIEMAP on 2-stripe file with hole test" && return
5828
5829         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
5830         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
5831
5832         trap cleanup_130 EXIT RETURN
5833
5834         local fm_file=$DIR/$tfile
5835         lfs setstripe -s 65536 -c 2 $fm_file || error "setstripe failed on $fm_file"
5836         dd if=/dev/zero of=$fm_file seek=1 bs=1M count=1 || error "dd failed on $fm_file"
5837
5838         filefrag -ves $fm_file || error "filefrag $fm_file failed"
5839         filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" | grep -v "ext:" | grep -v "found"`
5840
5841         last_lun=`echo $filefrag_op | cut -d: -f5`
5842
5843         IFS=$'\n'
5844         tot_len=0
5845         num_luns=1
5846         for line in $filefrag_op
5847         do
5848                 frag_lun=`echo $line | cut -d: -f5`
5849                 ext_len=`echo $line | cut -d: -f4`
5850                 if (( $frag_lun != $last_lun )); then
5851                         logical=`echo $line | cut -d: -f2 | cut -d. -f1`
5852                         if (( logical != 512 )); then
5853                                 cleanup_130
5854                                 error "FIEMAP on $fm_file failed; returned logical start for lun $logical instead of 512"
5855                                 return
5856                         fi
5857                         if (( tot_len != 512 )); then
5858                                 cleanup_130
5859                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of 1024"
5860                                 return
5861                         else
5862                                 (( num_luns += 1 ))
5863                                 tot_len=0
5864                         fi
5865                 fi
5866                 (( tot_len += ext_len ))
5867                 last_lun=$frag_lun
5868         done
5869         if (( num_luns != 2 || tot_len != 512 )); then
5870                 cleanup_130
5871                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
5872                 return
5873         fi
5874
5875         cleanup_130
5876
5877         echo "FIEMAP on 2-stripe file with hole succeeded"
5878 }
5879 run_test 130c "FIEMAP (2-stripe file with hole)"
5880
5881 test_130d() {
5882         [ "$OSTCOUNT" -lt "3" ] && skip_env "skipping FIEMAP on N-stripe file test" && return
5883
5884         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
5885         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
5886
5887         trap cleanup_130 EXIT RETURN
5888
5889         local fm_file=$DIR/$tfile
5890         lfs setstripe -s 65536 -c $OSTCOUNT $fm_file || error "setstripe failed on $fm_file"
5891         dd if=/dev/zero of=$fm_file bs=1M count=$OSTCOUNT || error "dd failed on $fm_file"
5892
5893         filefrag -ves $fm_file || error "filefrag $fm_file failed"
5894         filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" | grep -v "ext:" | grep -v "found"`
5895
5896         last_lun=`echo $filefrag_op | cut -d: -f5`
5897
5898         IFS=$'\n'
5899         tot_len=0
5900         num_luns=1
5901         for line in $filefrag_op
5902         do
5903                 frag_lun=`echo $line | cut -d: -f5`
5904                 ext_len=`echo $line | cut -d: -f4`
5905                 if (( $frag_lun != $last_lun )); then
5906                         if (( tot_len != 1024 )); then
5907                                 cleanup_130
5908                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of 1024"
5909                                 return
5910                         else
5911                                 (( num_luns += 1 ))
5912                                 tot_len=0
5913                         fi
5914                 fi
5915                 (( tot_len += ext_len ))
5916                 last_lun=$frag_lun
5917         done
5918         if (( num_luns != OSTCOUNT || tot_len != 1024 )); then
5919                 cleanup_130
5920                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
5921                 return
5922         fi
5923
5924         cleanup_130
5925
5926         echo "FIEMAP on N-stripe file succeeded"
5927 }
5928 run_test 130d "FIEMAP (N-stripe file)"
5929
5930 test_130e() {
5931         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping continuation FIEMAP test" && return
5932
5933         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
5934         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
5935
5936         trap cleanup_130 EXIT RETURN
5937
5938         local fm_file=$DIR/$tfile
5939         lfs setstripe -s 131072 -c 2 $fm_file || error "setstripe failed on $fm_file"
5940         NUM_BLKS=512
5941         EXPECTED_LEN=$(( (NUM_BLKS / 2) * 64 ))
5942         for ((i = 0; i < $NUM_BLKS; i++))
5943         do
5944                 dd if=/dev/zero of=$fm_file count=1 bs=64k seek=$((2*$i)) conv=notrunc > /dev/null 2>&1
5945         done
5946
5947         filefrag -ves $fm_file || error "filefrag $fm_file failed"
5948         filefrag_op=`filefrag -ve $fm_file | grep -A 12000 "ext:" | grep -v "ext:" | grep -v "found"`
5949
5950         last_lun=`echo $filefrag_op | cut -d: -f5`
5951
5952         IFS=$'\n'
5953         tot_len=0
5954         num_luns=1
5955         for line in $filefrag_op
5956         do
5957                 frag_lun=`echo $line | cut -d: -f5`
5958                 ext_len=`echo $line | cut -d: -f4`
5959                 if (( $frag_lun != $last_lun )); then
5960                         if (( tot_len != $EXPECTED_LEN )); then
5961                                 cleanup_130
5962                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of $EXPECTED_LEN"
5963                                 return
5964                         else
5965                                 (( num_luns += 1 ))
5966                                 tot_len=0
5967                         fi
5968                 fi
5969                 (( tot_len += ext_len ))
5970                 last_lun=$frag_lun
5971         done
5972         if (( num_luns != 2 || tot_len != $EXPECTED_LEN )); then
5973                 cleanup_130
5974                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
5975                 return
5976         fi
5977
5978         cleanup_130
5979
5980         echo "FIEMAP with continuation calls succeeded"
5981 }
5982 run_test 130e "FIEMAP (test continuation FIEMAP calls)"
5983
5984 # Test for writev/readv
5985 test_131a() {
5986         rwv -f $DIR/$tfile -w -n 3 524288 1048576 1572864 || \
5987         error "writev test failed"
5988         rwv -f $DIR/$tfile -r -v -n 2 1572864 1048576 || \
5989         error "readv failed"
5990         rm -f $DIR/$tfile
5991 }
5992 run_test 131a "test iov's crossing stripe boundary for writev/readv"
5993
5994 test_131b() {
5995         rwv -f $DIR/$tfile -w -a -n 3 524288 1048576 1572864 || \
5996         error "append writev test failed"
5997         rwv -f $DIR/$tfile -w -a -n 2 1572864 1048576 || \
5998         error "append writev test failed"
5999         rm -f $DIR/$tfile
6000 }
6001 run_test 131b "test append writev"
6002
6003 test_131c() {
6004         rwv -f $DIR/$tfile -w -d -n 1 1048576 || return 0
6005         error "NOT PASS"
6006 }
6007 run_test 131c "test read/write on file w/o objects"
6008
6009 test_131d() {
6010         rwv -f $DIR/$tfile -w -n 1 1572864
6011         NOB=`rwv -f $DIR/$tfile -r -n 3 524288 524288 1048576 | awk '/error/ {print $6}'`
6012         if [ "$NOB" != 1572864 ]; then
6013                 error "Short read filed: read $NOB bytes instead of 1572864"
6014         fi
6015         rm -f $DIR/$tfile
6016 }
6017 run_test 131d "test short read"
6018
6019 test_131e() {
6020         rwv -f $DIR/$tfile -w -s 1048576 -n 1 1048576
6021         rwv -f $DIR/$tfile -r -z -s 0 -n 1 524288 || \
6022         error "read hitting hole failed"
6023         rm -f $DIR/$tfile
6024 }
6025 run_test 131e "test read hitting hole"
6026
6027 get_ost_param() {
6028         local token=$1
6029         local gl_sum=0
6030         for node in $(osts_nodes); do
6031                 gl=$(do_node $node "$LCTL get_param -n ost.OSS.ost.stats" | awk '/'$token'/ {print $2}' | head -n 1)
6032                 [ x$gl = x"" ] && gl=0
6033                 gl_sum=$((gl_sum + gl))
6034         done
6035         echo $gl
6036 }
6037
6038 som_mode_switch() {
6039         local som=$1
6040         local gl1=$2
6041         local gl2=$3
6042
6043         if [ x$som = x"enabled" ]; then
6044                 [ $((gl2 - gl1)) -gt 0 ] && error "no glimpse RPC is expected"
6045                 do_facet mgs "$LCTL conf_param $FSNAME.mdt.som=disabled"
6046         else
6047                 [ $((gl2 - gl1)) -gt 0 ] || error "some glimpse RPC is expected"
6048                 do_facet mgs "$LCTL conf_param $FSNAME.mdt.som=enabled"
6049         fi
6050
6051         # do remount to make new mount-conf parameters actual
6052         echo remounting...
6053         sync
6054         stopall
6055         setupall
6056 }
6057
6058 test_132() { #1028, SOM
6059         local num=$(get_mds_dir $DIR)
6060         local mymds=mds${num}
6061
6062         dd if=/dev/zero of=$DIR/$tfile count=1 2>/dev/null
6063         cancel_lru_locks osc
6064
6065         som1=$(do_facet $mymds "$LCTL get_param mdt.*.som" |  awk -F= ' {print $2}' | head -n 1)
6066
6067         gl1=$(get_ost_param "ldlm_glimpse_enqueue")
6068         stat $DIR/$tfile >/dev/null
6069         gl2=$(get_ost_param "ldlm_glimpse_enqueue")
6070         echo "====> SOM is "$som1", "$((gl2 - gl1))" glimpse RPC occured"
6071         rm $DIR/$tfile
6072         som_mode_switch $som1 $gl1 $gl2
6073
6074         dd if=/dev/zero of=$DIR/$tfile count=1 2>/dev/null
6075         cancel_lru_locks osc
6076
6077         som2=$(do_facet $mymds "$LCTL get_param mdt.*.som" |  awk -F= ' {print $2}' | head -n 1)
6078         if [ $som1 == $som2 ]; then
6079             error "som is still "$som2
6080             if [ x$som2 = x"enabled" ]; then
6081                 som2="disabled"
6082             else
6083                 som2="enabled"
6084             fi
6085         fi
6086
6087         gl1=$(get_ost_param "ldlm_glimpse_enqueue")
6088         stat $DIR/$tfile >/dev/null
6089         gl2=$(get_ost_param "ldlm_glimpse_enqueue")
6090         echo "SOM is "$som2", "$((gl2 - gl1))" glimpse RPC occured"
6091         som_mode_switch $som2 $gl1 $gl2
6092 }
6093 run_test 132 "som avoids glimpse rpc"
6094
6095 test_140() { #bug-17379
6096         mkdir -p $DIR/$tdir || error "Creating dir $DIR/$tdir"
6097         cd $DIR/$tdir || error "Changing to $DIR/$tdir"
6098         cp /usr/bin/stat . || error "Copying stat to $DIR/$tdir"
6099
6100         # VFS limits max symlink depth to 5(4KSTACK) or 7(8KSTACK) or 8
6101         local i=0
6102         while i=`expr $i + 1`; do
6103                 mkdir -p $i || error "Creating dir $i"
6104                 cd $i || error "Changing to $i"
6105                 ln -s ../stat stat || error "Creating stat symlink"
6106                 # Read the symlink until ELOOP present,
6107                 # not LBUGing the system is considered success,
6108                 # we didn't overrun the stack.
6109                 $OPENFILE -f O_RDONLY stat >/dev/null 2>&1; ret=$?
6110                 [ $ret -ne 0 ] && {
6111                         if [ $ret -eq 40 ]; then
6112                                 break  # -ELOOP
6113                         else
6114                                 error "Open stat symlink"
6115                                 return
6116                         fi
6117                 }
6118         done
6119         i=`expr $i - 1`
6120         echo "The symlink depth = $i"
6121         [ $i -eq 5 -o $i -eq 7 -o $i -eq 8 ] || error "Invalid symlink depth"
6122 }
6123 run_test 140 "Check reasonable stack depth (shouldn't LBUG) ===="
6124
6125 test_150() {
6126         local TF="$TMP/$tfile"
6127
6128         dd if=/dev/urandom of=$TF bs=6096 count=1 || error "dd failed"
6129         cp $TF $DIR/$tfile
6130         cancel_lru_locks osc
6131         cmp $TF $DIR/$tfile || error "$TMP/$tfile $DIR/$tfile differ"
6132         remount_client $MOUNT
6133         df -P $MOUNT
6134         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (remount)"
6135
6136         $TRUNCATE $TF 6000
6137         $TRUNCATE $DIR/$tfile 6000
6138         cancel_lru_locks osc
6139         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (truncate1)"
6140
6141         echo "12345" >>$TF
6142         echo "12345" >>$DIR/$tfile
6143         cancel_lru_locks osc
6144         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (append1)"
6145
6146         echo "12345" >>$TF
6147         echo "12345" >>$DIR/$tfile
6148         cancel_lru_locks osc
6149         cmp $TF $DIR/$tfile || error "$TF $DIR/$tfile differ (append2)"
6150
6151         rm -f $TF
6152         true
6153 }
6154 run_test 150 "truncate/append tests"
6155
6156 function roc_hit() {
6157     local list=$(comma_list $(osts_nodes))
6158
6159     ACCNUM=$(do_nodes $list $LCTL get_param -n obdfilter.*.stats | \
6160         awk '/'cache_hit'/ {sum+=$2} END {print sum}')
6161     echo $ACCNUM
6162 }
6163
6164 function set_cache() {
6165     local on=1
6166
6167     if [ "$2" == "off" ]; then
6168         on=0;
6169     fi
6170     local list=$(comma_list $(osts_nodes))
6171     do_nodes $list lctl set_param obdfilter.*.${1}_cache_enable $on
6172
6173     cancel_lru_locks osc
6174 }
6175
6176 test_151() {
6177         remote_ost_nodsh && skip "remote OST with nodsh" && return
6178
6179         local CPAGES=3
6180         local list=$(comma_list $(osts_nodes))
6181
6182         # check whether obdfilter is cache capable at all
6183         if ! do_nodes $list $LCTL get_param -n obdfilter.*.read_cache_enable > /dev/null; then
6184                 echo "not cache-capable obdfilter"
6185                 return 0
6186         fi
6187
6188         # check cache is enabled on all obdfilters
6189         if do_nodes $list $LCTL get_param -n obdfilter.*.read_cache_enable | grep 0 >&/dev/null; then
6190                 echo "oss cache is disabled"
6191                 return 0
6192         fi
6193
6194         do_nodes $list $LCTL set_param -n obdfilter.*.writethrough_cache_enable 1
6195
6196         # pages should be in the case right after write
6197         dd if=/dev/urandom of=$DIR/$tfile bs=4k count=$CPAGES || error "dd failed"
6198         local BEFORE=`roc_hit`
6199         cancel_lru_locks osc
6200         cat $DIR/$tfile >/dev/null
6201         local AFTER=`roc_hit`
6202         if ! let "AFTER - BEFORE == CPAGES"; then
6203                 error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
6204         fi
6205
6206         # the following read invalidates the cache
6207         cancel_lru_locks osc
6208         do_nodes $list $LCTL set_param -n obdfilter.*.read_cache_enable 0
6209         cat $DIR/$tfile >/dev/null
6210
6211         # now data shouldn't be found in the cache
6212         BEFORE=`roc_hit`
6213         cancel_lru_locks osc
6214         cat $DIR/$tfile >/dev/null
6215         AFTER=`roc_hit`
6216         if let "AFTER - BEFORE != 0"; then
6217                 error "IN CACHE: before: $BEFORE, after: $AFTER"
6218         fi
6219
6220         do_nodes $list $LCTL set_param -n obdfilter.*.read_cache_enable 1
6221         rm -f $DIR/$tfile
6222 }
6223 run_test 151 "test cache on oss and controls ==============================="
6224
6225 test_152() {
6226         local TF="$TMP/$tfile"
6227
6228         # simulate ENOMEM during write
6229 #define OBD_FAIL_OST_NOMEM      0x226
6230         lctl set_param fail_loc=0x80000226
6231         dd if=/dev/urandom of=$TF bs=6096 count=1 || error "dd failed"
6232         cp $TF $DIR/$tfile
6233         sync || error "sync failed"
6234         lctl set_param fail_loc=0
6235
6236         # discard client's cache
6237         cancel_lru_locks osc
6238
6239         # simulate ENOMEM during read
6240         lctl set_param fail_loc=0x80000226
6241         cmp $TF $DIR/$tfile || error "cmp failed"
6242         lctl set_param fail_loc=0
6243
6244         rm -f $TF
6245 }
6246 run_test 152 "test read/write with enomem ============================"
6247
6248 test_153() {
6249         multiop $DIR/$tfile Ow4096Ycu || error "multiop failed"
6250 }
6251 run_test 153 "test if fdatasync does not crash ======================="
6252
6253 test_154() {
6254         cp /etc/hosts $DIR/$tfile
6255
6256         fid=$($LFS path2fid $DIR/$tfile)
6257         rc=$?
6258         [ $rc -ne 0 ] && error "error: could not get fid for $DIR/$tfile."
6259
6260         echo "open fid $fid"
6261         diff /etc/hosts $DIR/.lustre/fid/$fid || error "open by fid failed: did not find expected data in file."
6262
6263         echo "Opening a file by FID succeeded"
6264 }
6265 run_test 154 "Opening a file by FID"
6266
6267 test_155_load() {
6268     local temp=$TMP/$tfile
6269     local file=$DIR/$tfile
6270     local list=$(comma_list $(osts_nodes))
6271     local big=$(do_nodes $list grep "cache" /proc/cpuinfo | \
6272         awk '{sum+=$4} END{print sum}')
6273
6274     log big is $big K
6275
6276     dd if=/dev/urandom of=$temp bs=6096 count=1 || \
6277         error "dd of=$temp bs=6096 count=1 failed"
6278     cp $temp $file
6279     cancel_lru_locks osc
6280     cmp $temp $file || error "$temp $file differ"
6281
6282     $TRUNCATE $temp 6000
6283     $TRUNCATE $file 6000
6284     cmp $temp $file || error "$temp $file differ (truncate1)"
6285
6286     echo "12345" >>$temp
6287     echo "12345" >>$file
6288     cmp $temp $file || error "$temp $file differ (append1)"
6289
6290     echo "12345" >>$temp
6291     echo "12345" >>$file
6292     cmp $temp $file || error "$temp $file differ (append2)"
6293
6294     dd if=/dev/urandom of=$temp bs=$((big*2)) count=1k || \
6295         error "dd of=$temp bs=$((big*2)) count=1k failed"
6296     cp $temp $file
6297     ls -lh $temp $file
6298     cancel_lru_locks osc
6299     cmp $temp $file || error "$temp $file differ"
6300
6301     rm -f $temp
6302     true
6303 }
6304
6305 test_155a() {
6306     set_cache read on
6307     set_cache writethrough on
6308     test_155_load
6309 }
6310 run_test 155a "Verification of correctness: read cache:on write_cache:on"
6311
6312 test_155b() {
6313     set_cache read on
6314     set_cache writethrough off
6315     test_155_load
6316 }
6317 run_test 155b "Verification of correctness: read cache:on write_cache:off"
6318
6319 test_155c() {
6320     set_cache read off
6321     set_cache writethrough on
6322     test_155_load
6323 }
6324 run_test 155c "Verification of correctness: read cache:off write_cache:on"
6325
6326 test_155d() {
6327     set_cache read off
6328     set_cache writethrough off
6329     test_155_load
6330 }
6331 run_test 155d "Verification of correctness: read cache:off write_cache:off "
6332
6333 test_156() {
6334     local CPAGES=3
6335     local BEFORE
6336     local AFTER
6337     local file="$DIR/$tfile"
6338
6339     log "Turn on read and write cache"
6340     set_cache read on
6341     set_cache writethrough on
6342
6343     log "Write data and read it back."
6344     log "Read should be satisfied from the cache."
6345     dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
6346     BEFORE=`roc_hit`
6347     cancel_lru_locks osc
6348     cat $file >/dev/null
6349     AFTER=`roc_hit`
6350     if ! let "AFTER - BEFORE == CPAGES"; then
6351         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
6352     else
6353         log "cache hits:: before: $BEFORE, after: $AFTER"
6354     fi
6355
6356     log "Read again; it should be satisfied from the cache."
6357     BEFORE=$AFTER
6358     cancel_lru_locks osc
6359     cat $file >/dev/null
6360     AFTER=`roc_hit`
6361     if ! let "AFTER - BEFORE == CPAGES"; then
6362         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
6363     else
6364         log "cache hits:: before: $BEFORE, after: $AFTER"
6365     fi
6366
6367
6368     log "Turn off the read cache and turn on the write cache"
6369     set_cache read off
6370     set_cache writethrough on
6371
6372     log "Read again; it should be satisfied from the cache."
6373     BEFORE=`roc_hit`
6374     cancel_lru_locks osc
6375     cat $file >/dev/null
6376     AFTER=`roc_hit`
6377     if ! let "AFTER - BEFORE == CPAGES"; then
6378         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
6379     else
6380         log "cache hits:: before: $BEFORE, after: $AFTER"
6381     fi
6382
6383     log "Read again; it should not be satisfied from the cache."
6384     BEFORE=$AFTER
6385     cancel_lru_locks osc
6386     cat $file >/dev/null
6387     AFTER=`roc_hit`
6388     if ! let "AFTER - BEFORE == 0"; then
6389         error "IN CACHE: before: $BEFORE, after: $AFTER"
6390     else
6391         log "cache hits:: before: $BEFORE, after: $AFTER"
6392     fi
6393
6394     log "Write data and read it back."
6395     log "Read should be satisfied from the cache."
6396     dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
6397     BEFORE=`roc_hit`
6398     cancel_lru_locks osc
6399     cat $file >/dev/null
6400     AFTER=`roc_hit`
6401     if ! let "AFTER - BEFORE == CPAGES"; then
6402         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
6403     else
6404         log "cache hits:: before: $BEFORE, after: $AFTER"
6405     fi
6406
6407     log "Read again; it should not be satisfied from the cache."
6408     BEFORE=$AFTER
6409     cancel_lru_locks osc
6410     cat $file >/dev/null
6411     AFTER=`roc_hit`
6412     if ! let "AFTER - BEFORE == 0"; then
6413         error "IN CACHE: before: $BEFORE, after: $AFTER"
6414     else
6415         log "cache hits:: before: $BEFORE, after: $AFTER"
6416     fi
6417
6418
6419     log "Turn off read and write cache"
6420     set_cache read off
6421     set_cache writethrough off
6422
6423     log "Write data and read it back"
6424     log "It should not be satisfied from the cache."
6425     rm -f $file
6426     dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
6427     cancel_lru_locks osc
6428     BEFORE=`roc_hit`
6429     cat $file >/dev/null
6430     AFTER=`roc_hit`
6431     if ! let "AFTER - BEFORE == 0"; then
6432         error_ignore 20762 "IN CACHE: before: $BEFORE, after: $AFTER"
6433     else
6434         log "cache hits:: before: $BEFORE, after: $AFTER"
6435     fi
6436
6437
6438     log "Turn on the read cache and turn off the write cache"
6439     set_cache read on
6440     set_cache writethrough off
6441
6442     log "Write data and read it back"
6443     log "It should not be satisfied from the cache."
6444     rm -f $file
6445     dd if=/dev/urandom of=$file bs=4k count=$CPAGES || error "dd failed"
6446     BEFORE=`roc_hit`
6447     cancel_lru_locks osc
6448     cat $file >/dev/null
6449     AFTER=`roc_hit`
6450     if ! let "AFTER - BEFORE == 0"; then
6451         error_ignore 20762 "IN CACHE: before: $BEFORE, after: $AFTER"
6452     else
6453         log "cache hits:: before: $BEFORE, after: $AFTER"
6454     fi
6455
6456     log "Read again; it should be satisfied from the cache."
6457     BEFORE=`roc_hit`
6458     cancel_lru_locks osc
6459     cat $file >/dev/null
6460     AFTER=`roc_hit`
6461     if ! let "AFTER - BEFORE == CPAGES"; then
6462         error "NOT IN CACHE: before: $BEFORE, after: $AFTER"
6463     else
6464         log "cache hits:: before: $BEFORE, after: $AFTER"
6465     fi
6466
6467     rm -f $file
6468 }
6469 run_test 156 "Verification of tunables ============================"
6470
6471 #Changelogs
6472 err17935 () {
6473     if [ $MDSCOUNT -gt 1 ]; then
6474         error_ignore 17935 $*
6475     else
6476         error $*
6477     fi
6478 }
6479 test_160() {
6480     USER=$(do_facet $SINGLEMDS lctl --device $MDT0 changelog_register -n)
6481     echo "Registered as changelog user $USER"
6482     do_facet $SINGLEMDS lctl get_param -n mdd.$MDT0.changelog_users | \
6483         grep -q $USER || error "User $USER not found in changelog_users"
6484
6485     # change something
6486     mkdir -p $DIR/$tdir/pics/2008/zachy
6487     touch $DIR/$tdir/pics/2008/zachy/timestamp
6488     cp /etc/hosts $DIR/$tdir/pics/2008/zachy/pic1.jpg
6489     mv $DIR/$tdir/pics/2008/zachy $DIR/$tdir/pics/zach
6490     ln $DIR/$tdir/pics/zach/pic1.jpg $DIR/$tdir/pics/2008/portland.jpg
6491     ln -s $DIR/$tdir/pics/2008/portland.jpg $DIR/$tdir/pics/desktop.jpg
6492     rm $DIR/$tdir/pics/desktop.jpg
6493
6494     $LFS changelog $MDT0 | tail -5
6495
6496     echo "verifying changelog mask"
6497     do_facet $SINGLEMDS lctl set_param mdd.$MDT0.changelog_mask="-mkdir"
6498     mkdir -p $DIR/$tdir/pics/2009/sofia
6499     do_facet $SINGLEMDS lctl set_param mdd.$MDT0.changelog_mask="+mkdir"
6500     mkdir $DIR/$tdir/pics/2009/zachary
6501     DIRS=$($LFS changelog $MDT0 | tail -5 | grep -c MKDIR)
6502     [ $DIRS -eq 1 ] || err17935 "changelog mask count $DIRS != 1"
6503
6504     # verify contents
6505     echo "verifying target fid"
6506     fidc=$($LFS changelog $MDT0 | grep timestamp | grep "CREAT" | \
6507         tail -1 | awk '{print $6}')
6508     fidf=$($LFS path2fid $DIR/$tdir/pics/zach/timestamp)
6509     [ "$fidc" == "t=$fidf" ] || \
6510         err17935 "fid in changelog $fidc != file fid $fidf"
6511     echo "verifying parent fid"
6512     fidc=$($LFS changelog $MDT0 | grep timestamp | grep "CREAT" | \
6513         tail -1 | awk '{print $7}')
6514     fidf=$($LFS path2fid $DIR/$tdir/pics/zach)
6515     [ "$fidc" == "p=$fidf" ] || \
6516         err17935 "pfid in changelog $fidc != dir fid $fidf"
6517
6518     USER_REC1=$(do_facet $SINGLEMDS lctl get_param -n \
6519         mdd.$MDT0.changelog_users | grep $USER | awk '{print $2}')
6520     $LFS changelog_clear $MDT0 $USER $(($USER_REC1 + 5))
6521     USER_REC2=$(do_facet $SINGLEMDS lctl get_param -n \
6522         mdd.$MDT0.changelog_users | grep $USER | awk '{print $2}')
6523     echo "verifying user clear: $(( $USER_REC1 + 5 )) == $USER_REC2"
6524     [ $USER_REC2 == $(($USER_REC1 + 5)) ] || \
6525         err17935 "user index should be $(($USER_REC1 + 5)); is $USER_REC2"
6526
6527     MIN_REC=$(do_facet $SINGLEMDS lctl get_param mdd.$MDT0.changelog_users | \
6528         awk 'min == "" || $2 < min {min = $2}; END {print min}')
6529     FIRST_REC=$($LFS changelog $MDT0 | head -1 | awk '{print $1}')
6530     echo "verifying min purge: $(( $MIN_REC + 1 )) == $FIRST_REC"
6531     [ $FIRST_REC == $(($MIN_REC + 1)) ] || \
6532         err17935 "first index should be $(($MIN_REC + 1)); is $FIRST_REC"
6533
6534     echo "verifying user deregister"
6535     do_facet $SINGLEMDS lctl --device $MDT0 changelog_deregister $USER
6536     do_facet $SINGLEMDS lctl get_param -n mdd.$MDT0.changelog_users | \
6537         grep -q $USER && error "User $USER still found in changelog_users"
6538
6539     USERS=$(( $(do_facet $SINGLEMDS lctl get_param -n \
6540         mdd.$MDT0.changelog_users | wc -l) - 2 ))
6541     if [ $USERS -eq 0 ]; then
6542         LAST_REC1=$(do_facet $SINGLEMDS lctl get_param -n \
6543             mdd.$MDT0.changelog_users | head -1 | awk '{print $3}')
6544         touch $DIR/$tdir/chloe
6545         LAST_REC2=$(do_facet $SINGLEMDS lctl get_param -n \
6546             mdd.$MDT0.changelog_users | head -1 | awk '{print $3}')
6547         echo "verify changelogs are off if we were the only user: $LAST_REC1 == $LAST_REC2"
6548         [ $LAST_REC1 == $LAST_REC2 ] || error "changelogs not off"
6549     else
6550         echo "$USERS other changelog users; can't verify off"
6551     fi
6552 }
6553 run_test 160 "changelog sanity"
6554
6555 test_161() {
6556     mkdir -p $DIR/$tdir
6557     cp /etc/hosts $DIR/$tdir/$tfile
6558     mkdir $DIR/$tdir/foo1
6559     mkdir $DIR/$tdir/foo2
6560     ln $DIR/$tdir/$tfile $DIR/$tdir/foo1/sofia
6561     ln $DIR/$tdir/$tfile $DIR/$tdir/foo2/zachary
6562     ln $DIR/$tdir/$tfile $DIR/$tdir/foo1/luna
6563     ln $DIR/$tdir/$tfile $DIR/$tdir/foo2/thor
6564     local FID=$($LFS path2fid $DIR/$tdir/$tfile | tr -d '[')
6565     if [ "$($LFS fid2path $DIR $FID | wc -l)" != "5" ]; then
6566         $LFS fid2path $DIR $FID
6567         err17935 "bad link ea"
6568     fi
6569     # middle
6570     rm $DIR/$tdir/foo2/zachary
6571     # last
6572     rm $DIR/$tdir/foo2/thor
6573     # first
6574     rm $DIR/$tdir/$tfile
6575     # rename
6576     mv $DIR/$tdir/foo1/sofia $DIR/$tdir/foo2/maggie
6577     if [ "$($LFS fid2path $DIR --link 1 $FID)" != "/$tdir/foo2/maggie" ]
6578         then
6579         $LFS fid2path $DIR $FID
6580         err17935 "bad link rename"
6581     fi
6582     rm $DIR/$tdir/foo2/maggie
6583
6584     # overflow the EA
6585     local longname=filename_avg_len_is_thirty_two_
6586     createmany -l$DIR/$tdir/foo1/luna $DIR/$tdir/foo2/$longname 1000 || \
6587         error "failed to hardlink many files"
6588     links=$($LFS fid2path $DIR $FID | wc -l)
6589     echo -n "${links}/1000 links in link EA"
6590     [ ${links} -gt 60 ] || err17935 "expected at least 60 links in link EA"
6591     unlinkmany $DIR/$tdir/foo2/$longname 1000 || \
6592         error "failed to unlink many hardlinks"
6593 }
6594 run_test 161 "link ea sanity"
6595
6596 check_path() {
6597     local expected=$1
6598     shift
6599     local fid=$2
6600
6601     local path=$(${LFS} fid2path $*)
6602     RC=$?
6603
6604     if [ $RC -ne 0 ]; then
6605         err17935 "path looked up of $expected failed. Error $RC"
6606         return $RC
6607     elif [ "${path}" != "${expected}" ]; then
6608         err17935 "path looked up \"${path}\" instead of \"${expected}\""
6609         return 2
6610     fi
6611     echo "fid $fid resolves to path $path"
6612 }
6613
6614 test_162() {
6615     # Make changes to filesystem
6616     mkdir -p $DIR/$tdir/d2
6617     touch $DIR/$tdir/d2/$tfile
6618     touch $DIR/$tdir/d2/x1
6619     touch $DIR/$tdir/d2/x2
6620     mkdir -p $DIR/$tdir/d2/a/b/c
6621     mkdir -p $DIR/$tdir/d2/p/q/r
6622         # regular file
6623     FID=$($LFS path2fid $DIR/$tdir/d2/$tfile | tr -d '[')
6624     check_path "/$tdir/d2/$tfile" $DIR $FID --link 0
6625
6626         # softlink
6627     ln -s $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/p/q/r/slink
6628     FID=$($LFS path2fid $DIR/$tdir/d2/p/q/r/slink | tr -d '[')
6629     check_path "/$tdir/d2/p/q/r/slink" $DIR $FID --link 0
6630
6631         # hardlink
6632     ln $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/p/q/r/hlink
6633     mv $DIR/$tdir/d2/$tfile $DIR/$tdir/d2/a/b/c/new_file
6634     FID=$($LFS path2fid $DIR/$tdir/d2/a/b/c/new_file | tr -d '[')
6635     # fid2path dir/fsname should both work
6636     check_path "/$tdir/d2/a/b/c/new_file" $FSNAME $FID --link 1
6637     check_path "/$tdir/d2/p/q/r/hlink" $DIR $FID --link 0
6638
6639     # hardlink count: check that there are 2 links
6640     # Doesnt work with CMD yet: 17935
6641         ${LFS} fid2path $DIR $FID | wc -l | grep -q 2 || \
6642                 err17935 "expected 2 links"
6643
6644         # hardlink indexing: remove the first link
6645     rm $DIR/$tdir/d2/p/q/r/hlink
6646     check_path "/$tdir/d2/a/b/c/new_file" $DIR $FID --link 0
6647
6648         return 0
6649 }
6650 run_test 162 "path lookup sanity"
6651
6652 test_163() {
6653         remote_mds_nodsh && skip "remote MDS with nodsh" && return
6654         copytool --test $FSNAME || { skip "copytool not runnable: $?" && return; }
6655         copytool $FSNAME &
6656         sleep 1
6657         local uuid=$($LCTL get_param -n mdc.${FSNAME}-MDT0000-mdc-*.uuid)
6658         # this proc file is temporary and linux-only
6659         do_facet mds lctl set_param mdt.${FSNAME}-MDT0000.mdccomm=$uuid ||\
6660          error "kernel->userspace send failed"
6661         kill -INT $!
6662 }
6663 run_test 163 "kernel <-> userspace comms"
6664
6665 test_169() {
6666         # do directio so as not to populate the page cache
6667         log "creating a 10 Mb file"
6668         multiop $DIR/$tfile oO_CREAT:O_DIRECT:O_RDWR:w$((10*1048576))c || error "multiop failed while creating a file"
6669         log "starting reads"
6670         dd if=$DIR/$tfile of=/dev/null bs=4096 &
6671         log "truncating the file"
6672         multiop $DIR/$tfile oO_TRUNC:c || error "multiop failed while truncating the file"
6673         log "killing dd"
6674         kill %+ || true # reads might have finished
6675         echo "wait until dd is finished"
6676         wait
6677         log "removing the temporary file"
6678         rm -rf $DIR/$tfile || error "tmp file removal failed"
6679 }
6680 run_test 169 "parallel read and truncate should not deadlock"
6681
6682 test_170() {
6683         $LCTL clear     # bug 18514
6684         $LCTL debug_daemon start $TMP/${tfile}_log_good
6685         touch $DIR/$tfile
6686         $LCTL debug_daemon stop
6687         sed -e "s/^...../a/g" $TMP/${tfile}_log_good > $TMP/${tfile}_log_bad ||
6688                error "sed failed to read log_good"
6689
6690         $LCTL debug_daemon start $TMP/${tfile}_log_good
6691         rm -rf $DIR/$tfile
6692         $LCTL debug_daemon stop
6693
6694         $LCTL df $TMP/${tfile}_log_bad > $TMP/${tfile}_log_bad.out 2>&1 ||
6695                error "lctl df log_bad failed"
6696
6697         local bad_line=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $9}')
6698         local good_line1=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $5}')
6699
6700         $LCTL df $TMP/${tfile}_log_good > $TMP/${tfile}_log_good.out 2>&1
6701         local good_line2=$(tail -n 1 $TMP/${tfile}_log_good.out | awk '{print $5}')
6702
6703         [ "$bad_line" ] && [ "$good_line1" ] && [ "$good_line2" ] ||
6704                 error "bad_line good_line1 good_line2 are empty"
6705
6706         cat $TMP/${tfile}_log_good >> $TMP/${tfile}_logs_corrupt
6707         cat $TMP/${tfile}_log_bad >> $TMP/${tfile}_logs_corrupt
6708         cat $TMP/${tfile}_log_good >> $TMP/${tfile}_logs_corrupt
6709
6710         $LCTL df $TMP/${tfile}_logs_corrupt > $TMP/${tfile}_log_bad.out 2>&1
6711         local bad_line_new=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $9}')
6712         local good_line_new=$(tail -n 1 $TMP/${tfile}_log_bad.out | awk '{print $5}')
6713
6714         [ "$bad_line_new" ] && [ "$good_line_new" ] ||
6715                 error "bad_line_new good_line_new are empty"
6716
6717         local expected_good=$((good_line1 + good_line2*2))
6718
6719         rm -f $TMP/${tfile}*
6720         if [ $bad_line -ne $bad_line_new ]; then
6721                 error "expected $bad_line bad lines, but got $bad_line_new"
6722                 return 1
6723         fi
6724
6725         if [ $expected_good -ne $good_line_new ]; then
6726                 error "expected $expected_good good lines, but got $good_line_new"
6727                 return 2
6728         fi
6729         true
6730 }
6731 run_test 170 "test lctl df to handle corrupted log ====================="
6732
6733 test_171() { # bug20592
6734 #define OBD_FAIL_PTLRPC_DUMP_LOG         0x50e
6735         $LCTL set_param fail_loc=0x50e
6736         $LCTL set_param fail_val=3000
6737         multiop_bg_pause $DIR/$tfile Os || true
6738         # cause log dump
6739         sleep 3
6740         if dmesg | grep "recursive fault"; then
6741                 error "caught a recursive fault"
6742         fi
6743         $LCTL set_param fail_loc=0
6744         true
6745 }
6746 run_test 171 "test libcfs_debug_dumplog_thread stuck in do_exit() ======"
6747
6748 # it would be good to share it with obdfilter-survey/libecho code
6749 setup_obdecho_osc () {
6750         local rc=0
6751         local ost_nid=$1
6752         local obdfilter_name=$2
6753         [ $rc -eq 0 ] && { $LCTL attach osc ${obdfilter_name}_osc     \
6754                            ${obdfilter_name}_osc_UUID || rc=2; }
6755         [ $rc -eq 0 ] && { $LCTL --device ${obdfilter_name}_osc setup \
6756                            ${obdfilter_name}_UUID  $ost_nid || rc=3; }
6757         return $rc
6758 }
6759
6760 cleaup_obdecho_osc () {
6761         local obdfilter_name=$1
6762         $LCTL --device ${obdfilter_name}_osc cleanup >/dev/null
6763         $LCTL --device ${obdfilter_name}_osc detach  >/dev/null
6764         return 0
6765 }
6766
6767 obdecho_create_test() {
6768         local OBD=$1
6769         local node=$2
6770         local rc=0
6771         do_facet $node "$LCTL attach echo_client ec ec_uuid" || rc=1
6772         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec setup $OBD" ||    \
6773                            rc=2; }
6774         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec create 1" ||      \
6775                            rc=3; }
6776         [ $rc -eq 0 ] && { do_facet $node "$LCTL --device ec test_brw 0 w 1" ||\
6777                            rc=4; }
6778         [ $rc -eq 0 -o $rc -gt 2 ] && { do_facet $node "$LCTL --device ec "    \
6779                                         "cleanup" || rc=5; }
6780         [ $rc -eq 0 -o $rc -gt 1 ] && { do_facet $node "$LCTL --device ec "    \
6781                                         "detach" || rc=6; }
6782         return $rc
6783 }
6784
6785 test_180() {
6786         local rc=0
6787         local rmmod_local=0
6788         local rmmod_remote=0
6789
6790         lsmod | grep -q obdecho || \
6791                 { load_module obdecho/obdecho && rmmod_local=1; }
6792         OBD=$($LCTL dl | grep -v mdt | grep osc | awk '{print $4;exit}')
6793         HOST=$($LCTL dl -t | grep -v mdt | grep osc | awk '{print $7;exit}')
6794         OBD=`echo $OBD | sed 's/-osc-.*$//'`
6795         [ "x$OBD" != "x" ] && { setup_obdecho_osc $HOST $OBD || rc=1; } || rc=1
6796         [ $rc -eq 0 ] && { obdecho_create_test ${OBD}_osc client || rc=2; }
6797         [ "x$OBD" != "x" ] && cleaup_obdecho_osc $OBD
6798         [ $rmmod_local -eq 1 ] && rmmod obdecho
6799         [ $rc -eq 0 ] || return $rc
6800
6801         do_facet ost "lsmod | grep -q obdecho || "                      \
6802                      "{ insmod ${LUSTRE}/obdecho/obdecho.ko || "        \
6803                      "modprobe obdecho; }" && rmmod_remote=1
6804         OBD=$(do_facet ost $LCTL dl | awk '/obdfilter/ {print $4;exit}')
6805         [ "x$OBD" != "x" ] && { obdecho_create_test $OBD ost || rc=3; }
6806         [ $rmmod_remote -eq 1 ] && do_facet ost "rmmod obdecho"
6807         [ $rc -eq 0 ] || return $rc
6808
6809         true
6810 }
6811 run_test 180 "test obdecho ============================================"
6812
6813 # OST pools tests
6814 POOL=${POOL:-cea1}
6815 TGT_COUNT=$OSTCOUNT
6816 TGTPOOL_FIRST=1
6817 TGTPOOL_MAX=$(($TGT_COUNT - 1))
6818 TGTPOOL_STEP=2
6819 TGTPOOL_LIST=`seq $TGTPOOL_FIRST $TGTPOOL_STEP $TGTPOOL_MAX`
6820 POOL_ROOT=${POOL_ROOT:-$DIR/d200.pools}
6821 POOL_DIR=$POOL_ROOT/dir_tst
6822 POOL_FILE=$POOL_ROOT/file_tst
6823
6824 check_file_in_pool()
6825 {
6826         file=$1
6827         res=$($GETSTRIPE $file | grep 0x | cut -f2)
6828         for i in $res
6829         do
6830                 found=$(echo :$TGTPOOL_LIST: | tr " " ":"  | grep :$i:)
6831                 if [[ "$found" == "" ]]
6832                 then
6833                         echo "pool list: $TGTPOOL_LIST"
6834                         echo "striping: $res"
6835                         error "$file not allocated in $POOL"
6836                         return 1
6837                 fi
6838         done
6839         return 0
6840 }
6841
6842 trap "cleanup_pools $FSNAME" EXIT
6843
6844 test_200a() {
6845         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
6846     create_pool $FSNAME.$POOL || return $?
6847         [ $($LFS pool_list $FSNAME | grep -c $POOL) -eq 1 ] ||
6848                 error "$POOL not in lfs pool_list"
6849 }
6850 run_test 200a "Create new pool =========================================="
6851
6852 test_200b() {
6853         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
6854         TGT=$(for i in $TGTPOOL_LIST; do printf "$FSNAME-OST%04x_UUID " $i; done)
6855         do_facet mgs $LCTL pool_add $FSNAME.$POOL \
6856                 $FSNAME-OST[$TGTPOOL_FIRST-$TGTPOOL_MAX/$TGTPOOL_STEP]
6857         wait_update $HOSTNAME "lctl get_param -n lov.$FSNAME-*.pools.$POOL | sort -u | tr '\n' ' ' " "$TGT" ||
6858                 error "Add to pool failed"
6859         local lfscount=$($LFS pool_list $FSNAME.$POOL | grep -c "\-OST")
6860         local addcount=$((($TGTPOOL_MAX - $TGTPOOL_FIRST) / $TGTPOOL_STEP + 1))
6861         [ $lfscount -eq $addcount ] ||
6862                 error "lfs pool_list bad ost count $lfscount != $addcount"
6863 }
6864 run_test 200b "Add targets to a pool ===================================="
6865
6866 test_200c() {
6867         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
6868         mkdir -p $POOL_DIR
6869         $SETSTRIPE -c 2 -p $POOL $POOL_DIR
6870         [ $? = 0 ] || error "Cannot set pool $POOL to $POOL_DIR"
6871 }
6872 run_test 200c "Set pool on a directory ================================="
6873
6874 test_200d() {
6875         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
6876         res=$($GETSTRIPE --pool $POOL_DIR | awk '/^pool:/ {print $2}')
6877         [ "$res" = $POOL ] || error "Pool on $POOL_DIR is $res, not $POOL"
6878 }
6879 run_test 200d "Check pool on a directory ==============================="
6880
6881 test_200e() {
6882         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
6883         failed=0
6884         for i in $(seq -w 1 $(($TGT_COUNT * 3)))
6885         do
6886                 file=$POOL_DIR/file-$i
6887                 touch $file
6888                 check_file_in_pool $file
6889                 if [[ $? != 0 ]]
6890                 then
6891                         failed=$(($failed + 1))
6892                 fi
6893         done
6894         [ "$failed" = 0 ] || error "$failed files not allocated in $POOL"
6895 }
6896 run_test 200e "Check files allocation from directory pool =============="
6897
6898 test_200f() {
6899         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
6900         mkdir -p $POOL_FILE
6901         failed=0
6902         for i in $(seq -w 1 $(($TGT_COUNT * 3)))
6903         do
6904                 file=$POOL_FILE/spoo-$i
6905                 $SETSTRIPE -p $POOL $file
6906                 check_file_in_pool $file
6907                 if [[ $? != 0 ]]
6908                 then
6909                         failed=$(($failed + 1))
6910                 fi
6911         done
6912         [ "$failed" = 0 ] || error "$failed files not allocated in $POOL"
6913 }
6914 run_test 200f "Create files in a pool ==================================="
6915
6916 test_200g() {
6917         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
6918         TGT=$($LCTL get_param -n lov.$FSNAME-clilov-*.pools.$POOL | tr '\n' ' ')
6919         res=$($LFS df --pool $FSNAME.$POOL | awk '{print $1}' | grep "$FSNAME-OST" | tr '\n' ' ')
6920         [ "$res" = "$TGT" ] || error "Pools OSTs '$TGT' is not '$res' that lfs df reports"
6921 }
6922 run_test 200g "lfs df a pool ============================================"
6923
6924 test_201a() {
6925         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
6926         TGT=$($LCTL get_param -n lov.$FSNAME-*.pools.$POOL | head -1)
6927         do_facet mgs $LCTL pool_remove $FSNAME.$POOL $TGT
6928         wait_update $HOSTNAME "lctl get_param -n lov.$FSNAME-*.pools.$POOL | grep $TGT" "" ||
6929                 error "$TGT not removed from $FSNAME.$POOL"
6930 }
6931 run_test 201a "Remove a target from a pool ============================="
6932
6933 test_201b() {
6934         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
6935         for TGT in $($LCTL get_param -n lov.$FSNAME-*.pools.$POOL | sort -u)
6936         do
6937                 do_facet mgs $LCTL pool_remove $FSNAME.$POOL $TGT
6938         done
6939         wait_update $HOSTNAME "lctl get_param -n lov.$FSNAME-*.pools.$POOL" "" ||
6940                 error "Pool $FSNAME.$POOL cannot be drained"
6941         # striping on an empty/nonexistant pool should fall back to "pool of everything"
6942         touch ${POOL_DIR}/$tfile || error "failed to use fallback striping for empty pool"
6943         # setstripe on an empty pool should fail
6944         $SETSTRIPE -p $POOL ${POOL_FILE}/$tfile 2>/dev/null && \
6945                 error "expected failure when creating file with empty pool"
6946         return 0
6947 }
6948 run_test 201b "Remove all targets from a pool =========================="
6949
6950 test_201c() {
6951         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
6952         do_facet mgs $LCTL pool_destroy $FSNAME.$POOL
6953
6954         sleep 2
6955     # striping on an empty/nonexistant pool should fall back to "pool of everything"
6956         touch ${POOL_DIR}/$tfile || error "failed to use fallback striping for missing pool"
6957         # setstripe on an empty pool should fail
6958         $SETSTRIPE -p $POOL ${POOL_FILE}/$tfile 2>/dev/null && \
6959                 error "expected failure when creating file with missing pool"
6960
6961         # get param should return err once pool is gone
6962         if wait_update $HOSTNAME "lctl get_param -n lov.$FSNAME-*.pools.$POOL 2>/dev/null ||
6963                         echo foo" "foo"; then
6964                 remove_pool_from_list $FSNAME.$POOL
6965                 return 0
6966         fi
6967         error "Pool $FSNAME.$POOL is not destroyed"
6968 }
6969 run_test 201c "Remove a pool ============================================"
6970
6971 cleanup_pools $FSNAME
6972
6973 test_212() {
6974         size=`date +%s`
6975         size=$((size % 8192 + 1))
6976         dd if=/dev/urandom of=$DIR/f212 bs=1k count=$size
6977         sendfile $DIR/f212 $DIR/f212.xyz || error "sendfile wrong"
6978         rm -f $DIR/f212 $DIR/f212.xyz
6979 }
6980 run_test 212 "Sendfile test ============================================"
6981
6982 test_213() {
6983         dd if=/dev/zero of=$DIR/$tfile bs=4k count=4
6984         cancel_lru_locks osc
6985         lctl set_param fail_loc=0x8000040f
6986         # generate a read lock
6987         cat $DIR/$tfile > /dev/null
6988         # write to the file, it will try to cancel the above read lock.
6989         cat /etc/hosts >> $DIR/$tfile
6990 }
6991 run_test 213 "OSC lock completion and cancel race don't crash - bug 18829"
6992
6993 test_214() { # for bug 20133
6994         mkdir -p $DIR/d214p/d214c
6995         for (( i=0; i < 340; i++ )) ; do
6996                 touch $DIR/d214p/d214c/a$i
6997         done
6998
6999         ls -l $DIR/d214p || error "ls -l $DIR/d214p failed"
7000         mv $DIR/d214p/d214c $DIR/ || error "mv $DIR/d214p/d214c $DIR/ failed"
7001         ls $DIR/d214c || error "ls $DIR/d214c failed"
7002         rm -rf $DIR/d214* || error "rm -rf $DIR/d214* failed"
7003 }
7004 run_test 214 "hash-indexed directory test - bug 20133"
7005
7006 # having "abc" as 1st arg, creates $TMP/lnet_abc.out and $TMP/lnet_abc.sys
7007 create_lnet_proc_files() {
7008         cat /proc/sys/lnet/$1 >$TMP/lnet_$1.out || error "cannot read /proc/sys/lnet/$1"
7009         sysctl lnet.$1 >$TMP/lnet_$1.sys_tmp || error "cannot read lnet.$1"
7010
7011         sed "s/^lnet.$1\ =\ //g" "$TMP/lnet_$1.sys_tmp" >$TMP/lnet_$1.sys
7012         rm -f "$TMP/lnet_$1.sys_tmp"
7013 }
7014
7015 # counterpart of create_lnet_proc_files
7016 remove_lnet_proc_files() {
7017         rm -f $TMP/lnet_$1.out $TMP/lnet_$1.sys
7018 }
7019
7020 # uses 1st arg as trailing part of filename, 2nd arg as description for reports,
7021 # 3rd arg as regexp for body
7022 check_lnet_proc_stats() {
7023         local l=$(cat "$TMP/lnet_$1" |wc -l)
7024         [ $l = 1 ] || (cat "$TMP/lnet_$1" && error "$2 is not of 1 line: $l")
7025
7026         grep -E "$3" "$TMP/lnet_$1" || (cat "$TMP/lnet_$1" && error "$2 misformatted")
7027 }
7028
7029 # uses 1st arg as trailing part of filename, 2nd arg as description for reports,
7030 # 3rd arg as regexp for body, 4th arg as regexp for 1st line, 5th arg is
7031 # optional and can be regexp for 2nd line (lnet.routes case)
7032 check_lnet_proc_entry() {
7033         local blp=2            # blp stands for 'position of 1st line of body'
7034         [ "$5" = "" ] || blp=3 # lnet.routes case
7035
7036         local l=$(cat "$TMP/lnet_$1" |wc -l)
7037         # subtracting one from $blp because the body can be empty
7038         [ "$l" -ge "$(($blp - 1))" ] || (cat "$TMP/lnet_$1" && error "$2 is too short: $l")
7039
7040         sed -n '1 p' "$TMP/lnet_$1" |grep -E "$4" >/dev/null ||
7041                 (cat "$TMP/lnet_$1" && error "1st line of $2 misformatted")
7042
7043         [ "$5" = "" ] || sed -n '2 p' "$TMP/lnet_$1" |grep -E "$5" >/dev/null ||
7044                 (cat "$TMP/lnet_$1" && error "2nd line of $2 misformatted")
7045
7046         # bail out if any unexpected line happened
7047         sed -n "$blp~1 p" "$TMP/lnet_$1" |grep -Ev "$3"
7048         [ "$?" != 0 ] || error "$2 misformatted"
7049 }
7050
7051 test_215() { # for bugs 18102, 21079, 21517
7052         local N='(0|[1-9][0-9]*)'   # non-negative numeric
7053         local P='[1-9][0-9]*'       # positive numeric
7054         local I='(0|-?[1-9][0-9]*)' # any numeric (0 | >0 | <0)
7055         local NET='[a-z][a-z0-9]*'  # LNET net like o2ib2
7056         local ADDR='[0-9.]+'        # LNET addr like 10.0.0.1
7057         local NID="$ADDR@$NET"      # LNET nid like 10.0.0.1@o2ib2
7058
7059         local L1 # regexp for 1st line
7060         local L2 # regexp for 2nd line (optional)
7061         local BR # regexp for the rest (body)
7062
7063         # /proc/sys/lnet/stats should look as 11 space-separated non-negative numerics
7064         BR="^$N $N $N $N $N $N $N $N $N $N $N$"
7065         create_lnet_proc_files "stats"
7066         check_lnet_proc_stats "stats.out" "/proc/sys/lnet/stats" "$BR"
7067         check_lnet_proc_stats "stats.sys" "lnet.stats" "$BR"
7068         remove_lnet_proc_files "stats"
7069
7070         # /proc/sys/lnet/routes should look like this:
7071         # Routing disabled/enabled
7072         # net hops state router
7073         # where net is a string like tcp0, hops >= 0, state is up/down,
7074         # router is a string like 192.168.1.1@tcp2
7075         L1="^Routing (disabled|enabled)$"
7076         L2="^net +hops +state +router$"
7077         BR="^$NET +$N +(up|down) +$NID$"
7078         create_lnet_proc_files "routes"
7079         check_lnet_proc_entry "routes.out" "/proc/sys/lnet/routes" "$BR" "$L1" "$L2"
7080         check_lnet_proc_entry "routes.sys" "lnet.routes" "$BR" "$L1" "$L2"
7081         remove_lnet_proc_files "routes"
7082
7083         # /proc/sys/lnet/routers should look like this:
7084         # ref rtr_ref alive_cnt state last_ping ping_sent deadline down_ni router
7085         # where ref > 0, rtr_ref > 0, alive_cnt >= 0, state is up/down,
7086         # last_ping >= 0, ping_sent is boolean (0/1), deadline and down_ni are
7087         # numeric (0 or >0 or <0), router is a string like 192.168.1.1@tcp2
7088         L1="^ref +rtr_ref +alive_cnt +state +last_ping +ping_sent +deadline +down_ni +router$"
7089         BR="^$P +$P +$N +(up|down) +$N +(0|1) +$I +$I +$NID$"
7090         create_lnet_proc_files "routers"
7091         check_lnet_proc_entry "routers.out" "/proc/sys/lnet/routers" "$BR" "$L1"
7092         check_lnet_proc_entry "routers.sys" "lnet.routers" "$BR" "$L1"
7093         remove_lnet_proc_files "routers"
7094
7095         # /proc/sys/lnet/peers should look like this:
7096         # nid refs state max rtr min tx min queue
7097         # where nid is a string like 192.168.1.1@tcp2, refs > 0,
7098         # state is up/down/NA, max >= 0. rtr, min, tx, min are
7099         # numeric (0 or >0 or <0), queue >= 0.
7100         L1="^nid +refs +state +max +rtr +min +tx +min +queue$"
7101         BR="^$NID +$P +(up|down|NA) +$N +$I +$I +$I +$I +$N$"
7102         create_lnet_proc_files "peers"
7103         check_lnet_proc_entry "peers.out" "/proc/sys/lnet/peers" "$BR" "$L1"
7104         check_lnet_proc_entry "peers.sys" "lnet.peers" "$BR" "$L1"
7105         remove_lnet_proc_files "peers"
7106
7107         # /proc/sys/lnet/buffers  should look like this:
7108         # pages count credits min
7109         # where pages >=0, count >=0, credits and min are numeric (0 or >0 or <0)
7110         L1="^pages +count +credits +min$"
7111         BR="^ +$N +$N +$I +$I$"
7112         create_lnet_proc_files "buffers"
7113         check_lnet_proc_entry "buffers.out" "/proc/sys/lnet/buffers" "$BR" "$L1"
7114         check_lnet_proc_entry "buffers.sys" "lnet.buffers" "$BR" "$L1"
7115         remove_lnet_proc_files "buffers"
7116
7117         # /proc/sys/lnet/nis should look like this:
7118         # nid status alive refs peer rtr max tx min
7119         # where nid is a string like 192.168.1.1@tcp2, status is up/down,
7120         # alive is numeric (0 or >0 or <0), refs > 0, peer >= 0,
7121         # rtr >= 0, max >=0, tx and min are numeric (0 or >0 or <0).
7122         L1="^nid +status +alive +refs +peer +rtr +max +tx +min$"
7123         BR="^$NID +(up|down) +$I +$P +$N +$N +$N +$I +$I$"
7124         create_lnet_proc_files "nis"
7125         check_lnet_proc_entry "nis.out" "/proc/sys/lnet/nis" "$BR" "$L1"
7126         check_lnet_proc_entry "nis.sys" "lnet.nis" "$BR" "$L1"
7127         remove_lnet_proc_files "nis"
7128
7129         # can we successfully write to /proc/sys/lnet/stats?
7130         echo "0" >/proc/sys/lnet/stats || error "cannot write to /proc/sys/lnet/stats"
7131         sysctl -w lnet.stats=0 || error "cannot write to lnet.stats"
7132 }
7133 run_test 215 "/proc/sys/lnet exists and has proper content - bugs 18102, 21079, 21517"
7134
7135 test_216() { # bug 20317
7136         local node
7137         local p="$TMP/sanityN-$TESTNAME.parameters"
7138         save_lustre_params $HOSTNAME "osc.*.contention_seconds" > $p
7139         for node in $(osts_nodes); do
7140                 save_lustre_params $node "ldlm.namespaces.filter-*.max_nolock_bytes" >> $p
7141                 save_lustre_params $node "ldlm.namespaces.filter-*.contended_locks" >> $p
7142                 save_lustre_params $node "ldlm.namespaces.filter-*.contention_seconds" >> $p
7143         done
7144         clear_osc_stats
7145
7146         # agressive lockless i/o settings
7147         for node in $(osts_nodes); do
7148                 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'
7149         done
7150         lctl set_param -n osc.*.contention_seconds 60
7151
7152         $DIRECTIO write $DIR/$tfile 0 10 4096
7153         $CHECKSTAT -s 40960 $DIR/$tfile
7154
7155         # disable lockless i/o
7156         for node in $(osts_nodes); do
7157                 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'
7158         done
7159         lctl set_param -n osc.*.contention_seconds 0
7160         clear_osc_stats
7161
7162         dd if=/dev/zero of=$DIR/$tfile count=0
7163         $CHECKSTAT -s 0 $DIR/$tfile
7164
7165         restore_lustre_params <$p
7166         rm -f $p
7167         rm $DIR/$tfile
7168 }
7169 run_test 216 "check lockless direct write works and updates file size and kms correctly"
7170
7171 #
7172 # tests that do cleanup/setup should be run at the end
7173 #
7174
7175 test_900() {
7176         local ls
7177         #define OBD_FAIL_MGC_PAUSE_PROCESS_LOG   0x903
7178         $LCTL set_param fail_loc=0x903
7179         # cancel_lru_locks mgc - does not work due to lctl set_param syntax
7180         for ls in /proc/fs/lustre/ldlm/namespaces/MGC*/lru_size; do
7181                 echo "clear" > $ls
7182         done
7183         FAIL_ON_ERROR=true cleanup
7184         FAIL_ON_ERROR=true setup
7185 }
7186 run_test 900 "umount should not race with any mgc requeue thread"
7187
7188 log "cleanup: ======================================================"
7189 check_and_cleanup_lustre
7190 if [ "$I_MOUNTED" != "yes" ]; then
7191         lctl set_param debug="$OLDDEBUG" 2> /dev/null || true
7192 fi
7193
7194 echo '=========================== finished ==============================='
7195 [ -f "$SANITYLOG" ] && cat $SANITYLOG && grep -q FAIL $SANITYLOG && exit 1 || true
7196 echo "$0: completed"