lustre/tests/sanity.sh

   1 #!/bin/bash
   2 #
   3 # Run select tests by setting ONLY, or as arguments to the script.
   4 # Skip specific tests by setting EXCEPT.
   5 #
   6 # e.g. ONLY="22 23" or ONLY="`seq 32 39`" or EXCEPT="31"
   7 set -e
   8
   9 ONLY=${ONLY:-"$*"}
  10 # bug number for skipped test: 2108 9789 3637 9789 3561 12622 12653 12653 5188 10764 16260
  11 ALWAYS_EXCEPT="                42a  42b  42c  42d  45   51d   65a   65e   68   75    119d  $SANITY_EXCEPT"
  12 # bug number for skipped test: 2108 9789 3637 9789 3561 5188/5749 1443
  13 #ALWAYS_EXCEPT=${ALWAYS_EXCEPT:-"27m 42a 42b 42c 42d 45 68 76"}
  14 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  15
  16 # Tests that fail on uml
  17 CPU=`awk '/model/ {print $4}' /proc/cpuinfo`
  18 #                                    buffer i/o errs             sock spc runas
  19 [ "$CPU" = "UML" ] && EXCEPT="$EXCEPT 27m 27n 27o 27p 27q 27r 31d 54a  64b 99a 99b 99c 99d 99e 99f 101"
  20
  21 # test76 is not valid with FIDs because inode numbers are not reused
  22 ALWAYS_EXCEPT="$ALWAYS_EXCEPT 76"
  23
  24 case `uname -r` in
  25 2.4*) FSTYPE=${FSTYPE:-ext3} ;;
  26 2.6*) FSTYPE=${FSTYPE:-ldiskfs} ;;
  27 *) error "unsupported kernel" ;;
  28 esac
  29
  30 SRCDIR=$(cd $(dirname $0); echo $PWD)
  31 export PATH=$PATH:/sbin
  32
  33 TMP=${TMP:-/tmp}
  34
  35 CHECKSTAT=${CHECKSTAT:-"checkstat -v"}
  36 CREATETEST=${CREATETEST:-createtest}
  37 LFS=${LFS:-lfs}
  38 SETSTRIPE=${SETSTRIPE:-"$LFS setstripe"}
  39 GETSTRIPE=${GETSTRIPE:-"$LFS getstripe"}
  40 LSTRIPE=${LSTRIPE:-"$LFS setstripe"}
  41 LFIND=${LFIND:-"$LFS find"}
  42 LVERIFY=${LVERIFY:-ll_dirstripe_verify}
  43 LSTRIPEINFO=${LSTRIPEINFO:-ll_getstripe_info}
  44 LCTL=${LCTL:-lctl}
  45 MCREATE=${MCREATE:-mcreate}
  46 OPENFILE=${OPENFILE:-openfile}
  47 OPENUNLINK=${OPENUNLINK:-openunlink}
  48 READS=${READS:-"reads"}
  49 TOEXCL=${TOEXCL:-toexcl}
  50 TRUNCATE=${TRUNCATE:-truncate}
  51 MUNLINK=${MUNLINK:-munlink}
  52 SOCKETSERVER=${SOCKETSERVER:-socketserver}
  53 SOCKETCLIENT=${SOCKETCLIENT:-socketclient}
  54 IOPENTEST1=${IOPENTEST1:-iopentest1}
  55 IOPENTEST2=${IOPENTEST2:-iopentest2}
  56 MEMHOG=${MEMHOG:-memhog}
  57 DIRECTIO=${DIRECTIO:-directio}
  58 ACCEPTOR_PORT=${ACCEPTOR_PORT:-988}
  59 UMOUNT=${UMOUNT:-"umount -d"}
  60 STRIPES_PER_OBJ=-1
  61 CHECK_GRANT=${CHECK_GRANT:-"yes"}
  62 GRANT_CHECK_LIST=${GRANT_CHECK_LIST:-""}
  63
  64 export NAME=${NAME:-local}
  65
  66 SAVE_PWD=$PWD
  67
  68 CLEANUP=${CLEANUP:-:}
  69 SETUP=${SETUP:-:}
  70 TRACE=${TRACE:-""}
  71 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
  72 . $LUSTRE/tests/test-framework.sh
  73 init_test_env $@
  74 . ${CONFIG:=$LUSTRE/tests/cfg/${NAME}.sh}
  75
  76 [ "$SLOW" = "no" ] && EXCEPT_SLOW="24o 27m 36f 36g 51b 51c 60c 63 64b 68 71 73 77f 78 101 103 115 120g 124b"
  77
  78 SANITYLOG=${TESTSUITELOG:-$TMP/$(basename $0 .sh).log}
  79 FAIL_ON_ERROR=false
  80
  81 cleanup() {
  82         echo -n "cln.."
  83         pgrep ll_sa > /dev/null && { echo "There are ll_sa thread not exit!"; exit 20; }
  84         cleanupall ${FORCE} $* || { echo "FAILed to clean up"; exit 20; }
  85 }
  86 setup() {
  87         echo -n "mnt.."
  88         load_modules
  89         setupall || exit 10
  90         echo "done"
  91 }
  92
  93 check_kernel_version() {
  94         VERSION_FILE=version
  95         WANT_VER=$1
  96         GOT_VER=$(lctl get_param -n $VERSION_FILE | awk '/kernel:/ {print $2}')
  97         [ $GOT_VER == "patchless" ] && return 0
  98         [ $GOT_VER -ge $WANT_VER ] && return 0
  99         log "test needs at least kernel version $WANT_VER, running $GOT_VER"
 100         return 1
 101 }
 102
 103 if [ "$ONLY" == "cleanup" ]; then
 104        sh llmountcleanup.sh
 105        exit 0
 106 fi
 107
 108 [ "$SANITYLOG" ] && rm -f $SANITYLOG || true
 109
 110 check_and_setup_lustre
 111
 112 DIR=${DIR:-$MOUNT}
 113 assert_DIR
 114
 115 LOVNAME=`lctl get_param -n llite.*.lov.common_name | tail -n 1`
 116 OSTCOUNT=`lctl get_param -n lov.$LOVNAME.numobd`
 117 STRIPECOUNT=`lctl get_param -n lov.$LOVNAME.stripecount`
 118 STRIPESIZE=`lctl get_param -n lov.$LOVNAME.stripesize`
 119 ORIGFREE=`lctl get_param -n lov.$LOVNAME.kbytesavail`
 120 MAXFREE=${MAXFREE:-$((200000 * $OSTCOUNT))}
 121
 122 [ -f $DIR/d52a/foo ] && chattr -a $DIR/d52a/foo
 123 [ -f $DIR/d52b/foo ] && chattr -i $DIR/d52b/foo
 124 rm -rf $DIR/[Rdfs][0-9]*
 125
 126 # $RUNAS_ID may get set incorrectly somewhere else
 127 [ $UID -eq 0 -a $RUNAS_ID -eq 0 ] && error "\$RUNAS_ID set to 0, but \$UID is also 0!"
 128
 129 check_runas_id $RUNAS_ID $RUNAS
 130
 131 build_test_filter
 132
 133 if [ "${ONLY}" = "MOUNT" ] ; then
 134         echo "Lustre is up, please go on"
 135         exit
 136 fi
 137
 138 echo "preparing for tests involving mounts"
 139 EXT2_DEV=${EXT2_DEV:-$TMP/SANITY.LOOP}
 140 touch $EXT2_DEV
 141 mke2fs -j -F $EXT2_DEV 8000 > /dev/null
 142 echo # add a newline after mke2fs.
 143
 144 umask 077
 145
 146 OLDDEBUG="`lctl get_param -n debug 2> /dev/null`"
 147 lctl set_param debug=-1 2> /dev/null || true
 148 test_0() {
 149         touch $DIR/$tfile
 150         $CHECKSTAT -t file $DIR/$tfile || error
 151         rm $DIR/$tfile
 152         $CHECKSTAT -a $DIR/$tfile || error
 153 }
 154 run_test 0 "touch .../$tfile ; rm .../$tfile ====================="
 155
 156 test_0b() {
 157         chmod 0755 $DIR || error
 158         $CHECKSTAT -p 0755 $DIR || error
 159 }
 160 run_test 0b "chmod 0755 $DIR ============================="
 161
 162 test_1a() {
 163         mkdir $DIR/d1
 164         mkdir $DIR/d1/d2
 165         mkdir $DIR/d1/d2 && error "we expect EEXIST, but not returned"
 166         $CHECKSTAT -t dir $DIR/d1/d2 || error
 167 }
 168 run_test 1a "mkdir .../d1; mkdir .../d1/d2 ====================="
 169
 170 test_1b() {
 171         rmdir $DIR/d1/d2
 172         rmdir $DIR/d1
 173         $CHECKSTAT -a $DIR/d1 || error
 174 }
 175 run_test 1b "rmdir .../d1/d2; rmdir .../d1 ====================="
 176
 177 test_2a() {
 178         mkdir $DIR/d2
 179         touch $DIR/d2/f
 180         $CHECKSTAT -t file $DIR/d2/f || error
 181 }
 182 run_test 2a "mkdir .../d2; touch .../d2/f ======================"
 183
 184 test_2b() {
 185         rm -r $DIR/d2
 186         $CHECKSTAT -a $DIR/d2 || error
 187 }
 188 run_test 2b "rm -r .../d2; checkstat .../d2/f ======================"
 189
 190 test_3a() {
 191         mkdir $DIR/d3
 192         $CHECKSTAT -t dir $DIR/d3 || error
 193 }
 194 run_test 3a "mkdir .../d3 ======================================"
 195
 196 test_3b() {
 197         if [ ! -d $DIR/d3 ]; then
 198                 mkdir $DIR/d3
 199         fi
 200         touch $DIR/d3/f
 201         $CHECKSTAT -t file $DIR/d3/f || error
 202 }
 203 run_test 3b "touch .../d3/f ===================================="
 204
 205 test_3c() {
 206         rm -r $DIR/d3
 207         $CHECKSTAT -a $DIR/d3 || error
 208 }
 209 run_test 3c "rm -r .../d3 ======================================"
 210
 211 test_4a() {
 212         mkdir $DIR/d4
 213         $CHECKSTAT -t dir $DIR/d4 || error
 214 }
 215 run_test 4a "mkdir .../d4 ======================================"
 216
 217 test_4b() {
 218         if [ ! -d $DIR/d4 ]; then
 219                 mkdir $DIR/d4
 220         fi
 221         mkdir $DIR/d4/d2
 222         $CHECKSTAT -t dir $DIR/d4/d2 || error
 223 }
 224 run_test 4b "mkdir .../d4/d2 ==================================="
 225
 226 test_5() {
 227         mkdir $DIR/d5
 228         mkdir $DIR/d5/d2
 229         chmod 0707 $DIR/d5/d2
 230         $CHECKSTAT -t dir -p 0707 $DIR/d5/d2 || error
 231 }
 232 run_test 5 "mkdir .../d5 .../d5/d2; chmod .../d5/d2 ============"
 233
 234 test_6a() {
 235         touch $DIR/f6a
 236         chmod 0666 $DIR/f6a || error
 237         $CHECKSTAT -t file -p 0666 -u \#$UID $DIR/f6a || error
 238 }
 239 run_test 6a "touch .../f6a; chmod .../f6a ======================"
 240
 241 test_6b() {
 242         [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID = UID = $UID -- skipping" && return
 243         if [ ! -f $DIR/f6a ]; then
 244                 touch $DIR/f6a
 245                 chmod 0666 $DIR/f6a
 246         fi
 247         $RUNAS chmod 0444 $DIR/f6a && error
 248         $CHECKSTAT -t file -p 0666 -u \#$UID $DIR/f6a || error
 249 }
 250 run_test 6b "$RUNAS chmod .../f6a (should return error) =="
 251
 252 test_6c() {
 253         [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID = UID = $UID -- skipping" && return
 254         touch $DIR/f6c
 255         chown $RUNAS_ID $DIR/f6c || error
 256         $CHECKSTAT -t file -u \#$RUNAS_ID $DIR/f6c || error
 257 }
 258 run_test 6c "touch .../f6c; chown .../f6c ======================"
 259
 260 test_6d() {
 261         [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID = UID = $UID -- skipping" && return
 262         if [ ! -f $DIR/f6c ]; then
 263                 touch $DIR/f6c
 264                 chown $RUNAS_ID $DIR/f6c
 265         fi
 266         $RUNAS chown $UID $DIR/f6c && error
 267         $CHECKSTAT -t file -u \#$RUNAS_ID $DIR/f6c || error
 268 }
 269 run_test 6d "$RUNAS chown .../f6c (should return error) =="
 270
 271 test_6e() {
 272         [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID = UID = $UID -- skipping" && return
 273         touch $DIR/f6e
 274         chgrp $RUNAS_ID $DIR/f6e || error
 275         $CHECKSTAT -t file -u \#$UID -g \#$RUNAS_ID $DIR/f6e || error
 276 }
 277 run_test 6e "touch .../f6e; chgrp .../f6e ======================"
 278
 279 test_6f() {
 280         [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID = UID = $UID -- skipping" && return
 281         if [ ! -f $DIR/f6e ]; then
 282                 touch $DIR/f6e
 283                 chgrp $RUNAS_ID $DIR/f6e
 284         fi
 285         $RUNAS chgrp $UID $DIR/f6e && error
 286         $CHECKSTAT -t file -u \#$UID -g \#$RUNAS_ID $DIR/f6e || error
 287 }
 288 run_test 6f "$RUNAS chgrp .../f6e (should return error) =="
 289
 290 test_6g() {
 291         [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID = UID = $UID -- skipping" && return
 292         mkdir $DIR/d6g || error
 293         chmod 777 $DIR/d6g || error
 294         $RUNAS mkdir $DIR/d6g/d || error
 295         chmod g+s $DIR/d6g/d || error
 296         mkdir $DIR/d6g/d/subdir
 297         $CHECKSTAT -g \#$RUNAS_ID $DIR/d6g/d/subdir || error
 298 }
 299 run_test 6g "Is new dir in sgid dir inheriting group?"
 300
 301 test_6h() { # bug 7331
 302         [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID = UID = $UID -- skipping" && return
 303         touch $DIR/f6h || error "touch failed"
 304         chown $RUNAS_ID:$RUNAS_ID $DIR/f6h || error "initial chown failed"
 305         $RUNAS -G$RUNAS_ID chown $RUNAS_ID:0 $DIR/f6h && error "chown worked"
 306         $CHECKSTAT -t file -u \#$RUNAS_ID -g \#$RUNAS_ID $DIR/f6h || error
 307 }
 308 run_test 6h "$RUNAS chown RUNAS_ID.0 .../f6h (should return error)"
 309
 310 test_7a() {
 311         mkdir $DIR/d7
 312         $MCREATE $DIR/d7/f
 313         chmod 0666 $DIR/d7/f
 314         $CHECKSTAT -t file -p 0666 $DIR/d7/f || error
 315 }
 316 run_test 7a "mkdir .../d7; mcreate .../d7/f; chmod .../d7/f ===="
 317
 318 test_7b() {
 319         if [ ! -d $DIR/d7 ]; then
 320                 mkdir $DIR/d7
 321         fi
 322         $MCREATE $DIR/d7/f2
 323         echo -n foo > $DIR/d7/f2
 324         [ "`cat $DIR/d7/f2`" = "foo" ] || error
 325         $CHECKSTAT -t file -s 3 $DIR/d7/f2 || error
 326 }
 327 run_test 7b "mkdir .../d7; mcreate d7/f2; echo foo > d7/f2 ====="
 328
 329 test_8() {
 330         mkdir $DIR/d8
 331         touch $DIR/d8/f
 332         chmod 0666 $DIR/d8/f
 333         $CHECKSTAT -t file -p 0666 $DIR/d8/f || error
 334 }
 335 run_test 8 "mkdir .../d8; touch .../d8/f; chmod .../d8/f ======="
 336
 337 test_9() {
 338         mkdir $DIR/d9
 339         mkdir $DIR/d9/d2
 340         mkdir $DIR/d9/d2/d3
 341         $CHECKSTAT -t dir $DIR/d9/d2/d3 || error
 342 }
 343 run_test 9 "mkdir .../d9 .../d9/d2 .../d9/d2/d3 ================"
 344
 345 test_10() {
 346         mkdir $DIR/d10
 347         mkdir $DIR/d10/d2
 348         touch $DIR/d10/d2/f
 349         $CHECKSTAT -t file $DIR/d10/d2/f || error
 350 }
 351 run_test 10 "mkdir .../d10 .../d10/d2; touch .../d10/d2/f ======"
 352
 353 test_11() {
 354         mkdir $DIR/d11
 355         mkdir $DIR/d11/d2
 356         chmod 0666 $DIR/d11/d2
 357         chmod 0705 $DIR/d11/d2
 358         $CHECKSTAT -t dir -p 0705 $DIR/d11/d2 || error
 359 }
 360 run_test 11 "mkdir .../d11 d11/d2; chmod .../d11/d2 ============"
 361
 362 test_12() {
 363         mkdir $DIR/d12
 364         touch $DIR/d12/f
 365         chmod 0666 $DIR/d12/f
 366         chmod 0654 $DIR/d12/f
 367         $CHECKSTAT -t file -p 0654 $DIR/d12/f || error
 368 }
 369 run_test 12 "touch .../d12/f; chmod .../d12/f .../d12/f ========"
 370
 371 test_13() {
 372         mkdir $DIR/d13
 373         dd if=/dev/zero of=$DIR/d13/f count=10
 374         >  $DIR/d13/f
 375         $CHECKSTAT -t file -s 0 $DIR/d13/f || error
 376 }
 377 run_test 13 "creat .../d13/f; dd .../d13/f; > .../d13/f ========"
 378
 379 test_14() {
 380         mkdir $DIR/d14
 381         touch $DIR/d14/f
 382         rm $DIR/d14/f
 383         $CHECKSTAT -a $DIR/d14/f || error
 384 }
 385 run_test 14 "touch .../d14/f; rm .../d14/f; rm .../d14/f ======="
 386
 387 test_15() {
 388         mkdir $DIR/d15
 389         touch $DIR/d15/f
 390         mv $DIR/d15/f $DIR/d15/f2
 391         $CHECKSTAT -t file $DIR/d15/f2 || error
 392 }
 393 run_test 15 "touch .../d15/f; mv .../d15/f .../d15/f2 =========="
 394
 395 test_16() {
 396         mkdir $DIR/d16
 397         touch $DIR/d16/f
 398         rm -rf $DIR/d16/f
 399         $CHECKSTAT -a $DIR/d16/f || error
 400 }
 401 run_test 16 "touch .../d16/f; rm -rf .../d16/f ================="
 402
 403 test_17a() {
 404         mkdir -p $DIR/d17
 405         touch $DIR/d17/f
 406         ln -s $DIR/d17/f $DIR/d17/l-exist
 407         ls -l $DIR/d17
 408         $CHECKSTAT -l $DIR/d17/f $DIR/d17/l-exist || error
 409         $CHECKSTAT -f -t f $DIR/d17/l-exist || error
 410         rm -f $DIR/d17/l-exist
 411         $CHECKSTAT -a $DIR/d17/l-exist || error
 412 }
 413 run_test 17a "symlinks: create, remove (real) =================="
 414
 415 test_17b() {
 416         mkdir -p $DIR/d17
 417         ln -s no-such-file $DIR/d17/l-dangle
 418         ls -l $DIR/d17
 419         $CHECKSTAT -l no-such-file $DIR/d17/l-dangle || error
 420         $CHECKSTAT -fa $DIR/d17/l-dangle || error
 421         rm -f $DIR/d17/l-dangle
 422         $CHECKSTAT -a $DIR/d17/l-dangle || error
 423 }
 424 run_test 17b "symlinks: create, remove (dangling) =============="
 425
 426 test_17c() { # bug 3440 - don't save failed open RPC for replay
 427         mkdir -p $DIR/d17
 428         ln -s foo $DIR/d17/f17c
 429         cat $DIR/d17/f17c && error "opened non-existent symlink" || true
 430 }
 431 run_test 17c "symlinks: open dangling (should return error) ===="
 432
 433 test_17d() {
 434         mkdir -p $DIR/d17
 435         ln -s foo $DIR/d17/f17d
 436         touch $DIR/d17/f17d || error "creating to new symlink"
 437 }
 438 run_test 17d "symlinks: create dangling ========================"
 439
 440 test_17e() {
 441         mkdir -p $DIR/$tdir
 442         local foo=$DIR/$tdir/$tfile
 443         ln -s $foo $foo || error "create symlink failed"
 444         ls -l $foo || error "ls -l failed"
 445         ls $foo && error "ls not failed" || true
 446 }
 447 run_test 17e "symlinks: create recursive symlink (should return error) ===="
 448
 449 test_17f() {
 450         mkdir -p $DIR/d17f
 451         ln -s 1234567890/2234567890/3234567890/4234567890 $DIR/d17f/111
 452         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890 $DIR/d17f/222
 453         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890 $DIR/d17f/333
 454         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890 $DIR/d17f/444
 455         ln -s 1234567890/2234567890/3234567890/4234567890/5234567890/6234567890/7234567890/8234567890/9234567890/a234567890/b234567890/c234567890/d234567890/f234567890 $DIR/d17f/555
 456         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
 457         ls -l  $DIR/d17f
 458 }
 459 run_test 17f "symlinks: long and very long symlink name ========================"
 460
 461 test_18() {
 462         touch $DIR/f
 463         ls $DIR || error
 464 }
 465 run_test 18 "touch .../f ; ls ... =============================="
 466
 467 test_19a() {
 468         touch $DIR/f19
 469         ls -l $DIR
 470         rm $DIR/f19
 471         $CHECKSTAT -a $DIR/f19 || error
 472 }
 473 run_test 19a "touch .../f19 ; ls -l ... ; rm .../f19 ==========="
 474
 475 test_19b() {
 476         ls -l $DIR/f19 && error || true
 477 }
 478 run_test 19b "ls -l .../f19 (should return error) =============="
 479
 480 test_19c() {
 481         [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID = UID = $UID -- skipping" && return
 482         $RUNAS touch $DIR/f19 && error || true
 483 }
 484 run_test 19c "$RUNAS touch .../f19 (should return error) =="
 485
 486 test_19d() {
 487         cat $DIR/f19 && error || true
 488 }
 489 run_test 19d "cat .../f19 (should return error) =============="
 490
 491 test_20() {
 492         touch $DIR/f
 493         rm $DIR/f
 494         log "1 done"
 495         touch $DIR/f
 496         rm $DIR/f
 497         log "2 done"
 498         touch $DIR/f
 499         rm $DIR/f
 500         log "3 done"
 501         $CHECKSTAT -a $DIR/f || error
 502 }
 503 run_test 20 "touch .../f ; ls -l ... ==========================="
 504
 505 test_21() {
 506         mkdir $DIR/d21
 507         [ -f $DIR/d21/dangle ] && rm -f $DIR/d21/dangle
 508         ln -s dangle $DIR/d21/link
 509         echo foo >> $DIR/d21/link
 510         cat $DIR/d21/dangle
 511         $CHECKSTAT -t link $DIR/d21/link || error
 512         $CHECKSTAT -f -t file $DIR/d21/link || error
 513 }
 514 run_test 21 "write to dangling link ============================"
 515
 516 test_22() {
 517         WDIR=$DIR/$tdir
 518         mkdir -p $WDIR
 519         chown $RUNAS_ID $WDIR
 520         (cd $WDIR || error "cd $WDIR failed";
 521         $RUNAS tar cf - /etc/hosts /etc/sysconfig/network | \
 522         $RUNAS tar xf -)
 523         ls -lR $WDIR/etc || error "ls -lR $WDIR/etc failed"
 524         $CHECKSTAT -t dir $WDIR/etc || error "checkstat -t dir failed"
 525         $CHECKSTAT -u \#$RUNAS_ID $WDIR/etc || error "checkstat -u failed"
 526 }
 527 run_test 22 "unpack tar archive as non-root user ==============="
 528
 529 test_23() {
 530         mkdir $DIR/d23
 531         $TOEXCL $DIR/d23/f23
 532         $TOEXCL -e $DIR/d23/f23 || error
 533 }
 534 run_test 23 "O_CREAT|O_EXCL in subdir =========================="
 535
 536 test_24a() {
 537         echo '== rename sanity =============================================='
 538         echo '-- same directory rename'
 539         mkdir $DIR/R1
 540         touch $DIR/R1/f
 541         mv $DIR/R1/f $DIR/R1/g
 542         $CHECKSTAT -t file $DIR/R1/g || error
 543 }
 544 run_test 24a "touch .../R1/f; rename .../R1/f .../R1/g ========="
 545
 546 test_24b() {
 547         mkdir $DIR/R2
 548         touch $DIR/R2/{f,g}
 549         mv $DIR/R2/f $DIR/R2/g
 550         $CHECKSTAT -a $DIR/R2/f || error
 551         $CHECKSTAT -t file $DIR/R2/g || error
 552 }
 553 run_test 24b "touch .../R2/{f,g}; rename .../R2/f .../R2/g ====="
 554
 555 test_24c() {
 556         mkdir $DIR/R3
 557         mkdir $DIR/R3/f
 558         mv $DIR/R3/f $DIR/R3/g
 559         $CHECKSTAT -a $DIR/R3/f || error
 560         $CHECKSTAT -t dir $DIR/R3/g || error
 561 }
 562 run_test 24c "mkdir .../R3/f; rename .../R3/f .../R3/g ========="
 563
 564 test_24d() {
 565         mkdir $DIR/R4
 566         mkdir $DIR/R4/{f,g}
 567         mrename $DIR/R4/f $DIR/R4/g
 568         $CHECKSTAT -a $DIR/R4/f || error
 569         $CHECKSTAT -t dir $DIR/R4/g || error
 570 }
 571 run_test 24d "mkdir .../R4/{f,g}; rename .../R4/f .../R4/g ====="
 572
 573 test_24e() {
 574         echo '-- cross directory renames --'
 575         mkdir $DIR/R5{a,b}
 576         touch $DIR/R5a/f
 577         mv $DIR/R5a/f $DIR/R5b/g
 578         $CHECKSTAT -a $DIR/R5a/f || error
 579         $CHECKSTAT -t file $DIR/R5b/g || error
 580 }
 581 run_test 24e "touch .../R5a/f; rename .../R5a/f .../R5b/g ======"
 582
 583 test_24f() {
 584         mkdir $DIR/R6{a,b}
 585         touch $DIR/R6a/f $DIR/R6b/g
 586         mv $DIR/R6a/f $DIR/R6b/g
 587         $CHECKSTAT -a $DIR/R6a/f || error
 588         $CHECKSTAT -t file $DIR/R6b/g || error
 589 }
 590 run_test 24f "touch .../R6a/f R6b/g; mv .../R6a/f .../R6b/g ===="
 591
 592 test_24g() {
 593         mkdir $DIR/R7{a,b}
 594         mkdir $DIR/R7a/d
 595         mv $DIR/R7a/d $DIR/R7b/e
 596         $CHECKSTAT -a $DIR/R7a/d || error
 597         $CHECKSTAT -t dir $DIR/R7b/e || error
 598 }
 599 run_test 24g "mkdir .../R7{a,b}/d; mv .../R7a/d .../R7b/e ======"
 600
 601 test_24h() {
 602         mkdir $DIR/R8{a,b}
 603         mkdir $DIR/R8a/d $DIR/R8b/e
 604         mrename $DIR/R8a/d $DIR/R8b/e
 605         $CHECKSTAT -a $DIR/R8a/d || error
 606         $CHECKSTAT -t dir $DIR/R8b/e || error
 607 }
 608 run_test 24h "mkdir .../R8{a,b}/{d,e}; rename .../R8a/d .../R8b/e"
 609
 610 test_24i() {
 611         echo "-- rename error cases"
 612         mkdir $DIR/R9
 613         mkdir $DIR/R9/a
 614         touch $DIR/R9/f
 615         mrename $DIR/R9/f $DIR/R9/a
 616         $CHECKSTAT -t file $DIR/R9/f || error
 617         $CHECKSTAT -t dir  $DIR/R9/a || error
 618         $CHECKSTAT -a file $DIR/R9/a/f || error
 619 }
 620 run_test 24i "rename file to dir error: touch f ; mkdir a ; rename f a"
 621
 622 test_24j() {
 623         mkdir $DIR/R10
 624         mrename $DIR/R10/f $DIR/R10/g
 625         $CHECKSTAT -t dir $DIR/R10 || error
 626         $CHECKSTAT -a $DIR/R10/f || error
 627         $CHECKSTAT -a $DIR/R10/g || error
 628 }
 629 run_test 24j "source does not exist ============================"
 630
 631 test_24k() {
 632         mkdir $DIR/R11a $DIR/R11a/d
 633         touch $DIR/R11a/f
 634         mv $DIR/R11a/f $DIR/R11a/d
 635         $CHECKSTAT -a $DIR/R11a/f || error
 636         $CHECKSTAT -t file $DIR/R11a/d/f || error
 637 }
 638 run_test 24k "touch .../R11a/f; mv .../R11a/f .../R11a/d ======="
 639
 640 # bug 2429 - rename foo foo foo creates invalid file
 641 test_24l() {
 642         f="$DIR/f24l"
 643         multiop $f OcNs || error
 644 }
 645 run_test 24l "Renaming a file to itself ========================"
 646
 647 test_24m() {
 648         f="$DIR/f24m"
 649         multiop $f OcLN ${f}2 ${f}2 || error "link ${f}2 ${f}2 failed"
 650         # on ext3 this does not remove either the source or target files
 651         # though the "expected" operation would be to remove the source
 652         $CHECKSTAT -t file ${f} || error "${f} missing"
 653         $CHECKSTAT -t file ${f}2 || error "${f}2 missing"
 654 }
 655 run_test 24m "Renaming a file to a hard link to itself ========="
 656
 657 test_24n() {
 658     f="$DIR/f24n"
 659     # this stats the old file after it was renamed, so it should fail
 660     touch ${f}
 661     $CHECKSTAT ${f}
 662     mv ${f} ${f}.rename
 663     $CHECKSTAT ${f}.rename
 664     $CHECKSTAT -a ${f}
 665 }
 666 run_test 24n "Statting the old file after renaming (Posix rename 2)"
 667
 668 test_24o() {
 669         check_kernel_version 37 || return 0
 670         mkdir -p $DIR/d24o
 671         rename_many -s random -v -n 10 $DIR/d24o
 672 }
 673 run_test 24o "rename of files during htree split ==============="
 674
 675 test_24p() {
 676         mkdir $DIR/R12{a,b}
 677         DIRINO=`ls -lid $DIR/R12a | awk '{ print $1 }'`
 678         mrename $DIR/R12a $DIR/R12b
 679         $CHECKSTAT -a $DIR/R12a || error
 680         $CHECKSTAT -t dir $DIR/R12b || error
 681         DIRINO2=`ls -lid $DIR/R12b | awk '{ print $1 }'`
 682         [ "$DIRINO" = "$DIRINO2" ] || error "R12a $DIRINO != R12b $DIRINO2"
 683 }
 684 run_test 24p "mkdir .../R12{a,b}; rename .../R12a .../R12b"
 685
 686 test_24q() {
 687         mkdir $DIR/R13{a,b}
 688         DIRINO=`ls -lid $DIR/R13a | awk '{ print $1 }'`
 689         multiop_bg_pause $DIR/R13b D_c || return 1
 690         MULTIPID=$!
 691
 692         mrename $DIR/R13a $DIR/R13b
 693         $CHECKSTAT -a $DIR/R13a || error
 694         $CHECKSTAT -t dir $DIR/R13b || error
 695         DIRINO2=`ls -lid $DIR/R13b | awk '{ print $1 }'`
 696         [ "$DIRINO" = "$DIRINO2" ] || error "R13a $DIRINO != R13b $DIRINO2"
 697         kill -USR1 $MULTIPID
 698         wait $MULTIPID || error "multiop close failed"
 699 }
 700 run_test 24q "mkdir .../R13{a,b}; open R13b rename R13a R13b ==="
 701
 702 test_24r() { #bug 3789
 703         mkdir $DIR/R14a $DIR/R14a/b
 704         mrename $DIR/R14a $DIR/R14a/b && error "rename to subdir worked!"
 705         $CHECKSTAT -t dir $DIR/R14a || error "$DIR/R14a missing"
 706         $CHECKSTAT -t dir $DIR/R14a/b || error "$DIR/R14a/b missing"
 707 }
 708 run_test 24r "mkdir .../R14a/b; rename .../R14a .../R14a/b ====="
 709
 710 test_24s() {
 711         mkdir $DIR/R15a $DIR/R15a/b $DIR/R15a/b/c
 712         mrename $DIR/R15a $DIR/R15a/b/c && error "rename to sub-subdir worked!"
 713         $CHECKSTAT -t dir $DIR/R15a || error "$DIR/R15a missing"
 714         $CHECKSTAT -t dir $DIR/R15a/b/c || error "$DIR/R15a/b/c missing"
 715 }
 716 run_test 24s "mkdir .../R15a/b/c; rename .../R15a .../R15a/b/c ="
 717 test_24t() {
 718         mkdir $DIR/R16a $DIR/R16a/b $DIR/R16a/b/c
 719         mrename $DIR/R16a/b/c $DIR/R16a && error "rename to sub-subdir worked!"
 720         $CHECKSTAT -t dir $DIR/R16a || error "$DIR/R16a missing"
 721         $CHECKSTAT -t dir $DIR/R16a/b/c || error "$DIR/R16a/b/c missing"
 722 }
 723 run_test 24t "mkdir .../R16a/b/c; rename .../R16a/b/c .../R16a ="
 724
 725 test_24u() { # bug12192
 726         multiop $DIR/$tfile C2w$((2048 * 1024))c || error
 727         $CHECKSTAT -s $((2048 * 1024)) $DIR/$tfile || error "wrong file size"
 728 }
 729 run_test 24u "create stripe file"
 730
 731 test_25a() {
 732         echo '== symlink sanity ============================================='
 733
 734         mkdir $DIR/d25
 735         ln -s d25 $DIR/s25
 736         touch $DIR/s25/foo || error
 737 }
 738 run_test 25a "create file in symlinked directory ==============="
 739
 740 test_25b() {
 741         [ ! -d $DIR/d25 ] && test_25a
 742         $CHECKSTAT -t file $DIR/s25/foo || error
 743 }
 744 run_test 25b "lookup file in symlinked directory ==============="
 745
 746 test_26a() {
 747         mkdir $DIR/d26
 748         mkdir $DIR/d26/d26-2
 749         ln -s d26/d26-2 $DIR/s26
 750         touch $DIR/s26/foo || error
 751 }
 752 run_test 26a "multiple component symlink ======================="
 753
 754 test_26b() {
 755         mkdir -p $DIR/d26b/d26-2
 756         ln -s d26b/d26-2/foo $DIR/s26-2
 757         touch $DIR/s26-2 || error
 758 }
 759 run_test 26b "multiple component symlink at end of lookup ======"
 760
 761 test_26c() {
 762         mkdir $DIR/d26.2
 763         touch $DIR/d26.2/foo
 764         ln -s d26.2 $DIR/s26.2-1
 765         ln -s s26.2-1 $DIR/s26.2-2
 766         ln -s s26.2-2 $DIR/s26.2-3
 767         chmod 0666 $DIR/s26.2-3/foo
 768 }
 769 run_test 26c "chain of symlinks ================================"
 770
 771 # recursive symlinks (bug 439)
 772 test_26d() {
 773         ln -s d26-3/foo $DIR/d26-3
 774 }
 775 run_test 26d "create multiple component recursive symlink ======"
 776
 777 test_26e() {
 778         [ ! -h $DIR/d26-3 ] && test_26d
 779         rm $DIR/d26-3
 780 }
 781 run_test 26e "unlink multiple component recursive symlink ======"
 782
 783 # recursive symlinks (bug 7022)
 784 test_26f() {
 785         mkdir -p $DIR/$tdir
 786         mkdir $DIR/$tdir/$tfile        || error "mkdir $DIR/$tdir/$tfile failed"
 787         cd $DIR/$tdir/$tfile           || error "cd $DIR/$tdir/$tfile failed"
 788         mkdir -p lndir/bar1      || error "mkdir lndir/bar1 failed"
 789         mkdir $tfile             || error "mkdir $tfile failed"
 790         cd $tfile                || error "cd $tfile failed"
 791         ln -s .. dotdot          || error "ln dotdot failed"
 792         ln -s dotdot/lndir lndir || error "ln lndir failed"
 793         cd $DIR/$tdir                 || error "cd $DIR/$tdir failed"
 794         output=`ls $tfile/$tfile/lndir/bar1`
 795         [ "$output" = bar1 ] && error "unexpected output"
 796         rm -r $tfile             || error "rm $tfile failed"
 797         $CHECKSTAT -a $DIR/$tfile || error "$tfile not gone"
 798 }
 799 run_test 26f "rm -r of a directory which has recursive symlink ="
 800
 801 test_27a() {
 802         echo '== stripe sanity =============================================='
 803         mkdir -p $DIR/d27 || error "mkdir failed"
 804         $SETSTRIPE $DIR/d27/f0 -c 1 || error "lstripe failed"
 805         $CHECKSTAT -t file $DIR/d27/f0 || error "checkstat failed"
 806         pass
 807         log "== test_27a: write to one stripe file ========================="
 808         cp /etc/hosts $DIR/d27/f0 || error
 809 }
 810 run_test 27a "one stripe file =================================="
 811
 812 test_27c() {
 813         [ "$OSTCOUNT" -lt "2" ] && skip "skipping 2-stripe test" && return
 814         mkdir -p $DIR/d27
 815         $SETSTRIPE $DIR/d27/f01 -c 2 || error "lstripe failed"
 816         [ `$GETSTRIPE $DIR/d27/f01 | grep -A 10 obdidx | wc -l` -eq 4 ] ||
 817                 error "two-stripe file doesn't have two stripes"
 818         pass
 819         log "== test_27c: write to two stripe file file f01 ================"
 820         dd if=/dev/zero of=$DIR/d27/f01 bs=4k count=4 || error "dd failed"
 821 }
 822 run_test 27c "create two stripe file f01 ======================="
 823
 824 test_27d() {
 825         mkdir -p $DIR/d27
 826         $SETSTRIPE -c0 -i-1 -s0 $DIR/d27/fdef || error "lstripe failed"
 827         $CHECKSTAT -t file $DIR/d27/fdef || error "checkstat failed"
 828         dd if=/dev/zero of=$DIR/d27/fdef bs=4k count=4 || error
 829 }
 830 run_test 27d "create file with default settings ================"
 831
 832 test_27e() {
 833         mkdir -p $DIR/d27
 834         $SETSTRIPE $DIR/d27/f12 -c 2 || error "lstripe failed"
 835         $SETSTRIPE $DIR/d27/f12 -c 2 && error "lstripe succeeded twice"
 836         $CHECKSTAT -t file $DIR/d27/f12 || error "checkstat failed"
 837 }
 838 run_test 27e "lstripe existing file (should return error) ======"
 839
 840 test_27f() {
 841         mkdir -p $DIR/d27
 842         $SETSTRIPE $DIR/d27/fbad -s 100 -i 0 -c 1 && error "lstripe failed"
 843         dd if=/dev/zero of=$DIR/d27/f12 bs=4k count=4 || error "dd failed"
 844         $GETSTRIPE $DIR/d27/fbad || error "lfs getstripe failed"
 845 }
 846 run_test 27f "lstripe with bad stripe size (should return error)"
 847
 848 test_27g() {
 849         mkdir -p $DIR/d27
 850         $MCREATE $DIR/d27/fnone || error "mcreate failed"
 851         pass
 852         log "== test 27h: lfs getstripe with no objects ===================="
 853         $GETSTRIPE $DIR/d27/fnone 2>&1 | grep "no stripe info" || error "has object"
 854         pass
 855         log "== test 27i: lfs getstripe with some objects =================="
 856         touch $DIR/d27/fsome || error "touch failed"
 857         $GETSTRIPE $DIR/d27/fsome | grep obdidx || error "missing objects"
 858 }
 859 run_test 27g "test lfs getstripe ==========================================="
 860
 861 test_27j() {
 862         mkdir -p $DIR/d27
 863         $SETSTRIPE $DIR/d27/f27j -i $OSTCOUNT && error "lstripe failed"||true
 864 }
 865 run_test 27j "lstripe with bad stripe offset (should return error)"
 866
 867 test_27k() { # bug 2844
 868         mkdir -p $DIR/d27
 869         FILE=$DIR/d27/f27k
 870         LL_MAX_BLKSIZE=$((4 * 1024 * 1024))
 871         [ ! -d $DIR/d27 ] && mkdir -p $DIR/d27
 872         $SETSTRIPE $FILE -s 67108864 || error "lstripe failed"
 873         BLKSIZE=`stat $FILE | awk '/IO Block:/ { print $7 }'`
 874         [ $BLKSIZE -le $LL_MAX_BLKSIZE ] || error "$BLKSIZE > $LL_MAX_BLKSIZE"
 875         dd if=/dev/zero of=$FILE bs=4k count=1
 876         BLKSIZE=`stat $FILE | awk '/IO Block:/ { print $7 }'`
 877         [ $BLKSIZE -le $LL_MAX_BLKSIZE ] || error "$BLKSIZE > $LL_MAX_BLKSIZE"
 878 }
 879 run_test 27k "limit i_blksize for broken user apps ============="
 880
 881 test_27l() {
 882         mkdir -p $DIR/d27
 883         mcreate $DIR/f27l || error "creating file"
 884         $RUNAS $SETSTRIPE $DIR/f27l -c 1 && \
 885                 error "lstripe should have failed" || true
 886 }
 887 run_test 27l "check setstripe permissions (should return error)"
 888
 889 test_27m() {
 890         [ "$OSTCOUNT" -lt "2" ] && skip "$OSTCOUNT < 2 OSTs -- skipping" && return
 891         if [ $ORIGFREE -gt $MAXFREE ]; then
 892                 skip "$ORIGFREE > $MAXFREE skipping out-of-space test on OST0"
 893                 return
 894         fi
 895         mkdir -p $DIR/d27
 896         $SETSTRIPE $DIR/d27/f27m_1 -i 0 -c 1
 897         dd if=/dev/zero of=$DIR/d27/f27m_1 bs=1024 count=$MAXFREE && \
 898                 error "dd should fill OST0"
 899         i=2
 900         while $SETSTRIPE $DIR/d27/f27m_$i -i 0 -c 1 ; do
 901                 i=`expr $i + 1`
 902                 [ $i -gt 256 ] && break
 903         done
 904         i=`expr $i + 1`
 905         touch $DIR/d27/f27m_$i
 906         [ `$GETSTRIPE $DIR/d27/f27m_$i | grep -A 10 obdidx | awk '{print $1}'| grep -w "0"` ] && \
 907                 error "OST0 was full but new created file still use it"
 908         i=`expr $i + 1`
 909         touch $DIR/d27/f27m_$i
 910         [ `$GETSTRIPE $DIR/d27/f27m_$i | grep -A 10 obdidx | awk '{print $1}'| grep -w "0"` ] && \
 911                 error "OST0 was full but new created file still use it"
 912         rm -r $DIR/d27
 913         sleep 15
 914 }
 915 run_test 27m "create file while OST0 was full =================="
 916
 917 # osc's keep a NOSPC stick flag that gets unset with rmdir
 918 reset_enospc() {
 919         [ "$1" ] && FAIL_LOC=$1 || FAIL_LOC=0
 920         mkdir -p $DIR/d27/nospc
 921         rmdir $DIR/d27/nospc
 922         lctl set_param fail_loc=$FAIL_LOC
 923 }
 924
 925 exhaust_precreations() {
 926         OSTIDX=$1
 927         OST=$(lctl get_param -n lov.${LOVNAME}.target_obd |
 928               grep ${OSTIDX}": " | \
 929               awk '{print $2}' | sed -e 's/_UUID$//')
 930         # on the mdt's osc
 931         last_id=$(lctl get_param -n osc.*${OST}-osc-MDT0000.prealloc_last_id)
 932         next_id=$(lctl get_param -n osc.*${OST}-osc-MDT0000.prealloc_next_id)
 933
 934         mkdir -p $DIR/d27/${OST}
 935         $SETSTRIPE $DIR/d27/${OST} -i $OSTIDX -c 1
 936 #define OBD_FAIL_OST_ENOSPC              0x215
 937         lctl set_param fail_loc=0x215
 938         echo "Creating to objid $last_id on ost $OST..."
 939         createmany -o $DIR/d27/${OST}/f $next_id $((last_id - next_id + 2))
 940         lctl get_param -n osc.*${OST}-osc-MDT0000.prealloc* | grep '[0-9]'
 941         reset_enospc $2
 942 }
 943
 944 exhaust_all_precreations() {
 945         local i
 946         for (( i=0; i < OSTCOUNT; i++ )) ; do
 947                 exhaust_precreations $i 0x215
 948         done
 949         reset_enospc $1
 950 }
 951
 952 test_27n() {
 953         [ "$OSTCOUNT" -lt "2" ] && skip "too few OSTs" && return
 954         remote_mds && skip "remote MDS" && return
 955
 956         reset_enospc
 957         rm -f $DIR/d27/f27n
 958         exhaust_precreations 0 0x80000215
 959
 960         touch $DIR/d27/f27n || error
 961
 962         reset_enospc
 963 }
 964 run_test 27n "create file with some full OSTs =================="
 965
 966 test_27o() {
 967         [ "$OSTCOUNT" -lt "2" ] && skip "too few OSTs" && return
 968         remote_mds && skip "remote MDS" && return
 969
 970         reset_enospc
 971         rm -f $DIR/d27/f27o
 972         exhaust_all_precreations 0x215
 973         sleep 5
 974
 975         touch $DIR/d27/f27o && error "able to create $DIR/d27/f27o"
 976
 977         reset_enospc
 978         rm -rf $DIR/d27/*
 979 }
 980 run_test 27o "create file with all full OSTs (should error) ===="
 981
 982 test_27p() {
 983         [ "$OSTCOUNT" -lt "2" ] && skip "too few OSTs" && return
 984         remote_mds && skip "remote MDS" && return
 985
 986         reset_enospc
 987         rm -f $DIR/d27/f27p
 988
 989         $MCREATE $DIR/d27/f27p || error
 990         $TRUNCATE $DIR/d27/f27p 80000000 || error
 991         $CHECKSTAT -s 80000000 $DIR/d27/f27p || error
 992
 993         exhaust_precreations 0 0x80000215
 994         echo foo >> $DIR/d27/f27p || error
 995         $CHECKSTAT -s 80000004 $DIR/d27/f27p || error
 996
 997         reset_enospc
 998 }
 999 run_test 27p "append to a truncated file with some full OSTs ==="
1000
1001 test_27q() {
1002         [ "$OSTCOUNT" -lt "2" ] && skip "too few OSTs" && return
1003         remote_mds && skip "remote MDS" && return
1004
1005         reset_enospc
1006         rm -f $DIR/d27/f27q
1007
1008         $MCREATE $DIR/d27/f27q || error "mcreate $DIR/d27/f27q failed"
1009         $TRUNCATE $DIR/d27/f27q 80000000 ||error "truncate $DIR/d27/f27q failed"
1010         $CHECKSTAT -s 80000000 $DIR/d27/f27q || error "checkstat failed"
1011
1012         exhaust_all_precreations 0x215
1013
1014         echo foo >> $DIR/d27/f27q && error "append succeeded"
1015         $CHECKSTAT -s 80000000 $DIR/d27/f27q || error "checkstat 2 failed"
1016
1017         reset_enospc
1018 }
1019 run_test 27q "append to truncated file with all OSTs full (should error) ==="
1020
1021 test_27r() {
1022         [ "$OSTCOUNT" -lt "2" ] && skip "too few OSTs" && return
1023         remote_mds && skip "remote MDS" && return
1024
1025         reset_enospc
1026         rm -f $DIR/d27/f27r
1027         exhaust_precreations 0 0x80000215
1028
1029         $SETSTRIPE $DIR/d27/f27r -i 0 -c 2 # && error
1030
1031         reset_enospc
1032 }
1033 run_test 27r "stripe file with some full OSTs (shouldn't LBUG) ="
1034
1035 test_27s() { # bug 10725
1036        mkdir -p $DIR/$tdir
1037        $LSTRIPE $DIR/$tdir $((2048 * 1024 * 1024)) -1 2 && \
1038                error "stripe width >= 2^32 succeeded" || true
1039 }
1040 run_test 27s "lsm_xfersize overflow (should error) (bug 10725)"
1041
1042 test_27t() { # bug 10864
1043         WDIR=`pwd`
1044         WLFS=`which lfs`
1045         cd $DIR
1046         touch $tfile
1047         $WLFS getstripe $tfile
1048         cd $WDIR
1049 }
1050 run_test 27t "check that utils parse path correctly"
1051
1052 test_27u() { # bug 4900
1053         [ "$OSTCOUNT" -lt "2" ] && skip "too few OSTs" && return
1054         remote_mds && skip "remote MDS" && return
1055
1056         #define OBD_FAIL_MDS_OSC_PRECREATE      0x13d
1057
1058         lctl set_param fail_loc=0x13d
1059         mkdir -p $DIR/d27u
1060         createmany -o $DIR/d27u/t- 1000
1061         lctl set_param fail_loc=0
1062
1063         TLOG=$DIR/$tfile.getstripe
1064         $GETSTRIPE $DIR/d27u > $TLOG
1065         OBJS=`awk -vobj=0 '($1 == 0) { obj += 1 } END { print obj;}' $TLOG`
1066         unlinkmany $DIR/d27u/t- 1000
1067         [ $OBJS -gt 0 ] && \
1068                 error "$OBJS objects created on OST-0.  See $TLOG" || pass
1069 }
1070 run_test 27u "skip object creation on OSC w/o objects =========="
1071
1072 test_27v() { # bug 4900
1073         [ "$OSTCOUNT" -lt "2" ] && skip "too few OSTs" && return
1074         remote_mds && skip "remote MDS" && return
1075
1076         exhaust_all_precreations
1077
1078         mkdir -p $DIR/$tdir
1079         $SETSTRIPE $DIR/$tdir -c 1         # 1 stripe / file
1080
1081         touch $DIR/$tdir/$tfile
1082         #define OBD_FAIL_TGT_DELAY_PRECREATE     0x705
1083         lctl set_param fail_loc=0x705
1084         START=`date +%s`
1085         for F in `seq 1 32`; do
1086                 touch $DIR/$tdir/$tfile.$F
1087         done
1088         lctl set_param fail_loc=0
1089
1090         FINISH=`date +%s`
1091         TIMEOUT=`lctl get_param -n timeout`
1092         [ $((FINISH - START)) -ge $((TIMEOUT / 2)) ] && \
1093                error "$FINISH - $START >= $TIMEOUT / 2"
1094
1095         reset_enospc
1096 }
1097 run_test 27v "skip object creation on slow OST ================="
1098
1099 test_27w() { # bug 10997
1100         mkdir -p $DIR/d27w || error "mkdir failed"
1101         $LSTRIPE $DIR/d27w/f0 -s 65536 || error "lstripe failed"
1102         size=`$LSTRIPEINFO $DIR/d27w/f0 | awk {'print $1'}`
1103         [ $size -ne 65536 ] && error "stripe size $size != 65536" || true
1104
1105         [ "$OSTCOUNT" -lt "2" ] && skip "skipping multiple stripe count/offset test" && return
1106         for i in `seq 1 $OSTCOUNT`; do
1107                 offset=$(($i-1))
1108                 $LSTRIPE $DIR/d27w/f$i -c $i -i $offset || error "lstripe -c $i -i $offset failed"
1109                 count=`$LSTRIPEINFO $DIR/d27w/f$i | awk {'print $2'}`
1110                 index=`$LSTRIPEINFO $DIR/d27w/f$i | awk {'print $3'}`
1111                 [ $count -ne $i ] && error "stripe count $count != $i" || true
1112                 [ $index -ne $offset ] && error "stripe offset $index != $offset" || true
1113         done
1114 }
1115 run_test 27w "check lfs setstripe -c -s -i options ============="
1116
1117 test_28() {
1118         mkdir $DIR/d28
1119         $CREATETEST $DIR/d28/ct || error
1120 }
1121 run_test 28 "create/mknod/mkdir with bad file types ============"
1122
1123 test_29() {
1124         cancel_lru_locks mdc
1125         mkdir $DIR/d29
1126         touch $DIR/d29/foo
1127         log 'first d29'
1128         ls -l $DIR/d29
1129
1130         declare -i LOCKCOUNTORIG=0
1131         for lock_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_count); do
1132                 let LOCKCOUNTORIG=$LOCKCOUNTORIG+$lock_count
1133         done
1134         [ $LOCKCOUNTORIG -eq 0 ] && echo "No mdc lock count" && return 1
1135
1136         declare -i LOCKUNUSEDCOUNTORIG=0
1137         for unused_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_unused_count); do
1138                 let LOCKUNUSEDCOUNTORIG=$LOCKUNUSEDCOUNTORIG+$unused_count
1139         done
1140
1141         log 'second d29'
1142         ls -l $DIR/d29
1143         log 'done'
1144
1145         declare -i LOCKCOUNTCURRENT=0
1146         for lock_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_count); do
1147                 let LOCKCOUNTCURRENT=$LOCKCOUNTCURRENT+$lock_count
1148         done
1149
1150         declare -i LOCKUNUSEDCOUNTCURRENT=0
1151         for unused_count in $(lctl get_param -n ldlm.namespaces.*mdc*.lock_unused_count); do
1152                 let LOCKUNUSEDCOUNTCURRENT=$LOCKUNUSEDCOUNTCURRENT+$unused_count
1153         done
1154
1155         if [ "$LOCKCOUNTCURRENT" -gt "$LOCKCOUNTORIG" ]; then
1156                 lctl set_param -n ldlm.dump_namespaces ""
1157                 error "CURRENT: $LOCKCOUNTCURRENT > $LOCKCOUNTORIG"
1158                 $LCTL dk | sort -k4 -t: > $TMP/test_29.dk
1159                 log "dumped log to $TMP/test_29.dk (bug 5793)"
1160                 return 2
1161         fi
1162         if [ "$LOCKUNUSEDCOUNTCURRENT" -gt "$LOCKUNUSEDCOUNTORIG" ]; then
1163                 error "UNUSED: $LOCKUNUSEDCOUNTCURRENT > $LOCKUNUSEDCOUNTORIG"
1164                 $LCTL dk | sort -k4 -t: > $TMP/test_29.dk
1165                 log "dumped log to $TMP/test_29.dk (bug 5793)"
1166                 return 3
1167         fi
1168 }
1169 run_test 29 "IT_GETATTR regression  ============================"
1170
1171 test_30() {
1172         cp `which ls` $DIR || cp /bin/ls $DIR
1173         $DIR/ls /
1174         rm $DIR/ls
1175 }
1176 run_test 30 "run binary from Lustre (execve) ==================="
1177
1178 test_31a() {
1179         $OPENUNLINK $DIR/f31 $DIR/f31 || error
1180         $CHECKSTAT -a $DIR/f31 || error
1181 }
1182 run_test 31a "open-unlink file =================================="
1183
1184 test_31b() {
1185         touch $DIR/f31 || error
1186         ln $DIR/f31 $DIR/f31b || error
1187         multiop $DIR/f31b Ouc || error
1188         $CHECKSTAT -t file $DIR/f31 || error
1189 }
1190 run_test 31b "unlink file with multiple links while open ======="
1191
1192 test_31c() {
1193         touch $DIR/f31 || error
1194         ln $DIR/f31 $DIR/f31c || error
1195         multiop_bg_pause $DIR/f31 O_uc || return 1
1196         MULTIPID=$!
1197         multiop $DIR/f31c Ouc
1198         kill -USR1 $MULTIPID
1199         wait $MULTIPID
1200 }
1201 run_test 31c "open-unlink file with multiple links ============="
1202
1203 test_31d() {
1204         opendirunlink $DIR/d31d $DIR/d31d || error
1205         $CHECKSTAT -a $DIR/d31d || error
1206 }
1207 run_test 31d "remove of open directory ========================="
1208
1209 test_31e() { # bug 2904
1210         check_kernel_version 34 || return 0
1211         openfilleddirunlink $DIR/d31e || error
1212 }
1213 run_test 31e "remove of open non-empty directory ==============="
1214
1215 test_31f() { # bug 4554
1216         set -vx
1217         mkdir $DIR/d31f
1218         $SETSTRIPE $DIR/d31f -s 1048576 -c 1
1219         cp /etc/hosts $DIR/d31f
1220         ls -l $DIR/d31f
1221         $GETSTRIPE $DIR/d31f/hosts
1222         multiop_bg_pause $DIR/d31f D_c || return 1
1223         MULTIPID=$!
1224
1225         rm -rv $DIR/d31f || error "first of $DIR/d31f"
1226         mkdir $DIR/d31f
1227         $SETSTRIPE $DIR/d31f -s 1048576 -c 1
1228         cp /etc/hosts $DIR/d31f
1229         ls -l $DIR/d31f
1230         $DIR/d31f/hosts
1231         multiop_bg_pause $DIR/d31f D_c || return 1
1232         MULTIPID2=$!
1233
1234         kill -USR1 $MULTIPID || error "first opendir $MULTIPID not running"
1235         wait $MULTIPID || error "first opendir $MULTIPID failed"
1236
1237         sleep 6
1238
1239         kill -USR1 $MULTIPID2 || error "second opendir $MULTIPID not running"
1240         wait $MULTIPID2 || error "second opendir $MULTIPID2 failed"
1241         set +vx
1242 }
1243 run_test 31f "remove of open directory with open-unlink file ==="
1244
1245 test_31g() {
1246         echo "-- cross directory link --"
1247         mkdir $DIR/d31g{a,b}
1248         touch $DIR/d31ga/f
1249         ln $DIR/d31ga/f $DIR/d31gb/g
1250         $CHECKSTAT -t file $DIR/d31ga/f || error "source"
1251         [ `stat -c%h $DIR/d31ga/f` == '2' ] || error "source nlink"
1252         $CHECKSTAT -t file $DIR/d31gb/g || error "target"
1253         [ `stat -c%h $DIR/d31gb/g` == '2' ] || error "target nlink"
1254 }
1255 run_test 31g "cross directory link==============="
1256
1257 test_31h() {
1258         echo "-- cross directory link --"
1259         mkdir $DIR/d31h
1260         mkdir $DIR/d31h/dir
1261         touch $DIR/d31h/f
1262         ln $DIR/d31h/f $DIR/d31h/dir/g
1263         $CHECKSTAT -t file $DIR/d31h/f || error "source"
1264         [ `stat -c%h $DIR/d31h/f` == '2' ] || error "source nlink"
1265         $CHECKSTAT -t file $DIR/d31h/dir/g || error "target"
1266         [ `stat -c%h $DIR/d31h/dir/g` == '2' ] || error "target nlink"
1267 }
1268 run_test 31h "cross directory link under child==============="
1269
1270 test_31i() {
1271         echo "-- cross directory link --"
1272         mkdir $DIR/d31i
1273         mkdir $DIR/d31i/dir
1274         touch $DIR/d31i/dir/f
1275         ln $DIR/d31i/dir/f $DIR/d31i/g
1276         $CHECKSTAT -t file $DIR/d31i/dir/f || error "source"
1277         [ `stat -c%h $DIR/d31i/dir/f` == '2' ] || error "source nlink"
1278         $CHECKSTAT -t file $DIR/d31i/g || error "target"
1279         [ `stat -c%h $DIR/d31i/g` == '2' ] || error "target nlink"
1280 }
1281 run_test 31i "cross directory link under parent==============="
1282
1283
1284 test_31j() {
1285         mkdir $DIR/d31j
1286         mkdir $DIR/d31j/dir1
1287         ln $DIR/d31j/dir1 $DIR/d31j/dir2 && error "ln for dir"
1288         link $DIR/d31j/dir1 $DIR/d31j/dir3 && error "link for dir"
1289         mlink $DIR/d31j/dir1 $DIR/d31j/dir4 && error "mlink for dir"
1290         mlink $DIR/d31j/dir1 $DIR/d31j/dir1 && error "mlink to the same dir"
1291         return 0
1292 }
1293 run_test 31j "link for directory==============="
1294
1295
1296 test_31k() {
1297         mkdir $DIR/d31k
1298         touch $DIR/d31k/s
1299         touch $DIR/d31k/exist
1300         mlink $DIR/d31k/s $DIR/d31k/t || error "mlink"
1301         mlink $DIR/d31k/s $DIR/d31k/exist && error "mlink to exist file"
1302         mlink $DIR/d31k/s $DIR/d31k/s && error "mlink to the same file"
1303         mlink $DIR/d31k/s $DIR/d31k && error "mlink to parent dir"
1304         mlink $DIR/d31k $DIR/d31k/s && error "mlink parent dir to target"
1305         mlink $DIR/d31k/not-exist $DIR/d31k/foo && error "mlink non-existing to new"
1306         mlink $DIR/d31k/not-exist $DIR/d31k/s && error "mlink non-existing to exist"
1307         return 0
1308 }
1309 run_test 31k "link to file: the same, non-existing, dir==============="
1310
1311 test_31m() {
1312         mkdir $DIR/d31m
1313         touch $DIR/d31m/s
1314         mkdir $DIR/d31m2
1315         touch $DIR/d31m2/exist
1316         mlink $DIR/d31m/s $DIR/d31m2/t || error "mlink"
1317         mlink $DIR/d31m/s $DIR/d31m2/exist && error "mlink to exist file"
1318         mlink $DIR/d31m/s $DIR/d31m2 && error "mlink to parent dir"
1319         mlink $DIR/d31m2 $DIR/d31m/s && error "mlink parent dir to target"
1320         mlink $DIR/d31m/not-exist $DIR/d31m2/foo && error "mlink non-existing to new"
1321         mlink $DIR/d31m/not-exist $DIR/d31m2/s && error "mlink non-existing to exist"
1322         return 0
1323 }
1324 run_test 31m "link to file: the same, non-existing, dir==============="
1325
1326 test_32a() {
1327         echo "== more mountpoints and symlinks ================="
1328         [ -e $DIR/d32a ] && rm -fr $DIR/d32a
1329         mkdir -p $DIR/d32a/ext2-mountpoint
1330         mount -t ext2 -o loop $EXT2_DEV $DIR/d32a/ext2-mountpoint || error
1331         $CHECKSTAT -t dir $DIR/d32a/ext2-mountpoint/.. || error
1332         $UMOUNT $DIR/d32a/ext2-mountpoint || error
1333 }
1334 run_test 32a "stat d32a/ext2-mountpoint/.. ====================="
1335
1336 test_32b() {
1337         [ -e $DIR/d32b ] && rm -fr $DIR/d32b
1338         mkdir -p $DIR/d32b/ext2-mountpoint
1339         mount -t ext2 -o loop $EXT2_DEV $DIR/d32b/ext2-mountpoint || error
1340         ls -al $DIR/d32b/ext2-mountpoint/.. || error
1341         $UMOUNT $DIR/d32b/ext2-mountpoint || error
1342 }
1343 run_test 32b "open d32b/ext2-mountpoint/.. ====================="
1344
1345 test_32c() {
1346         [ -e $DIR/d32c ] && rm -fr $DIR/d32c
1347         mkdir -p $DIR/d32c/ext2-mountpoint
1348         mount -t ext2 -o loop $EXT2_DEV $DIR/d32c/ext2-mountpoint || error
1349         mkdir -p $DIR/d32c/d2/test_dir
1350         $CHECKSTAT -t dir $DIR/d32c/ext2-mountpoint/../d2/test_dir || error
1351         $UMOUNT $DIR/d32c/ext2-mountpoint || error
1352 }
1353 run_test 32c "stat d32c/ext2-mountpoint/../d2/test_dir ========="
1354
1355 test_32d() {
1356         [ -e $DIR/d32d ] && rm -fr $DIR/d32d
1357         mkdir -p $DIR/d32d/ext2-mountpoint
1358         mount -t ext2 -o loop $EXT2_DEV $DIR/d32d/ext2-mountpoint || error
1359         mkdir -p $DIR/d32d/d2/test_dir
1360         ls -al $DIR/d32d/ext2-mountpoint/../d2/test_dir || error
1361         $UMOUNT $DIR/d32d/ext2-mountpoint || error
1362 }
1363 run_test 32d "open d32d/ext2-mountpoint/../d2/test_dir ========="
1364
1365 test_32e() {
1366         [ -e $DIR/d32e ] && rm -fr $DIR/d32e
1367         mkdir -p $DIR/d32e/tmp
1368         TMP_DIR=$DIR/d32e/tmp
1369         ln -s $DIR/d32e $TMP_DIR/symlink11
1370         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
1371         $CHECKSTAT -t link $DIR/d32e/tmp/symlink11 || error
1372         $CHECKSTAT -t link $DIR/d32e/symlink01 || error
1373 }
1374 run_test 32e "stat d32e/symlink->tmp/symlink->lustre-subdir ===="
1375
1376 test_32f() {
1377         [ -e $DIR/d32f ] && rm -fr $DIR/d32f
1378         mkdir -p $DIR/d32f/tmp
1379         TMP_DIR=$DIR/d32f/tmp
1380         ln -s $DIR/d32f $TMP_DIR/symlink11
1381         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
1382         ls $DIR/d32f/tmp/symlink11  || error
1383         ls $DIR/d32f/symlink01 || error
1384 }
1385 run_test 32f "open d32f/symlink->tmp/symlink->lustre-subdir ===="
1386
1387 test_32g() {
1388         TMP_DIR=$DIR/$tdir/tmp
1389         mkdir -p $TMP_DIR $DIR/${tdir}2
1390         ln -s $DIR/${tdir}2 $TMP_DIR/symlink12
1391         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
1392         $CHECKSTAT -t link $TMP_DIR/symlink12 || error
1393         $CHECKSTAT -t link $DIR/$tdir/symlink02 || error
1394         $CHECKSTAT -t dir -f $TMP_DIR/symlink12 || error
1395         $CHECKSTAT -t dir -f $DIR/$tdir/symlink02 || error
1396 }
1397 run_test 32g "stat d32g/symlink->tmp/symlink->lustre-subdir/${tdir}2"
1398
1399 test_32h() {
1400         rm -fr $DIR/$tdir $DIR/${tdir}2
1401         TMP_DIR=$DIR/$tdir/tmp
1402         mkdir -p $TMP_DIR $DIR/${tdir}2
1403         ln -s $DIR/${tdir}2 $TMP_DIR/symlink12
1404         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
1405         ls $TMP_DIR/symlink12 || error
1406         ls $DIR/$tdir/symlink02  || error
1407 }
1408 run_test 32h "open d32h/symlink->tmp/symlink->lustre-subdir/${tdir}2"
1409
1410 test_32i() {
1411         [ -e $DIR/d32i ] && rm -fr $DIR/d32i
1412         mkdir -p $DIR/d32i/ext2-mountpoint
1413         mount -t ext2 -o loop $EXT2_DEV $DIR/d32i/ext2-mountpoint || error
1414         touch $DIR/d32i/test_file
1415         $CHECKSTAT -t file $DIR/d32i/ext2-mountpoint/../test_file || error
1416         $UMOUNT $DIR/d32i/ext2-mountpoint || error
1417 }
1418 run_test 32i "stat d32i/ext2-mountpoint/../test_file ==========="
1419
1420 test_32j() {
1421         [ -e $DIR/d32j ] && rm -fr $DIR/d32j
1422         mkdir -p $DIR/d32j/ext2-mountpoint
1423         mount -t ext2 -o loop $EXT2_DEV $DIR/d32j/ext2-mountpoint || error
1424         touch $DIR/d32j/test_file
1425         cat $DIR/d32j/ext2-mountpoint/../test_file || error
1426         $UMOUNT $DIR/d32j/ext2-mountpoint || error
1427 }
1428 run_test 32j "open d32j/ext2-mountpoint/../test_file ==========="
1429
1430 test_32k() {
1431         rm -fr $DIR/d32k
1432         mkdir -p $DIR/d32k/ext2-mountpoint
1433         mount -t ext2 -o loop $EXT2_DEV $DIR/d32k/ext2-mountpoint
1434         mkdir -p $DIR/d32k/d2
1435         touch $DIR/d32k/d2/test_file || error
1436         $CHECKSTAT -t file $DIR/d32k/ext2-mountpoint/../d2/test_file || error
1437         $UMOUNT $DIR/d32k/ext2-mountpoint || error
1438 }
1439 run_test 32k "stat d32k/ext2-mountpoint/../d2/test_file ========"
1440
1441 test_32l() {
1442         rm -fr $DIR/d32l
1443         mkdir -p $DIR/d32l/ext2-mountpoint
1444         mount -t ext2 -o loop $EXT2_DEV $DIR/d32l/ext2-mountpoint || error
1445         mkdir -p $DIR/d32l/d2
1446         touch $DIR/d32l/d2/test_file
1447         cat  $DIR/d32l/ext2-mountpoint/../d2/test_file || error
1448         $UMOUNT $DIR/d32l/ext2-mountpoint || error
1449 }
1450 run_test 32l "open d32l/ext2-mountpoint/../d2/test_file ========"
1451
1452 test_32m() {
1453         rm -fr $DIR/d32m
1454         mkdir -p $DIR/d32m/tmp
1455         TMP_DIR=$DIR/d32m/tmp
1456         ln -s $DIR $TMP_DIR/symlink11
1457         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
1458         $CHECKSTAT -t link $DIR/d32m/tmp/symlink11 || error
1459         $CHECKSTAT -t link $DIR/d32m/symlink01 || error
1460 }
1461 run_test 32m "stat d32m/symlink->tmp/symlink->lustre-root ======"
1462
1463 test_32n() {
1464         rm -fr $DIR/d32n
1465         mkdir -p $DIR/d32n/tmp
1466         TMP_DIR=$DIR/d32n/tmp
1467         ln -s $DIR $TMP_DIR/symlink11
1468         ln -s $TMP_DIR/symlink11 $TMP_DIR/../symlink01
1469         ls -l $DIR/d32n/tmp/symlink11  || error
1470         ls -l $DIR/d32n/symlink01 || error
1471 }
1472 run_test 32n "open d32n/symlink->tmp/symlink->lustre-root ======"
1473
1474 test_32o() {
1475         rm -fr $DIR/d32o $DIR/$tfile
1476         touch $DIR/$tfile
1477         mkdir -p $DIR/d32o/tmp
1478         TMP_DIR=$DIR/d32o/tmp
1479         ln -s $DIR/$tfile $TMP_DIR/symlink12
1480         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
1481         $CHECKSTAT -t link $DIR/d32o/tmp/symlink12 || error
1482         $CHECKSTAT -t link $DIR/d32o/symlink02 || error
1483         $CHECKSTAT -t file -f $DIR/d32o/tmp/symlink12 || error
1484         $CHECKSTAT -t file -f $DIR/d32o/symlink02 || error
1485 }
1486 run_test 32o "stat d32o/symlink->tmp/symlink->lustre-root/$tfile"
1487
1488 test_32p() {
1489     log 32p_1
1490         rm -fr $DIR/d32p
1491     log 32p_2
1492         rm -f $DIR/$tfile
1493     log 32p_3
1494         touch $DIR/$tfile
1495     log 32p_4
1496         mkdir -p $DIR/d32p/tmp
1497     log 32p_5
1498         TMP_DIR=$DIR/d32p/tmp
1499     log 32p_6
1500         ln -s $DIR/$tfile $TMP_DIR/symlink12
1501     log 32p_7
1502         ln -s $TMP_DIR/symlink12 $TMP_DIR/../symlink02
1503     log 32p_8
1504         cat $DIR/d32p/tmp/symlink12 || error
1505     log 32p_9
1506         cat $DIR/d32p/symlink02 || error
1507     log 32p_10
1508 }
1509 run_test 32p "open d32p/symlink->tmp/symlink->lustre-root/$tfile"
1510
1511 test_32q() {
1512         [ -e $DIR/d32q ] && rm -fr $DIR/d32q
1513         mkdir -p $DIR/d32q
1514         touch $DIR/d32q/under_the_mount
1515         mount -t ext2 -o loop $EXT2_DEV $DIR/d32q
1516         ls $DIR/d32q/under_the_mount && error || true
1517         $UMOUNT $DIR/d32q || error
1518 }
1519 run_test 32q "stat follows mountpoints in Lustre (should return error)"
1520
1521 test_32r() {
1522         [ -e $DIR/d32r ] && rm -fr $DIR/d32r
1523         mkdir -p $DIR/d32r
1524         touch $DIR/d32r/under_the_mount
1525         mount -t ext2 -o loop $EXT2_DEV $DIR/d32r
1526         ls $DIR/d32r | grep -q under_the_mount && error || true
1527         $UMOUNT $DIR/d32r || error
1528 }
1529 run_test 32r "opendir follows mountpoints in Lustre (should return error)"
1530
1531 test_33() {
1532         rm -f $DIR/$tfile
1533         touch $DIR/$tfile
1534         chmod 444 $DIR/$tfile
1535         chown $RUNAS_ID $DIR/$tfile
1536         log 33_1
1537         $RUNAS $OPENFILE -f O_RDWR $DIR/$tfile && error || true
1538         log 33_2
1539 }
1540 run_test 33 "write file with mode 444 (should return error) ===="
1541
1542 test_33a() {
1543         rm -fr $DIR/d33
1544         mkdir -p $DIR/d33
1545         chown $RUNAS_ID $DIR/d33
1546         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/d33/f33|| error "create"
1547         $RUNAS $OPENFILE -f O_RDWR:O_CREAT -m 0444 $DIR/d33/f33 && \
1548                 error "open RDWR" || true
1549 }
1550 run_test 33a "test open file(mode=0444) with O_RDWR (should return error)"
1551
1552 test_33b() {
1553         rm -fr $DIR/d33
1554         mkdir -p $DIR/d33
1555         chown $RUNAS_ID $DIR/d33
1556         $RUNAS $OPENFILE -f 1286739555 $DIR/d33/f33 && error "create" || true
1557 }
1558 run_test 33b "test open file with malformed flags (No panic and return error)"
1559
1560 TEST_34_SIZE=${TEST_34_SIZE:-2000000000000}
1561 test_34a() {
1562         rm -f $DIR/f34
1563         $MCREATE $DIR/f34 || error
1564         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" || error
1565         $TRUNCATE $DIR/f34 $TEST_34_SIZE || error
1566         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" || error
1567         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
1568 }
1569 run_test 34a "truncate file that has not been opened ==========="
1570
1571 test_34b() {
1572         [ ! -f $DIR/f34 ] && test_34a
1573         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
1574         $OPENFILE -f O_RDONLY $DIR/f34
1575         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" || error
1576         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
1577 }
1578 run_test 34b "O_RDONLY opening file doesn't create objects ====="
1579
1580 test_34c() {
1581         [ ! -f $DIR/f34 ] && test_34a
1582         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
1583         $OPENFILE -f O_RDWR $DIR/f34
1584         $GETSTRIPE $DIR/f34 2>&1 | grep -q "no stripe info" && error
1585         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
1586 }
1587 run_test 34c "O_RDWR opening file-with-size works =============="
1588
1589 test_34d() {
1590         [ ! -f $DIR/f34 ] && test_34a
1591         dd if=/dev/zero of=$DIR/f34 conv=notrunc bs=4k count=1 || error
1592         $CHECKSTAT -s $TEST_34_SIZE $DIR/f34 || error
1593         rm $DIR/f34
1594 }
1595 run_test 34d "write to sparse file ============================="
1596
1597 test_34e() {
1598         rm -f $DIR/f34e
1599         $MCREATE $DIR/f34e || error
1600         $TRUNCATE $DIR/f34e 1000 || error
1601         $CHECKSTAT -s 1000 $DIR/f34e || error
1602         $OPENFILE -f O_RDWR $DIR/f34e
1603         $CHECKSTAT -s 1000 $DIR/f34e || error
1604 }
1605 run_test 34e "create objects, some with size and some without =="
1606
1607 test_34f() { # bug 6242, 6243
1608         SIZE34F=48000
1609         rm -f $DIR/f34f
1610         $MCREATE $DIR/f34f || error
1611         $TRUNCATE $DIR/f34f $SIZE34F || error "truncating $DIR/f3f to $SIZE34F"
1612         dd if=$DIR/f34f of=$TMP/f34f
1613         $CHECKSTAT -s $SIZE34F $TMP/f34f || error "$TMP/f34f not $SIZE34F bytes"
1614         dd if=/dev/zero of=$TMP/f34fzero bs=$SIZE34F count=1
1615         cmp $DIR/f34f $TMP/f34fzero || error "$DIR/f34f not all zero"
1616         cmp $TMP/f34f $TMP/f34fzero || error "$TMP/f34f not all zero"
1617         rm $TMP/f34f $TMP/f34fzero $DIR/f34f
1618 }
1619 run_test 34f "read from a file with no objects until EOF ======="
1620
1621 test_35a() {
1622         cp /bin/sh $DIR/f35a
1623         chmod 444 $DIR/f35a
1624         chown $RUNAS_ID $DIR/f35a
1625         $RUNAS $DIR/f35a && error || true
1626         rm $DIR/f35a
1627 }
1628 run_test 35a "exec file with mode 444 (should return and not leak) ====="
1629
1630 test_36a() {
1631         rm -f $DIR/f36
1632         utime $DIR/f36 || error
1633 }
1634 run_test 36a "MDS utime check (mknod, utime) ==================="
1635
1636 test_36b() {
1637         echo "" > $DIR/f36
1638         utime $DIR/f36 || error
1639 }
1640 run_test 36b "OST utime check (open, utime) ===================="
1641
1642 test_36c() {
1643         rm -f $DIR/d36/f36
1644         mkdir $DIR/d36
1645         chown $RUNAS_ID $DIR/d36
1646         $RUNAS utime $DIR/d36/f36 || error
1647 }
1648 run_test 36c "non-root MDS utime check (mknod, utime) =========="
1649
1650 test_36d() {
1651         [ ! -d $DIR/d36 ] && test_36c
1652         echo "" > $DIR/d36/f36
1653         $RUNAS utime $DIR/d36/f36 || error
1654 }
1655 run_test 36d "non-root OST utime check (open, utime) ==========="
1656
1657 test_36e() {
1658         [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID = UID = $UID -- skipping" && return
1659         mkdir -p $DIR/$tdir
1660         touch $DIR/$tdir/$tfile
1661         $RUNAS utime $DIR/$tdir/$tfile && \
1662                 error "utime worked, expected failure" || true
1663 }
1664 run_test 36e "utime on non-owned file (should return error) ===="
1665
1666 test_36f() {
1667         export LANG=C LC_LANG=C # for date language
1668
1669         DATESTR="Dec 20  2000"
1670         mkdir -p $DIR/$tdir
1671         #define OBD_FAIL_OST_BRW_PAUSE_BULK 0x214
1672         lctl set_param fail_loc=0x80000214
1673         date; date +%s
1674         cp /etc/hosts $DIR/$tdir/$tfile
1675         sync & # write RPC generated with "current" inode timestamp, but delayed
1676         sleep 1
1677         touch --date="$DATESTR" $DIR/$tdir/$tfile # setattr timestamp in past
1678         LS_BEFORE="`ls -l $DIR/$tdir/$tfile`" # old timestamp from client cache
1679         cancel_lru_locks osc
1680         LS_AFTER="`ls -l $DIR/$tdir/$tfile`"  # timestamp from OST object
1681         date; date +%s
1682         [ "$LS_BEFORE" != "$LS_AFTER" ] && \
1683                 echo "BEFORE: $LS_BEFORE" && \
1684                 echo "AFTER : $LS_AFTER" && \
1685                 echo "WANT  : $DATESTR" && \
1686                 error "$DIR/$tdir/$tfile timestamps changed" || true
1687 }
1688 run_test 36f "utime on file racing with OST BRW write =========="
1689
1690 test_36g() {
1691         remote_ost && skip "remote OST" && return
1692         export FMD_MAX_AGE=`do_facet ost1 lctl get_param -n obdfilter.*.client_cache_seconds 2> /dev/null | head -n 1`
1693         FMD_BEFORE="`awk '/ll_fmd_cache/ { print $2 }' /proc/slabinfo`"
1694         touch $DIR/d36/$tfile
1695         sleep $((FMD_MAX_AGE + 12))
1696         FMD_AFTER="`awk '/ll_fmd_cache/ { print $2 }' /proc/slabinfo`"
1697         [ "$FMD_AFTER" -gt "$FMD_BEFORE" ] && \
1698                 echo "AFTER : $FMD_AFTER > BEFORE $FMD_BEFORE" && \
1699                 error "fmd didn't expire after ping" || true
1700 }
1701 run_test 36g "filter mod data cache expiry ====================="
1702
1703 test_37() {
1704         mkdir -p $DIR/$tdir
1705         echo f > $DIR/$tdir/fbugfile
1706         mount -t ext2 -o loop $EXT2_DEV $DIR/$tdir
1707         ls $DIR/$tdir | grep "\<fbugfile\>" && error
1708         $UMOUNT $DIR/$tdir || error
1709         rm -f $DIR/$tdir/fbugfile || error
1710 }
1711 run_test 37 "ls a mounted file system to check old content ====="
1712
1713 test_38() {
1714         o_directory $DIR/$tfile
1715 }
1716 run_test 38 "open a regular file with O_DIRECTORY =============="
1717
1718 test_39() {
1719         touch $DIR/$tfile
1720         touch $DIR/${tfile}2
1721 #       ls -l  $DIR/$tfile $DIR/${tfile}2
1722 #       ls -lu  $DIR/$tfile $DIR/${tfile}2
1723 #       ls -lc  $DIR/$tfile $DIR/${tfile}2
1724         sleep 2
1725         $OPENFILE -f O_CREAT:O_TRUNC:O_WRONLY $DIR/${tfile}2
1726         if [ ! $DIR/${tfile}2 -nt $DIR/$tfile ]; then
1727                 echo "mtime"
1728                 ls -l  $DIR/$tfile $DIR/${tfile}2
1729                 echo "atime"
1730                 ls -lu  $DIR/$tfile $DIR/${tfile}2
1731                 echo "ctime"
1732                 ls -lc  $DIR/$tfile $DIR/${tfile}2
1733                 error "O_TRUNC didn't change timestamps"
1734         fi
1735 }
1736 run_test 39 "mtime changed on create ==========================="
1737
1738 test_40() {
1739         dd if=/dev/zero of=$DIR/f40 bs=4096 count=1
1740         $RUNAS $OPENFILE -f O_WRONLY:O_TRUNC $DIR/f40 && error
1741         $CHECKSTAT -t file -s 4096 $DIR/f40 || error
1742 }
1743 run_test 40 "failed open(O_TRUNC) doesn't truncate ============="
1744
1745 test_41() {
1746         # bug 1553
1747         small_write $DIR/f41 18
1748 }
1749 run_test 41 "test small file write + fstat ====================="
1750
1751 count_ost_writes() {
1752         lctl get_param -n osc.*.stats |
1753             awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }'
1754 }
1755
1756 # decent default
1757 WRITEBACK_SAVE=500
1758 DIRTY_RATIO_SAVE=40
1759 MAX_DIRTY_RATIO=50
1760 BG_DIRTY_RATIO_SAVE=10
1761 MAX_BG_DIRTY_RATIO=25
1762
1763 start_writeback() {
1764         trap 0
1765         # in 2.6, restore /proc/sys/vm/dirty_writeback_centisecs,
1766         # dirty_ratio, dirty_background_ratio
1767         if [ -f /proc/sys/vm/dirty_writeback_centisecs ]; then
1768                 sysctl -w vm.dirty_writeback_centisecs=$WRITEBACK_SAVE
1769                 sysctl -w vm.dirty_background_ratio=$BG_DIRTY_RATIO_SAVE
1770                 sysctl -w vm.dirty_ratio=$DIRTY_RATIO_SAVE
1771         else
1772                 # if file not here, we are a 2.4 kernel
1773                 kill -CONT `pidof kupdated`
1774         fi
1775 }
1776
1777 stop_writeback() {
1778         # setup the trap first, so someone cannot exit the test at the
1779         # exact wrong time and mess up a machine
1780         trap start_writeback EXIT
1781         # in 2.6, save and 0 /proc/sys/vm/dirty_writeback_centisecs
1782         if [ -f /proc/sys/vm/dirty_writeback_centisecs ]; then
1783                 WRITEBACK_SAVE=`sysctl -n vm.dirty_writeback_centisecs`
1784                 sysctl -w vm.dirty_writeback_centisecs=0
1785                 sysctl -w vm.dirty_writeback_centisecs=0
1786                 # save and increase /proc/sys/vm/dirty_ratio
1787                 DIRTY_RATIO_SAVE=`sysctl -n vm.dirty_ratio`
1788                 sysctl -w vm.dirty_ratio=$MAX_DIRTY_RATIO
1789                 # save and increase /proc/sys/vm/dirty_background_ratio
1790                 BG_DIRTY_RATIO_SAVE=`sysctl -n vm.dirty_background_ratio`
1791                 sysctl -w vm.dirty_background_ratio=$MAX_BG_DIRTY_RATIO
1792         else
1793                 # if file not here, we are a 2.4 kernel
1794                 kill -STOP `pidof kupdated`
1795         fi
1796 }
1797
1798 # ensure that all stripes have some grant before we test client-side cache
1799 setup_test42() {
1800         [ "$SETUP_TEST42" ] && return
1801         for i in `seq -f $DIR/f42-%g 1 $OSTCOUNT`; do
1802                 dd if=/dev/zero of=$i bs=4k count=1
1803                 rm $i
1804         done
1805         SETUP_TEST42=DONE
1806 }
1807
1808 # Tests 42* verify that our behaviour is correct WRT caching, file closure,
1809 # file truncation, and file removal.
1810 test_42a() {
1811         setup_test42
1812         cancel_lru_locks osc
1813         stop_writeback
1814         sync; sleep 1; sync # just to be safe
1815         BEFOREWRITES=`count_ost_writes`
1816         lctl get_param -n osc.*[oO][sS][cC][_-]*.cur_grant_bytes | grep "[0-9]"
1817         dd if=/dev/zero of=$DIR/f42a bs=1024 count=100
1818         AFTERWRITES=`count_ost_writes`
1819         [ $BEFOREWRITES -eq $AFTERWRITES ] || \
1820                 error "$BEFOREWRITES < $AFTERWRITES"
1821         start_writeback
1822 }
1823 run_test 42a "ensure that we don't flush on close =============="
1824
1825 test_42b() {
1826         setup_test42
1827         cancel_lru_locks osc
1828         stop_writeback
1829         sync
1830         dd if=/dev/zero of=$DIR/f42b bs=1024 count=100
1831         BEFOREWRITES=`count_ost_writes`
1832         $MUNLINK $DIR/f42b || error "$MUNLINK $DIR/f42b: $?"
1833         AFTERWRITES=`count_ost_writes`
1834         if [ $BEFOREWRITES -lt $AFTERWRITES ]; then
1835                 error "$BEFOREWRITES < $AFTERWRITES on unlink"
1836         fi
1837         BEFOREWRITES=`count_ost_writes`
1838         sync || error "sync: $?"
1839         AFTERWRITES=`count_ost_writes`
1840         if [ $BEFOREWRITES -lt $AFTERWRITES ]; then
1841                 error "$BEFOREWRITES < $AFTERWRITES on sync"
1842         fi
1843         dmesg | grep 'error from obd_brw_async' && error 'error writing back'
1844         start_writeback
1845         return 0
1846 }
1847 run_test 42b "test destroy of file with cached dirty data ======"
1848
1849 # if these tests just want to test the effect of truncation,
1850 # they have to be very careful.  consider:
1851 # - the first open gets a {0,EOF}PR lock
1852 # - the first write conflicts and gets a {0, count-1}PW
1853 # - the rest of the writes are under {count,EOF}PW
1854 # - the open for truncate tries to match a {0,EOF}PR
1855 #   for the filesize and cancels the PWs.
1856 # any number of fixes (don't get {0,EOF} on open, match
1857 # composite locks, do smarter file size management) fix
1858 # this, but for now we want these tests to verify that
1859 # the cancellation with truncate intent works, so we
1860 # start the file with a full-file pw lock to match against
1861 # until the truncate.
1862 trunc_test() {
1863         test=$1
1864         file=$DIR/$test
1865         offset=$2
1866         cancel_lru_locks osc
1867         stop_writeback
1868         # prime the file with 0,EOF PW to match
1869         touch $file
1870         $TRUNCATE $file 0
1871         sync; sync
1872         # now the real test..
1873         dd if=/dev/zero of=$file bs=1024 count=100
1874         BEFOREWRITES=`count_ost_writes`
1875         $TRUNCATE $file $offset
1876         cancel_lru_locks osc
1877         AFTERWRITES=`count_ost_writes`
1878         start_writeback
1879 }
1880
1881 test_42c() {
1882         trunc_test 42c 1024
1883         [ $BEFOREWRITES -eq $AFTERWRITES ] && \
1884             error "beforewrites $BEFOREWRITES == afterwrites $AFTERWRITES on truncate"
1885         rm $file
1886 }
1887 run_test 42c "test partial truncate of file with cached dirty data"
1888
1889 test_42d() {
1890         trunc_test 42d 0
1891         [ $BEFOREWRITES -eq $AFTERWRITES ] || \
1892             error "beforewrites $BEFOREWRITES != afterwrites $AFTERWRITES on truncate"
1893         rm $file
1894 }
1895 run_test 42d "test complete truncate of file with cached dirty data"
1896
1897 test_43() {
1898         mkdir -p $DIR/$tdir
1899         cp -p /bin/ls $DIR/$tdir/$tfile
1900         multiop $DIR/$tdir/$tfile Ow_c &
1901         pid=$!
1902         # give multiop a chance to open
1903         sleep 1
1904
1905         $DIR/$tdir/$tfile && error || true
1906         kill -USR1 $pid
1907 }
1908 run_test 43 "execution of file opened for write should return -ETXTBSY"
1909
1910 test_43a() {
1911         mkdir -p $DIR/d43
1912         cp -p `which multiop` $DIR/d43/multiop || cp -p multiop $DIR/d43/multiop
1913         MULTIOP_PROG=$DIR/d43/multiop multiop_bg_pause $TMP/test43.junk O_c || return 1
1914         MULTIOP_PID=$!
1915         multiop $DIR/d43/multiop Oc && error "expected error, got success"
1916         kill -USR1 $MULTIOP_PID || return 2
1917         wait $MULTIOP_PID || return 3
1918         rm $TMP/test43.junk
1919 }
1920 run_test 43a "open(RDWR) of file being executed should return -ETXTBSY"
1921
1922 test_43b() {
1923         mkdir -p $DIR/d43
1924         cp -p `which multiop` $DIR/d43/multiop || cp -p multiop $DIR/d43/multiop
1925         MULTIOP_PROG=$DIR/d43/multiop multiop_bg_pause $TMP/test43.junk O_c || return 1
1926         MULTIOP_PID=$!
1927         truncate $DIR/d43/multiop 0 && error "expected error, got success"
1928         kill -USR1 $MULTIOP_PID || return 2
1929         wait $MULTIOP_PID || return 3
1930         rm $TMP/test43.junk
1931 }
1932 run_test 43b "truncate of file being executed should return -ETXTBSY"
1933
1934 test_43c() {
1935         local testdir="$DIR/d43c"
1936         mkdir -p $testdir
1937         cp $SHELL $testdir/
1938         ( cd $(dirname $SHELL) && md5sum $(basename $SHELL) ) | \
1939                 ( cd $testdir && md5sum -c)
1940 }
1941 run_test 43c "md5sum of copy into lustre========================"
1942
1943 test_44() {
1944         [  "$OSTCOUNT" -lt "2" ] && skip "skipping 2-stripe test" && return
1945         dd if=/dev/zero of=$DIR/f1 bs=4k count=1 seek=1023
1946         dd if=$DIR/f1 bs=4k count=1 > /dev/null
1947 }
1948 run_test 44 "zero length read from a sparse stripe ============="
1949
1950 test_44a() {
1951     local nstripe=`$LCTL lov_getconfig $DIR | grep default_stripe_count: | \
1952                          awk '{print $2}'`
1953     [ -z "$nstripe" ] && skip "can't get stripe info" && return
1954     [ "$nstripe" -gt "$OSTCOUNT" ] && skip "Wrong default_stripe_count: $nstripe (OSTCOUNT: $OSTCOUNT)" && return
1955     local stride=`$LCTL lov_getconfig $DIR | grep default_stripe_size: | \
1956                       awk '{print $2}'`
1957     if [ $nstripe -eq 0 -o $nstripe -eq -1 ] ; then
1958         nstripe=`$LCTL lov_getconfig $DIR | grep obd_count: | awk '{print $2}'`
1959     fi
1960
1961     OFFSETS="0 $((stride/2)) $((stride-1))"
1962     for offset in $OFFSETS ; do
1963       for i in `seq 0 $((nstripe-1))`; do
1964         local GLOBALOFFSETS=""
1965         local size=$((((i + 2 * $nstripe )*$stride + $offset)))  # Bytes
1966         local myfn=$DIR/d44a-$size
1967         echo "--------writing $myfn at $size"
1968         ll_sparseness_write $myfn $size  || error "ll_sparseness_write"
1969         GLOBALOFFSETS="$GLOBALOFFSETS $size"
1970         ll_sparseness_verify $myfn $GLOBALOFFSETS \
1971                             || error "ll_sparseness_verify $GLOBALOFFSETS"
1972
1973         for j in `seq 0 $((nstripe-1))`; do
1974             size=$((((j + $nstripe )*$stride + $offset)))  # Bytes
1975             ll_sparseness_write $myfn $size || error "ll_sparseness_write"
1976             GLOBALOFFSETS="$GLOBALOFFSETS $size"
1977         done
1978         ll_sparseness_verify $myfn $GLOBALOFFSETS \
1979                             || error "ll_sparseness_verify $GLOBALOFFSETS"
1980         rm -f $myfn
1981       done
1982     done
1983 }
1984 run_test 44a "test sparse pwrite ==============================="
1985
1986 dirty_osc_total() {
1987         tot=0
1988         for d in `lctl get_param -n osc.*.cur_dirty_bytes`; do
1989                 tot=$(($tot + $d))
1990         done
1991         echo $tot
1992 }
1993 do_dirty_record() {
1994         before=`dirty_osc_total`
1995         echo executing "\"$*\""
1996         eval $*
1997         after=`dirty_osc_total`
1998         echo before $before, after $after
1999 }
2000 test_45() {
2001         f="$DIR/f45"
2002         # Obtain grants from OST if it supports it
2003         echo blah > ${f}_grant
2004         stop_writeback
2005         sync
2006         do_dirty_record "echo blah > $f"
2007         [ $before -eq $after ] && error "write wasn't cached"
2008         do_dirty_record "> $f"
2009         [ $before -gt $after ] || error "truncate didn't lower dirty count"
2010         do_dirty_record "echo blah > $f"
2011         [ $before -eq $after ] && error "write wasn't cached"
2012         do_dirty_record "sync"
2013         [ $before -gt $after ] || error "writeback didn't lower dirty count"
2014         do_dirty_record "echo blah > $f"
2015         [ $before -eq $after ] && error "write wasn't cached"
2016         do_dirty_record "cancel_lru_locks osc"
2017         [ $before -gt $after ] || error "lock cancellation didn't lower dirty count"
2018         start_writeback
2019 }
2020 run_test 45 "osc io page accounting ============================"
2021
2022 page_size() {
2023         getconf PAGE_SIZE
2024 }
2025
2026 # in a 2 stripe file (lov.sh), page 1023 maps to page 511 in its object.  this
2027 # test tickles a bug where re-dirtying a page was failing to be mapped to the
2028 # objects offset and an assert hit when an rpc was built with 1023's mapped
2029 # offset 511 and 511's raw 511 offset. it also found general redirtying bugs.
2030 test_46() {
2031         f="$DIR/f46"
2032         stop_writeback
2033         sync
2034         dd if=/dev/zero of=$f bs=`page_size` seek=511 count=1
2035         sync
2036         dd conv=notrunc if=/dev/zero of=$f bs=`page_size` seek=1023 count=1
2037         dd conv=notrunc if=/dev/zero of=$f bs=`page_size` seek=511 count=1
2038         sync
2039         start_writeback
2040 }
2041 run_test 46 "dirtying a previously written page ================"
2042
2043 # Check that device nodes are created and then visible correctly (#2091)
2044 test_47() {
2045         cmknod $DIR/test_47_node || error
2046 }
2047 run_test 47 "Device nodes check ================================"
2048
2049 test_48a() { # bug 2399
2050         check_kernel_version 34 || return 0
2051         mkdir -p $DIR/d48a
2052         cd $DIR/d48a
2053         mv $DIR/d48a $DIR/d48.new || error "move directory failed"
2054         mkdir $DIR/d48a || error "recreate directory failed"
2055         touch foo || error "'touch foo' failed after recreating cwd"
2056         mkdir bar || error "'mkdir foo' failed after recreating cwd"
2057         if check_kernel_version 44; then
2058                 touch .foo || error "'touch .foo' failed after recreating cwd"
2059                 mkdir .bar || error "'mkdir .foo' failed after recreating cwd"
2060         fi
2061         ls . > /dev/null || error "'ls .' failed after recreating cwd"
2062         ls .. > /dev/null || error "'ls ..' failed after removing cwd"
2063         cd . || error "'cd .' failed after recreating cwd"
2064         mkdir . && error "'mkdir .' worked after recreating cwd"
2065         rmdir . && error "'rmdir .' worked after recreating cwd"
2066         ln -s . baz || error "'ln -s .' failed after recreating cwd"
2067         cd .. || error "'cd ..' failed after recreating cwd"
2068 }
2069 run_test 48a "Access renamed working dir (should return errors)="
2070
2071 test_48b() { # bug 2399
2072         check_kernel_version 34 || return 0
2073         mkdir -p $DIR/d48b
2074         cd $DIR/d48b
2075         rmdir $DIR/d48b || error "remove cwd $DIR/d48b failed"
2076         touch foo && error "'touch foo' worked after removing cwd"
2077         mkdir foo && error "'mkdir foo' worked after removing cwd"
2078         if check_kernel_version 44; then
2079                 touch .foo && error "'touch .foo' worked after removing cwd"
2080                 mkdir .foo && error "'mkdir .foo' worked after removing cwd"
2081         fi
2082         ls . > /dev/null && error "'ls .' worked after removing cwd"
2083         ls .. > /dev/null || error "'ls ..' failed after removing cwd"
2084         is_patchless || ( cd . && error "'cd .' worked after removing cwd" )
2085         mkdir . && error "'mkdir .' worked after removing cwd"
2086         rmdir . && error "'rmdir .' worked after removing cwd"
2087         ln -s . foo && error "'ln -s .' worked after removing cwd"
2088         cd .. || echo "'cd ..' failed after removing cwd `pwd`"  #bug 3517
2089 }
2090 run_test 48b "Access removed working dir (should return errors)="
2091
2092 test_48c() { # bug 2350
2093         check_kernel_version 36 || return 0
2094         #lctl set_param debug=-1
2095         #set -vx
2096         mkdir -p $DIR/d48c/dir
2097         cd $DIR/d48c/dir
2098         $TRACE rmdir $DIR/d48c/dir || error "remove cwd $DIR/d48c/dir failed"
2099         $TRACE touch foo && error "'touch foo' worked after removing cwd"
2100         $TRACE mkdir foo && error "'mkdir foo' worked after removing cwd"
2101         if check_kernel_version 44; then
2102                 touch .foo && error "'touch .foo' worked after removing cwd"
2103                 mkdir .foo && error "'mkdir .foo' worked after removing cwd"
2104         fi
2105         $TRACE ls . && error "'ls .' worked after removing cwd"
2106         $TRACE ls .. || error "'ls ..' failed after removing cwd"
2107         is_patchless || ( $TRACE cd . && error "'cd .' worked after removing cwd" )
2108         $TRACE mkdir . && error "'mkdir .' worked after removing cwd"
2109         $TRACE rmdir . && error "'rmdir .' worked after removing cwd"
2110         $TRACE ln -s . foo && error "'ln -s .' worked after removing cwd"
2111         $TRACE cd .. || echo "'cd ..' failed after removing cwd `pwd`" #bug 3415
2112 }
2113 run_test 48c "Access removed working subdir (should return errors)"
2114
2115 test_48d() { # bug 2350
2116         check_kernel_version 36 || return 0
2117         #lctl set_param debug=-1
2118         #set -vx
2119         mkdir -p $DIR/d48d/dir
2120         cd $DIR/d48d/dir
2121         $TRACE rmdir $DIR/d48d/dir || error "remove cwd $DIR/d48d/dir failed"
2122         $TRACE rmdir $DIR/d48d || error "remove parent $DIR/d48d failed"
2123         $TRACE touch foo && error "'touch foo' worked after removing parent"
2124         $TRACE mkdir foo && error "'mkdir foo' worked after removing parent"
2125         if check_kernel_version 44; then
2126                 touch .foo && error "'touch .foo' worked after removing parent"
2127                 mkdir .foo && error "'mkdir .foo' worked after removing parent"
2128         fi
2129         $TRACE ls . && error "'ls .' worked after removing parent"
2130         $TRACE ls .. && error "'ls ..' worked after removing parent"
2131         is_patchless || ( $TRACE cd . && error "'cd .' worked after recreate parent" )
2132         $TRACE mkdir . && error "'mkdir .' worked after removing parent"
2133         $TRACE rmdir . && error "'rmdir .' worked after removing parent"
2134         $TRACE ln -s . foo && error "'ln -s .' worked after removing parent"
2135         is_patchless || ( $TRACE cd .. && error "'cd ..' worked after removing parent" || true )
2136 }
2137 run_test 48d "Access removed parent subdir (should return errors)"
2138
2139 test_48e() { # bug 4134
2140         check_kernel_version 41 || return 0
2141         #lctl set_param debug=-1
2142         #set -vx
2143         mkdir -p $DIR/d48e/dir
2144         cd $DIR/d48e/dir
2145         $TRACE rmdir $DIR/d48e/dir || error "remove cwd $DIR/d48e/dir failed"
2146         $TRACE rmdir $DIR/d48e || error "remove parent $DIR/d48e failed"
2147         $TRACE touch $DIR/d48e || error "'touch $DIR/d48e' failed"
2148         $TRACE chmod +x $DIR/d48e || error "'chmod +x $DIR/d48e' failed"
2149         # On a buggy kernel addition of "touch foo" after cd .. will
2150         # produce kernel oops in lookup_hash_it
2151         touch ../foo && error "'cd ..' worked after recreate parent"
2152         cd $DIR
2153         $TRACE rm $DIR/d48e || error "rm '$DIR/d48e' failed"
2154 }
2155 run_test 48e "Access to recreated parent subdir (should return errors)"
2156
2157 test_50() {
2158         # bug 1485
2159         mkdir $DIR/d50
2160         cd $DIR/d50
2161         ls /proc/$$/cwd || error
2162 }
2163 run_test 50 "special situations: /proc symlinks  ==============="
2164
2165 test_51a() {    # was test_51
2166         # bug 1516 - create an empty entry right after ".." then split dir
2167         mkdir $DIR/d51
2168         touch $DIR/d51/foo
2169         $MCREATE $DIR/d51/bar
2170         rm $DIR/d51/foo
2171         createmany -m $DIR/d51/longfile 201
2172         FNUM=202
2173         while [ `ls -sd $DIR/d51 | awk '{ print $1 }'` -eq 4 ]; do
2174                 $MCREATE $DIR/d51/longfile$FNUM
2175                 FNUM=$(($FNUM + 1))
2176                 echo -n "+"
2177         done
2178         echo
2179         ls -l $DIR/d51 > /dev/null || error
2180 }
2181 run_test 51a "special situations: split htree with empty entry =="
2182
2183 #export NUMTEST=70000
2184 # FIXME: I select a relatively small number to do basic test.
2185 # large number may give panic(). debugging on this is going on.
2186 export NUMTEST=70
2187 test_51b() {
2188         NUMFREE=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
2189         [ $NUMFREE -lt 21000 ] && \
2190                 skip "not enough free inodes ($NUMFREE)" && \
2191                 return
2192
2193         check_kernel_version 40 || NUMTEST=31000
2194         [ $NUMFREE -lt $NUMTEST ] && NUMTEST=$(($NUMFREE - 50))
2195
2196         mkdir -p $DIR/d51b
2197         createmany -d $DIR/d51b/t- $NUMTEST
2198 }
2199 run_test 51b "mkdir .../t-0 --- .../t-$NUMTEST ===================="
2200
2201 test_51bb() {
2202         [ -z "$CLIENTS" ] && skip "needs >= 2 CLIENTS" && return
2203         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return
2204
2205         NUMFREE=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
2206         [ $NUMFREE -lt 21000 ] && \
2207                 skip "not enough free inodes ($NUMFREE)" && \
2208                 return
2209
2210         check_kernel_version 40 || NUMTEST=31000
2211         [ $NUMFREE -lt $NUMTEST ] && NUMTEST=$(($NUMFREE - 50))
2212
2213         mkdir -p $DIR/d51bb
2214
2215         IUSED=$(lfs df -i $DIR | grep MDT | awk '{print $3}')
2216         OLDUSED=($IUSED)
2217
2218         do_nodes $CLIENTS "mkdir -p $DIR/\$(hostname)"
2219
2220         ls $DIR
2221
2222         do_nodes $CLIENTS "createmany -d $DIR/\$(hostname)/t- $NUMTEST"
2223         IUSED=$(lfs df -i $DIR | grep MDT | awk '{print $3}')
2224         NEWUSED=($IUSED)
2225
2226         local rc=0
2227         for ((i=0; i<${#NEWUSED[@]}; i++)); do
2228                 echo "mds $i: inodes count OLD ${OLDUSED[$i]} NEW ${NEWUSED[$i]}"
2229                 [ ${OLDUSED[$i]} -lt ${NEWUSED[$i]} ] || rc=1
2230         done
2231
2232         [ $rc -ne 0 ] && error "no CMD functionality!"
2233 }
2234 run_test 51bb "mkdir .../t-0 --- .../t-$NUMTEST (CMD) ===================="
2235
2236
2237 test_51c() {
2238         [ ! -d $DIR/d51b ] && skip "$DIR/51b missing" && \
2239                 return
2240
2241         unlinkmany -d $DIR/d51b/t- $NUMTEST
2242 }
2243 run_test 51c "rmdir .../t-0 --- .../t-$NUMTEST ===================="
2244
2245 test_51d() {
2246         [  "$OSTCOUNT" -lt "3" ] && skip "skipping test with few OSTs" && return
2247         mkdir -p $DIR/d51d
2248         createmany -o $DIR/d51d/t- 1000
2249         $LFS getstripe $DIR/d51d > $TMP/files
2250         for N in `seq 0 $((OSTCOUNT - 1))`; do
2251             OBJS[$N]=`awk -vobjs=0 '($1 == '$N') { objs += 1 } END { print objs;}' $TMP/files`
2252             OBJS0[$N]=`grep -A 1 idx $TMP/files | awk -vobjs=0 '($1 == '$N') { objs += 1 } END { print objs;}'`
2253             log "OST$N has ${OBJS[$N]} objects, ${OBJS0[$N]} are index 0"
2254         done
2255         unlinkmany $DIR/d51d/t- 1000
2256
2257         NLAST=0
2258         for N in `seq 1 $((OSTCOUNT - 1))`; do
2259             [ ${OBJS[$N]} -lt $((${OBJS[$NLAST]} - 20)) ] && \
2260                 error "OST $N has less objects vs OST $NLAST (${OBJS[$N]} < ${OBJS[$NLAST]}"
2261             [ ${OBJS[$N]} -gt $((${OBJS[$NLAST]} + 20)) ] && \
2262                 error "OST $N has less objects vs OST $NLAST (${OBJS[$N]} < ${OBJS[$NLAST]}"
2263
2264             [ ${OBJS0[$N]} -lt $((${OBJS0[$NLAST]} - 20)) ] && \
2265                 error "OST $N has less #0 objects vs OST $NLAST (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
2266             [ ${OBJS0[$N]} -gt $((${OBJS0[$NLAST]} + 20)) ] && \
2267                 error "OST $N has less #0 objects vs OST $NLAST (${OBJS0[$N]} < ${OBJS0[$NLAST]}"
2268             NLAST=$N
2269         done
2270 }
2271 run_test 51d "check object distribution ===================="
2272
2273 test_52a() {
2274         [ -f $DIR/d52a/foo ] && chattr -a $DIR/d52a/foo
2275         mkdir -p $DIR/d52a
2276         touch $DIR/d52a/foo
2277         chattr =a $DIR/d52a/foo || error "chattr =a failed"
2278         echo bar >> $DIR/d52a/foo || error "append bar failed"
2279         cp /etc/hosts $DIR/d52a/foo && error "cp worked"
2280         rm -f $DIR/d52a/foo 2>/dev/null && error "rm worked"
2281         link $DIR/d52a/foo $DIR/d52a/foo_link 2>/dev/null && error "link worked"
2282         echo foo >> $DIR/d52a/foo || error "append foo failed"
2283         mrename $DIR/d52a/foo $DIR/d52a/foo_ren && error "rename worked"
2284         lsattr $DIR/d52a/foo | egrep -q "^-+a-+ $DIR/d52a/foo" || error "lsattr"
2285         chattr -a $DIR/d52a/foo || error "chattr -a failed"
2286
2287         rm -fr $DIR/d52a || error "cleanup rm failed"
2288 }
2289 run_test 52a "append-only flag test (should return errors) ====="
2290
2291 test_52b() {
2292         [ -f $DIR/d52b/foo ] && chattr -i $DIR/d52b/foo
2293         mkdir -p $DIR/d52b
2294         touch $DIR/d52b/foo
2295         chattr =i $DIR/d52b/foo || error
2296         cat test > $DIR/d52b/foo && error
2297         cp /etc/hosts $DIR/d52b/foo && error
2298         rm -f $DIR/d52b/foo 2>/dev/null && error
2299         link $DIR/d52b/foo $DIR/d52b/foo_link 2>/dev/null && error
2300         echo foo >> $DIR/d52b/foo && error
2301         mrename $DIR/d52b/foo $DIR/d52b/foo_ren && error
2302         [ -f $DIR/d52b/foo ] || error
2303         [ -f $DIR/d52b/foo_ren ] && error
2304         lsattr $DIR/d52b/foo | egrep -q "^-+i-+ $DIR/d52b/foo" || error
2305         chattr -i $DIR/d52b/foo || error
2306
2307         rm -fr $DIR/d52b || error
2308 }
2309 run_test 52b "immutable flag test (should return errors) ======="
2310
2311 test_53() {
2312         remote_mds && skip "remote MDS" && return
2313
2314         # only test MDT0000
2315         for value in `lctl get_param osc.*-osc-MDT0000.prealloc_last_id` ; do
2316                 param=`echo ${value[0]} | cut -d "=" -f1`
2317                 ostname=`echo $param | cut -d "." -f2 | cut -d - -f 1-2`
2318                 ost_last=`lctl get_param -n obdfilter.$ostname.last_id | head -n 1`
2319                 mds_last=`lctl get_param -n $param`
2320                 echo "$ostname.last_id=$ost_last ; MDS.last_id=$mds_last"
2321                 if [ $ost_last != $mds_last ]; then
2322                     error "$ostname.last_id=$ost_last ; MDS.last_id=$mds_last"
2323                 fi
2324         done
2325 }
2326 run_test 53 "verify that MDS and OSTs agree on pre-creation ===="
2327
2328 test_54a() {
2329         [ ! -f "$SOCKETSERVER" ] && skip "no socketserver, skipping" && return
2330         [ ! -f "$SOCKETCLIENT" ] && skip "no socketclient, skipping" && return
2331         $SOCKETSERVER $DIR/socket
2332         $SOCKETCLIENT $DIR/socket || error
2333         $MUNLINK $DIR/socket
2334 }
2335 run_test 54a "unix domain socket test =========================="
2336
2337 test_54b() {
2338         f="$DIR/f54b"
2339         mknod $f c 1 3
2340         chmod 0666 $f
2341         dd if=/dev/zero of=$f bs=`page_size` count=1
2342 }
2343 run_test 54b "char device works in lustre ======================"
2344
2345 find_loop_dev() {
2346         [ -b /dev/loop/0 ] && LOOPBASE=/dev/loop/
2347         [ -b /dev/loop0 ] && LOOPBASE=/dev/loop
2348         [ -z "$LOOPBASE" ] && echo "/dev/loop/0 and /dev/loop0 gone?" && return
2349
2350         for i in `seq 3 7`; do
2351                 losetup $LOOPBASE$i > /dev/null 2>&1 && continue
2352                 LOOPDEV=$LOOPBASE$i
2353                 LOOPNUM=$i
2354                 break
2355         done
2356 }
2357
2358 test_54c() {
2359         tfile="$DIR/f54c"
2360         tdir="$DIR/d54c"
2361         loopdev="$DIR/loop54c"
2362
2363         find_loop_dev
2364         [ -z "$LOOPNUM" ] && echo "couldn't find empty loop device" && return
2365         mknod $loopdev b 7 $LOOPNUM
2366         echo "make a loop file system with $tfile on $loopdev ($LOOPNUM)..."
2367         dd if=/dev/zero of=$tfile bs=`page_size` seek=1024 count=1 > /dev/null
2368         losetup $loopdev $tfile || error "can't set up $loopdev for $tfile"
2369         mkfs.ext2 $loopdev || error "mke2fs on $loopdev"
2370         mkdir -p $tdir
2371         mount -t ext2 $loopdev $tdir || error "error mounting $loopdev on $tdir"
2372         dd if=/dev/zero of=$tdir/tmp bs=`page_size` count=30 || error "dd write"
2373         df $tdir
2374         dd if=$tdir/tmp of=/dev/zero bs=`page_size` count=30 || error "dd read"
2375         $UMOUNT $tdir
2376         losetup -d $loopdev
2377         rm $loopdev
2378 }
2379 run_test 54c "block device works in lustre ====================="
2380
2381 test_54d() {
2382         f="$DIR/f54d"
2383         string="aaaaaa"
2384         mknod $f p
2385         [ "$string" = `echo $string > $f | cat $f` ] || error
2386 }
2387 run_test 54d "fifo device works in lustre ======================"
2388
2389 test_54e() {
2390         check_kernel_version 46 || return 0
2391         f="$DIR/f54e"
2392         string="aaaaaa"
2393         cp -aL /dev/console $f
2394         echo $string > $f || error
2395 }
2396 run_test 54e "console/tty device works in lustre ======================"
2397
2398 check_fstype() {
2399         grep -q $FSTYPE /proc/filesystems && return 1
2400         modprobe $FSTYPE
2401         grep -q $FSTYPE /proc/filesystems && return 1
2402         insmod ../$FSTYPE/$FSTYPE.o
2403         grep -q $FSTYPE /proc/filesystems && return 1
2404         insmod ../$FSTYPE/$FSTYPE.ko
2405         grep -q $FSTYPE /proc/filesystems && return 1
2406         return 0
2407 }
2408
2409 test_55() {
2410         rm -rf $DIR/d55
2411         mkdir $DIR/d55
2412         check_fstype && skip "can't find fs $FSTYPE" && return
2413         mount -t $FSTYPE -o loop,iopen $EXT2_DEV $DIR/d55 || error "mounting"
2414         touch $DIR/d55/foo
2415         $IOPENTEST1 $DIR/d55/foo $DIR/d55 || error "running $IOPENTEST1"
2416         $IOPENTEST2 $DIR/d55 || error "running $IOPENTEST2"
2417         echo "check for $EXT2_DEV. Please wait..."
2418         rm -rf $DIR/d55/*
2419         $UMOUNT $DIR/d55 || error "unmounting"
2420 }
2421 run_test 55 "check iopen_connect_dentry() ======================"
2422
2423 test_56a() {    # was test_56
2424         rm -rf $DIR/d56
2425         $SETSTRIPE -d $DIR
2426         mkdir $DIR/d56
2427         mkdir $DIR/d56/dir
2428         NUMFILES=3
2429         NUMFILESx2=$(($NUMFILES * 2))
2430         for i in `seq 1 $NUMFILES` ; do
2431                 touch $DIR/d56/file$i
2432                 touch $DIR/d56/dir/file$i
2433         done
2434
2435         # test lfs getstripe with --recursive
2436         FILENUM=`$GETSTRIPE --recursive $DIR/d56 | grep -c obdidx`
2437         [ $FILENUM -eq $NUMFILESx2 ] || error \
2438                 "lfs getstripe --recursive $DIR/d56 wrong: found $FILENUM, expected $NUMFILESx2"
2439         FILENUM=`$GETSTRIPE $DIR/d56 | grep -c obdidx`
2440         [ $FILENUM -eq $NUMFILES ] || error \
2441                 "lfs getstripe $DIR/d56 without --recursive wrong: found $FILENUM, expected $NUMFILES"
2442         echo "lfs getstripe --recursive passed."
2443
2444         # test lfs getstripe with file instead of dir
2445         FILENUM=`$GETSTRIPE $DIR/d56/file1 | grep -c obdidx`
2446         [ $FILENUM  -eq 1 ] || error \
2447                  "lfs getstripe $DIR/d56/file1 wrong:found $FILENUM, expected 1"
2448         echo "lfs getstripe file passed."
2449
2450         #test lfs getstripe with --verbose
2451         [ `$GETSTRIPE --verbose $DIR/d56 | grep -c lmm_magic` -eq $NUMFILES ] ||\
2452                 error "lfs getstripe --verbose $DIR/d56 wrong: should find $NUMFILES lmm_magic info"
2453         [ `$GETSTRIPE $DIR/d56 | grep -c lmm_magic` -eq 0 ] || error \
2454                 "lfs getstripe $DIR/d56 without --verbose wrong: should not show lmm_magic info"
2455         echo "lfs getstripe --verbose passed."
2456
2457         #test lfs getstripe with --obd
2458         $GETSTRIPE --obd wrong_uuid $DIR/d56 2>&1 | grep -q "unknown obduuid" || \
2459                 error "lfs getstripe --obd wrong_uuid should return error message"
2460
2461         [  "$OSTCOUNT" -lt 2 ] && \
2462                 skip "skipping other lfs getstripe --obd test" && return
2463         FILENUM=`$GETSTRIPE --recursive $DIR/d56 | sed -n '/^[   ]*1[    ]/p' | wc -l`
2464         OBDUUID=`$GETSTRIPE --recursive $DIR/d56 | sed -n '/^[   ]*1:/p' | awk '{print $2}'`
2465         FOUND=`$GETSTRIPE -r --obd $OBDUUID $DIR/d56 | wc -l`
2466         [ $FOUND -eq $FILENUM ] || \
2467                 error "lfs getstripe --obd wrong: found $FOUND, expected $FILENUM"
2468         [ `$GETSTRIPE -r -v --obd $OBDUUID $DIR/d56 | sed '/^[   ]*1[    ]/d' |\
2469                 sed -n '/^[      ]*[0-9][0-9]*[  ]/p' | wc -l` -eq 0 ] || \
2470                 error "lfs getstripe --obd wrong: should not show file on other obd"
2471         echo "lfs getstripe --obd passed."
2472 }
2473 run_test 56a "check lfs getstripe ===================================="
2474
2475 NUMFILES=3
2476 NUMDIRS=3
2477 setup_56() {
2478         LOCAL_NUMFILES=$1
2479         LOCAL_NUMDIRS=$2
2480         if [ ! -d "$DIR/${tdir}g" ] ; then
2481                 mkdir -p $DIR/${tdir}g
2482                 for i in `seq 1 $LOCAL_NUMFILES` ; do
2483                         touch $DIR/${tdir}g/file$i
2484                 done
2485                 for i in `seq 1 $LOCAL_NUMDIRS` ; do
2486                         mkdir $DIR/${tdir}g/dir$i
2487                         for j in `seq 1 $LOCAL_NUMFILES` ; do
2488                                 touch $DIR/${tdir}g/dir$i/file$j
2489                         done
2490                 done
2491         fi
2492 }
2493
2494 setup_56_special() {
2495         LOCAL_NUMFILES=$1
2496         LOCAL_NUMDIRS=$2
2497         TDIR=$DIR/${tdir}g
2498         setup_56 $1 $2
2499         if [ ! -e "$TDIR/loop1b" ] ; then
2500                 for i in `seq 1 $LOCAL_NUMFILES` ; do
2501                         mknod $TDIR/loop${i}b b 7 $i
2502                         mknod $TDIR/null${i}c c 1 3
2503                         ln -s $TDIR/file1 $TDIR/link${i}l
2504                 done
2505                 for i in `seq 1 $LOCAL_NUMDIRS` ; do
2506                         mknod $TDIR/dir$i/loop${i}b b 7 $i
2507                         mknod $TDIR/dir$i/null${i}c c 1 3
2508                         ln -s $TDIR/dir$i/file1 $TDIR/dir$i/link${i}l
2509                 done
2510         fi
2511 }
2512
2513 test_56g() {
2514         $LSTRIPE -d $DIR
2515
2516         setup_56 $NUMFILES $NUMDIRS
2517
2518         EXPECTED=$(($NUMDIRS + 2))
2519         # test lfs find with -name
2520         for i in `seq 1 $NUMFILES` ; do
2521                 NUMS=`$LFIND -name "*$i" $DIR/${tdir}g | wc -l`
2522                 [ $NUMS -eq $EXPECTED ] || error \
2523                         "lfs find -name \"*$i\" $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2524         done
2525         echo "lfs find -name passed."
2526 }
2527 run_test 56g "check lfs find -name ============================="
2528
2529 test_56h() {
2530         $LSTRIPE -d $DIR
2531
2532         setup_56 $NUMFILES $NUMDIRS
2533
2534         EXPECTED=$((($NUMDIRS+1)*($NUMFILES-1)+$NUMFILES))
2535         # test lfs find with ! -name
2536         for i in `seq 1 $NUMFILES` ; do
2537                 NUMS=`$LFIND ! -name "*$i" $DIR/${tdir}g | wc -l`
2538                 [ $NUMS -eq $EXPECTED ] || error \
2539                         "lfs find ! -name \"*$i\" $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2540         done
2541         echo "lfs find ! -name passed."
2542 }
2543 run_test 56h "check lfs find ! -name ============================="
2544
2545 test_56i() {
2546        tdir=${tdir}i
2547        mkdir -p $DIR/$tdir
2548        UUID=`$GETSTRIPE $DIR/$tdir | awk '/0: / { print $2 }'`
2549        OUT="`$LFIND -ost $UUID $DIR/$tdir`"
2550        [ "$OUT" ] && error "$LFIND returned directory '$OUT'" || true
2551 }
2552 run_test 56i "check 'lfs find -ost UUID' skips directories ======="
2553
2554 test_56j() {
2555         setup_56_special $NUMFILES $NUMDIRS
2556
2557         EXPECTED=$((NUMDIRS+1))
2558         NUMS=`$LFIND -type d $DIR/${tdir}g | wc -l`
2559         [ $NUMS -eq $EXPECTED ] || \
2560                 error "lfs find -type d $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2561 }
2562 run_test 56j "check lfs find -type d ============================="
2563
2564 test_56k() {
2565         setup_56_special $NUMFILES $NUMDIRS
2566
2567         EXPECTED=$(((NUMDIRS+1) * NUMFILES))
2568         NUMS=`$LFIND -type f $DIR/${tdir}g | wc -l`
2569         [ $NUMS -eq $EXPECTED ] || \
2570                 error "lfs find -type f $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2571 }
2572 run_test 56k "check lfs find -type f ============================="
2573
2574 test_56l() {
2575         setup_56_special $NUMFILES $NUMDIRS
2576
2577         EXPECTED=$((NUMDIRS + NUMFILES))
2578         NUMS=`$LFIND -type b $DIR/${tdir}g | wc -l`
2579         [ $NUMS -eq $EXPECTED ] || \
2580                 error "lfs find -type b $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2581 }
2582 run_test 56l "check lfs find -type b ============================="
2583
2584 test_56m() {
2585         setup_56_special $NUMFILES $NUMDIRS
2586
2587         EXPECTED=$((NUMDIRS + NUMFILES))
2588         NUMS=`$LFIND -type c $DIR/${tdir}g | wc -l`
2589         [ $NUMS -eq $EXPECTED ] || \
2590                 error "lfs find -type c $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2591 }
2592 run_test 56m "check lfs find -type c ============================="
2593
2594 test_56n() {
2595         setup_56_special $NUMFILES $NUMDIRS
2596
2597         EXPECTED=$((NUMDIRS + NUMFILES))
2598         NUMS=`$LFIND -type l $DIR/${tdir}g | wc -l`
2599         [ $NUMS -eq $EXPECTED ] || \
2600                 error "lfs find -type l $DIR/${tdir}g wrong: found $NUMS, expected $EXPECTED"
2601 }
2602 run_test 56n "check lfs find -type l ============================="
2603
2604 test_56o() {
2605         setup_56 $NUMFILES $NUMDIRS
2606         TDIR=$DIR/${tdir}g
2607
2608         utime $TDIR/file1 > /dev/null || error
2609         utime $TDIR/file2 > /dev/null || error
2610         utime $TDIR/dir1 > /dev/null || error
2611         utime $TDIR/dir2 > /dev/null || error
2612         utime $TDIR/dir1/file1 > /dev/null || error
2613
2614         EXPECTED=5
2615         NUMS=`$LFIND -mtime +1 $TDIR | wc -l`
2616         [ $NUMS -eq $EXPECTED ] || \
2617                 error "lfs find -mtime $TDIR wrong: found $NUMS, expected $EXPECTED"
2618 }
2619 run_test 56o "check lfs find -mtime for old files =========================="
2620
2621 test_56p() {
2622         [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID = UID = $UID -- skipping" && return
2623
2624         TDIR=$DIR/${tdir}g
2625         rm -rf $TDIR
2626
2627         setup_56 $NUMFILES $NUMDIRS
2628
2629         chown $RUNAS_ID $TDIR/file* || error "chown $DIR/${tdir}g/file$i failed"
2630         EXPECTED=$NUMFILES
2631         NUMS="`$LFIND -uid $RUNAS_ID $TDIR | wc -l`"
2632         [ $NUMS -eq $EXPECTED ] || \
2633                 error "lfs find -uid $TDIR wrong: found $NUMS, expected $EXPECTED"
2634
2635         EXPECTED=$(( ($NUMFILES+1) * $NUMDIRS + 1))
2636         NUMS="`$LFIND ! -uid $RUNAS_ID $TDIR | wc -l`"
2637         [ $NUMS -eq $EXPECTED ] || \
2638                 error "lfs find ! -uid $TDIR wrong: found $NUMS, expected $EXPECTED"
2639
2640         echo "lfs find -uid and ! -uid passed."
2641 }
2642 run_test 56p "check lfs find -uid and ! -uid ==============================="
2643
2644 test_56q() {
2645         [ $RUNAS_ID -eq $UID ] && skip "RUNAS_ID = UID = $UID -- skipping" && return
2646
2647         TDIR=$DIR/${tdir}g
2648         rm -rf $TDIR
2649
2650         setup_56 $NUMFILES $NUMDIRS
2651
2652         chgrp $RUNAS_ID $TDIR/file* || error "chown $DIR/${tdir}g/file$i failed"
2653         EXPECTED=$NUMFILES
2654         NUMS="`$LFIND -gid $RUNAS_ID $TDIR | wc -l`"
2655         [ $NUMS -eq $EXPECTED ] || \
2656                 error "lfs find -gid $TDIR wrong: found $NUMS, expected $EXPECTED"
2657
2658         EXPECTED=$(( ($NUMFILES+1) * $NUMDIRS + 1))
2659         NUMS="`$LFIND ! -gid $RUNAS_ID $TDIR | wc -l`"
2660         [ $NUMS -eq $EXPECTED ] || \
2661                 error "lfs find ! -gid $TDIR wrong: found $NUMS, expected $EXPECTED"
2662
2663         echo "lfs find -gid and ! -gid passed."
2664 }
2665 run_test 56q "check lfs find -gid and ! -gid ==============================="
2666
2667 test_57a() {
2668         # note test will not do anything if MDS is not local
2669         remote_mds && skip "remote MDS" && return
2670         local MNTDEV="osd.*MDT*.mntdev"
2671         DEV=$(lctl get_param -n $MNTDEV)
2672         [ -z "$DEV" ] && error "can't access $MNTDEV"
2673         for DEV in `lctl get_param -n $MNTDEV`; do
2674                 dumpe2fs -h $DEV > $TMP/t57a.dump || error "can't access $DEV"
2675                 DEVISIZE=`awk '/Inode size:/ { print $3 }' $TMP/t57a.dump`
2676                 [ "$DEVISIZE" -gt 128 ] || error "inode size $DEVISIZE"
2677                 rm $TMP/t57a.dump
2678         done
2679 }
2680 run_test 57a "verify MDS filesystem created with large inodes =="
2681
2682 test_57b() {
2683         FILECOUNT=100
2684         FILE1=$DIR/d57b/f1
2685         FILEN=$DIR/d57b/f$FILECOUNT
2686         rm -rf $DIR/d57b || error "removing $DIR/d57b"
2687         mkdir -p $DIR/d57b || error "creating $DIR/d57b"
2688         echo "mcreating $FILECOUNT files"
2689         createmany -m $DIR/d57b/f 1 $FILECOUNT || \
2690                 error "creating files in $DIR/d57b"
2691
2692         # verify that files do not have EAs yet
2693         $GETSTRIPE $FILE1 2>&1 | grep -q "no stripe" || error "$FILE1 has an EA"
2694         $GETSTRIPE $FILEN 2>&1 | grep -q "no stripe" || error "$FILEN has an EA"
2695
2696         MDSFREE="`lctl get_param -n osd.*MDT0000.kbytesfree 2> /dev/null`"
2697         MDCFREE="`lctl get_param -n mdc.*.kbytesfree | head -n 1`"
2698         echo "opening files to create objects/EAs"
2699         for FILE in `seq -f $DIR/d57b/f%g 1 $FILECOUNT`; do
2700                 $OPENFILE -f O_RDWR $FILE > /dev/null || error "opening $FILE"
2701         done
2702
2703         # verify that files have EAs now
2704         $GETSTRIPE $FILE1 | grep -q "obdidx" || error "$FILE1 missing EA"
2705         $GETSTRIPE $FILEN | grep -q "obdidx" || error "$FILEN missing EA"
2706
2707         sleep 1 # make sure we get new statfs data
2708 #       MDSFREE2="`lctl get_param -n mds.*.kbytesfree`"
2709 #       MDCFREE2="`lctl get_param -n mdc.*.kbytesfree`"
2710 #       if [ "$MDCFREE2" -lt "$((MDCFREE - 8))" ]; then
2711 #               if [ "$MDSFREE" != "$MDSFREE2" ]; then
2712 #                       error "MDC before $MDCFREE != after $MDCFREE2"
2713 #               else
2714 #                       echo "MDC before $MDCFREE != after $MDCFREE2"
2715 #                       echo "unable to confirm if MDS has large inodes"
2716 #               fi
2717 #       fi
2718         rm -rf $DIR/d57b
2719 }
2720 run_test 57b "default LOV EAs are stored inside large inodes ==="
2721
2722 test_58() {
2723     [ -z "$(which wiretest 2>/dev/null)" ] && skip "could not find wiretest" && return
2724     wiretest
2725 }
2726 run_test 58 "verify cross-platform wire constants =============="
2727
2728 test_59() {
2729         echo "touch 130 files"
2730         createmany -o $DIR/f59- 130
2731         echo "rm 130 files"
2732         unlinkmany $DIR/f59- 130
2733         sync
2734         sleep 2
2735         # wait for commitment of removal
2736 }
2737 run_test 59 "verify cancellation of llog records async ========="
2738
2739 TEST60_HEAD="test_60 run $RANDOM"
2740 test_60a() {
2741         [ ! -f run-llog.sh ] && skip "missing subtest run-llog.sh" && return
2742         log "$TEST60_HEAD - from kernel mode"
2743         sh run-llog.sh
2744 }
2745 run_test 60a "llog sanity tests run from kernel module =========="
2746
2747 test_60b() { # bug 6411
2748         dmesg > $DIR/$tfile
2749         LLOG_COUNT=`dmesg | awk "/$TEST60_HEAD/{marker = 1; from_marker = 0;}
2750                                  /llog.test/ {
2751                                          if (marker)
2752                                                  from_marker++
2753                                          from_begin++
2754                                  }
2755                                  END {
2756                                          if (marker)
2757                                                  print from_marker
2758                                          else
2759                                                  print from_begin
2760                                  }"`
2761         [ $LLOG_COUNT -gt 50 ] && error "CDEBUG_LIMIT not limiting messages ($LLOG_COUNT)"|| true
2762 }
2763 run_test 60b "limit repeated messages from CERROR/CWARN ========"
2764
2765 test_60c() {
2766         echo "create 5000 files"
2767         createmany -o $DIR/f60c- 5000
2768 #define OBD_FAIL_MDS_LLOG_CREATE_FAILED  0x13c
2769         lctl set_param fail_loc=0x8000013c
2770         unlinkmany $DIR/f60c- 5000
2771         lctl set_param fail_loc=0
2772 }
2773 run_test 60c "unlink file when mds full"
2774
2775 test_60d() {
2776         SAVEPRINTK=$(lctl get_param -n printk)
2777
2778         # verify "lctl mark" is even working"
2779         MESSAGE="test message ID $RANDOM $$"
2780         $LCTL mark "$MESSAGE" || error "$LCTL mark failed"
2781         dmesg | grep -q "$MESSAGE" || error "didn't find debug marker in log"
2782
2783         lctl set_param printk=0 || error "set lnet.printk failed"
2784         lctl get_param -n printk | grep emerg || error "lnet.printk dropped emerg"
2785         MESSAGE="new test message ID $RANDOM $$"
2786         # Assume here that libcfs_debug_mark_buffer() uses D_WARNING
2787         $LCTL mark "$MESSAGE" || error "$LCTL mark failed"
2788         dmesg | grep -q "$MESSAGE" && error "D_WARNING wasn't masked" || true
2789
2790         lctl set_param -n printk="$SAVEPRINTK"
2791 }
2792 run_test 60d "test printk console message masking"
2793
2794 test_61() {
2795         f="$DIR/f61"
2796         dd if=/dev/zero of=$f bs=`page_size` count=1
2797         cancel_lru_locks osc
2798         multiop $f OSMWUc || error
2799         sync
2800 }
2801 run_test 61 "mmap() writes don't make sync hang ================"
2802
2803 # bug 2330 - insufficient obd_match error checking causes LBUG
2804 test_62() {
2805         f="$DIR/f62"
2806         echo foo > $f
2807         cancel_lru_locks osc
2808         lctl set_param fail_loc=0x405
2809         cat $f && error "cat succeeded, expect -EIO"
2810         lctl set_param fail_loc=0
2811 }
2812 # This test is now irrelevant (as of bug 10718 inclusion), we no longer
2813 # match every page all of the time.
2814 #run_test 62 "verify obd_match failure doesn't LBUG (should -EIO)"
2815
2816 # bug 2319 - oig_wait() interrupted causes crash because of invalid waitq.
2817 test_63a() {    # was test_63
2818         MAX_DIRTY_MB=`lctl get_param -n osc.*.max_dirty_mb | head -n 1`
2819         lctl set_param -n osc.*.max_dirty_mb 0
2820         for i in `seq 10` ; do
2821                 dd if=/dev/zero of=$DIR/f63 bs=8k &
2822                 sleep 5
2823                 kill $!
2824                 sleep 1
2825         done
2826
2827         lctl set_param -n osc.*.max_dirty_mb $MAX_DIRTY_MB
2828         rm -f $DIR/f63 || true
2829 }
2830 run_test 63a "Verify oig_wait interruption does not crash ======="
2831
2832 # bug 2248 - async write errors didn't return to application on sync
2833 # bug 3677 - async write errors left page locked
2834 test_63b() {
2835         debugsave
2836         lctl set_param debug=-1
2837
2838         # ensure we have a grant to do async writes
2839         dd if=/dev/zero of=$DIR/$tfile bs=4k count=1
2840         rm $DIR/$tfile
2841
2842         #define OBD_FAIL_OSC_BRW_PREP_REQ        0x406
2843         lctl set_param fail_loc=0x80000406
2844         multiop $DIR/$tfile Owy && \
2845                 error "sync didn't return ENOMEM"
2846         sync; sleep 2; sync     # do a real sync this time to flush page
2847         lctl get_param -n llite.*.dump_page_cache | grep locked && \
2848                 error "locked page left in cache after async error" || true
2849         debugrestore
2850 }
2851 run_test 63b "async write errors should be returned to fsync ==="
2852
2853 test_64a () {
2854         df $DIR
2855         lctl get_param -n osc.*[oO][sS][cC][_-]*.cur* | grep "[0-9]"
2856 }
2857 run_test 64a "verify filter grant calculations (in kernel) ====="
2858
2859 test_64b () {
2860         [ ! -f oos.sh ] && skip "missing subtest oos.sh" && return
2861         sh oos.sh $MOUNT
2862 }
2863 run_test 64b "check out-of-space detection on client ==========="
2864
2865 # bug 1414 - set/get directories' stripe info
2866 test_65a() {
2867         mkdir -p $DIR/d65
2868         touch $DIR/d65/f1
2869         $LVERIFY $DIR/d65 $DIR/d65/f1 || error "lverify failed"
2870 }
2871 run_test 65a "directory with no stripe info ===================="
2872
2873 test_65b() {
2874         mkdir -p $DIR/d65
2875         $SETSTRIPE $DIR/d65 -s $(($STRIPESIZE * 2)) -i 0 -c 1 || error "setstripe"
2876         touch $DIR/d65/f2
2877         $LVERIFY $DIR/d65 $DIR/d65/f2 || error "lverify failed"
2878 }
2879 run_test 65b "directory setstripe $(($STRIPESIZE * 2)) 0 1 ==============="
2880
2881 test_65c() {
2882         if [ $OSTCOUNT -gt 1 ]; then
2883                 mkdir -p $DIR/d65
2884                 $SETSTRIPE $DIR/d65 -s $(($STRIPESIZE * 4)) -i 1 \
2885                         -c $(($OSTCOUNT - 1)) || error "setstripe"
2886                 touch $DIR/d65/f3
2887                 $LVERIFY $DIR/d65 $DIR/d65/f3 || error "lverify failed"
2888         fi
2889 }
2890 run_test 65c "directory setstripe $(($STRIPESIZE * 4)) 1 $(($OSTCOUNT - 1))"
2891
2892 test_65d() {
2893         mkdir -p $DIR/d65
2894         if [ $STRIPECOUNT -le 0 ]; then
2895                 sc=1
2896         elif [ $STRIPECOUNT -gt 160 ]; then
2897 #LOV_MAX_STRIPE_COUNT is 160
2898                 [ $OSTCOUNT -gt 160 ] && sc=160 || sc=$(($OSTCOUNT - 1))
2899         else
2900                 sc=$(($STRIPECOUNT - 1))
2901         fi
2902         $SETSTRIPE $DIR/d65 -s $STRIPESIZE -c $sc || error "setstripe"
2903         touch $DIR/d65/f4 $DIR/d65/f5
2904         $LVERIFY $DIR/d65 $DIR/d65/f4 $DIR/d65/f5 || error "lverify failed"
2905 }
2906 run_test 65d "directory setstripe $STRIPESIZE -1 stripe_count =============="
2907
2908 test_65e() {
2909         mkdir -p $DIR/d65
2910
2911         $SETSTRIPE $DIR/d65 || error "setstripe"
2912         $GETSTRIPE -v $DIR/d65 | grep "Default" || error "no stripe info failed"
2913         touch $DIR/d65/f6
2914         $LVERIFY $DIR/d65 $DIR/d65/f6 || error "lverify failed"
2915 }
2916 run_test 65e "directory setstripe defaults ======================="
2917
2918 test_65f() {
2919         mkdir -p $DIR/d65f
2920         $RUNAS $SETSTRIPE $DIR/d65f && error "setstripe succeeded" || true
2921 }
2922 run_test 65f "dir setstripe permission (should return error) ==="
2923
2924 test_65g() {
2925         mkdir -p $DIR/d65
2926         $SETSTRIPE $DIR/d65 -s $(($STRIPESIZE * 2)) -i 0 -c 1 || error "setstripe"
2927         $SETSTRIPE -d $DIR/d65 || error "setstripe"
2928         $GETSTRIPE -v $DIR/d65 | grep "Default" || \
2929                 error "delete default stripe failed"
2930 }
2931 run_test 65g "directory setstripe -d ==========================="
2932
2933 test_65h() {
2934         mkdir -p $DIR/d65
2935         $SETSTRIPE $DIR/d65 -s $(($STRIPESIZE * 2)) -i 0 -c 1 || error "setstripe"
2936         mkdir -p $DIR/d65/dd1
2937         [ "`$GETSTRIPE -v $DIR/d65 | grep "^count"`" == \
2938           "`$GETSTRIPE -v $DIR/d65/dd1 | grep "^count"`" ] || error "stripe info inherit failed"
2939 }
2940 run_test 65h "directory stripe info inherit ===================="
2941
2942 test_65i() { # bug6367
2943         $SETSTRIPE $MOUNT -s 65536 -c -1
2944 }
2945 run_test 65i "set non-default striping on root directory (bug 6367)="
2946
2947 test_65j() { # bug6367
2948         sync; sleep 1
2949         # if we aren't already remounting for each test, do so for this test
2950         if [ "$CLEANUP" = ":" -a "$I_MOUNTED" = "yes" ]; then
2951                 cleanup || error "failed to unmount"
2952                 setup
2953         fi
2954         $SETSTRIPE -d $MOUNT || error "setstripe failed"
2955 }
2956 run_test 65j "set default striping on root directory (bug 6367)="
2957
2958 test_65k() { # bug11679
2959         [ "$OSTCOUNT" -lt 2 ] && skip "too few OSTs" && return
2960         remote_mds_nodsh && skip "remote MDS" && return
2961
2962         echo "Check OST status: "
2963         MDS_OSCS=`do_facet $SINGLEMDS lctl dl | awk '/[oO][sS][cC].*md[ts]/ { print $4 }'`
2964         for OSC in $MDS_OSCS; do
2965                 echo $OSC "is activate"
2966                 do_facet $SINGLEMDS lctl --device %$OSC activate
2967         done
2968         do_facet client mkdir -p $DIR/$tdir
2969         for INACTIVE_OSC in $MDS_OSCS; do
2970                 echo $INACTIVE_OSC "is Deactivate:"
2971                 do_facet $SINGLEMDS lctl --device  %$INACTIVE_OSC deactivate
2972                 for STRIPE_OSC in $MDS_OSCS; do
2973                         STRIPE_OST=`osc_to_ost $STRIPE_OSC`
2974                         STRIPE_INDEX=`do_facet $SINGLEMDS lctl get_param -n lov.*md*.target_obd |
2975                                       grep $STRIPE_OST | awk -F: '{print $1}' | head -n 1`
2976
2977                         [ -f $DIR/$tdir/${STRIPE_INDEX} ] && continue
2978                         echo "$SETSTRIPE $DIR/$tdir/${STRIPE_INDEX} -i ${STRIPE_INDEX} -c 1"
2979                         do_facet client $SETSTRIPE $DIR/$tdir/${STRIPE_INDEX} -i ${STRIPE_INDEX} -c 1
2980                         RC=$?
2981                         [ $RC -ne 0 ] && error "setstripe should have succeeded"
2982                 done
2983                 do_facet client rm -f $DIR/$tdir/*
2984                 echo $INACTIVE_OSC "is Activate."
2985                 do_facet $SINGLEMDS lctl --device  %$INACTIVE_OSC activate
2986         done
2987 }
2988 run_test 65k "validate manual striping works properly with deactivated OSCs"
2989
2990 test_65l() { # bug 12836
2991         mkdir -p $DIR/$tdir/test_dir
2992         $SETSTRIPE $DIR/$tdir/test_dir -c -1
2993         $LFS find -mtime -1 $DIR/$tdir >/dev/null
2994 }
2995 run_test 65l "lfs find on -1 stripe dir ========================"
2996
2997 # bug 2543 - update blocks count on client
2998 test_66() {
2999         COUNT=${COUNT:-8}
3000         dd if=/dev/zero of=$DIR/f66 bs=1k count=$COUNT
3001         sync; sleep 1; sync
3002         BLOCKS=`ls -s $DIR/f66 | awk '{ print $1 }'`
3003         [ $BLOCKS -ge $COUNT ] || error "$DIR/f66 blocks $BLOCKS < $COUNT"
3004 }
3005 run_test 66 "update inode blocks count on client ==============="
3006
3007 LLOOP=
3008 cleanup_68() {
3009         trap 0
3010         if [ ! -z "$LLOOP" ]; then
3011                 swapoff $LLOOP || error "swapoff failed"
3012                 $LCTL blockdev_detach $LLOOP || error "detach failed"
3013                 rm -f $LLOOP
3014                 unset LLOOP
3015         fi
3016         rm -f $DIR/f68
3017 }
3018
3019 meminfo() {
3020         awk '($1 == "'$1':") { print $2 }' /proc/meminfo
3021 }
3022
3023 swap_used() {
3024         swapon -s | awk '($1 == "'$1'") { print $4 }'
3025 }
3026
3027
3028 # excercise swapping to lustre by adding a high priority swapfile entry
3029 # and then consuming memory until it is used.
3030 test_68() {
3031         [ "$UID" != 0 ] && skip "must run as root" && return
3032         lctl get_param -n devices | grep -q obdfilter && \
3033                 skip "local OST" && return
3034
3035         grep -q llite_lloop /proc/modules
3036         [ $? -ne 0 ] && skip "can't find module llite_lloop" && return
3037
3038         [ -z "`$LCTL list_nids | grep -v tcp`" ] && \
3039                 skip "can't reliably test swap with TCP" && return
3040
3041         MEMTOTAL=`meminfo MemTotal`
3042         NR_BLOCKS=$((MEMTOTAL>>8))
3043         [[ $NR_BLOCKS -le 2048 ]] && NR_BLOCKS=2048
3044
3045         LLOOP=$TMP/lloop.`date +%s`.`date +%N`
3046         dd if=/dev/zero of=$DIR/f68 bs=64k seek=$NR_BLOCKS count=1
3047         mkswap $DIR/f68
3048
3049         $LCTL blockdev_attach $DIR/f68 $LLOOP || error "attach failed"
3050
3051         trap cleanup_68 EXIT
3052
3053         swapon -p 32767 $LLOOP || error "swapon $LLOOP failed"
3054
3055         echo "before: `swapon -s | grep $LLOOP`"
3056         $MEMHOG $MEMTOTAL || error "error allocating $MEMTOTAL kB"
3057         echo "after: `swapon -s | grep $LLOOP`"
3058         SWAPUSED=`swap_used $LLOOP`
3059
3060         cleanup_68
3061
3062         [ $SWAPUSED -eq 0 ] && echo "no swap used???" || true
3063 }
3064 run_test 68 "support swapping to Lustre ========================"
3065
3066 # bug5265, obdfilter oa2dentry return -ENOENT
3067 # #define OBD_FAIL_OST_ENOENT 0x217
3068 test_69() {
3069         [ $(lctl get_param -n devices | grep -c obdfilter) -eq 0 ] && \
3070                 skip "skipping test for remote OST" && return
3071
3072         f="$DIR/$tfile"
3073         touch $f
3074
3075         $DIRECTIO write ${f}.2 0 1 || error "directio write error"
3076
3077         lctl set_param fail_loc=0x217
3078         truncate $f 1 # vmtruncate() will ignore truncate() error.
3079         $DIRECTIO write $f 0 2 && error "write succeeded, expect -ENOENT"
3080
3081         lctl set_param fail_loc=0
3082         $DIRECTIO write $f 0 2 || error "write error"
3083
3084         cancel_lru_locks osc
3085         $DIRECTIO read $f 0 1 || error "read error"
3086
3087         lctl set_param fail_loc=0x217
3088         $DIRECTIO read $f 1 1 && error "read succeeded, expect -ENOENT"
3089
3090         lctl set_param fail_loc=0
3091         rm -f $f
3092 }
3093 run_test 69 "verify oa2dentry return -ENOENT doesn't LBUG ======"
3094
3095 test_71() {
3096     sh rundbench -C -D $DIR 2 || error "dbench failed!"
3097 }
3098 run_test 71 "Running dbench on lustre (don't segment fault) ===="
3099
3100 test_72() { # bug 5695 - Test that on 2.6 remove_suid works properly
3101         check_kernel_version 43 || return 0
3102         [ "$RUNAS_ID" = "$UID" ] && skip "RUNAS_ID = UID = $UID -- skipping" && return
3103
3104         # Check that testing environment is properly set up. Skip if not
3105         FAIL_ON_ERROR=false check_runas_id_ret $RUNAS_ID $RUNAS || {
3106                 skip "User $RUNAS_ID does not exist - skipping"
3107                 return 0
3108         }
3109         # We had better clear the $DIR to get enough space for dd
3110         rm -rf $DIR/*
3111         touch $DIR/f72
3112         chmod 777 $DIR/f72
3113         chmod ug+s $DIR/f72
3114         $RUNAS dd if=/dev/zero of=$DIR/f72 bs=512 count=1 || error
3115         # See if we are still setuid/sgid
3116         test -u $DIR/f72 -o -g $DIR/f72 && error "S/gid is not dropped on write"
3117         # Now test that MDS is updated too
3118         cancel_lru_locks mdc
3119         test -u $DIR/f72 -o -g $DIR/f72 && error "S/gid is not dropped on MDS"
3120         true
3121 }
3122 run_test 72 "Test that remove suid works properly (bug5695) ===="
3123
3124 # bug 3462 - multiple simultaneous MDC requests
3125 test_73() {
3126         mkdir $DIR/d73-1
3127         mkdir $DIR/d73-2
3128         multiop_bg_pause $DIR/d73-1/f73-1 O_c || return 1
3129         pid1=$!
3130
3131         lctl set_param fail_loc=0x80000129
3132         multiop $DIR/d73-1/f73-2 Oc &
3133         sleep 1
3134         lctl set_param fail_loc=0
3135
3136         multiop $DIR/d73-2/f73-3 Oc &
3137         pid3=$!
3138
3139         kill -USR1 $pid1
3140         wait $pid1 || return 1
3141
3142         sleep 25
3143
3144         $CHECKSTAT -t file $DIR/d73-1/f73-1 || return 4
3145         $CHECKSTAT -t file $DIR/d73-1/f73-2 || return 5
3146         $CHECKSTAT -t file $DIR/d73-2/f73-3 || return 6
3147
3148         rm -rf $DIR/d73-*
3149 }
3150 run_test 73 "multiple MDC requests (should not deadlock)"
3151
3152 test_74a() { # bug 6149, 6184
3153         #define OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT 0x30e
3154         #
3155         # very important to OR with OBD_FAIL_ONCE (0x80000000) -- otherwise it
3156         # will spin in a tight reconnection loop
3157         touch $DIR/f74a
3158         lctl set_param fail_loc=0x8000030e
3159         # get any lock that won't be difficult - lookup works.
3160         ls $DIR/f74a
3161         lctl set_param fail_loc=0
3162         true
3163 }
3164 run_test 74a "ldlm_enqueue freed-export error path, ls (shouldn't LBUG)"
3165
3166 test_74b() { # bug 13310
3167         #define OBD_FAIL_LDLM_ENQUEUE_OLD_EXPORT 0x30e
3168         #
3169         # very important to OR with OBD_FAIL_ONCE (0x80000000) -- otherwise it
3170         # will spin in a tight reconnection loop
3171         lctl set_param fail_loc=0x8000030e
3172         # get a "difficult" lock
3173         touch $DIR/f74b
3174         lctl set_param fail_loc=0
3175         true
3176 }
3177 run_test 74b "ldlm_enqueue freed-export error path, touch (shouldn't LBUG)"
3178
3179 JOIN=${JOIN:-"lfs join"}
3180 F75=$DIR/f75
3181 F128k=${F75}_128k
3182 FHEAD=${F75}_head
3183 FTAIL=${F75}_tail
3184 export T75_PREP=no
3185 test75_prep() {
3186         [ $T75_PREP = "yes" ] && return
3187         echo "using F75=$F75, F128k=$F128k, FHEAD=$FHEAD, FTAIL=$FTAIL"
3188
3189         dd if=/dev/urandom of=${F75}_128k bs=128k count=1 || error "dd failed"
3190         log "finished dd"
3191         chmod 777 ${F128k}
3192         T75_PREP=yes
3193 }
3194
3195 test_75a() {
3196 #       skipped temporarily: we do not have join file currently
3197 #       please remove this when ready - huanghua
3198         return
3199         test75_prep
3200
3201         cp -p ${F128k} ${FHEAD}
3202         log "finished cp to $FHEAD"
3203         cp -p ${F128k} ${FTAIL}
3204         log "finished cp to $FTAIL"
3205         cat ${F128k} ${F128k} > ${F75}_sim_sim
3206
3207         $JOIN ${FHEAD} ${FTAIL} || error "join ${FHEAD} ${FTAIL} error"
3208         log "finished join $FHEAD to ${F75}_sim_sim"
3209         cmp ${FHEAD} ${F75}_sim_sim || error "${FHEAD} ${F75}_sim_sim differ"
3210         log "finished cmp $FHEAD to ${F75}_sim_sim"
3211         $CHECKSTAT -a ${FTAIL} || error "tail ${FTAIL} still exist after join"
3212 }
3213 run_test 75a "TEST join file ===================================="
3214
3215 test_75b() {
3216 #       skipped temporarily: we do not have join file currently
3217 #       please remove this when ready - huanghua
3218         return
3219         test75_prep
3220
3221         cp -p ${F128k} ${FTAIL}
3222         cat ${F75}_sim_sim >> ${F75}_join_sim
3223         cat ${F128k} >> ${F75}_join_sim
3224         $JOIN ${FHEAD} ${FTAIL} || error "join ${FHEAD} ${FTAIL} error"
3225         cmp ${FHEAD} ${F75}_join_sim || \
3226                 error "${FHEAD} ${F75}_join_sim are different"
3227         $CHECKSTAT -a ${FTAIL} || error "tail ${FTAIL} exist after join"
3228 }
3229 run_test 75b "TEST join file 2 =================================="
3230
3231 test_75c() {
3232 #       skipped temporarily: we do not have join file currently
3233 #       please remove this when ready - huanghua
3234         return
3235         test75_prep
3236
3237         cp -p ${F128k} ${FTAIL}
3238         cat ${F128k} >> ${F75}_sim_join
3239         cat ${F75}_join_sim >> ${F75}_sim_join
3240         $JOIN ${FTAIL} ${FHEAD} || error "join error"
3241         cmp ${FTAIL} ${F75}_sim_join || \
3242                 error "${FTAIL} ${F75}_sim_join are different"
3243         $CHECKSTAT -a ${FHEAD} || error "tail ${FHEAD} exist after join"
3244 }
3245 run_test 75c "TEST join file 3 =================================="
3246
3247 test_75d() {
3248 #       skipped temporarily: we do not have join file currently
3249 #       please remove this when ready - huanghua
3250         return
3251         test75_prep
3252
3253         cp -p ${F128k} ${FHEAD}
3254         cp -p ${F128k} ${FHEAD}_tmp
3255         cat ${F75}_sim_sim >> ${F75}_join_join
3256         cat ${F75}_sim_join >> ${F75}_join_join
3257         $JOIN ${FHEAD} ${FHEAD}_tmp || error "join ${FHEAD} ${FHEAD}_tmp error"
3258         $JOIN ${FHEAD} ${FTAIL} || error "join ${FHEAD} ${FTAIL} error"
3259         cmp ${FHEAD} ${F75}_join_join ||error "${FHEAD} ${F75}_join_join differ"        $CHECKSTAT -a ${FHEAD}_tmp || error "${FHEAD}_tmp exist after join"
3260         $CHECKSTAT -a ${FTAIL} || error "tail ${FTAIL} exist after join (2)"
3261 }
3262 run_test 75d "TEST join file 4 =================================="
3263
3264 test_75e() {
3265 #       skipped temporarily: we do not have join file currently
3266 #       please remove this when ready - huanghua
3267         return
3268         test75_prep
3269
3270         rm -rf ${FHEAD} || "delete join file error"
3271 }
3272 run_test 75e "TEST join file 5 (remove joined file) ============="
3273
3274 test_75f() {
3275 #       skipped temporarily: we do not have join file currently
3276 #       please remove this when ready - huanghua
3277         return
3278         test75_prep
3279
3280         cp -p ${F128k} ${F75}_join_10_compare
3281         cp -p ${F128k} ${F75}_join_10
3282         for ((i = 0; i < 10; i++)); do
3283                 cat ${F128k} >> ${F75}_join_10_compare
3284                 cp -p ${F128k} ${FTAIL}
3285                 $JOIN ${F75}_join_10 ${FTAIL} || \
3286                         error "join ${F75}_join_10 ${FTAIL} error"
3287                 $CHECKSTAT -a ${FTAIL} || error "tail file exist after join"
3288         done
3289         cmp ${F75}_join_10 ${F75}_join_10_compare || \
3290                 error "files ${F75}_join_10 ${F75}_join_10_compare differ"
3291 }
3292 run_test 75f "TEST join file 6 (join 10 files) =================="
3293
3294 test_75g() {
3295 #       skipped temporarily: we do not have join file currently
3296 #       please remove this when ready - huanghua
3297         return
3298         [ ! -f ${F75}_join_10 ] && echo "${F75}_join_10 missing" && return
3299         $LFS getstripe ${F75}_join_10
3300
3301         $OPENUNLINK ${F75}_join_10 ${F75}_join_10 || error "files unlink open"
3302
3303         ls -l $F75*
3304 }
3305 run_test 75g "TEST join file 7 (open unlink) ===================="
3306
3307 num_inodes() {
3308         awk '/lustre_inode_cache/ {print $2; exit}' /proc/slabinfo
3309 }
3310
3311 test_76() { # bug 1443
3312         DETH=$(grep deathrow /proc/kallsyms /proc/ksyms 2> /dev/null | wc -l)
3313         [ $DETH -eq 0 ] && skip "No _iget." && return 0
3314         BEFORE_INODES=`num_inodes`
3315         echo "before inodes: $BEFORE_INODES"
3316         local COUNT=1000
3317         [ "$SLOW" = "no" ] && COUNT=100
3318         for i in `seq $COUNT`; do
3319                 touch $DIR/$tfile
3320                 rm -f $DIR/$tfile
3321         done
3322         AFTER_INODES=`num_inodes`
3323         echo "after inodes: $AFTER_INODES"
3324         [ $AFTER_INODES -gt $((BEFORE_INODES + 32)) ] && \
3325                 error "inode slab grew from $BEFORE_INODES to $AFTER_INODES"
3326         true
3327 }
3328 run_test 76 "destroy duplicate inodes in client inode cache ===="
3329
3330 export ORIG_CSUM=""
3331 set_checksums()
3332 {
3333         # Note: in sptlrpc modes which enable its own bulk checksum, the
3334         # original crc32_le bulk checksum will be automatically disabled,
3335         # and the OBD_FAIL_OSC_CHECKSUM_SEND/OBD_FAIL_OSC_CHECKSUM_RECEIVE
3336         # will be checked by sptlrpc code against sptlrpc bulk checksum.
3337         # In this case set_checksums() will not be no-op, because sptlrpc
3338         # bulk checksum will be enabled all through the test.
3339
3340         [ "$ORIG_CSUM" ] || ORIG_CSUM=`lctl get_param -n osc.*.checksums | head -n1`
3341         lctl set_param -n osc.*.checksums $1
3342         return 0
3343 }
3344
3345 export ORIG_CSUM_TYPE=""
3346 CKSUM_TYPES=${CKSUM_TYPES:-"crc32 adler"}
3347 set_checksum_type()
3348 {
3349         [ "$ORIG_CSUM_TYPE" ] || \
3350                 ORIG_CSUM_TYPE=`lctl get_param -n osc/*osc-[^mM]*/checksum_type |
3351                                 sed 's/.*\[\(.*\)\].*/\1/g' | head -n1`
3352         lctl set_param -n osc.*osc-[^mM]*.checksum_type $1
3353         log "set checksum type to $1"
3354         return 0
3355 }
3356 F77_TMP=$TMP/f77-temp
3357 F77SZ=8
3358 setup_f77() {
3359         dd if=/dev/urandom of=$F77_TMP bs=1M count=$F77SZ || \
3360                 error "error writing to $F77_TMP"
3361 }
3362
3363 test_77a() { # bug 10889
3364         [ ! -f $F77_TMP ] && setup_f77
3365         set_checksums 1
3366         dd if=$F77_TMP of=$DIR/$tfile bs=1M count=$F77SZ || error "dd error"
3367         set_checksums 0
3368 }
3369 run_test 77a "normal checksum read/write operation ============="
3370
3371 test_77b() { # bug 10889
3372         [ ! -f $F77_TMP ] && setup_f77
3373         #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
3374         lctl set_param fail_loc=0x80000409
3375         set_checksums 1
3376         dd if=$F77_TMP of=$DIR/f77b bs=1M count=$F77SZ conv=sync || \
3377                 error "dd error: $?"
3378         lctl set_param fail_loc=0
3379         set_checksums 0
3380 }
3381 run_test 77b "checksum error on client write ===================="
3382
3383 test_77c() { # bug 10889
3384         [ ! -f $DIR/f77b ] && skip "requires 77b - skipping" && return
3385         set_checksums 1
3386         for algo in $CKSUM_TYPES; do
3387                 cancel_lru_locks osc
3388                 set_checksum_type $algo
3389                 #define OBD_FAIL_OSC_CHECKSUM_RECEIVE    0x408
3390                 lctl set_param fail_loc=0x80000408
3391                 cmp $F77_TMP $DIR/f77b || error "file compare failed"
3392                 lctl set_param fail_loc=0
3393         done
3394         set_checksums 0
3395         set_checksum_type $ORIG_CSUM_TYPE
3396 }
3397 run_test 77c "checksum error on client read ==================="
3398
3399 test_77d() { # bug 10889
3400         #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
3401         lctl set_param fail_loc=0x80000409
3402         set_checksums 1
3403         directio write $DIR/f77 0 $F77SZ $((1024 * 1024)) || \
3404                 error "direct write: rc=$?"
3405         lctl set_param fail_loc=0
3406         set_checksums 0
3407 }
3408 run_test 77d "checksum error on OST direct write ==============="
3409
3410 test_77e() { # bug 10889
3411         [ ! -f $DIR/f77 ] && skip "requires 77d - skipping" && return
3412         #define OBD_FAIL_OSC_CHECKSUM_RECEIVE    0x408
3413         lctl set_param fail_loc=0x80000408
3414         set_checksums 1
3415         cancel_lru_locks osc
3416         directio read $DIR/f77 0 $F77SZ $((1024 * 1024)) || \
3417                 error "direct read: rc=$?"
3418         lctl set_param fail_loc=0
3419         set_checksums 0
3420 }
3421 run_test 77e "checksum error on OST direct read ================"
3422
3423 test_77f() { # bug 10889
3424         set_checksums 1
3425         for algo in $CKSUM_TYPES; do
3426                 cancel_lru_locks osc
3427                 set_checksum_type $algo
3428                 #define OBD_FAIL_OSC_CHECKSUM_SEND       0x409
3429                 lctl set_param fail_loc=0x409
3430                 directio write $DIR/f77 0 $F77SZ $((1024 * 1024)) && \
3431                         error "direct write succeeded"
3432                 lctl set_param fail_loc=0
3433         done
3434         set_checksum_type $ORIG_CSUM_TYPE
3435         set_checksums 0
3436 }
3437 run_test 77f "repeat checksum error on write (expect error) ===="
3438
3439 test_77g() { # bug 10889
3440         [ $(lctl get_param -n devices | grep -c obdfilter) -eq 0 ] && \
3441                 skip "remote OST" && return
3442         [ ! -f $F77_TMP ] && setup_f77
3443         #define OBD_FAIL_OST_CHECKSUM_RECEIVE       0x21a
3444         lctl set_param fail_loc=0x8000021a
3445         set_checksums 1
3446         dd if=$F77_TMP of=$DIR/f77 bs=1M count=$F77SZ || \
3447                 error "write error: rc=$?"
3448         lctl set_param fail_loc=0
3449         set_checksums 0
3450 }
3451 run_test 77g "checksum error on OST write ======================"
3452
3453 test_77h() { # bug 10889
3454         [ $(lctl get_param -n devices | grep -c obdfilter) -eq 0 ] && \
3455                 skip "remote OST" && return
3456         [ ! -f $DIR/f77 ] && skip "requires 77g - skipping" && return
3457         cancel_lru_locks osc
3458         #define OBD_FAIL_OST_CHECKSUM_SEND          0x21b
3459         lctl set_param fail_loc=0x8000021b
3460         set_checksums 1
3461         cmp $F77_TMP $DIR/f77 || error "file compare failed"
3462         lctl set_param fail_loc=0
3463         set_checksums 0
3464 }
3465 run_test 77h "checksum error on OST read ======================="
3466
3467 test_77i() { # bug 13805
3468         #define OBD_FAIL_OSC_CONNECT_CKSUM       0x40b
3469         lctl set_param fail_loc=0x40b
3470         remount_client $MOUNT
3471         lctl set_param fail_loc=0
3472         for VALUE in `lctl get_param osc.*osc-[^mM]*.checksum_type`; do
3473                 PARAM=`echo ${VALUE[0]} | cut -d "=" -f1`
3474                 algo=`lctl get_param -n $PARAM | sed 's/.*\[\(.*\)\].*/\1/g'`
3475                 [ "$algo" = "crc32" ] || error "algo set to $algo instead of crc32"
3476         done
3477         remount_client $MOUNT
3478 }
3479 run_test 77i "client not supporting OSD_CONNECT_CKSUM =========="
3480
3481 test_77j() { # bug 13805
3482         #define OBD_FAIL_OSC_CKSUM_ADLER_ONLY    0x40c
3483         lctl set_param fail_loc=0x40c
3484         remount_client $MOUNT
3485         lctl set_param fail_loc=0
3486         sleep 2 # wait async osc connect to finish
3487         for VALUE in `lctl get_param osc.*osc-[^mM]*.checksum_type`; do
3488                 PARAM=`echo ${VALUE[0]} | cut -d "=" -f1`
3489                 algo=`lctl get_param -n $PARAM | sed 's/.*\[\(.*\)\].*/\1/g'`
3490                 [ "$algo" = "adler" ] || error "algo set to $algo instead of adler"
3491         done
3492         remount_client $MOUNT
3493 }
3494 run_test 77j "client only supporting ADLER32 ===================="
3495
3496 [ "$ORIG_CSUM" ] && set_checksums $ORIG_CSUM || true
3497 rm -f $F77_TMP
3498 unset F77_TMP
3499
3500 test_78() { # bug 10901
3501         NSEQ=5
3502         F78SIZE=$(($(awk '/MemFree:/ { print $2 }' /proc/meminfo) / 1024))
3503         echo "MemFree: $F78SIZE, Max file size: $MAXFREE"
3504         MEMTOTAL=$(($(awk '/MemTotal:/ { print $2 }' /proc/meminfo) / 1024))
3505         echo "MemTotal: $MEMTOTAL"
3506 # reserve 256MB of memory for the kernel and other running processes,
3507 # and then take 1/2 of the remaining memory for the read/write buffers.
3508         MEMTOTAL=$(((MEMTOTAL - 256 ) / 2))
3509         echo "Mem to use for directio: $MEMTOTAL"
3510         [ $F78SIZE -gt $MEMTOTAL ] && F78SIZE=$MEMTOTAL
3511         [ $F78SIZE -gt 512 ] && F78SIZE=512
3512         [ $F78SIZE -gt $((MAXFREE / 1024)) ] && F78SIZE=$((MAXFREE / 1024))
3513         SMALLESTOST=`lfs df $DIR |grep OST | awk '{print $4}' |sort -n |head -1`
3514         echo "Smallest OST: $SMALLESTOST"
3515         [ $SMALLESTOST -lt 10240 ] && \
3516                 skip "too small OSTSIZE, useless to run large O_DIRECT test" && return 0
3517
3518         [ $F78SIZE -gt $((SMALLESTOST * $OSTCOUNT / 1024 - 5)) ] && \
3519                 F78SIZE=$((SMALLESTOST * $OSTCOUNT / 1024 - 5))
3520         [ "$SLOW" = "no" ] && NSEQ=1 && [ $F78SIZE -gt 32 ] && F78SIZE=32
3521         echo "File size: $F78SIZE"
3522         $SETSTRIPE $DIR/$tfile -c -1 || error "setstripe failed"
3523         for i in `seq 1 $NSEQ`
3524         do
3525                 FSIZE=$(($F78SIZE / ($NSEQ - $i + 1)))
3526                 echo directIO rdwr round $i of $NSEQ
3527                 $DIRECTIO rdwr $DIR/$tfile 0 $FSIZE 1048576||error "rdwr failed"
3528         done
3529
3530         rm -f $DIR/$tfile
3531 }
3532 run_test 78 "handle large O_DIRECT writes correctly ============"
3533
3534 test_79() { # bug 12743
3535         [ $(lctl get_param -n devices | grep -c obdfilter) -eq 0 ] &&
3536                 skip "skipping test for remote OST" && return
3537
3538         wait_delete_completed
3539
3540         BKTOTAL=`lctl get_param -n obdfilter.*.kbytestotal | awk 'BEGIN{total=0}; {total+=$1}; END{print total}'`
3541         BKFREE=`lctl get_param -n obdfilter.*.kbytesfree | awk 'BEGIN{free=0}; {free+=$1}; END{print free}'`
3542         BKAVAIL=`lctl get_param -n obdfilter.*.kbytesavail | awk 'BEGIN{avail=0}; {avail+=$1}; END{print avail}'`
3543         STRING=`df -P $MOUNT | tail -n 1 | awk '{print $2","$3","$4}'`
3544         DFTOTAL=`echo $STRING | cut -d, -f1`
3545         DFUSED=`echo $STRING  | cut -d, -f2`
3546         DFAVAIL=`echo $STRING | cut -d, -f3`
3547         DFFREE=$(($DFTOTAL - $DFUSED))
3548
3549         ALLOWANCE=$((64 * $OSTCOUNT))
3550
3551         if [ $DFTOTAL -lt $(($BKTOTAL - $ALLOWANCE)) ] ||
3552            [ $DFTOTAL -gt $(($BKTOTAL + $ALLOWANCE)) ] ; then
3553                 error "df total($DFTOTAL) mismatch OST total($BKTOTAL)"
3554         fi
3555         if [ $DFFREE -lt $(($BKFREE - $ALLOWANCE)) ] ||
3556            [ $DFFREE -gt $(($BKFREE + $ALLOWANCE)) ] ; then
3557                 error "df free($DFFREE) mismatch OST free($BKFREE)"
3558         fi
3559         if [ $DFAVAIL -lt $(($BKAVAIL - $ALLOWANCE)) ] ||
3560            [ $DFAVAIL -gt $(($BKAVAIL + $ALLOWANCE)) ] ; then
3561                 error "df avail($DFAVAIL) mismatch OST avail($BKAVAIL)"
3562         fi
3563 }
3564 run_test 79 "df report consistency check ======================="
3565
3566 test_80() { # bug 10718
3567         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1M
3568         sync; sleep 1; sync
3569         BEFORE=`date +%s`
3570         cancel_lru_locks OSC
3571         AFTER=`date +%s`
3572         DIFF=$((AFTER-BEFORE))
3573         if [ $DIFF -gt 1 ] ; then
3574                 error "elapsed for 1M@1T = $DIFF"
3575         fi
3576         true
3577 }
3578 run_test 80 "Page eviction is equally fast at high offsets too  ===="
3579
3580 # on the LLNL clusters, runas will still pick up root's $TMP settings,
3581 # which will not be writable for the runas user, and then you get a CVS
3582 # error message with a corrupt path string (CVS bug) and panic.
3583 # We're not using much space, so just stick it in /tmp, which is safe.
3584 OLDTMPDIR=$TMPDIR
3585 OLDTMP=$TMP
3586 TMPDIR=/tmp
3587 TMP=/tmp
3588 OLDHOME=$HOME
3589 [ $RUNAS_ID -ne $UID ] && HOME=/tmp
3590
3591 test_99a() {
3592         mkdir -p $DIR/d99cvsroot
3593         chown $RUNAS_ID $DIR/d99cvsroot
3594         $RUNAS cvs -d $DIR/d99cvsroot init || error
3595 }
3596 run_test 99a "cvs init ========================================="
3597
3598 test_99b() {
3599         [ -z "$(which cvs 2>/dev/null)" ] && skip "could not find cvs" && return
3600         [ ! -d $DIR/d99cvsroot ] && test_99a
3601         cd /etc/init.d
3602         # some versions of cvs import exit(1) when asked to import links or
3603         # files they can't read.  ignore those files.
3604         TOIGNORE=$(find . -type l -printf '-I %f\n' -o \
3605                         ! -perm +4 -printf '-I %f\n')
3606         $RUNAS cvs -d $DIR/d99cvsroot import -m "nomesg" $TOIGNORE \
3607                 d99reposname vtag rtag
3608 }
3609 run_test 99b "cvs import ======================================="
3610
3611 test_99c() {
3612         [ -z "$(which cvs 2>/dev/null)" ] && skip "could not find cvs" && return
3613         [ ! -d $DIR/d99cvsroot ] && test_99b
3614         cd $DIR
3615         mkdir -p $DIR/d99reposname
3616         chown $RUNAS_ID $DIR/d99reposname
3617         $RUNAS cvs -d $DIR/d99cvsroot co d99reposname
3618 }
3619 run_test 99c "cvs checkout ====================================="
3620
3621 test_99d() {
3622         [ -z "$(which cvs 2>/dev/null)" ] && skip "could not find cvs" && return
3623         [ ! -d $DIR/d99cvsroot ] && test_99c
3624         cd $DIR/d99reposname
3625         $RUNAS touch foo99
3626         $RUNAS cvs add -m 'addmsg' foo99
3627 }
3628 run_test 99d "cvs add =========================================="
3629
3630 test_99e() {
3631         [ -z "$(which cvs 2>/dev/null)" ] && skip "could not find cvs" && return
3632         [ ! -d $DIR/d99cvsroot ] && test_99c
3633         cd $DIR/d99reposname
3634         $RUNAS cvs update
3635 }
3636 run_test 99e "cvs update ======================================="
3637
3638 test_99f() {
3639         [ -z "$(which cvs 2>/dev/null)" ] && skip "could not find cvs" && return
3640         [ ! -d $DIR/d99cvsroot ] && test_99d
3641         cd $DIR/d99reposname
3642         $RUNAS cvs commit -m 'nomsg' foo99
3643 }
3644 run_test 99f "cvs commit ======================================="
3645
3646 test_100() {
3647         netstat -tna | while read PROT SND RCV LOCAL REMOTE STAT; do
3648                 [ "$PROT" != "tcp" ] && continue
3649                 RPORT=`echo $REMOTE | cut -d: -f2`
3650                 [ "$RPORT" != "$ACCEPTOR_PORT" ] && continue
3651                 LPORT=`echo $LOCAL | cut -d: -f2`
3652                 if [ $LPORT -ge 1024 ]; then
3653                         echo "bad: $PROT $SND $RCV $LOCAL $REMOTE $STAT"
3654                         netstat -tna
3655                         error "local: $LPORT > 1024, remote: $RPORT"
3656                 fi
3657         done
3658         true
3659 }
3660 run_test 100 "check local port using privileged port ==========="
3661
3662 function get_named_value()
3663 {
3664     local tag
3665
3666     tag=$1
3667     while read ;do
3668         line=$REPLY
3669         case $line in
3670         $tag*)
3671             echo $line | sed "s/^$tag//"
3672             break
3673             ;;
3674         esac
3675     done
3676 }
3677
3678 export CACHE_MAX=`lctl get_param -n llite.*.max_cached_mb | head -n 1`
3679 cleanup_101() {
3680         lctl set_param -n llite.*.max_cached_mb $CACHE_MAX
3681         trap 0
3682 }
3683
3684 test_101() {
3685         local s
3686         local discard
3687         local nreads=10000
3688         [ "$CPU" = "UML" ] && nreads=1000
3689         local cache_limit=32
3690
3691         lctl set_param -n osc.*-osc*.rpc_stats 0
3692         trap cleanup_101 EXIT
3693         lctl set_param -n llite.*.read_ahead_stats 0
3694         lctl set_param -n llite.*.max_cached_mb $cache_limit
3695
3696         #
3697         # randomly read 10000 of 64K chunks from file 3x 32MB in size
3698         #
3699         echo "nreads: $nreads file size: $((cache_limit * 3))MB"
3700         $READS -f $DIR/$tfile -s$((cache_limit * 3192 * 1024)) -b65536 -C -n$nreads -t 180
3701
3702         discard=0
3703         for s in `lctl get_param -n llite.*.read_ahead_stats | \
3704                 get_named_value 'read but discarded' | cut -d" " -f1`; do
3705                         discard=$(($discard + $s))
3706         done
3707         cleanup_101
3708
3709         if [ $(($discard * 10)) -gt $nreads ] ;then
3710                 lctl get_param osc.*-osc*.rpc_stats
3711                 lctl get_param llite.*.read_ahead_stats
3712                 error "too many ($discard) discarded pages"
3713         fi
3714         rm -f $DIR/$tfile || true
3715 }
3716 run_test 101 "check read-ahead for random reads ================"
3717
3718 export SETUP_TEST101=no
3719 setup_test101() {
3720         [ "$SETUP_TEST101" = "yes" ] && return
3721         mkdir -p $DIR/$tdir
3722         STRIPE_SIZE=1048576
3723         STRIPE_COUNT=$OSTCOUNT
3724         STRIPE_OFFSET=0
3725
3726         trap cleanup_test101 EXIT
3727         # prepare the read-ahead file
3728         $SETSTRIPE $DIR/$tfile -s $STRIPE_SIZE -i $STRIPE_OFFSET -c $OSTCOUNT
3729
3730         dd if=/dev/zero of=$DIR/$tfile bs=1024k count=100 2> /dev/null
3731         SETUP_TEST101=yes
3732 }
3733
3734 cleanup_test101() {
3735         [ "$SETUP_TEST101" = "yes" ] || return
3736         trap 0
3737         rm -rf $DIR/$tdir
3738         SETUP_TEST101=no
3739 }
3740
3741 calc_total() {
3742         awk 'BEGIN{total=0}; {total+=$1}; END{print total}'
3743 }
3744
3745 ra_check_101() {
3746         local READ_SIZE=$1
3747         local STRIPE_SIZE=1048576
3748         local RA_INC=1048576
3749         local STRIDE_LENGTH=$((STRIPE_SIZE/READ_SIZE))
3750         local FILE_LENGTH=$((64*100))
3751         local discard_limit=$((((STRIDE_LENGTH - 1)*3/(STRIDE_LENGTH*OSTCOUNT))* \
3752                              (STRIDE_LENGTH*OSTCOUNT - STRIDE_LENGTH)))
3753         DISCARD=`$LCTL get_param -n llite.*.read_ahead_stats | \
3754                         get_named_value 'read but discarded' | \
3755                         cut -d" " -f1 | calc_total`
3756
3757         if [ $DISCARD -gt $discard_limit ]; then
3758                 lctl get_param llite.*.read_ahead_stats
3759                 error "Too many ($DISCARD) discarded pages with size (${READ_SIZE})"
3760         else
3761                 echo "Read-ahead success for size ${READ_SIZE}"
3762         fi
3763 }
3764
3765 test_101b() {
3766         [ "$OSTCOUNT" -lt "2" ] && skip "skipping stride IO stride-ahead test" && return
3767         local STRIPE_SIZE=1048576
3768         local STRIDE_SIZE=$((STRIPE_SIZE*OSTCOUNT))
3769         local FILE_LENGTH=$((STRIPE_SIZE*100))
3770         local ITERATION=$((FILE_LENGTH/STRIDE_SIZE))
3771         # prepare the read-ahead file
3772         setup_test101
3773         cancel_lru_locks osc
3774         for BIDX in 2 4 8 16 32 64 128 256
3775         do
3776                 local BSIZE=$((BIDX*4096))
3777                 local READ_COUNT=$((STRIPE_SIZE/BSIZE))
3778                 local STRIDE_LENGTH=$((STRIDE_SIZE/BSIZE))
3779                 local OFFSET=$((STRIPE_SIZE/BSIZE*(OSTCOUNT - 1)))
3780                 $LCTL set_param -n llite.*.read_ahead_stats 0
3781                 $READS -f $DIR/$tfile  -l $STRIDE_LENGTH -o $OFFSET \
3782                               -s $FILE_LENGTH -b $STRIPE_SIZE -a $READ_COUNT -n $ITERATION
3783                 cancel_lru_locks osc
3784                 ra_check_101 $BSIZE
3785         done
3786         cleanup_test101
3787         true
3788 }
3789 run_test 101b "check stride-io mode read-ahead ================="
3790
3791 export SETUP_TEST102=no
3792 setup_test102() {
3793         [ "$SETUP_TEST102" = "yes" ] && return
3794         mkdir -p $DIR/$tdir
3795         STRIPE_SIZE=65536
3796         STRIPE_COUNT=4
3797         STRIPE_OFFSET=2
3798
3799         trap cleanup_test102 EXIT
3800         cd $DIR
3801         $SETSTRIPE $tdir -s $STRIPE_SIZE -i $STRIPE_OFFSET -c $STRIPE_COUNT
3802         cd $DIR/$tdir
3803         for num in 1 2 3 4
3804         do
3805                 for count in 1 2 3 4
3806                 do
3807                         for offset in 0 1 2 3
3808                         do
3809                                 local stripe_size=`expr $STRIPE_SIZE \* $num`
3810                                 local file=file"$num-$offset-$count"
3811                                 $SETSTRIPE $file -s $stripe_size -i $offset -c $count
3812                         done
3813                 done
3814         done
3815
3816         cd $DIR
3817         star -c  f=$TMP/f102.tar $tdir
3818         SETUP_TEST102=yes
3819 }
3820
3821 cleanup_test102() {
3822         [ "$SETUP_TEST102" = "yes" ] || return
3823         trap 0
3824         rm -f $TMP/f102.tar
3825         rm -rf $DIR/$tdir
3826         SETUP_TEST102=no
3827 }
3828
3829 test_102a() {
3830         local testfile=$DIR/xattr_testfile
3831
3832         rm -f $testfile
3833         touch $testfile
3834
3835         [ "$UID" != 0 ] && skip "must run as root" && return
3836         [ -z "`lctl get_param -n mdc.*-mdc-*.connect_flags | grep xattr`" ] && skip "must have user_xattr" && return
3837
3838         [ -z "$(which setfattr 2>/dev/null)" ] && skip "could not find setfattr" && return
3839
3840         echo "set/get xattr..."
3841         setfattr -n trusted.name1 -v value1 $testfile || error
3842         [ "`getfattr -n trusted.name1 $testfile 2> /dev/null | \
3843         grep "trusted.name1"`" == "trusted.name1=\"value1\"" ] || error
3844
3845         setfattr -n user.author1 -v author1 $testfile || error
3846         [ "`getfattr -n user.author1 $testfile 2> /dev/null | \
3847         grep "user.author1"`" == "user.author1=\"author1\"" ] || error
3848
3849         echo "listxattr..."
3850         setfattr -n trusted.name2 -v value2 $testfile || error
3851         setfattr -n trusted.name3 -v value3 $testfile || error
3852         [ `getfattr -d -m "^trusted" $testfile 2> /dev/null | \
3853         grep "trusted.name" | wc -l` -eq 3 ] || error
3854
3855
3856         setfattr -n user.author2 -v author2 $testfile || error
3857         setfattr -n user.author3 -v author3 $testfile || error
3858         [ `getfattr -d -m "^user" $testfile 2> /dev/null | \
3859         grep "user" | wc -l` -eq 3 ] || error
3860
3861         echo "remove xattr..."
3862         setfattr -x trusted.name1 $testfile || error
3863         getfattr -d -m trusted $testfile 2> /dev/null | \
3864         grep "trusted.name1" && error || true
3865
3866         setfattr -x user.author1 $testfile || error
3867         getfattr -d -m user $testfile 2> /dev/null | \
3868         grep "user.author1" && error || true
3869
3870         # b10667: setting lustre special xattr be silently discarded
3871         echo "set lustre special xattr ..."
3872         setfattr -n "trusted.lov" -v "invalid value" $testfile || error
3873
3874         rm -f $testfile
3875 }
3876 run_test 102a "user xattr test =================================="
3877
3878 test_102b() {
3879         # b10930: get/set/list trusted.lov xattr
3880         echo "get/set/list trusted.lov xattr ..."
3881         [ "$OSTCOUNT" -lt "2" ] && skip "skipping 2-stripe test" && return
3882         local testfile=$DIR/$tfile
3883         $SETSTRIPE $testfile -s 65536 -i 1 -c 2
3884         getfattr -d -m "^trusted" $testfile 2> /dev/null | \
3885         grep "trusted.lov" || error "can't get trusted.lov from $testfile"
3886
3887         local testfile2=${testfile}2
3888         local value=`getfattr -n trusted.lov $testfile 2> /dev/null | \
3889                      grep "trusted.lov" |sed -e 's/[^=]\+=//'`
3890
3891         $MCREATE $testfile2
3892         setfattr -n trusted.lov -v $value $testfile2
3893         local tmp_file=${testfile}3
3894         $GETSTRIPE -v $testfile2 > $tmp_file
3895         local stripe_size=`grep "size"  $tmp_file| awk '{print $2}'`
3896         local stripe_count=`grep "count"  $tmp_file| awk '{print $2}'`
3897         [ "$stripe_size" -eq 65536 ] || error "stripe size $stripe_size != 65536"
3898         [ "$stripe_count" -eq 2 ] || error "stripe count $stripe_count != 2"
3899 }
3900 run_test 102b "getfattr/setfattr for trusted.lov EAs ============"
3901
3902 test_102c() {
3903         # b10930: get/set/list lustre.lov xattr
3904         echo "get/set/list lustre.lov xattr ..."
3905         [ "$OSTCOUNT" -lt "2" ] && skip "skipping 2-stripe test" && return
3906         mkdir -p $DIR/$tdir
3907         chown $RUNAS_ID $DIR/$tdir
3908         local testfile=$DIR/$tdir/$tfile
3909         $RUNAS $SETSTRIPE $testfile -s 65536 -i 1 -c 2
3910         $RUNAS getfattr -d -m "^lustre" $testfile 2> /dev/null | \
3911         grep "lustre.lov" || error "can't get lustre.lov from $testfile"
3912
3913         local testfile2=${testfile}2
3914         local value=`getfattr -n lustre.lov $testfile 2> /dev/null | \
3915                      grep "lustre.lov" |sed -e 's/[^=]\+=//'  `
3916
3917         $RUNAS $MCREATE $testfile2
3918         $RUNAS setfattr -n lustre.lov -v $value $testfile2
3919         local tmp_file=${testfile}3
3920         $RUNAS $GETSTRIPE -v $testfile2 > $tmp_file
3921         local stripe_size=`grep "size"  $tmp_file| awk '{print $2}'`
3922         local stripe_count=`grep "count"  $tmp_file| awk '{print $2}'`
3923         [ $stripe_size -eq 65536 ] || error "stripe size $stripe_size != 65536"
3924         [ $stripe_count -eq 2 ] || error "stripe count $stripe_count != 2"
3925 }
3926 run_test 102c "non-root getfattr/setfattr for lustre.lov EAs ==========="
3927
3928 get_stripe_info() {
3929         stripe_size=0
3930         stripe_count=0
3931         stripe_offset=0
3932         local lines=`sed -n '/obdidx/=' $1`
3933         stripe_size=`awk '{if($1~/size/) print $2}' $1`
3934         stripe_count=`awk '{if($1~/count/) print $2}' $1`
3935         lines=`expr $lines + 1`
3936         stripe_offset=`sed -n ${lines}p $1 |awk '{print $1}'`
3937 }
3938
3939 compare_stripe_info1() {
3940         for num in 1 2 3 4
3941         do
3942                 for count in 1 2 3 4
3943                 do
3944                         for offset in 0 1 2 3
3945                         do
3946                                 local size=`expr $STRIPE_SIZE \* $num`
3947                                 local file=file"$num-$offset-$count"
3948                                 local tmp_file=out
3949                                 $GETSTRIPE -v $file > $tmp_file
3950                                 get_stripe_info  $tmp_file
3951                                 if test $stripe_size -ne $size
3952                                 then
3953                                         error "$file: different stripe size" && return
3954                                 fi
3955                                 if test $stripe_count -ne $count
3956                                 then
3957                                         error "$file: different stripe count" && return
3958                                 fi
3959                                 if test $stripe_offset -ne 0
3960                                 then
3961                                         error "$file: different stripe offset" && return
3962                                 fi
3963                                 rm -f $tmp_file
3964                         done
3965                 done
3966         done
3967 }
3968
3969 compare_stripe_info2() {
3970         for num in 1 2 3 4
3971         do
3972                 for count in 1 2 3 4
3973                 do
3974                         for offset in 0 1 2 3
3975                         do
3976                                 local size=`expr $STRIPE_SIZE \* $num`
3977                                 local file=file"$num-$offset-$count"
3978                                 local tmp_file=out
3979                                 $GETSTRIPE -v $file > $tmp_file
3980                                 get_stripe_info  $tmp_file
3981                                 if test $stripe_size -ne $size
3982                                 then
3983                                         error "$file: different stripe size" && return
3984                                 fi
3985                                 if test $stripe_count -ne $count
3986                                 then
3987                                         error "$file: different stripe count" && return
3988                                 fi
3989                                 if test $stripe_offset -ne $offset
3990                                 then
3991                                         error "$file: different stripe offset" && return
3992                                 fi
3993                                 rm -f $tmp_file
3994                         done
3995                 done
3996         done
3997 }
3998
3999 test_102d() {
4000         # b10930: star test for trusted.lov xattr
4001         star --xhelp 2>&1 | grep -q nolustre
4002         if [ $? -ne 0 ]
4003         then
4004                 skip "being skipped because a lustre-aware star is not installed." && return
4005         fi
4006         [ "$OSTCOUNT" -lt "4" ] && skip "skipping 4-stripe test" && return
4007         setup_test102
4008         mkdir -p $DIR/d102d
4009         star -x  f=$TMP/f102.tar -C $DIR/d102d
4010         cd $DIR/d102d/$tdir
4011         compare_stripe_info1
4012
4013 }
4014 run_test 102d "star restore stripe info from tarfile,not keep osts ==========="
4015
4016 test_102e() {
4017         # b10930: star test for trusted.lov xattr
4018         star --xhelp 2>&1 | grep -q nolustre
4019         [ $? -ne 0 ] && skip "lustre-aware star is not installed" && return
4020         [ "$OSTCOUNT" -lt "4" ] && skip "skipping 4-stripe test" && return
4021         setup_test102
4022         mkdir -p $DIR/d102e
4023         star -x  -preserve-osts f=$TMP/f102.tar -C $DIR/d102e
4024         cd $DIR/d102e/$tdir
4025         compare_stripe_info2
4026 }
4027 run_test 102e "star restore stripe info from tarfile, keep osts ==========="
4028
4029 test_102f() {
4030         # b10930: star test for trusted.lov xattr
4031         star --xhelp 2>&1 | grep -q nolustre
4032         [ $? -ne 0 ] && skip "lustre-aware star is not installed" && return
4033         [ "$OSTCOUNT" -lt "4" ] && skip "skipping 4-stripe test" && return
4034         setup_test102
4035         mkdir -p $DIR/d102f
4036         cd $DIR
4037         star -copy  $tdir $DIR/d102f
4038         cd $DIR/d102f/$tdir
4039         compare_stripe_info1
4040 }
4041 run_test 102f "star copy files, not keep osts ==========="
4042
4043 test_102g() {
4044         # b10930: star test for trusted.lov xattr
4045         star --xhelp 2>&1 | grep -q nolustre
4046         [ $? -ne 0 ] && skip "lustre-aware star is not installed" && return
4047         [ "$OSTCOUNT" -lt "4" ] && skip "skipping 4-stripe test" && return
4048         setup_test102
4049         mkdir -p $DIR/d102g
4050         cd $DIR
4051         star -copy -preserve-osts $tdir $DIR/d102g
4052         cd $DIR/d102g/$tdir
4053         compare_stripe_info2
4054         cleanup_test102
4055 }
4056 run_test 102g "star copy files, keep osts ==========="
4057
4058 test_102h() { # bug 15777
4059         [ -z $(lctl get_param -n mdc.*.connect_flags | grep xattr) ] &&
4060                 skip "must have user_xattr" && return
4061         [ -z "$(which setfattr 2>/dev/null)" ] &&
4062                 skip "could not find setfattr" && return
4063
4064         XBIG=trusted.big
4065         XSIZE=1024
4066         touch $DIR/$tfile
4067         VALUE=datadatadatadatadatadatadatadata
4068         while [ $(echo $VALUE | wc -c) -lt $XSIZE ]; do
4069                 VALUE="$VALUE$VALUE"
4070         done
4071         log "save $XBIG on $DIR/$tfile"
4072         setfattr -n $XBIG -v "$VALUE" $DIR/$tfile ||
4073                 error "saving $XBIG on $DIR/$tfile failed"
4074         ORIG=$(getfattr -n $XBIG $DIR/$tfile 2> /dev/null | grep $XBIG)
4075         OSIZE=$(echo $ORIG | wc -c)
4076         [ $OSIZE -lt $XSIZE ] && error "set $XBIG too small ($OSIZE < $XSIZE)"
4077
4078         XSML=trusted.sml
4079         log "save $XSML on $DIR/$tfile"
4080         setfattr -n $XSML -v val $DIR/$tfile ||
4081                 error "saving $XSML on $DIR/$tfile failed"
4082         NEW=$(getfattr -n $XBIG $DIR/$tfile 2> /dev/null | grep $XBIG)
4083         if [ "$NEW" != "$ORIG" ]; then
4084                 log "orig: $ORIG"
4085                 log "new: $NEW"
4086                 error "$XBIG different after saving $XSML"
4087         fi
4088
4089         log "grow $XSML on $DIR/$tfile"
4090         setfattr -n $XSML -v "$VALUE" $DIR/$tfile ||
4091                 error "growing $XSML on $DIR/$tfile failed"
4092         NEW=$(getfattr -n $XBIG $DIR/$tfile 2> /dev/null | grep $XBIG)
4093         if [ "$NEW" != "$ORIG" ]; then
4094                 log "orig: $ORIG"
4095                 log "new: $NEW"
4096                 error "$XBIG different after growing $XSML"
4097         fi
4098         log "$XBIG still valid after growing $XSML"
4099 }
4100 run_test 102h "grow xattr from inside inode to external block"
4101
4102 run_acl_subtest()
4103 {
4104     $LUSTRE/tests/acl/run $LUSTRE/tests/acl/$1.test
4105     return $?
4106 }
4107
4108 test_103 () {
4109     [ "$UID" != 0 ] && skip "must run as root" && return
4110     [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep acl)" ] && skip "must have acl enabled" && return
4111     [ -z "$(which setfacl 2>/dev/null)" ] && skip "could not find setfacl" && return
4112     $GSS && skip "could not run under gss" && return
4113
4114     declare -a identity_old
4115
4116     for num in `seq $MDSCOUNT`; do
4117         switch_identity $num true || identity_old[$num]=$?
4118     done
4119
4120     SAVE_UMASK=`umask`
4121     umask 0022
4122     cd $DIR
4123
4124     echo "performing cp ..."
4125     run_acl_subtest cp || error
4126     echo "performing getfacl-noacl..."
4127     run_acl_subtest getfacl-noacl || error
4128     echo "performing misc..."
4129     run_acl_subtest misc || error
4130     echo "performing permissions..."
4131     run_acl_subtest permissions || error
4132     echo "performing setfacl..."
4133     run_acl_subtest setfacl || error
4134
4135     # inheritance test got from HP
4136     echo "performing inheritance..."
4137     cp $LUSTRE/tests/acl/make-tree . || error
4138     chmod +x make-tree || error
4139     run_acl_subtest inheritance || error
4140     rm -f make-tree
4141
4142     cd $SAVE_PWD
4143     umask $SAVE_UMASK
4144
4145     for num in `seq $MDSCOUNT`; do
4146         if [ "${identity_old[$num]}" = 1 ]; then
4147             switch_identity $num false || identity_old[$num]=$?
4148         fi
4149     done
4150 }
4151 run_test 103 "acl test ========================================="
4152
4153 test_104() {
4154         touch $DIR/$tfile
4155         lfs df || error "lfs df failed"
4156         lfs df -ih || error "lfs df -ih failed"
4157         lfs df -h $DIR || error "lfs df -h $DIR failed"
4158         lfs df -i $DIR || error "lfs df -i $DIR failed"
4159         lfs df $DIR/$tfile || error "lfs df $DIR/$tfile failed"
4160         lfs df -ih $DIR/$tfile || error "lfs df -ih $DIR/$tfile failed"
4161
4162         OSC=`lctl get_param -n devices | awk '/-osc-/ {print $4}' | head -n 1`
4163         lctl --device %$OSC deactivate
4164         lfs df || error "lfs df with deactivated OSC failed"
4165         lctl --device %$OSC recover
4166         lfs df || error "lfs df with reactivated OSC failed"
4167 }
4168 run_test 104 "lfs df [-ih] [path] test ========================="
4169
4170 test_105a() {
4171         # doesn't work on 2.4 kernels
4172         touch $DIR/$tfile
4173         if [ -n "`mount | grep \"$DIR.*flock\" | grep -v noflock`" ];
4174         then
4175                 flocks_test 1 on -f $DIR/$tfile || error "fail flock on"
4176         else
4177                 flocks_test 1 off -f $DIR/$tfile || error "fail flock off"
4178         fi
4179 }
4180 run_test 105a "flock when mounted without -o flock test ========"
4181
4182 test_105b() {
4183         touch $DIR/$tfile
4184         if [ -n "`mount | grep \"$DIR.*flock\" | grep -v noflock`" ];
4185         then
4186                 flocks_test 1 on -c $DIR/$tfile || error "fail flock on"
4187         else
4188                 flocks_test 1 off -c $DIR/$tfile || error "fail flock off"
4189         fi
4190 }
4191 run_test 105b "fcntl when mounted without -o flock test ========"
4192
4193 test_105c() {
4194         touch $DIR/$tfile
4195         if [ -n "`mount | grep \"$DIR.*flock\" | grep -v noflock`" ];
4196         then
4197                 flocks_test 1 on -l $DIR/$tfile || error "fail flock on"
4198         else
4199                 flocks_test 1 off -l $DIR/$tfile || error "fail flock off"
4200         fi
4201 }
4202 run_test 105c "lockf when mounted without -o flock test ========"
4203
4204 test_105d() { # bug 15924
4205         mkdir -p $DIR/$tdir
4206         [ -z "`mount | grep \"$DIR.*flock\" | grep -v noflock`" ] && \
4207                 skip "mount w/o flock enabled" && return
4208         #define OBD_FAIL_LDLM_CP_CB_WAIT  0x315
4209         $LCTL set_param fail_loc=0x80000315
4210         flocks_test 2 $DIR/$tdir
4211 }
4212 run_test 105d "flock race (should not freeze) ========"
4213
4214 test_106() { #bug 10921
4215         mkdir -p $DIR/$tdir
4216         $DIR/$tdir && error "exec $DIR/$tdir succeeded"
4217         chmod 777 $DIR/$tdir || error "chmod $DIR/$tdir failed"
4218 }
4219 run_test 106 "attempt exec of dir followed by chown of that dir"
4220
4221 test_107() {
4222         CDIR=`pwd`
4223         cd $DIR
4224
4225         local file=core
4226         rm -f $file
4227
4228         local save_pattern=$(sysctl -n kernel.core_pattern)
4229         local save_uses_pid=$(sysctl -n kernel.core_uses_pid)
4230         sysctl -w kernel.core_pattern=$file
4231         sysctl -w kernel.core_uses_pid=0
4232
4233         ulimit -c unlimited
4234         sleep 60 &
4235         SLEEPPID=$!
4236
4237         sleep 1
4238
4239         kill -s 11 $SLEEPPID
4240         wait $SLEEPPID
4241         if [ -e $file ]; then
4242                 size=`stat -c%s $file`
4243                 [ $size -eq 0 ] && error "Fail to create core file $file"
4244         else
4245                 error "Fail to create core file $file"
4246         fi
4247         rm -f $file
4248         sysctl -w kernel.core_pattern=$save_pattern
4249         sysctl -w kernel.core_uses_pid=$save_uses_pid
4250         cd $CDIR
4251 }
4252 run_test 107 "Coredump on SIG"
4253
4254 test_110() {
4255         mkdir -p $DIR/d110
4256         mkdir $DIR/d110/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || error "mkdir with 255 char fail"
4257         mkdir $DIR/d110/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && error "mkdir with 256 char should fail, but not"
4258         touch $DIR/d110/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx || error "create with 255 char fail"
4259         touch $DIR/d110/yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy && error ""create with 256 char should fail, but not
4260
4261         ls -l $DIR/d110
4262 }
4263 run_test 110 "filename length checking"
4264
4265 test_115() {
4266         OSTIO_pre=$(ps -e|grep ll_ost_io|awk '{print $4}'|sort -n|tail -1|\
4267             cut -c11-20)
4268         [ -z "$OSTIO_pre" ] && skip "no OSS threads" && \
4269             return
4270         echo "Starting with $OSTIO_pre threads"
4271
4272         NUMTEST=20000
4273         NUMFREE=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
4274         [ $NUMFREE -lt $NUMTEST ] && NUMTEST=$(($NUMFREE - 1000))
4275         echo "$NUMTEST creates/unlinks"
4276         mkdir -p $DIR/$tdir
4277         createmany -o $DIR/$tdir/$tfile $NUMTEST
4278         unlinkmany $DIR/$tdir/$tfile $NUMTEST
4279
4280         OSTIO_post=$(ps -e|grep ll_ost_io|awk '{print $4}'|sort -n|tail -1|\
4281             cut -c11-20)
4282
4283         # don't return an error
4284         [ $OSTIO_post -eq $OSTIO_pre ] && echo \
4285             "WARNING: No new ll_ost_io threads were created ($OSTIO_pre)" &&\
4286             echo "This may be fine, depending on what ran before this test" &&\
4287             echo "and how fast this system is." && return
4288
4289         echo "Started with $OSTIO_pre threads, ended with $OSTIO_post"
4290 }
4291 run_test 115 "verify dynamic thread creation===================="
4292
4293 free_min_max () {
4294         wait_delete_completed
4295         AVAIL=($(lctl get_param -n osc.*[oO][sS][cC]-[^M]*.kbytesavail))
4296         echo OST kbytes available: ${AVAIL[@]}
4297         MAXI=0; MAXV=${AVAIL[0]}
4298         MINI=0; MINV=${AVAIL[0]}
4299         for ((i = 0; i < ${#AVAIL[@]}; i++)); do
4300             #echo OST $i: ${AVAIL[i]}kb
4301             if [ ${AVAIL[i]} -gt $MAXV ]; then
4302                 MAXV=${AVAIL[i]}; MAXI=$i
4303             fi
4304             if [ ${AVAIL[i]} -lt $MINV ]; then
4305                 MINV=${AVAIL[i]}; MINI=$i
4306             fi
4307         done
4308         echo Min free space: OST $MINI: $MINV
4309         echo Max free space: OST $MAXI: $MAXV
4310 }
4311
4312 test_116() {
4313         [ "$OSTCOUNT" -lt "2" ] && skip "$OSTCOUNT < 2 OSTs" && return
4314         remote_mds && skip "remote MDS" && return
4315
4316         echo -n "Free space priority "
4317         lctl get_param -n lov.*-clilov-*.qos_prio_free
4318         DELAY=$(lctl get_param -n lov.*-clilov-*.qos_maxage | head -1 | awk '{print $1}')
4319         declare -a AVAIL
4320         free_min_max
4321         [ $MINV -gt 960000 ] && skip "too much free space in OST$MINI, skip" &&\
4322                 return
4323
4324         # generate uneven OSTs
4325         mkdir -p $DIR/$tdir/OST${MINI}
4326         declare -i FILL
4327         FILL=$(($MINV / 4))
4328         echo "Filling 25% remaining space in OST${MINI} with ${FILL}Kb"
4329         $SETSTRIPE $DIR/$tdir/OST${MINI} -i $MINI -c 1
4330         i=0
4331         while [ $FILL -gt 0 ]; do
4332             i=$(($i + 1))
4333             dd if=/dev/zero of=$DIR/$tdir/OST${MINI}/$tfile-$i bs=2M count=1 2>/dev/null
4334             FILL=$(($FILL - 2048))
4335             echo -n .
4336         done
4337         FILL=$(($MINV / 4))
4338         sync
4339         sleep $DELAY
4340
4341         free_min_max
4342         DIFF=$(($MAXV - $MINV))
4343         DIFF2=$(($DIFF * 100 / $MINV))
4344         echo -n "diff=${DIFF}=${DIFF2}% must be > 20% for QOS mode..."
4345         if [ $DIFF2 -gt 20 ]; then
4346             echo "ok"
4347         else
4348             echo "failed - QOS mode won't be used"
4349             error_ignore "QOS imbalance criteria not met"
4350             return
4351         fi
4352
4353         MINI1=$MINI; MINV1=$MINV
4354         MAXI1=$MAXI; MAXV1=$MAXV
4355
4356         # now fill using QOS
4357         echo writing a bunch of files to QOS-assigned OSTs
4358         $SETSTRIPE $DIR/$tdir -c 1
4359         i=0
4360         while [ $FILL -gt 0 ]; do
4361             i=$(($i + 1))
4362             dd if=/dev/zero of=$DIR/$tdir/$tfile-$i bs=1024 count=200 2>/dev/null
4363             FILL=$(($FILL - 200))
4364             echo -n .
4365         done
4366         echo "wrote $i 200k files"
4367         sync
4368         sleep $DELAY
4369
4370         echo "Note: free space may not be updated, so measurements might be off"
4371         free_min_max
4372         DIFF2=$(($MAXV - $MINV))
4373         echo "free space delta: orig $DIFF final $DIFF2"
4374         [ $DIFF2 -gt $DIFF ] && echo "delta got worse!"
4375         DIFF=$(($MINV1 - ${AVAIL[$MINI1]}))
4376         echo "Wrote $DIFF to smaller OST $MINI1"
4377         DIFF2=$(($MAXV1 - ${AVAIL[$MAXI1]}))
4378         echo "Wrote $DIFF2 to larger OST $MAXI1"
4379         [ $DIFF -gt 0 ] && echo "Wrote $(($DIFF2 * 100 / $DIFF - 100))% more data to larger OST $MAXI1"
4380
4381         # Figure out which files were written where
4382         UUID=$(lctl get_param -n lov.${FSNAME}-clilov-*.target_obd |
4383                awk '/'$MINI1': / {print $2; exit}')
4384         echo $UUID
4385         MINC=$($GETSTRIPE --obd $UUID $DIR/$tdir | wc -l)
4386         echo "$MINC files created on smaller OST $MINI1"
4387         UUID=$(lctl get_param -n lov.${FSNAME}-clilov-*.target_obd |
4388                awk '/'$MAXI1': / {print $2; exit}')
4389         echo $UUID
4390         MAXC=$($GETSTRIPE --obd $UUID $DIR/$tdir | wc -l)
4391         echo "$MAXC files created on larger OST $MAXI1"
4392         [ $MINC -gt 0 ] && echo "Wrote $(($MAXC * 100 / $MINC - 100))% more files to larger OST $MAXI1"
4393         [ $MAXC -gt $MINC ] || error_ignore "stripe QOS didn't balance free space"
4394 }
4395 run_test 116 "stripe QOS: free space balance ==================="
4396
4397 test_117() # bug 10891
4398 {
4399         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1
4400         #define OBD_FAIL_OST_SETATTR_CREDITS 0x21e
4401         lctl set_param fail_loc=0x21e
4402         > $DIR/$tfile || error "truncate failed"
4403         lctl set_param fail_loc=0
4404         echo "Truncate succeeded."
4405 }
4406 run_test 117 "verify fsfilt_extend =========="
4407
4408 export OLD_RESENDCOUNT=""
4409 set_resend_count () {
4410         local PROC_RESENDCOUNT="osc.${FSNAME}-OST*-osc-*.resend_count"
4411         OLD_RESENDCOUNT=$(lctl get_param -n $PROC_RESENDCOUNT | head -1)
4412         lctl set_param -n $PROC_RESENDCOUNT $1
4413         echo resend_count is set to $(lctl get_param -n $PROC_RESENDCOUNT)
4414 }
4415
4416 [ "$SLOW" = "no" ] && set_resend_count 4 # for reduce test_118* time (bug 14842)
4417
4418 # Reset async IO behavior after error case
4419 reset_async() {
4420         FILE=$DIR/reset_async
4421
4422         # Ensure all OSCs are cleared
4423         $LSTRIPE $FILE 0 -1 -1
4424         dd if=/dev/zero of=$FILE bs=64k count=$OSTCOUNT
4425         sync
4426         rm $FILE
4427 }
4428
4429 test_118a() #bug 11710
4430 {
4431         reset_async
4432
4433         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
4434         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4435         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
4436
4437         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4438                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4439                 return 1;
4440         fi
4441 }
4442 run_test 118a "verify O_SYNC works =========="
4443
4444 test_118b()
4445 {
4446         remote_ost_nodsh && skip "remote OST" && return
4447
4448         reset_async
4449
4450         #define OBD_FAIL_OST_ENOENT 0x217
4451         set_nodes_failloc "$(osts_nodes)" 0x217
4452         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
4453         RC=$?
4454         set_nodes_failloc "$(osts_nodes)" 0
4455         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4456         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4457                     grep -c writeback)
4458
4459         if [[ $RC -eq 0 ]]; then
4460                 error "Must return error due to dropped pages, rc=$RC"
4461                 return 1;
4462         fi
4463
4464         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4465                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4466                 return 1;
4467         fi
4468
4469         echo "Dirty pages not leaked on ENOENT"
4470
4471         # Due to the above error the OSC will issue all RPCs syncronously
4472         # until a subsequent RPC completes successfully without error.
4473         multiop $DIR/$tfile Ow4096yc
4474         rm -f $DIR/$tfile
4475
4476         return 0
4477 }
4478 run_test 118b "Reclaim dirty pages on fatal error =========="
4479
4480 test_118c()
4481 {
4482         remote_ost_nodsh && skip "remote OST" && return
4483
4484         reset_async
4485
4486         #define OBD_FAIL_OST_EROFS               0x216
4487         set_nodes_failloc "$(osts_nodes)" 0x216
4488
4489         # multiop should block due to fsync until pages are written
4490         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
4491         MULTIPID=$!
4492         sleep 1
4493
4494         if [[ `ps h -o comm -p $MULTIPID` != "multiop" ]]; then
4495                 error "Multiop failed to block on fsync, pid=$MULTIPID"
4496         fi
4497
4498         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4499                     grep -c writeback)
4500         if [[ $WRITEBACK -eq 0 ]]; then
4501                 error "No page in writeback, writeback=$WRITEBACK"
4502         fi
4503
4504         set_nodes_failloc "$(osts_nodes)" 0
4505         wait $MULTIPID
4506         RC=$?
4507         if [[ $RC -ne 0 ]]; then
4508                 error "Multiop fsync failed, rc=$RC"
4509         fi
4510
4511         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4512         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4513                     grep -c writeback)
4514         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4515                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4516         fi
4517
4518         rm -f $DIR/$tfile
4519         echo "Dirty pages flushed via fsync on EROFS"
4520         return 0
4521 }
4522 run_test 118c "Fsync blocks on EROFS until dirty pages are flushed =========="
4523
4524 test_118d()
4525 {
4526         remote_ost_nodsh && skip "remote OST" && return
4527
4528         reset_async
4529
4530         #define OBD_FAIL_OST_BRW_PAUSE_BULK
4531         set_nodes_failloc "$(osts_nodes)" 0x214
4532         # multiop should block due to fsync until pages are written
4533         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
4534         MULTIPID=$!
4535         sleep 1
4536
4537         if [[ `ps h -o comm -p $MULTIPID` != "multiop" ]]; then
4538                 error "Multiop failed to block on fsync, pid=$MULTIPID"
4539         fi
4540
4541         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4542                     grep -c writeback)
4543         if [[ $WRITEBACK -eq 0 ]]; then
4544                 error "No page in writeback, writeback=$WRITEBACK"
4545         fi
4546
4547         wait $MULTIPID || error "Multiop fsync failed, rc=$?"
4548         set_nodes_failloc "$(osts_nodes)" 0
4549
4550         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4551         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4552                     grep -c writeback)
4553         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4554                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4555         fi
4556
4557         rm -f $DIR/$tfile
4558         echo "Dirty pages gaurenteed flushed via fsync"
4559         return 0
4560 }
4561 run_test 118d "Fsync validation inject a delay of the bulk =========="
4562
4563 test_118f() {
4564         reset_async
4565
4566         #define OBD_FAIL_OSC_BRW_PREP_REQ2        0x40a
4567         lctl set_param fail_loc=0x8000040a
4568
4569         # Should simulate EINVAL error which is fatal
4570         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
4571         RC=$?
4572         if [[ $RC -eq 0 ]]; then
4573                 error "Must return error due to dropped pages, rc=$RC"
4574         fi
4575
4576         lctl set_param fail_loc=0x0
4577
4578         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
4579         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4580         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4581                     grep -c writeback)
4582         if [[ $LOCKED -ne 0 ]]; then
4583                 error "Locked pages remain in cache, locked=$LOCKED"
4584         fi
4585
4586         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4587                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4588         fi
4589
4590         rm -f $DIR/$tfile
4591         echo "No pages locked after fsync"
4592
4593         reset_async
4594         return 0
4595 }
4596 run_test 118f "Simulate unrecoverable OSC side error =========="
4597
4598 test_118g() {
4599         reset_async
4600
4601         #define OBD_FAIL_OSC_BRW_PREP_REQ        0x406
4602         lctl set_param fail_loc=0x406
4603
4604         # simulate local -ENOMEM
4605         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
4606         RC=$?
4607
4608         lctl set_param fail_loc=0
4609         if [[ $RC -eq 0 ]]; then
4610                 error "Must return error due to dropped pages, rc=$RC"
4611         fi
4612
4613         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
4614         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4615         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4616                         grep -c writeback)
4617         if [[ $LOCKED -ne 0 ]]; then
4618                 error "Locked pages remain in cache, locked=$LOCKED"
4619         fi
4620
4621         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4622                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4623         fi
4624
4625         rm -f $DIR/$tfile
4626         echo "No pages locked after fsync"
4627
4628         reset_async
4629         return 0
4630 }
4631 run_test 118g "Don't stay in wait if we got local -ENOMEM  =========="
4632
4633 test_118h() {
4634         remote_ost_nodsh && skip "remote OST" && return
4635
4636         reset_async
4637
4638         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
4639         set_nodes_failloc "$(osts_nodes)" 0x20e
4640         # Should simulate ENOMEM error which is recoverable and should be handled by timeout
4641         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
4642         RC=$?
4643
4644         set_nodes_failloc "$(osts_nodes)" 0
4645         if [[ $RC -eq 0 ]]; then
4646                 error "Must return error due to dropped pages, rc=$RC"
4647         fi
4648
4649         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
4650         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4651         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache |
4652                     grep -c writeback)
4653         if [[ $LOCKED -ne 0 ]]; then
4654                 error "Locked pages remain in cache, locked=$LOCKED"
4655         fi
4656
4657         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4658                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4659         fi
4660
4661         rm -f $DIR/$tfile
4662         echo "No pages locked after fsync"
4663
4664         return 0
4665 }
4666 run_test 118h "Verify timeout in handling recoverables errors  =========="
4667
4668 test_118i() {
4669         remote_ost_nodsh && skip "remote OST" && return
4670
4671         reset_async
4672
4673         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
4674         set_nodes_failloc "$(osts_nodes)" 0x20e
4675
4676         # Should simulate ENOMEM error which is recoverable and should be handled by timeout
4677         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c &
4678         PID=$!
4679         sleep 5
4680         set_nodes_failloc "$(osts_nodes)" 0
4681
4682         wait $PID
4683         RC=$?
4684         if [[ $RC -ne 0 ]]; then
4685                 error "got error, but should be not, rc=$RC"
4686         fi
4687
4688         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
4689         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4690         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
4691         if [[ $LOCKED -ne 0 ]]; then
4692                 error "Locked pages remain in cache, locked=$LOCKED"
4693         fi
4694
4695         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4696                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4697         fi
4698
4699         rm -f $DIR/$tfile
4700         echo "No pages locked after fsync"
4701
4702         return 0
4703 }
4704 run_test 118i "Fix error before timeout in recoverable error  =========="
4705
4706 test_118j() {
4707         remote_ost_nodsh && skip "remote OST" && return
4708
4709         reset_async
4710
4711         #define OBD_FAIL_OST_BRW_WRITE_BULK2     0x220
4712         set_nodes_failloc "$(osts_nodes)" 0x220
4713
4714         # return -EIO from OST
4715         multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
4716         RC=$?
4717         set_nodes_failloc "$(osts_nodes)" 0x0
4718         if [[ $RC -eq 0 ]]; then
4719                 error "Must return error due to dropped pages, rc=$RC"
4720         fi
4721
4722         LOCKED=$(lctl get_param -n llite.*.dump_page_cache | grep -c locked)
4723         DIRTY=$(lctl get_param -n llite.*.dump_page_cache | grep -c dirty)
4724         WRITEBACK=$(lctl get_param -n llite.*.dump_page_cache | grep -c writeback)
4725         if [[ $LOCKED -ne 0 ]]; then
4726                 error "Locked pages remain in cache, locked=$LOCKED"
4727         fi
4728
4729         # in recoverable error on OST we want resend and stay until it finished
4730         if [[ $DIRTY -ne 0 || $WRITEBACK -ne 0 ]]; then
4731                 error "Dirty pages not flushed to disk, dirty=$DIRTY, writeback=$WRITEBACK"
4732         fi
4733
4734         rm -f $DIR/$tfile
4735         echo "No pages locked after fsync"
4736
4737         return 0
4738 }
4739 run_test 118j "Simulate unrecoverable OST side error =========="
4740
4741 test_118k()
4742 {
4743         #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
4744         set_nodes_failloc "$(osts_nodes)" 0x20e
4745         mkdir -p $DIR/$tdir
4746
4747         for ((i=0;i<10;i++)); do
4748                 (dd if=/dev/zero of=$DIR/$tdir/$tfile-$i bs=1M count=10 || \
4749                         error "dd to $DIR/$tdir/$tfile-$i failed" )&
4750                 SLEEPPID=$!
4751                 sleep 0.500s
4752                 kill $SLEEPPID
4753                 wait $SLEEPPID
4754         done
4755
4756         set_nodes_failloc "$(osts_nodes)" 0
4757 }
4758 run_test 118k "bio alloc -ENOMEM and IO TERM handling ========="
4759
4760 [ "$SLOW" = "no" ] && [ -n "$OLD_RESENDCOUNT" ] && set_resend_count $OLD_RESENDCOUNT
4761
4762 test_119a() # bug 11737
4763 {
4764         BSIZE=$((512 * 1024))
4765         directio write $DIR/$tfile 0 1 $BSIZE
4766         # We ask to read two blocks, which is more than a file size.
4767         # directio will indicate an error when requested and actual
4768         # sizes aren't equeal (a normal situation in this case) and
4769         # print actual read amount.
4770         NOB=`directio read $DIR/$tfile 0 2 $BSIZE | awk '/error/ {print $6}'`
4771         if [ "$NOB" != "$BSIZE" ]; then
4772                 error "read $NOB bytes instead of $BSIZE"
4773         fi
4774         rm -f $DIR/$tfile
4775 }
4776 run_test 119a "Short directIO read must return actual read amount"
4777
4778 test_119b() # bug 11737
4779 {
4780         [ "$OSTCOUNT" -lt "2" ] && skip "skipping 2-stripe test" && return
4781
4782         $SETSTRIPE $DIR/$tfile -c 2
4783         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 seek=1 || error "dd failed"
4784         sync
4785         multiop $DIR/$tfile oO_RDONLY:O_DIRECT:r$((2048 * 1024)) || \
4786                 error "direct read failed"
4787         rm -f $DIR/$tfile
4788 }
4789 run_test 119b "Sparse directIO read must return actual read amount"
4790
4791 test_119c() # bug 13099
4792 {
4793         BSIZE=1048576
4794         directio write $DIR/$tfile 3 1 $BSIZE || error "direct write failed"
4795         directio readhole $DIR/$tfile 0 2 $BSIZE || error "reading hole failed"
4796         rm -f $DIR/$tfile
4797 }
4798 run_test 119c "Testing for direct read hitting hole"
4799
4800 test_119d() # bug 15950
4801 {
4802         MAX_RPCS_IN_FLIGHT=`$LCTL get_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight`
4803         $LCTL set_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight 1
4804         BSIZE=1048576
4805         $SETSTRIPE $DIR/$tfile -i 0 -c 1 || error "setstripe failed"
4806         $DIRECTIO write $DIR/$tfile 0 1 $BSIZE || error "first directio failed"
4807         #define OBD_FAIL_OSC_DIO_PAUSE           0x40d
4808         lctl set_param fail_loc=0x40d
4809         $DIRECTIO write $DIR/$tfile 1 4 $BSIZE &
4810         pid_dio=$!
4811         sleep 1
4812         cat $DIR/$tfile > /dev/null &
4813         lctl set_param fail_loc=0
4814         pid_reads=$!
4815         wait $pid_dio
4816         log "the DIO writes have completed, now wait for the reads (should not block very long)"
4817         sleep 2
4818         [ -n "`ps h -p $pid_reads -o comm`" ] && \
4819         error "the read rpcs have not completed in 2s"
4820         rm -f $DIR/$tfile
4821         $LCTL set_param -n osc.*OST0000-osc-[^mM]*.max_rpcs_in_flight $MAX_RPCS_IN_FLIGHT
4822 }
4823 run_test 119d "The DIO path should try to send a new rpc once one is completed"
4824
4825 test_120a() {
4826         mkdir -p $DIR/$tdir
4827         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
4828                skip "no early lock cancel on server" && return 0
4829         lru_resize_disable mdc
4830         lru_resize_disable osc
4831         cancel_lru_locks mdc
4832         stat $DIR/$tdir > /dev/null
4833         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
4834         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
4835         mkdir $DIR/$tdir/d1
4836         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
4837         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
4838         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
4839         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
4840         lru_resize_enable mdc
4841         lru_resize_enable osc
4842 }
4843 run_test 120a "Early Lock Cancel: mkdir test"
4844
4845 test_120b() {
4846         mkdir -p $DIR/$tdir
4847         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
4848                skip "no early lock cancel on server" && return 0
4849         lru_resize_disable mdc
4850         lru_resize_disable osc
4851         cancel_lru_locks mdc
4852         stat $DIR/$tdir > /dev/null
4853         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
4854         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
4855         touch $DIR/$tdir/f1
4856         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
4857         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
4858         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
4859         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
4860         lru_resize_enable mdc
4861         lru_resize_enable osc
4862 }
4863 run_test 120b "Early Lock Cancel: create test"
4864
4865 test_120c() {
4866         mkdir -p $DIR/$tdir
4867         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
4868                skip "no early lock cancel on server" && return 0
4869         lru_resize_disable mdc
4870         lru_resize_disable osc
4871         mkdir -p $DIR/$tdir/d1 $DIR/$tdir/d2
4872         touch $DIR/$tdir/d1/f1
4873         cancel_lru_locks mdc
4874         stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 > /dev/null
4875         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
4876         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
4877         ln $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2
4878         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
4879         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
4880         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
4881         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
4882         lru_resize_enable mdc
4883         lru_resize_enable osc
4884 }
4885 run_test 120c "Early Lock Cancel: link test"
4886
4887 test_120d() {
4888         mkdir -p $DIR/$tdir
4889         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
4890                skip "no early lock cancel on server" && return 0
4891         lru_resize_disable mdc
4892         lru_resize_disable osc
4893         touch $DIR/$tdir
4894         cancel_lru_locks mdc
4895         stat $DIR/$tdir > /dev/null
4896         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
4897         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
4898         chmod a+x $DIR/$tdir
4899         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats | awk '/ldlm_cancel/ {print $2}'`
4900         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats | awk '/ldlm_bl_callback/ {print $2}'`
4901         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
4902         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
4903         lru_resize_enable mdc
4904         lru_resize_enable osc
4905 }
4906 run_test 120d "Early Lock Cancel: setattr test"
4907
4908 test_120e() {
4909         mkdir -p $DIR/$tdir
4910         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
4911                skip "no early lock cancel on server" && return 0
4912         lru_resize_disable mdc
4913         lru_resize_disable osc
4914         dd if=/dev/zero of=$DIR/$tdir/f1 count=1
4915         cancel_lru_locks mdc
4916         cancel_lru_locks osc
4917         dd if=$DIR/$tdir/f1 of=/dev/null
4918         stat $DIR/$tdir $DIR/$tdir/f1 > /dev/null
4919         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
4920               awk '/ldlm_cancel/ {print $2}'`
4921         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
4922               awk '/ldlm_bl_callback/ {print $2}'`
4923         unlink $DIR/$tdir/f1
4924         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
4925               awk '/ldlm_cancel/ {print $2}'`
4926         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
4927               awk '/ldlm_bl_callback/ {print $2}'`
4928         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
4929         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
4930         lru_resize_enable mdc
4931         lru_resize_enable osc
4932 }
4933 run_test 120e "Early Lock Cancel: unlink test"
4934
4935 test_120f() {
4936         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
4937                skip "no early lock cancel on server" && return 0
4938         mkdir -p $DIR/$tdir
4939         lru_resize_disable mdc
4940         lru_resize_disable osc
4941         mkdir -p $DIR/$tdir/d1 $DIR/$tdir/d2
4942         dd if=/dev/zero of=$DIR/$tdir/d1/f1 count=1
4943         dd if=/dev/zero of=$DIR/$tdir/d2/f2 count=1
4944         cancel_lru_locks mdc
4945         cancel_lru_locks osc
4946         dd if=$DIR/$tdir/d1/f1 of=/dev/null
4947         dd if=$DIR/$tdir/d2/f2 of=/dev/null
4948         stat $DIR/$tdir/d1 $DIR/$tdir/d2 $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2 > /dev/null
4949         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
4950               awk '/ldlm_cancel/ {print $2}'`
4951         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
4952               awk '/ldlm_bl_callback/ {print $2}'`
4953         mv $DIR/$tdir/d1/f1 $DIR/$tdir/d2/f2
4954         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
4955               awk '/ldlm_cancel/ {print $2}'`
4956         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
4957               awk '/ldlm_bl_callback/ {print $2}'`
4958         [ $can1 -eq $can2 ] || error $((can2-can1)) "cancel RPC occured."
4959         [ $blk1 -eq $blk2 ] || error $((blk2-blk1)) "blocking RPC occured."
4960         lru_resize_enable mdc
4961         lru_resize_enable osc
4962 }
4963 run_test 120f "Early Lock Cancel: rename test"
4964
4965 test_120g() {
4966         [ -z "`lctl get_param -n mdc.*.connect_flags | grep early_lock_cancel`" ] && \
4967                skip "no early lock cancel on server" && return 0
4968         lru_resize_disable mdc
4969         lru_resize_disable osc
4970         count=10000
4971         echo create $count files
4972         mkdir -p $DIR/$tdir
4973         cancel_lru_locks mdc
4974         cancel_lru_locks osc
4975         t0=`date +%s`
4976
4977         can0=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
4978               awk '/ldlm_cancel/ {print $2}'`
4979         blk0=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
4980               awk '/ldlm_bl_callback/ {print $2}'`
4981         createmany -o $DIR/$tdir/f $count
4982         sync
4983         can1=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
4984               awk '/ldlm_cancel/ {print $2}'`
4985         blk1=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
4986               awk '/ldlm_bl_callback/ {print $2}'`
4987         t1=`date +%s`
4988         echo total: $((can1-can0)) cancels, $((blk1-blk0)) blockings
4989         echo rm $count files
4990         rm -r $DIR/$tdir
4991         sync
4992         can2=`lctl get_param -n ldlm.services.ldlm_canceld.stats |
4993               awk '/ldlm_cancel/ {print $2}'`
4994         blk2=`lctl get_param -n ldlm.services.ldlm_cbd.stats |
4995               awk '/ldlm_bl_callback/ {print $2}'`
4996         t2=`date +%s`
4997         echo total: $count removes in $((t2-t1))
4998         echo total: $((can2-can1)) cancels, $((blk2-blk1)) blockings
4999         sleep 2
5000         # wait for commitment of removal
5001         lru_resize_enable mdc
5002         lru_resize_enable osc
5003 }
5004 run_test 120g "Early Lock Cancel: performance test"
5005
5006 test_121() { #bug #10589
5007         rm -rf $DIR/$tfile
5008         writes=$(LANG=C dd if=/dev/zero of=$DIR/$tfile count=1 2>&1 | awk -F '+' '/out/ {print $1}')
5009 #define OBD_FAIL_LDLM_CANCEL_RACE        0x310
5010         lctl set_param fail_loc=0x310
5011         cancel_lru_locks osc > /dev/null
5012         reads=$(LANG=C dd if=$DIR/$tfile of=/dev/null 2>&1 | awk -F '+' '/in/ {print $1}')
5013         lctl set_param fail_loc=0
5014         [ "$reads" -eq "$writes" ] || error "read" $reads "blocks, must be" $writes
5015 }
5016 run_test 121 "read cancel race ========="
5017
5018 test_123a() { # was test 123, statahead(bug 11401)
5019         SLOWOK=0
5020         if [ -z "$(grep "processor.*: 1" /proc/cpuinfo)" ]; then
5021                 log "testing on UP system. Performance may be not as good as expected."
5022                 SLOWOK=1
5023         fi
5024
5025         remount_client $MOUNT
5026         mkdir -p $DIR/$tdir
5027         error=0
5028         NUMFREE=`df -i -P $DIR | tail -n 1 | awk '{ print $4 }'`
5029         [ $NUMFREE -gt 100000 ] && NUMFREE=100000 || NUMFREE=$((NUMFREE-1000))
5030         MULT=10
5031         for ((i=1, j=0; i<=$NUMFREE; j=$i, i=$((i * MULT)) )); do
5032                 createmany -o $DIR/$tdir/$tfile $j $((i - j))
5033
5034                 lctl get_param -n llite.*.statahead_max | grep '[0-9]'
5035                 cancel_lru_locks mdc
5036                 cancel_lru_locks osc
5037                 stime=`date +%s`
5038                 ls -l $DIR/$tdir > /dev/null
5039                 etime=`date +%s`
5040                 delta_sa=$((etime - stime))
5041                 log "ls $i files with statahead:    $delta_sa sec"
5042                 lctl get_param -n llite.*.statahead_stats
5043
5044                 max=`lctl get_param -n llite.*.statahead_max | head -n 1`
5045                 lctl set_param -n llite.*.statahead_max 0
5046                 lctl get_param llite.*.statahead_max
5047                 cancel_lru_locks mdc
5048                 cancel_lru_locks osc
5049                 stime=`date +%s`
5050                 ls -l $DIR/$tdir > /dev/null
5051                 etime=`date +%s`
5052                 delta=$((etime - stime))
5053                 log "ls $i files without statahead: $delta sec"
5054
5055                 lctl set_param llite.*.statahead_max=$max
5056                 if [ $delta_sa -gt $(($delta + 2)) ]; then
5057                         log "ls $i files is slower with statahead!"
5058                         error=1
5059                 fi
5060
5061                 [ $delta -gt 20 ] && break
5062                 [ $delta -gt 8 ] && MULT=$((50 / delta))
5063                 [ "$SLOW" = "no" -a $delta -gt 3 ] && break
5064         done
5065         log "ls done"
5066
5067         stime=`date +%s`
5068         rm -r $DIR/$tdir
5069         sync
5070         etime=`date +%s`
5071         delta=$((etime - stime))
5072         log "rm -r $DIR/$tdir/: $delta seconds"
5073         log "rm done"
5074         lctl get_param -n llite.*.statahead_stats
5075         # wait for commitment of removal
5076         sleep 2
5077         [ $error -ne 0 -a $SLOWOK -eq 0 ] && error "statahead is slow!"
5078         return 0
5079 }
5080 run_test 123a "verify statahead work"
5081
5082 test_123b () { # statahead(bug 15027)
5083         mkdir -p $DIR/$tdir
5084         createmany -o $DIR/$tdir/$tfile-%d 1000
5085
5086         cancel_lru_locks mdc
5087         cancel_lru_locks osc
5088
5089 #define OBD_FAIL_MDC_GETATTR_ENQUEUE     0x803
5090         lctl set_param fail_loc=0x80000803
5091         ls -lR $DIR/$tdir > /dev/null
5092         log "ls done"
5093         lctl set_param fail_loc=0x0
5094         lctl get_param -n llite.*.statahead_stats
5095         rm -r $DIR/$tdir
5096         sync
5097
5098 }
5099 run_test 123b "not panic with network error in statahead enqueue (bug 15027)"
5100
5101 test_124a() {
5102         [ -z "`lctl get_param -n mdc.*.connect_flags | grep lru_resize`" ] && \
5103                skip "no lru resize on server" && return 0
5104         NR=2000
5105         mkdir -p $DIR/$tdir || error "failed to create $DIR/$tdir"
5106
5107         # use touch to produce $NR new locks
5108         log "create $NR files at $DIR/$tdir"
5109         createmany -o $DIR/$tdir/f $NR ||
5110                 error "failed to create $NR files in $DIR/$tdir"
5111
5112         cancel_lru_locks mdc
5113         ls -l $DIR/$tdir > /dev/null
5114
5115         NSDIR=""
5116         LRU_SIZE=0
5117         for VALUE in `lctl get_param ldlm.namespaces.*mdc-*.lru_size`; do
5118                 PARAM=`echo ${VALUE[0]} | cut -d "=" -f1`
5119                 LRU_SIZE=$(lctl get_param -n $PARAM)
5120                 if [ $LRU_SIZE -gt $(default_lru_size) ]; then
5121                         NSDIR=$(echo $PARAM | cut -d "." -f1-3)
5122                         log "using $(basename $NSDIR) namespace"
5123                         break
5124                 fi
5125         done
5126
5127         if [ -z "$NSDIR" -o $LRU_SIZE -lt $(default_lru_size) ]; then
5128                 skip "Not enough cached locks created!"
5129                 return 0
5130         fi
5131         log "created $LRU_SIZE lock(s)"
5132
5133         # we want to sleep 30s to not make test too long
5134         SLEEP=30
5135         SLEEP_ADD=2
5136
5137         # we know that lru resize allows one client to hold $LIMIT locks for 10h
5138         MAX_HRS=10
5139
5140         # get the pool limit
5141         LIMIT=`lctl get_param -n $NSDIR.pool.limit`
5142
5143         # calculate lock volume factor taking into account data set size and the
5144         # rule that number of locks will be getting smaller durring sleep interval
5145         # and we need to additionally enforce LVF to take this into account.
5146         # Use $LRU_SIZE_B here to take into account real number of locks created
5147         # in the case of CMD, LRU_SIZE_B != $NR in most of cases
5148         LVF=$(($MAX_HRS * 60 * 60 * $LIMIT / $SLEEP))
5149         LRU_SIZE_B=$LRU_SIZE
5150         log "make client drop locks $LVF times faster so that ${SLEEP}s is enough to cancel $LRU_SIZE lock(s)"
5151         OLD_LVF=`lctl get_param -n $NSDIR.pool.lock_volume_factor`
5152         lctl set_param -n $NSDIR.pool.lock_volume_factor $LVF
5153         log "sleep for $((SLEEP+SLEEP_ADD))s"
5154         sleep $((SLEEP+SLEEP_ADD))
5155         lctl set_param -n $NSDIR.pool.lock_volume_factor $OLD_LVF
5156         LRU_SIZE_A=`lctl get_param -n $NSDIR.lru_size`
5157
5158         [ $LRU_SIZE_B -gt $LRU_SIZE_A ] || {
5159                 error "No locks dropped in "$((SLEEP+SLEEP_ADD))"s. LRU size: $LRU_SIZE_A"
5160                 unlinkmany $DIR/$tdir/f $NR
5161                 return
5162         }
5163
5164         log "Dropped "$((LRU_SIZE_B-LRU_SIZE_A))" locks in "$((SLEEP+SLEEP_ADD))"s"
5165         log "unlink $NR files at $DIR/$tdir"
5166         unlinkmany $DIR/$tdir/f $NR
5167 }
5168 run_test 124a "lru resize ======================================="
5169
5170 get_max_pool_limit()
5171 {
5172         local limit=`lctl get_param -n ldlm.namespaces.*-MDT0000-mdc-*.pool.limit`
5173         local max=0
5174         for l in $limit; do
5175                 if test $l -gt $max; then
5176                         max=$l
5177                 fi
5178         done
5179         echo $max
5180 }
5181
5182 test_124b() {
5183         [ -z "`lctl get_param -n mdc.*.connect_flags | grep lru_resize`" ] && \
5184                skip "no lru resize on server" && return 0
5185
5186         LIMIT=`get_max_pool_limit`
5187
5188         NR=$(($(default_lru_size)*20))
5189         if [ $NR -gt $LIMIT ]; then
5190                 log "Limit lock number by $LIMIT locks"
5191                 NR=$LIMIT
5192         fi
5193         lru_resize_disable mdc
5194         mkdir -p $DIR/$tdir/disable_lru_resize ||
5195                 error "failed to create $DIR/$tdir/disable_lru_resize"
5196
5197         createmany -o $DIR/$tdir/disable_lru_resize/f $NR
5198         log "doing ls -la $DIR/$tdir/disable_lru_resize 3 times"
5199         cancel_lru_locks mdc
5200         stime=`date +%s`
5201         PID=""
5202         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
5203         PID="$PID $!"
5204         sleep 2
5205         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
5206         PID="$PID $!"
5207         sleep 2
5208         ls -la $DIR/$tdir/disable_lru_resize > /dev/null &
5209         PID="$PID $!"
5210         wait $PID
5211         etime=`date +%s`
5212         nolruresize_delta=$((etime-stime))
5213         log "ls -la time: $nolruresize_delta seconds"
5214         log "lru_size = $(lctl get_param -n ldlm.namespaces.*mdc*.lru_size)"
5215         unlinkmany $DIR/$tdir/disable_lru_resize/f $NR
5216
5217         lru_resize_enable mdc
5218         mkdir -p $DIR/$tdir/enable_lru_resize ||
5219                 error "failed to create $DIR/$tdir/enable_lru_resize"
5220
5221         createmany -o $DIR/$tdir/enable_lru_resize/f $NR
5222         log "doing ls -la $DIR/$tdir/enable_lru_resize 3 times"
5223         cancel_lru_locks mdc
5224         stime=`date +%s`
5225         PID=""
5226         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
5227         PID="$PID $!"
5228         sleep 2
5229         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
5230         PID="$PID $!"
5231         sleep 2
5232         ls -la $DIR/$tdir/enable_lru_resize > /dev/null &
5233         PID="$PID $!"
5234         wait $PID
5235         etime=`date +%s`
5236         lruresize_delta=$((etime-stime))
5237         log "ls -la time: $lruresize_delta seconds"
5238         log "lru_size = $(lctl get_param -n ldlm.namespaces.*mdc*.lru_size)"
5239
5240         if [ $lruresize_delta -gt $nolruresize_delta ]; then
5241                 log "ls -la is $(((lruresize_delta - $nolruresize_delta) * 100 / $nolruresize_delta))% slower with lru resize enabled"
5242         elif [ $nolruresize_delta -gt $lruresize_delta ]; then
5243                 log "ls -la is $(((nolruresize_delta - $lruresize_delta) * 100 / $nolruresize_delta))% faster with lru resize enabled"
5244         else
5245                 log "lru resize performs the same with no lru resize"
5246         fi
5247         unlinkmany $DIR/$tdir/enable_lru_resize/f $NR
5248 }
5249 run_test 124b "lru resize (performance test) ======================="
5250
5251 test_125() { # 13358
5252         [ -z "$(lctl get_param -n llite.*.client_type | grep local)" ] && skip "must run as local client" && return
5253         [ -z "$(lctl get_param -n mdc.*-mdc-*.connect_flags | grep acl)" ] && skip "must have acl enabled" && return
5254         mkdir -p $DIR/d125 || error "mkdir failed"
5255         $SETSTRIPE $DIR/d125 -s 65536 -c -1 || error "setstripe failed"
5256         setfacl -R -m u:bin:rwx $DIR/d125 || error "setfacl $DIR/d125 failed"
5257         ls -ld $DIR/d125 || error "cannot access $DIR/d125"
5258 }
5259 run_test 125 "don't return EPROTO when a dir has a non-default striping and ACLs"
5260
5261 test_126() { # bug 12829/13455
5262         [ -z "$(lctl get_param -n llite.*.client_type | grep local)" ] && skip "must run as local client" && return
5263         [ "$UID" != 0 ] && echo "skipping $TESTNAME (must run as root)" && return
5264         $RUNAS -u 0 -g 1 touch $DIR/$tfile || error "touch failed"
5265         gid=`ls -n $DIR/$tfile | awk '{print $4}'`
5266         rm -f $DIR/$tfile
5267         [ $gid -eq "1" ] || error "gid is set to" $gid "instead of 1"
5268 }
5269 run_test 126 "check that the fsgid provided by the client is taken into account"
5270
5271 test_127() { # bug 15521
5272         $LSTRIPE -i 0 -c 1 $DIR/$tfile
5273         $LCTL set_param osc.*.stats=0
5274         FSIZE=$((2048 * 1024))
5275         dd if=/dev/zero of=$DIR/$tfile bs=$FSIZE count=1
5276         cancel_lru_locks osc
5277         dd if=$DIR/$tfile of=/dev/null bs=$FSIZE
5278
5279         $LCTL get_param osc.*0000-osc-*.stats | grep samples > $DIR/${tfile}.tmp
5280         while read NAME COUNT SAMP UNIT MIN MAX SUM SUMSQ; do
5281                 echo "got $COUNT $NAME"
5282                 [ ! $MIN ] && error "Missing min value for $NAME proc entry"
5283                 eval $NAME=$COUNT || error "Wrong proc format"
5284
5285                 case $NAME in
5286                         read_bytes|write_bytes)
5287                         [ $MIN -lt 4096 ] && error "min is too small: $MIN"
5288                         [ $MIN -gt $FSIZE ] && error "min is too big: $MIN"
5289                         [ $MAX -lt 4096 ] && error "max is too small: $MAX"
5290                         [ $MAX -gt $FSIZE ] && error "max is too big: $MAX"
5291                         [ $SUM -ne $FSIZE ] && error "sum is wrong: $SUM"
5292                         [ $SUMSQ -lt $(((FSIZE /4096) * (4096 * 4096))) ] &&
5293                                 error "sumsquare is too small: $SUMSQ"
5294                         [ $SUMSQ -gt $((FSIZE * FSIZE)) ] &&
5295                                 error "sumsquare is too big: $SUMSQ"
5296                         ;;
5297                         *) ;;
5298                 esac
5299         done < $DIR/${tfile}.tmp
5300
5301         #check that we actually got some stats
5302         [ "$read_bytes" ] || error "Missing read_bytes stats"
5303         [ "$write_bytes" ] || error "Missing write_bytes stats"
5304         [ "$read_bytes" != 0 ] || error "no read done"
5305         [ "$write_bytes" != 0 ] || error "no write done"
5306 }
5307 run_test 127 "verify the client stats are sane"
5308
5309 test_128() { # bug 15212
5310         touch $DIR/$tfile
5311         $LFS 2>&1 <<-EOF | tee $TMP/$tfile.log
5312                 find $DIR/$tfile
5313                 find $DIR/$tfile
5314         EOF
5315
5316         result=$(grep error $TMP/$tfile.log)
5317         rm -f $DIR/$tfile
5318         [ -z "$result" ] || error "consecutive find's under interactive lfs failed"
5319 }
5320 run_test 128 "interactive lfs for 2 consecutive find's"
5321
5322 set_dir_limits () {
5323         local mntdev
5324         local node
5325
5326         local LDPROC=/proc/fs/ldiskfs
5327
5328         for node in $(mdts_nodes); do
5329                 devs=$(do_node $node "lctl get_param -n devices" | awk '($3 ~ "mdt" && $4 ~ "MDT") { print $4 }')
5330                 for dev in $devs; do
5331                         mntdev=$(do_node $node "lctl get_param -n osd.$dev.mntdev")
5332                         do_node $node "echo $1 >$LDPROC/\\\$(basename $mntdev)/max_dir_size"
5333                 done
5334         done
5335 }
5336 test_129() {
5337         [ "$FSTYPE" != "ldiskfs" ] && skip "not needed for FSTYPE=$FSTYPE" && return 0
5338
5339         EFBIG=27
5340         MAX=16384
5341
5342         set_dir_limits $MAX
5343
5344         mkdir -p $DIR/$tdir
5345
5346         I=0
5347         J=0
5348         while [ ! $I -gt $((MAX * MDSCOUNT)) ]; do
5349                 multiop $DIR/$tdir/$J Oc
5350                 rc=$?
5351                 if [ $rc -eq $EFBIG ]; then
5352                         set_dir_limits 0
5353                         echo "return code $rc received as expected"
5354                         return 0
5355                 elif [ $rc -ne 0 ]; then
5356                         set_dir_limits 0
5357                         error_exit "return code $rc received instead of expected $EFBIG"
5358                 fi
5359                 J=$((J+1))
5360                 I=$(stat -c%s "$DIR/$tdir")
5361         done
5362
5363         error "exceeded dir size limit $MAX x $MDSCOUNT $((MAX * MDSCOUNT)) : $I bytes"
5364         do_facet $SINGLEMDS "echo 0 >$LDPROC"
5365 }
5366 run_test 129 "test directory size limit ========================"
5367
5368 test_130a() {
5369         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
5370         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
5371
5372         local fm_file=$DIR/$tfile
5373         lfs setstripe -s 65536 -c 1 $fm_file || error "setstripe failed on $fm_file"
5374         dd if=/dev/zero of=$fm_file bs=65536 count=1 || error "dd failed for $fm_file"
5375
5376         filefrag -ves $fm_file || error "filefrag $fm_file failed"
5377         filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" | grep -v "ext:" | grep -v "found"`
5378
5379         lun=`$GETSTRIPE $fm_file  | grep -A 10 obdidx | awk '{print $1}' | grep -v "obdidx"`
5380
5381         start_blk=`echo $filefrag_op | cut -d: -f2 | cut -d. -f1`
5382         IFS=$'\n'
5383         tot_len=0
5384         for line in $filefrag_op
5385         do
5386                 frag_lun=`echo $line | cut -d: -f5`
5387                 ext_len=`echo $line | cut -d: -f4`
5388                 if (( $frag_lun != $lun )); then
5389                         error "FIEMAP on 1-stripe file($fm_file) failed"
5390                         return
5391                 fi
5392                 (( tot_len += ext_len ))
5393         done
5394
5395         if (( lun != frag_lun || start_blk != 0 || tot_len != 64 )); then
5396                 error "FIEMAP on 1-stripe file($fm_file) failed;"
5397                 return
5398         fi
5399         echo "FIEMAP on single striped file succeeded"
5400 }
5401 run_test 130a "FIEMAP (1-stripe file)"
5402
5403 test_130b() {
5404         [ "$OSTCOUNT" -lt "2" ] && skip "skipping FIEMAP on 2-stripe file test" && return
5405
5406         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
5407         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
5408
5409         local fm_file=$DIR/$tfile
5410         lfs setstripe -s 65536 -c 2 $fm_file || error "setstripe failed on $fm_file"
5411         dd if=/dev/zero of=$fm_file bs=1M count=2 || error "dd failed on $fm_file"
5412
5413         filefrag -ves $fm_file || error "filefrag $fm_file failed"
5414         filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" | grep -v "ext:" | grep -v "found"`
5415
5416         last_lun=`echo $filefrag_op | cut -d: -f5`
5417
5418         IFS=$'\n'
5419         tot_len=0
5420         num_luns=1
5421         for line in $filefrag_op
5422         do
5423                 frag_lun=`echo $line | cut -d: -f5`
5424                 ext_len=`echo $line | cut -d: -f4`
5425                 if (( $frag_lun != $last_lun )); then
5426                         if (( tot_len != 1024 )); then
5427                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of 256"
5428                                 return
5429                         else
5430                                 (( num_luns += 1 ))
5431                                 tot_len=0
5432                         fi
5433                 fi
5434                 (( tot_len += ext_len ))
5435                 last_lun=$frag_lun
5436         done
5437         if (( num_luns != 2 || tot_len != 1024 )); then
5438                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
5439                 return
5440         fi
5441
5442         echo "FIEMAP on 2-stripe file succeeded"
5443 }
5444 run_test 130b "FIEMAP (2-stripe file)"
5445
5446 test_130c() {
5447         [ "$OSTCOUNT" -lt "2" ] && skip "skipping FIEMAP on 2-stripe file with hole test" && return
5448
5449         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
5450         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
5451
5452         local fm_file=$DIR/$tfile
5453         lfs setstripe -s 65536 -c 2 $fm_file || error "setstripe failed on $fm_file"
5454         dd if=/dev/zero of=$fm_file seek=1 bs=1M count=1 || error "dd failed on $fm_file"
5455
5456         filefrag -ves $fm_file || error "filefrag $fm_file failed"
5457         filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" | grep -v "ext:" | grep -v "found"`
5458
5459         last_lun=`echo $filefrag_op | cut -d: -f5`
5460
5461         IFS=$'\n'
5462         tot_len=0
5463         num_luns=1
5464         for line in $filefrag_op
5465         do
5466                 frag_lun=`echo $line | cut -d: -f5`
5467                 ext_len=`echo $line | cut -d: -f4`
5468                 if (( $frag_lun != $last_lun )); then
5469                         logical=`echo $line | cut -d: -f2 | cut -d. -f1`
5470                         if (( logical != 512 )); then
5471                                 error "FIEMAP on $fm_file failed; returned logical start for lun $logical instead of 512"
5472                                 return
5473                         fi
5474                         if (( tot_len != 512 )); then
5475                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of 1024"
5476                                 return
5477                         else
5478                                 (( num_luns += 1 ))
5479                                 tot_len=0
5480                         fi
5481                 fi
5482                 (( tot_len += ext_len ))
5483                 last_lun=$frag_lun
5484         done
5485         if (( num_luns != 2 || tot_len != 512 )); then
5486                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
5487                 return
5488         fi
5489
5490         echo "FIEMAP on 2-stripe file with hole succeeded"
5491 }
5492 run_test 130c "FIEMAP (2-stripe file with hole)"
5493
5494 test_130d() {
5495         [ "$OSTCOUNT" -lt "3" ] && skip "skipping FIEMAP on N-stripe file test" && return
5496
5497         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
5498         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
5499
5500         local fm_file=$DIR/$tfile
5501         lfs setstripe -s 65536 -c $OSTCOUNT $fm_file || error "setstripe failed on $fm_file"
5502         dd if=/dev/zero of=$fm_file bs=1M count=$OSTCOUNT || error "dd failed on $fm_file"
5503
5504         filefrag -ves $fm_file || error "filefrag $fm_file failed"
5505         filefrag_op=`filefrag -ve $fm_file | grep -A 100 "ext:" | grep -v "ext:" | grep -v "found"`
5506
5507         last_lun=`echo $filefrag_op | cut -d: -f5`
5508
5509         IFS=$'\n'
5510         tot_len=0
5511         num_luns=1
5512         for line in $filefrag_op
5513         do
5514                 frag_lun=`echo $line | cut -d: -f5`
5515                 ext_len=`echo $line | cut -d: -f4`
5516                 if (( $frag_lun != $last_lun )); then
5517                         if (( tot_len != 1024 )); then
5518                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of 1024"
5519                                 return
5520                         else
5521                                 (( num_luns += 1 ))
5522                                 tot_len=0
5523                         fi
5524                 fi
5525                 (( tot_len += ext_len ))
5526                 last_lun=$frag_lun
5527         done
5528         if (( num_luns != OSTCOUNT || tot_len != 1024 )); then
5529                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
5530                 return
5531         fi
5532
5533         echo "FIEMAP on N-stripe file succeeded"
5534 }
5535 run_test 130d "FIEMAP (N-stripe file)"
5536
5537 test_130e() {
5538         [ "$OSTCOUNT" -lt "2" ] && skip "skipping continuation FIEMAP test" && return
5539
5540         filefrag_op=$(filefrag -e 2>&1 | grep "invalid option")
5541         [ -n "$filefrag_op" ] && skip "filefrag does not support FIEMAP" && return
5542
5543         local fm_file=$DIR/$tfile
5544         lfs setstripe -s 65536 -c 2 $fm_file || error "setstripe failed on $fm_file"
5545         NUM_BLKS=512
5546         EXPECTED_LEN=$(( (NUM_BLKS / 2) * 4 ))
5547         for ((i = 0; i < $NUM_BLKS; i++))
5548         do
5549                 dd if=/dev/zero of=$fm_file count=1 bs=4096 seek=$((2*$i)) conv=notrunc > /dev/null 2>&1
5550         done
5551
5552         filefrag -ves $fm_file || error "filefrag $fm_file failed"
5553         filefrag_op=`filefrag -ve $fm_file | grep -A 750 "ext:" | grep -v "ext:" | grep -v "found"`
5554
5555         last_lun=`echo $filefrag_op | cut -d: -f5`
5556
5557         IFS=$'\n'
5558         tot_len=0
5559         num_luns=1
5560         for line in $filefrag_op
5561         do
5562                 frag_lun=`echo $line | cut -d: -f5`
5563                 ext_len=`echo $line | cut -d: -f4`
5564                 if (( $frag_lun != $last_lun )); then
5565                         if (( tot_len != $EXPECTED_LEN )); then
5566                                 error "FIEMAP on $fm_file failed; returned len $tot_len for OST $last_lun instead of $EXPECTED_LEN"
5567                                 return
5568                         else
5569                                 (( num_luns += 1 ))
5570                                 tot_len=0
5571                         fi
5572                 fi
5573                 (( tot_len += ext_len ))
5574                 last_lun=$frag_lun
5575         done
5576         if (( num_luns != 2 || tot_len != $EXPECTED_LEN )); then
5577                 echo "$num_luns $tot_len"
5578                 error "FIEMAP on $fm_file failed; returned wrong number of luns or wrong len for OST $last_lun"
5579                 return
5580         fi
5581
5582         echo "FIEMAP with continuation calls succeeded"
5583 }
5584 run_test 130e "FIEMAP (test continuation FIEMAP calls)"
5585
5586 POOL=${POOL:-cea1}
5587 TGT_COUNT=$OSTCOUNT
5588 TGTPOOL_FIRST=1
5589 TGTPOOL_MAX=$(($TGT_COUNT - 1))
5590 TGTPOOL_STEP=2
5591 TGTPOOL_LIST=`seq $TGTPOOL_FIRST $TGTPOOL_STEP $TGTPOOL_MAX`
5592 POOL_ROOT=${POOL_ROOT:-$DIR/d200.pools}
5593 POOL_DIR=$POOL_ROOT/dir_tst
5594 POOL_FILE=$POOL_ROOT/file_tst
5595
5596 check_file_in_pool()
5597 {
5598         file=$1
5599         res=$($GETSTRIPE $file | grep 0x | cut -f2)
5600         for i in $res
5601         do
5602                 found=$(echo :$TGTPOOL_LIST: | tr " " ":"  | grep :$i:)
5603                 if [[ "$found" == "" ]]
5604                 then
5605                         echo "pool list: $TGTPOOL_LIST"
5606                         echo "striping: $res"
5607                         error "$file not allocated in $POOL"
5608                         return 1
5609                 fi
5610         done
5611         return 0
5612 }
5613
5614 test_200() {
5615         do_facet mgs $LCTL pool_new $FSNAME.$POOL
5616         do_facet mgs $LCTL get_param -n lov.$FSNAME-MDT0000-mdtlov.pools.$POOL
5617         [ $? == 0 ] || error "Pool creation of $POOL failed"
5618 }
5619 run_test 200 "Create new pool =========================================="
5620
5621 test_201() {
5622         TGT=$(seq -f $FSNAME-OST%04g_UUID $TGTPOOL_FIRST $TGTPOOL_STEP \
5623                 $TGTPOOL_MAX | tr '\n' ' ')
5624         do_facet mgs $LCTL pool_add $FSNAME.$POOL \
5625                 $FSNAME-OST[$TGTPOOL_FIRST-$TGTPOOL_MAX/$TGTPOOL_STEP]_UUID
5626         res=$(do_facet mgs $LCTL get_param -n lov.$FSNAME-MDT0000-mdtlov.pools.$POOL | sort \
5627                         | tr '\n' ' ')
5628         [ "$res" = "$TGT" ] || error "Pool content ($res) do not match requested ($TGT)"
5629 }
5630 run_test 201 "Add targets to a pool ===================================="
5631
5632 test_202a() {
5633         mkdir -p $POOL_DIR
5634         $SETSTRIPE -c 2 -p $POOL $POOL_DIR
5635         [ $? = 0 ] || error "Cannot set pool $POOL to $POOL_DIR"
5636 }
5637 run_test 202a "Set pool on a directory ================================="
5638
5639 test_202b() {
5640         res=$($GETSTRIPE $POOL_DIR | grep pool: | cut -f8 -d " ")
5641         [ "$res" = $POOL ] || error "Pool on $POOL_DIR is not $POOL"
5642 }
5643 run_test 202b "Check pool on a directory ==============================="
5644
5645 test_202c() {
5646         failed=0
5647         for i in $(seq -w 1 $(($TGT_COUNT * 3)))
5648         do
5649                 file=$POOL_DIR/file-$i
5650                 touch $file
5651                 check_file_in_pool $file
5652                 if [[ $? != 0 ]]
5653                 then
5654                         failed=$(($failed + 1))
5655                 fi
5656         done
5657         [ "$failed" = 0 ] || error "$failed files not allocated in $POOL"
5658 }
5659 run_test 202c "Check files allocation from directory pool =============="
5660
5661 test_203() {
5662         mkdir -p $POOL_FILE
5663         failed=0
5664         for i in $(seq -w 1 $(($TGT_COUNT * 3)))
5665         do
5666                 file=$POOL_FILE/spoo-$i
5667                 $SETSTRIPE -p $POOL $file
5668                 check_file_in_pool $file
5669                 if [[ $? != 0 ]]
5670                 then
5671                         failed=$(($failed + 1))
5672                 fi
5673         done
5674         [ "$failed" = 0 ] || error "$failed files not allocated in $POOL"
5675 }
5676 run_test 203 "Create files in a pool ==================================="
5677
5678 test_210a() {
5679         TGT=$(do_facet mgs $LCTL get_param -n lov.$FSNAME-MDT0000-mdtlov.pools.$POOL | head -1)
5680         do_facet mgs $LCTL pool_remove $FSNAME.$POOL $TGT
5681         res=$(do_facet mgs $LCTL get_param -n lov.$FSNAME-MDT0000-mdtlov.pools.$POOL | grep $TGT)
5682         [ "$res" = "" ] || error "$TGT not removed from $FSNAME.$POOL"
5683 }
5684 run_test 210a "Remove a target from a pool ============================="
5685
5686 test_210b() {
5687         for TGT in $(do_facet mgs $LCTL get_param -n lov.$FSNAME-MDT0000-mdtlov.pools.$POOL)
5688         do
5689                 do_facet mgs $LCTL pool_remove $FSNAME.$POOL $TGT
5690         done
5691         res=$(do_facet mgs $LCTL get_param -n lov.$FSNAME-MDT0000-mdtlov.pools.$POOL)
5692         [ "$res" = "" ] || error "Pool $FSNAME.$POOL cannot be drained"
5693 }
5694 run_test 210b "Remove all targets from a pool =========================="
5695
5696 test_211() {
5697         do_facet mgs $LCTL pool_destroy $FSNAME.$POOL
5698         res=$(do_facet mgs "$LCTL get_param -n lov.$FSNAME-MDT0000-mdtlov.pools.$POOL 2>/dev/null")
5699         [ "$res" = "" ] || error "Pool $FSNAME.$POOL is not destroyed"
5700 }
5701 run_test 211 "Remove a pool ============================================"
5702
5703 TMPDIR=$OLDTMPDIR
5704 TMP=$OLDTMP
5705 HOME=$OLDHOME
5706
5707 log "cleanup: ======================================================"
5708 check_and_cleanup_lustre
5709 if [ "$I_MOUNTED" != "yes" ]; then
5710         lctl set_param debug="$OLDDEBUG" 2> /dev/null || true
5711 fi
5712
5713 echo '=========================== finished ==============================='
5714 [ -f "$SANITYLOG" ] && cat $SANITYLOG && grep -q FAIL $SANITYLOG && exit 1 || true
5715 echo "$0: completed"