lustre/tests/replay-single.sh

   1 #!/bin/bash
   2
   3 set -e
   4 #set -v
   5
   6 #
   7 # This test needs to be run on the client
   8 #
   9 SAVE_PWD=$PWD
  10 export MULTIOP=${MULTIOP:-multiop}
  11 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
  12 SETUP=${SETUP:-}
  13 CLEANUP=${CLEANUP:-}
  14 . $LUSTRE/tests/test-framework.sh
  15 init_test_env $@
  16 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
  17 init_logging
  18 CHECK_GRANT=${CHECK_GRANT:-"yes"}
  19 GRANT_CHECK_LIST=${GRANT_CHECK_LIST:-""}
  20
  21 require_dsh_mds || exit 0
  22
  23 # Skip these tests
  24 # bug number for skipped tests:
  25 # b=17466/LU-472 : 61d
  26 # LU-5319 : 53a 53d
  27 ALWAYS_EXCEPT="61d 53a 53d $REPLAY_SINGLE_EXCEPT"
  28 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  29
  30 case "$(lsb_release -sr)" in    # only disable tests for el7
  31 7*)     # bug number:  LU-6455-----
  32         ALWAYS_EXCEPT="$ALWAYS_EXCEPT 28"
  33         ;;
  34 esac
  35
  36 #                                                  63 min  7 min  AT AT AT AT"
  37 [ "$SLOW" = "no" ] && EXCEPT_SLOW="1 2 3 4 6 12 16 44a      44b    65 66 67 68"
  38
  39 [ $(facet_fstype $SINGLEMDS) = "zfs" ] &&
  40 # bug number for skipped test:        LU-1867   LU-3127
  41         ALWAYS_EXCEPT="$ALWAYS_EXCEPT 89        73b"
  42
  43 build_test_filter
  44
  45 check_and_setup_lustre
  46
  47 mkdir -p $DIR
  48
  49 assert_DIR
  50 rm -rf $DIR/[df][0-9]* $DIR/f.$TESTSUITE.*
  51
  52 # LU-482 Avert LVM and VM inability to flush caches in pre .33 kernels
  53 if [ $LINUX_VERSION_CODE -lt $(version_code 2.6.33) ]; then
  54     sync
  55     do_facet $SINGLEMDS sync
  56 fi
  57
  58 test_0a() {     # was test_0
  59         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
  60         replay_barrier $SINGLEMDS
  61         fail $SINGLEMDS
  62         rmdir $DIR/$tdir
  63 }
  64 run_test 0a "empty replay"
  65
  66 test_0b() {
  67         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
  68
  69         # this test attempts to trigger a race in the precreation code,
  70         # and must run before any other objects are created on the filesystem
  71         fail ost1
  72         createmany -o $DIR/$tfile 20 || error "createmany -o $DIR/$tfile failed"
  73         unlinkmany $DIR/$tfile 20 || error "unlinkmany $DIR/$tfile failed"
  74 }
  75 run_test 0b "ensure object created after recover exists. (3284)"
  76
  77 test_0c() {
  78         replay_barrier $SINGLEMDS
  79         mcreate $DIR/$tfile
  80         umount $MOUNT
  81         facet_failover $SINGLEMDS
  82         zconf_mount $(hostname) $MOUNT || error "mount fails"
  83         client_up || error "post-failover df failed"
  84         # file shouldn't exist if replay-barrier works as expected
  85         rm $DIR/$tfile && error "File exists and it shouldn't"
  86         return 0
  87 }
  88 run_test 0c "check replay-barrier"
  89
  90 test_0d() {
  91         replay_barrier $SINGLEMDS
  92         umount $MOUNT
  93         facet_failover $SINGLEMDS
  94         zconf_mount $(hostname) $MOUNT || error "mount fails"
  95         client_up || error "post-failover df failed"
  96 }
  97 run_test 0d "expired recovery with no clients"
  98
  99 test_1() {
 100         replay_barrier $SINGLEMDS
 101         mcreate $DIR/$tfile
 102         fail $SINGLEMDS
 103         $CHECKSTAT -t file $DIR/$tfile ||
 104                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
 105         rm $DIR/$tfile
 106 }
 107 run_test 1 "simple create"
 108
 109 test_2a() {
 110         replay_barrier $SINGLEMDS
 111         touch $DIR/$tfile
 112         fail $SINGLEMDS
 113         $CHECKSTAT -t file $DIR/$tfile ||
 114                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
 115         rm $DIR/$tfile
 116 }
 117 run_test 2a "touch"
 118
 119 test_2b() {
 120         mcreate $DIR/$tfile || error "mcreate $DIR/$tfile failed"
 121         replay_barrier $SINGLEMDS
 122         touch $DIR/$tfile
 123         fail $SINGLEMDS
 124         $CHECKSTAT -t file $DIR/$tfile ||
 125                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
 126         rm $DIR/$tfile
 127 }
 128 run_test 2b "touch"
 129
 130 test_3a() {
 131         local file=$DIR/$tfile
 132         replay_barrier $SINGLEMDS
 133         mcreate $file
 134         openfile -f O_DIRECTORY $file
 135         fail $SINGLEMDS
 136         $CHECKSTAT -t file $file ||
 137                 error "$CHECKSTAT $file attribute check failed"
 138         rm $file
 139 }
 140 run_test 3a "replay failed open(O_DIRECTORY)"
 141
 142 test_3b() {
 143         replay_barrier $SINGLEMDS
 144         #define OBD_FAIL_MDS_OPEN_PACK | OBD_FAIL_ONCE
 145         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000114"
 146         touch $DIR/$tfile
 147         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 148         fail $SINGLEMDS
 149         $CHECKSTAT -t file $DIR/$tfile &&
 150                 error "$CHECKSTAT $DIR/$tfile attribute check should fail"
 151         return 0
 152 }
 153 run_test 3b "replay failed open -ENOMEM"
 154
 155 test_3c() {
 156         replay_barrier $SINGLEMDS
 157         #define OBD_FAIL_MDS_ALLOC_OBDO | OBD_FAIL_ONCE
 158         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000128"
 159         touch $DIR/$tfile
 160         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 161         fail $SINGLEMDS
 162
 163         $CHECKSTAT -t file $DIR/$tfile &&
 164                 error "$CHECKSTAT $DIR/$tfile attribute check should fail"
 165         return 0
 166 }
 167 run_test 3c "replay failed open -ENOMEM"
 168
 169 test_4a() {     # was test_4
 170         replay_barrier $SINGLEMDS
 171         for i in $(seq 10); do
 172                 echo "tag-$i" > $DIR/$tfile-$i
 173         done
 174         fail $SINGLEMDS
 175         for i in $(seq 10); do
 176                 grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
 177         done
 178 }
 179 run_test 4a "|x| 10 open(O_CREAT)s"
 180
 181 test_4b() {
 182         for i in $(seq 10); do
 183                 echo "tag-$i" > $DIR/$tfile-$i
 184         done
 185         replay_barrier $SINGLEMDS
 186         rm -rf $DIR/$tfile-*
 187         fail $SINGLEMDS
 188         $CHECKSTAT -t file $DIR/$tfile-* &&
 189                 error "$CHECKSTAT $DIR/$tfile-* attribute check should fail" ||
 190                 true
 191 }
 192 run_test 4b "|x| rm 10 files"
 193
 194 # The idea is to get past the first block of precreated files on both
 195 # osts, and then replay.
 196 test_5() {
 197         replay_barrier $SINGLEMDS
 198         for i in $(seq 220); do
 199                 echo "tag-$i" > $DIR/$tfile-$i
 200         done
 201         fail $SINGLEMDS
 202         for i in $(seq 220); do
 203                 grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
 204         done
 205         rm -rf $DIR/$tfile-*
 206         sleep 3
 207         # waiting for commitment of removal
 208 }
 209 run_test 5 "|x| 220 open(O_CREAT)"
 210
 211 test_6a() {     # was test_6
 212         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
 213         replay_barrier $SINGLEMDS
 214         mcreate $DIR/$tdir/$tfile
 215         fail $SINGLEMDS
 216         $CHECKSTAT -t dir $DIR/$tdir ||
 217                 error "$CHECKSTAT $DIR/$tdir attribute check failed"
 218         $CHECKSTAT -t file $DIR/$tdir/$tfile ||
 219                 error "$CHECKSTAT $DIR/$tdir/$tfile attribute check failed"
 220         sleep 2
 221         # waiting for log process thread
 222 }
 223 run_test 6a "mkdir + contained create"
 224
 225 test_6b() {
 226         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
 227         replay_barrier $SINGLEMDS
 228         rm -rf $DIR/$tdir
 229         fail $SINGLEMDS
 230         $CHECKSTAT -t dir $DIR/$tdir &&
 231                 error "$CHECKSTAT $DIR/$tdir attribute check should fail" ||
 232                 true
 233 }
 234 run_test 6b "|X| rmdir"
 235
 236 test_7() {
 237         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
 238         replay_barrier $SINGLEMDS
 239         mcreate $DIR/$tdir/$tfile
 240         fail $SINGLEMDS
 241         $CHECKSTAT -t dir $DIR/$tdir ||
 242                 error "$CHECKSTAT $DIR/$tdir attribute check failed"
 243         $CHECKSTAT -t file $DIR/$tdir/$tfile ||
 244                 error "$CHECKSTAT $DIR/$tdir/$tfile attribute check failed"
 245         rm -fr $DIR/$tdir
 246 }
 247 run_test 7 "mkdir |X| contained create"
 248
 249 test_8() {
 250         replay_barrier $SINGLEMDS
 251         multiop_bg_pause $DIR/$tfile mo_c ||
 252                 error "multiop mknod $DIR/$tfile failed"
 253         MULTIPID=$!
 254         fail $SINGLEMDS
 255         ls $DIR/$tfile
 256         $CHECKSTAT -t file $DIR/$tfile ||
 257                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
 258         kill -USR1 $MULTIPID || error "multiop mknod $MULTIPID not running"
 259         wait $MULTIPID || error "multiop mknod $MULTIPID failed"
 260         rm $DIR/$tfile
 261 }
 262 run_test 8 "creat open |X| close"
 263
 264 test_9() {
 265         replay_barrier $SINGLEMDS
 266         mcreate $DIR/$tfile
 267         local old_inum=$(ls -i $DIR/$tfile | awk '{print $1}')
 268         fail $SINGLEMDS
 269         local new_inum=$(ls -i $DIR/$tfile | awk '{print $1}')
 270
 271         echo " old_inum == $old_inum, new_inum == $new_inum"
 272         if [ $old_inum -eq $new_inum  ] ;
 273         then
 274                 echo "old_inum and new_inum match"
 275         else
 276                 echo " old_inum and new_inum do not match"
 277                 error "old index($old_inum) does not match new index($new_inum)"
 278         fi
 279         rm $DIR/$tfile
 280 }
 281 run_test 9 "|X| create (same inum/gen)"
 282
 283 test_10() {
 284         mcreate $DIR/$tfile || error "mcreate $DIR/$tfile failed"
 285         replay_barrier $SINGLEMDS
 286         mv $DIR/$tfile $DIR/$tfile-2
 287         rm -f $DIR/$tfile
 288         fail $SINGLEMDS
 289         $CHECKSTAT $DIR/$tfile &&
 290                 error "$CHECKSTAT $DIR/$tfile attribute check should fail"
 291         $CHECKSTAT $DIR/$tfile-2 ||
 292                 error "$CHECKSTAT $DIR/$tfile-2 attribute check failed"
 293         rm $DIR/$tfile-2
 294         return 0
 295 }
 296 run_test 10 "create |X| rename unlink"
 297
 298 test_11() {
 299         mcreate $DIR/$tfile || error "mcreate $DIR/$tfile failed"
 300         echo "old" > $DIR/$tfile
 301         mv $DIR/$tfile $DIR/$tfile-2
 302         replay_barrier $SINGLEMDS
 303         echo "new" > $DIR/$tfile
 304         grep new $DIR/$tfile
 305         grep old $DIR/$tfile-2
 306         fail $SINGLEMDS
 307         grep new $DIR/$tfile || error "grep $DIR/$tfile failed"
 308         grep old $DIR/$tfile-2 || error "grep $DIR/$tfile-2 failed"
 309 }
 310 run_test 11 "create open write rename |X| create-old-name read"
 311
 312 test_12() {
 313         mcreate $DIR/$tfile || error "mcreate $DIR/$tfile failed"
 314         multiop_bg_pause $DIR/$tfile o_tSc ||
 315                 error "multiop_bg_pause $DIR/$tfile failed"
 316         pid=$!
 317         rm -f $DIR/$tfile
 318         replay_barrier $SINGLEMDS
 319         kill -USR1 $pid || error "multiop $pid not running"
 320         wait $pid || error "multiop $pid failed"
 321
 322         fail $SINGLEMDS
 323         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
 324         return 0
 325 }
 326 run_test 12 "open, unlink |X| close"
 327
 328 # 1777 - replay open after committed chmod that would make
 329 #        a regular open a failure
 330 test_13() {
 331         mcreate $DIR/$tfile || error "mcreate $DIR/$tfile failed"
 332         multiop_bg_pause $DIR/$tfile O_wc ||
 333                 error "multiop_bg_pause $DIR/$tfile failed"
 334         pid=$!
 335         chmod 0 $DIR/$tfile
 336         $CHECKSTAT -p 0 $DIR/$tfile ||
 337                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
 338         replay_barrier $SINGLEMDS
 339         fail $SINGLEMDS
 340         kill -USR1 $pid || error "multiop $pid not running"
 341         wait $pid || error "multiop $pid failed"
 342
 343         $CHECKSTAT -s 1 -p 0 $DIR/$tfile ||
 344                 error "second $CHECKSTAT $DIR/$tfile attribute check failed"
 345         rm $DIR/$tfile || error "rm $DIR/$tfile failed"
 346         return 0
 347 }
 348 run_test 13 "open chmod 0 |x| write close"
 349
 350 test_14() {
 351         multiop_bg_pause $DIR/$tfile O_tSc ||
 352                 error "multiop_bg_pause $DIR/$tfile failed"
 353         pid=$!
 354         rm -f $DIR/$tfile
 355         replay_barrier $SINGLEMDS
 356         kill -USR1 $pid || error "multiop $pid not running"
 357         wait $pid || error "multiop $pid failed"
 358
 359         fail $SINGLEMDS
 360         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
 361         return 0
 362 }
 363 run_test 14 "open(O_CREAT), unlink |X| close"
 364
 365 test_15() {
 366         multiop_bg_pause $DIR/$tfile O_tSc ||
 367                 error "multiop_bg_pause $DIR/$tfile failed"
 368         pid=$!
 369         rm -f $DIR/$tfile
 370         replay_barrier $SINGLEMDS
 371         touch $DIR/$tfile-1 || error "touch $DIR/$tfile-1 failed"
 372         kill -USR1 $pid || error "multiop $pid not running"
 373         wait $pid || error "multiop $pid failed"
 374
 375         fail $SINGLEMDS
 376         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
 377         touch $DIR/$tfile-2 || error "touch $DIR/$tfile-2 failed"
 378         return 0
 379 }
 380 run_test 15 "open(O_CREAT), unlink |X|  touch new, close"
 381
 382 test_16() {
 383         replay_barrier $SINGLEMDS
 384         mcreate $DIR/$tfile
 385         munlink $DIR/$tfile
 386         mcreate $DIR/$tfile-2
 387         fail $SINGLEMDS
 388         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
 389         [ -e $DIR/$tfile-2 ] || error "file $DIR/$tfile-2 does not exist"
 390         munlink $DIR/$tfile-2 || error "munlink $DIR/$tfile-2 failed"
 391 }
 392 run_test 16 "|X| open(O_CREAT), unlink, touch new,  unlink new"
 393
 394 test_17() {
 395         replay_barrier $SINGLEMDS
 396         multiop_bg_pause $DIR/$tfile O_c ||
 397                 error "multiop_bg_pause $DIR/$tfile failed"
 398         pid=$!
 399         fail $SINGLEMDS
 400         kill -USR1 $pid || error "multiop $pid not running"
 401         wait $pid || error "multiop $pid failed"
 402         $CHECKSTAT -t file $DIR/$tfile ||
 403                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
 404         rm $DIR/$tfile
 405 }
 406 run_test 17 "|X| open(O_CREAT), |replay| close"
 407
 408 test_18() {
 409         replay_barrier $SINGLEMDS
 410         multiop_bg_pause $DIR/$tfile O_tSc ||
 411                 error "multiop_bg_pause $DIR/$tfile failed"
 412         pid=$!
 413         rm -f $DIR/$tfile
 414         touch $DIR/$tfile-2 || error "touch $DIR/$tfile-2 failed"
 415         echo "pid: $pid will close"
 416         kill -USR1 $pid || error "multiop $pid not running"
 417         wait $pid || error "multiop $pid failed"
 418
 419         fail $SINGLEMDS
 420         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
 421         [ -e $DIR/$tfile-2 ] || error "file $DIR/$tfile-2 does not exist"
 422         # this touch frequently fails
 423         touch $DIR/$tfile-3 || error "touch $DIR/$tfile-3 failed"
 424         munlink $DIR/$tfile-2 || error "munlink $DIR/$tfile-2 failed"
 425         munlink $DIR/$tfile-3 || error "munlink $DIR/$tfile-3 failed"
 426         return 0
 427 }
 428 run_test 18 "open(O_CREAT), unlink, touch new, close, touch, unlink"
 429
 430 # bug 1855 (a simpler form of test_11 above)
 431 test_19() {
 432         replay_barrier $SINGLEMDS
 433         mcreate $DIR/$tfile
 434         echo "old" > $DIR/$tfile
 435         mv $DIR/$tfile $DIR/$tfile-2
 436         grep old $DIR/$tfile-2
 437         fail $SINGLEMDS
 438         grep old $DIR/$tfile-2 || error "grep $DIR/$tfile-2 failed"
 439 }
 440 run_test 19 "mcreate, open, write, rename "
 441
 442 test_20a() {    # was test_20
 443         replay_barrier $SINGLEMDS
 444         multiop_bg_pause $DIR/$tfile O_tSc ||
 445                 error "multiop_bg_pause $DIR/$tfile failed"
 446         pid=$!
 447         rm -f $DIR/$tfile
 448
 449         fail $SINGLEMDS
 450         kill -USR1 $pid || error "multiop $pid not running"
 451         wait $pid || error "multiop $pid failed"
 452         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
 453         return 0
 454 }
 455 run_test 20a "|X| open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 456
 457 test_20b() { # bug 10480
 458         local wait_timeout=$((TIMEOUT * 4))
 459         local BEFOREUSED
 460         local AFTERUSED
 461
 462         BEFOREUSED=$(df -P $DIR | tail -1 | awk '{ print $3 }')
 463         dd if=/dev/zero of=$DIR/$tfile bs=4k count=10000 &
 464         while [ ! -e $DIR/$tfile ] ; do
 465                 usleep 60                      # give dd a chance to start
 466         done
 467
 468         $GETSTRIPE $DIR/$tfile || error "$GETSTRIPE $DIR/$tfile failed"
 469         # make it an orphan
 470         rm -f $DIR/$tfile || error "rm -f $DIR/$tfile failed"
 471         mds_evict_client
 472         client_up || client_up || true    # reconnect
 473
 474         do_facet $SINGLEMDS "lctl set_param -n osd*.*MDT*.force_sync 1"
 475
 476         fail $SINGLEMDS                            # start orphan recovery
 477         wait_recovery_complete $SINGLEMDS || error "MDS recovery not done"
 478         wait_delete_completed_mds $wait_timeout ||
 479                 error "delete did not complete"
 480
 481         AFTERUSED=$(df -P $DIR | tail -1 | awk '{ print $3 }')
 482         log "before $BEFOREUSED, after $AFTERUSED"
 483         (( $AFTERUSED > $BEFOREUSED + $(fs_log_size) )) &&
 484                 error "after $AFTERUSED > before $BEFOREUSED"
 485         return 0
 486 }
 487 run_test 20b "write, unlink, eviction, replay, (test mds_cleanup_orphans)"
 488
 489 test_20c() { # bug 10480
 490         multiop_bg_pause $DIR/$tfile Ow_c ||
 491                 error "multiop_bg_pause $DIR/$tfile failed"
 492         pid=$!
 493
 494         ls -la $DIR/$tfile
 495
 496         mds_evict_client
 497         client_up || client_up || true    # reconnect
 498
 499         kill -USR1 $pid || error "multiop $pid not running"
 500         wait $pid || error "multiop $pid failed"
 501         [ -s $DIR/$tfile ] || error "File was truncated"
 502
 503         return 0
 504 }
 505 run_test 20c "check that client eviction does not affect file content"
 506
 507 test_21() {
 508         replay_barrier $SINGLEMDS
 509         multiop_bg_pause $DIR/$tfile O_tSc ||
 510                 error "multiop_bg_pause $DIR/$tfile failed"
 511         pid=$!
 512         rm -f $DIR/$tfile
 513         touch $DIR/$tfile-1 || error "touch $DIR/$tfile-1 failed"
 514
 515         fail $SINGLEMDS
 516         kill -USR1 $pid || error "multiop $pid not running"
 517         wait $pid || error "multiop $pid failed"
 518         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
 519         touch $DIR/$tfile-2 || error "touch $DIR/$tfile-2 failed"
 520         return 0
 521 }
 522 run_test 21 "|X| open(O_CREAT), unlink touch new, replay, close (test mds_cleanup_orphans)"
 523
 524 test_22() {
 525         multiop_bg_pause $DIR/$tfile O_tSc ||
 526                 error "multiop_bg_pause $DIR/$tfile failed"
 527         pid=$!
 528
 529         replay_barrier $SINGLEMDS
 530         rm -f $DIR/$tfile
 531
 532         fail $SINGLEMDS
 533         kill -USR1 $pid || error "multiop $pid not running"
 534         wait $pid || error "multiop $pid failed"
 535         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
 536         return 0
 537 }
 538 run_test 22 "open(O_CREAT), |X| unlink, replay, close (test mds_cleanup_orphans)"
 539
 540 test_23() {
 541         multiop_bg_pause $DIR/$tfile O_tSc ||
 542                 error "multiop_bg_pause $DIR/$tfile failed"
 543         pid=$!
 544
 545         replay_barrier $SINGLEMDS
 546         rm -f $DIR/$tfile
 547         touch $DIR/$tfile-1 || error "touch $DIR/$tfile-1 failed"
 548
 549         fail $SINGLEMDS
 550         kill -USR1 $pid || error "multiop $pid not running"
 551         wait $pid || error "multiop $pid failed"
 552         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
 553         touch $DIR/$tfile-2 || error "touch $DIR/$tfile-2 failed"
 554         return 0
 555 }
 556 run_test 23 "open(O_CREAT), |X| unlink touch new, replay, close (test mds_cleanup_orphans)"
 557
 558 test_24() {
 559         multiop_bg_pause $DIR/$tfile O_tSc ||
 560                 error "multiop_bg_pause $DIR/$tfile failed"
 561         pid=$!
 562
 563         replay_barrier $SINGLEMDS
 564         fail $SINGLEMDS
 565         rm -f $DIR/$tfile
 566         kill -USR1 $pid || error "multiop $pid not running"
 567         wait $pid || error "multiop $pid failed"
 568         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
 569         return 0
 570 }
 571 run_test 24 "open(O_CREAT), replay, unlink, close (test mds_cleanup_orphans)"
 572
 573 test_25() {
 574         multiop_bg_pause $DIR/$tfile O_tSc ||
 575                 error "multiop_bg_pause $DIR/$tfile failed"
 576         pid=$!
 577         rm -f $DIR/$tfile
 578
 579         replay_barrier $SINGLEMDS
 580         fail $SINGLEMDS
 581         kill -USR1 $pid || error "multiop $pid not running"
 582         wait $pid || error "multiop $pid failed"
 583         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
 584         return 0
 585 }
 586 run_test 25 "open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 587
 588 test_26() {
 589         replay_barrier $SINGLEMDS
 590         multiop_bg_pause $DIR/$tfile-1 O_tSc ||
 591                 error "multiop_bg_pause $DIR/$tfile-1 failed"
 592         pid1=$!
 593         multiop_bg_pause $DIR/$tfile-2 O_tSc ||
 594                 error "multiop_bg_pause $DIR/$tfile-2 failed"
 595         pid2=$!
 596         rm -f $DIR/$tfile-1
 597         rm -f $DIR/$tfile-2
 598         kill -USR1 $pid2 || error "second multiop $pid2 not running"
 599         wait $pid2 || error "second multiop $pid2 failed"
 600
 601         fail $SINGLEMDS
 602         kill -USR1 $pid1 || error "multiop $pid1 not running"
 603         wait $pid1 || error "multiop $pid1 failed"
 604         [ -e $DIR/$tfile-1 ] && error "file $DIR/$tfile-1 should not exist"
 605         [ -e $DIR/$tfile-2 ] && error "file $DIR/$tfile-2 should not exist"
 606         return 0
 607 }
 608 run_test 26 "|X| open(O_CREAT), unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 609
 610 test_27() {
 611         replay_barrier $SINGLEMDS
 612         multiop_bg_pause $DIR/$tfile-1 O_tSc ||
 613                 error "multiop_bg_pause $DIR/$tfile-1 failed"
 614         pid1=$!
 615         multiop_bg_pause $DIR/$tfile-2 O_tSc ||
 616                 error "multiop_bg_pause $DIR/$tfile-2 failed"
 617         pid2=$!
 618         rm -f $DIR/$tfile-1
 619         rm -f $DIR/$tfile-2
 620
 621         fail $SINGLEMDS
 622         kill -USR1 $pid1 || error "multiop $pid1 not running"
 623         wait $pid1 || error "multiop $pid1 failed"
 624         kill -USR1 $pid2 || error "second multiop $pid2 not running"
 625         wait $pid2 || error "second multiop $pid2 failed"
 626         [ -e $DIR/$tfile-1 ] && error "file $DIR/$tfile-1 should not exist"
 627         [ -e $DIR/$tfile-2 ] && error "file $DIR/$tfile-2 should not exist"
 628         return 0
 629 }
 630 run_test 27 "|X| open(O_CREAT), unlink two, replay, close two (test mds_cleanup_orphans)"
 631
 632 test_28() {
 633         multiop_bg_pause $DIR/$tfile-1 O_tSc ||
 634                 error "multiop_bg_pause $DIR/$tfile-1 failed"
 635         pid1=$!
 636         multiop_bg_pause $DIR/$tfile-2 O_tSc ||
 637                 error "multiop_bg_pause $DIR/$tfile-2 failed"
 638         pid2=$!
 639         replay_barrier $SINGLEMDS
 640         rm -f $DIR/$tfile-1
 641         rm -f $DIR/$tfile-2
 642         kill -USR1 $pid2 || error "second multiop $pid2 not running"
 643         wait $pid2 || error "second multiop $pid2 failed"
 644
 645         fail $SINGLEMDS
 646         kill -USR1 $pid1 || error "multiop $pid1 not running"
 647         wait $pid1 || error "multiop $pid1 failed"
 648         [ -e $DIR/$tfile-1 ] && error "file $DIR/$tfile-1 should not exist"
 649         [ -e $DIR/$tfile-2 ] && error "file $DIR/$tfile-2 should not exist"
 650         return 0
 651 }
 652 run_test 28 "open(O_CREAT), |X| unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 653
 654 test_29() {
 655         multiop_bg_pause $DIR/$tfile-1 O_tSc ||
 656                 error "multiop_bg_pause $DIR/$tfile-1 failed"
 657         pid1=$!
 658         multiop_bg_pause $DIR/$tfile-2 O_tSc ||
 659                 error "multiop_bg_pause $DIR/$tfile-2 failed"
 660         pid2=$!
 661         replay_barrier $SINGLEMDS
 662         rm -f $DIR/$tfile-1
 663         rm -f $DIR/$tfile-2
 664
 665         fail $SINGLEMDS
 666         kill -USR1 $pid1 || error "multiop $pid1 not running"
 667         wait $pid1 || error "multiop $pid1 failed"
 668         kill -USR1 $pid2 || error "second multiop $pid2 not running"
 669         wait $pid2 || error "second multiop $pid2 failed"
 670         [ -e $DIR/$tfile-1 ] && error "file $DIR/$tfile-1 should not exist"
 671         [ -e $DIR/$tfile-2 ] && error "file $DIR/$tfile-2 should not exist"
 672         return 0
 673 }
 674 run_test 29 "open(O_CREAT), |X| unlink two, replay, close two (test mds_cleanup_orphans)"
 675
 676 test_30() {
 677         multiop_bg_pause $DIR/$tfile-1 O_tSc ||
 678                 error "multiop_bg_pause $DIR/$tfile-1 failed"
 679         pid1=$!
 680         multiop_bg_pause $DIR/$tfile-2 O_tSc ||
 681                 error "multiop_bg_pause $DIR/$tfile-2 failed"
 682         pid2=$!
 683         rm -f $DIR/$tfile-1
 684         rm -f $DIR/$tfile-2
 685
 686         replay_barrier $SINGLEMDS
 687         fail $SINGLEMDS
 688         kill -USR1 $pid1 || error "multiop $pid1 not running"
 689         wait $pid1 || error "multiop $pid1 failed"
 690         kill -USR1 $pid2 || error "second multiop $pid2 not running"
 691         wait $pid2 || error "second multiop $pid2 failed"
 692         [ -e $DIR/$tfile-1 ] && error "file $DIR/$tfile-1 should not exist"
 693         [ -e $DIR/$tfile-2 ] && error "file $DIR/$tfile-2 should not exist"
 694         return 0
 695 }
 696 run_test 30 "open(O_CREAT) two, unlink two, replay, close two (test mds_cleanup_orphans)"
 697
 698 test_31() {
 699         multiop_bg_pause $DIR/$tfile-1 O_tSc ||
 700                 error "multiop_bg_pause $DIR/$tfile-1 failed"
 701         pid1=$!
 702         multiop_bg_pause $DIR/$tfile-2 O_tSc ||
 703                 error "multiop_bg_pause $DIR/$tfile-2 failed"
 704         pid2=$!
 705         rm -f $DIR/$tfile-1
 706
 707         replay_barrier $SINGLEMDS
 708         rm -f $DIR/$tfile-2
 709         fail $SINGLEMDS
 710         kill -USR1 $pid1 || error "multiop $pid1 not running"
 711         wait $pid1 || error "multiop $pid1 failed"
 712         kill -USR1 $pid2 || error "second multiop $pid2 not running"
 713         wait $pid2 || error "second multiop $pid2 failed"
 714         [ -e $DIR/$tfile-1 ] && error "file $DIR/$tfile-1 should not exist"
 715         [ -e $DIR/$tfile-2 ] && error "file $DIR/$tfile-2 should not exist"
 716         return 0
 717 }
 718 run_test 31 "open(O_CREAT) two, unlink one, |X| unlink one, close two (test mds_cleanup_orphans)"
 719
 720 # tests for bug 2104; completion without crashing is success.  The close is
 721 # stale, but we always return 0 for close, so the app never sees it.
 722 test_32() {
 723         multiop_bg_pause $DIR/$tfile O_c ||
 724                 error "multiop_bg_pause $DIR/$tfile failed"
 725         pid1=$!
 726         multiop_bg_pause $DIR/$tfile O_c ||
 727                 error "second multiop_bg_pause $DIR/$tfile failed"
 728         pid2=$!
 729         mds_evict_client
 730         client_up || client_up || error "client_up failed"
 731         kill -USR1 $pid1 || error "multiop $pid1 not running"
 732         kill -USR1 $pid2 || error "second multiop $pid2 not running"
 733         wait $pid1 || error "multiop $pid1 failed"
 734         wait $pid2 || error "second multiop $pid2 failed"
 735         return 0
 736 }
 737 run_test 32 "close() notices client eviction; close() after client eviction"
 738
 739 test_33a() {
 740         createmany -o $DIR/$tfile-%d 10 ||
 741                 error "createmany create $DIR/$tfile failed"
 742         replay_barrier_nosync $SINGLEMDS
 743         fail_abort $SINGLEMDS
 744         # recreate shouldn't fail
 745         createmany -o $DIR/$tfile--%d 10 ||
 746                 error "createmany recreate $DIR/$tfile failed"
 747         rm $DIR/$tfile-* -f
 748         return 0
 749 }
 750 run_test 33a "fid seq shouldn't be reused after abort recovery"
 751
 752 test_33b() {
 753         #define OBD_FAIL_SEQ_ALLOC                          0x1311
 754         do_facet $SINGLEMDS "lctl set_param fail_loc=0x1311"
 755
 756         createmany -o $DIR/$tfile-%d 10
 757         replay_barrier_nosync $SINGLEMDS
 758         fail_abort $SINGLEMDS
 759         # recreate shouldn't fail
 760         createmany -o $DIR/$tfile--%d 10 ||
 761                 error "createmany recreate $DIR/$tfile failed"
 762         rm $DIR/$tfile-* -f
 763         return 0
 764 }
 765 run_test 33b "test fid seq allocation"
 766
 767 test_34() {
 768         multiop_bg_pause $DIR/$tfile O_c ||
 769                 error "multiop_bg_pause $DIR/$tfile failed"
 770         pid=$!
 771         rm -f $DIR/$tfile
 772
 773         replay_barrier $SINGLEMDS
 774         fail_abort $SINGLEMDS
 775         kill -USR1 $pid || error "multiop $pid not running"
 776         wait $pid || error "multiop $pid failed"
 777         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
 778         sync
 779         return 0
 780 }
 781 run_test 34 "abort recovery before client does replay (test mds_cleanup_orphans)"
 782
 783 # bug 2278 - generate one orphan on OST, then destroy it during recovery from llog
 784 test_35() {
 785         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
 786
 787         #define OBD_FAIL_MDS_REINT_NET_REP       0x119
 788         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000119"
 789         rm -f $DIR/$tfile &
 790         sleep 1
 791         sync
 792         sleep 1
 793         # give a chance to remove from MDS
 794         fail_abort $SINGLEMDS
 795         $CHECKSTAT -t file $DIR/$tfile &&
 796                 error "$CHECKSTAT $DIR/$tfile attribute check should fail" ||
 797                 true
 798 }
 799 run_test 35 "test recovery from llog for unlink op"
 800
 801 # b=2432 resent cancel after replay uses wrong cookie,
 802 # so don't resend cancels
 803 test_36() {
 804         replay_barrier $SINGLEMDS
 805         touch $DIR/$tfile
 806         checkstat $DIR/$tfile
 807         facet_failover $SINGLEMDS
 808         cancel_lru_locks mdc
 809         if dmesg | grep "unknown lock cookie"; then
 810                 error "cancel after replay failed"
 811         fi
 812 }
 813 run_test 36 "don't resend cancel"
 814
 815 # b=2368
 816 # directory orphans can't be unlinked from PENDING directory
 817 test_37() {
 818         rmdir $DIR/$tfile 2>/dev/null
 819         multiop_bg_pause $DIR/$tfile dD_c ||
 820                 error "multiop_bg_pause $DIR/$tfile failed"
 821         pid=$!
 822         rmdir $DIR/$tfile
 823
 824         replay_barrier $SINGLEMDS
 825         # clear the dmesg buffer so we only see errors from this recovery
 826         do_facet $SINGLEMDS dmesg -c >/dev/null
 827         fail_abort $SINGLEMDS
 828         kill -USR1 $pid || error "multiop $pid not running"
 829         do_facet $SINGLEMDS dmesg | grep "error .* unlinking .* from PENDING" &&
 830                 error "error unlinking files"
 831         wait $pid || error "multiop $pid failed"
 832         sync
 833         return 0
 834 }
 835 run_test 37 "abort recovery before client does replay (test mds_cleanup_orphans for directories)"
 836
 837 test_38() {
 838         createmany -o $DIR/$tfile-%d 800 ||
 839                 error "createmany -o $DIR/$tfile failed"
 840         unlinkmany $DIR/$tfile-%d 0 400 || error "unlinkmany $DIR/$tfile failed"
 841         replay_barrier $SINGLEMDS
 842         fail $SINGLEMDS
 843         unlinkmany $DIR/$tfile-%d 400 400 ||
 844                 error "unlinkmany $DIR/$tfile 400 failed"
 845         sleep 2
 846         $CHECKSTAT -t file $DIR/$tfile-* &&
 847                 error "$CHECKSTAT $DIR/$tfile-* attribute check should fail" ||
 848                 true
 849 }
 850 run_test 38 "test recovery from unlink llog (test llog_gen_rec) "
 851
 852 test_39() { # bug 4176
 853         createmany -o $DIR/$tfile-%d 800 ||
 854                 error "createmany -o $DIR/$tfile failed"
 855         replay_barrier $SINGLEMDS
 856         unlinkmany $DIR/$tfile-%d 0 400
 857         fail $SINGLEMDS
 858         unlinkmany $DIR/$tfile-%d 400 400 ||
 859                 error "unlinkmany $DIR/$tfile 400 failed"
 860         sleep 2
 861         $CHECKSTAT -t file $DIR/$tfile-* &&
 862                 error "$CHECKSTAT $DIR/$tfile-* attribute check should fail" ||
 863                 true
 864 }
 865 run_test 39 "test recovery from unlink llog (test llog_gen_rec) "
 866
 867 count_ost_writes() {
 868     lctl get_param -n osc.*.stats | awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }'
 869 }
 870
 871 #b=2477,2532
 872 test_40(){
 873         # always need connection to MDS to verify layout during IO. LU-2628.
 874         lctl get_param mdc.*.connect_flags | grep -q layout_lock &&
 875                 skip "layout_lock needs MDS connection for IO" && return 0
 876
 877         $LCTL mark multiop $MOUNT/$tfile OS_c
 878         multiop $MOUNT/$tfile OS_c  &
 879         PID=$!
 880         writeme -s $MOUNT/${tfile}-2 &
 881         WRITE_PID=$!
 882         sleep 1
 883         facet_failover $SINGLEMDS
 884         #define OBD_FAIL_MDS_CONNECT_NET         0x117
 885         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000117"
 886         kill -USR1 $PID
 887         stat1=$(count_ost_writes)
 888         sleep $TIMEOUT
 889         stat2=$(count_ost_writes)
 890         echo "$stat1, $stat2"
 891         if [ $stat1 -lt $stat2 ]; then
 892                 echo "writes continuing during recovery"
 893                 RC=0
 894         else
 895                 echo "writes not continuing during recovery, bug 2477"
 896                 RC=4
 897         fi
 898         echo "waiting for writeme $WRITE_PID"
 899         kill $WRITE_PID
 900         wait $WRITE_PID
 901
 902         echo "waiting for multiop $PID"
 903         wait $PID || error "multiop $PID failed"
 904         do_facet client munlink $MOUNT/$tfile  ||
 905                 error "munlink $MOUNT/$tfile failed"
 906         do_facet client munlink $MOUNT/${tfile}-2  ||
 907                 error "munlink $MOUNT/$tfile-2 failed"
 908         return $RC
 909 }
 910 run_test 40 "cause recovery in ptlrpc, ensure IO continues"
 911
 912 #b=2814
 913 # make sure that a read to one osc doesn't try to double-unlock its page just
 914 # because another osc is invalid.  trigger_group_io used to mistakenly return
 915 # an error if any oscs were invalid even after having successfully put rpcs
 916 # on valid oscs.  This was fatal if the caller was ll_readpage who unlocked
 917 # the page, guarnateeing that the unlock from the RPC completion would
 918 # assert on trying to unlock the unlocked page.
 919 test_41() {
 920     [ $OSTCOUNT -lt 2 ] &&
 921         skip_env "skipping test 41: we don't have a second OST to test with" &&
 922         return
 923
 924         local f=$MOUNT/$tfile
 925         # make sure the start of the file is ost1
 926         $SETSTRIPE -S $((128 * 1024)) -i 0 $f
 927         do_facet client dd if=/dev/zero of=$f bs=4k count=1 ||
 928                 error "dd on client failed"
 929         cancel_lru_locks osc
 930         # fail ost2 and read from ost1
 931         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS $ost2_svc)
 932         local osc2dev=$(do_facet $SINGLEMDS "lctl get_param -n devices" |
 933                 grep $mdtosc | awk '{print $1}')
 934         [ -z "$osc2dev" ] && echo "OST: $ost2_svc" &&
 935                 lctl get_param -n devices &&
 936                 error "OST 2 $osc2dev does not exist"
 937         do_facet $SINGLEMDS $LCTL --device $osc2dev deactivate ||
 938                 error "deactive device on $SINGLEMDS failed"
 939         do_facet client dd if=$f of=/dev/null bs=4k count=1 ||
 940                 error "second dd on client failed"
 941         do_facet $SINGLEMDS $LCTL --device $osc2dev activate ||
 942                 error "active device on $SINGLEMDS failed"
 943         return 0
 944 }
 945 run_test 41 "read from a valid osc while other oscs are invalid"
 946
 947 # test MDS recovery after ost failure
 948 test_42() {
 949         blocks=$(df -P $MOUNT | tail -n 1 | awk '{ print $2 }')
 950         createmany -o $DIR/$tfile-%d 800 ||
 951                 error "createmany -o $DIR/$tfile failed"
 952         replay_barrier ost1
 953         unlinkmany $DIR/$tfile-%d 0 400
 954         debugsave
 955         lctl set_param debug=-1
 956         facet_failover ost1
 957
 958         # osc is evicted, fs is smaller (but only with failout OSTs (bug 7287)
 959         #blocks_after=`df -P $MOUNT | tail -n 1 | awk '{ print $2 }'`
 960         #[ $blocks_after -lt $blocks ] || return 1
 961         echo "wait for MDS to timeout and recover"
 962         sleep $((TIMEOUT * 2))
 963         debugrestore
 964         unlinkmany $DIR/$tfile-%d 400 400 ||
 965                 error "unlinkmany $DIR/$tfile 400 failed"
 966         $CHECKSTAT -t file $DIR/$tfile-* &&
 967                 error "$CHECKSTAT $DIR/$tfile-* attribute check should fail" ||
 968                 true
 969 }
 970 run_test 42 "recovery after ost failure"
 971
 972 # timeout in MDS/OST recovery RPC will LBUG MDS
 973 test_43() { # bug 2530
 974         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 975
 976         replay_barrier $SINGLEMDS
 977
 978         # OBD_FAIL_OST_CREATE_NET 0x204
 979         do_facet ost1 "lctl set_param fail_loc=0x80000204"
 980         fail $SINGLEMDS
 981         sleep 10
 982
 983         return 0
 984 }
 985 run_test 43 "mds osc import failure during recovery; don't LBUG"
 986
 987 test_44a() { # was test_44
 988         local at_max_saved=0
 989
 990         local mdcdev=$($LCTL dl |
 991                 awk "/${FSNAME}-MDT0000-mdc-/ {if (\$2 == \"UP\") {print \$1}}")
 992         [ "$mdcdev" ] || error "${FSNAME}-MDT0000-mdc- not UP"
 993         [ $(echo $mdcdev | wc -w) -eq 1 ] ||
 994                 { $LCTL dl; error "looking for mdcdev=$mdcdev"; }
 995
 996         # adaptive timeouts slow this way down
 997         if at_is_enabled; then
 998                 at_max_saved=$(at_max_get mds)
 999                 at_max_set 40 mds
1000         fi
1001
1002         for i in $(seq 1 10); do
1003                 echo "$i of 10 ($(date +%s))"
1004                 do_facet $SINGLEMDS \
1005                         "lctl get_param -n md[ts].*.mdt.timeouts | grep service"
1006                 #define OBD_FAIL_TGT_CONN_RACE     0x701
1007                 do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000701"
1008                 # lctl below may fail, it is valid case
1009                 $LCTL --device $mdcdev recover
1010                 df $MOUNT
1011         done
1012         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1013         [ $at_max_saved -ne 0 ] && at_max_set $at_max_saved mds
1014         return 0
1015 }
1016 run_test 44a "race in target handle connect"
1017
1018 test_44b() {
1019         local mdcdev=$($LCTL dl |
1020                 awk "/${FSNAME}-MDT0000-mdc-/ {if (\$2 == \"UP\") {print \$1}}")
1021         [ "$mdcdev" ] || error "${FSNAME}-MDT0000-mdc not up"
1022         [ $(echo $mdcdev | wc -w) -eq 1 ] ||
1023                 { echo mdcdev=$mdcdev; $LCTL dl;
1024                   error "more than one ${FSNAME}-MDT0000-mdc"; }
1025
1026         for i in $(seq 1 10); do
1027                 echo "$i of 10 ($(date +%s))"
1028                 do_facet $SINGLEMDS \
1029                         "lctl get_param -n md[ts].*.mdt.timeouts | grep service"
1030                 #define OBD_FAIL_TGT_DELAY_RECONNECT 0x704
1031                 do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000704"
1032                 # lctl below may fail, it is valid case
1033                 $LCTL --device $mdcdev recover
1034                 df $MOUNT
1035         done
1036         return 0
1037 }
1038 run_test 44b "race in target handle connect"
1039
1040 test_44c() {
1041         replay_barrier $SINGLEMDS
1042         createmany -m $DIR/$tfile-%d 100 || error "failed to create directories"
1043         #define OBD_FAIL_TGT_RCVG_FLAG 0x712
1044         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000712"
1045         fail_abort $SINGLEMDS
1046         unlinkmany $DIR/$tfile-%d 100 && error "unliked after fail abort"
1047         fail $SINGLEMDS
1048         unlinkmany $DIR/$tfile-%d 100 && error "unliked after fail"
1049         return 0
1050 }
1051 run_test 44c "race in target handle connect"
1052
1053 # Handle failed close
1054 test_45() {
1055         local mdcdev=$($LCTL get_param -n devices |
1056                 awk "/ ${FSNAME}-MDT0000-mdc-/ {print \$1}")
1057         [ "$mdcdev" ] || error "${FSNAME}-MDT0000-mdc not up"
1058         [ $(echo $mdcdev | wc -w) -eq 1 ] ||
1059                 { echo mdcdev=$mdcdev; $LCTL dl;
1060                   error "more than one ${FSNAME}-MDT0000-mdc"; }
1061
1062         $LCTL --device $mdcdev recover ||
1063                 error "$LCTL --device $mdcdev recover failed"
1064
1065         multiop_bg_pause $DIR/$tfile O_c ||
1066                 error "multiop_bg_pause $DIR/$tfile failed"
1067         pid=$!
1068
1069         # This will cause the CLOSE to fail before even
1070         # allocating a reply buffer
1071         $LCTL --device $mdcdev deactivate ||
1072                 error "$LCTL --device $mdcdev deactivate failed"
1073
1074         # try the close
1075         kill -USR1 $pid || error "multiop $pid not running"
1076         wait $pid || error "multiop $pid failed"
1077
1078         $LCTL --device $mdcdev activate ||
1079                 error "$LCTL --device $mdcdev activate failed"
1080         sleep 1
1081
1082         $CHECKSTAT -t file $DIR/$tfile ||
1083                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
1084         return 0
1085 }
1086 run_test 45 "Handle failed close"
1087
1088 test_46() {
1089         dmesg -c >/dev/null
1090         drop_reply "touch $DIR/$tfile"
1091         fail $SINGLEMDS
1092         # ironically, the previous test, 45, will cause a real forced close,
1093         # so just look for one for this test
1094         dmesg | grep -i "force closing client file handle for $tfile" &&
1095                 error "found force closing in dmesg"
1096         return 0
1097 }
1098 run_test 46 "Don't leak file handle after open resend (3325)"
1099
1100 test_47() { # bug 2824
1101         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1102
1103         # create some files to make sure precreate has been done on all
1104         # OSTs. (just in case this test is run independently)
1105         createmany -o $DIR/$tfile 20  ||
1106                 error "createmany create $DIR/$tfile failed"
1107
1108         # OBD_FAIL_OST_CREATE_NET 0x204
1109         fail ost1
1110         do_facet ost1 "lctl set_param fail_loc=0x80000204"
1111         client_up || error "client_up failed"
1112
1113         # let the MDS discover the OST failure, attempt to recover, fail
1114         # and recover again.
1115         sleep $((3 * TIMEOUT))
1116
1117         # Without 2824, this createmany would hang
1118         createmany -o $DIR/$tfile 20 ||
1119                 error "createmany recraete $DIR/$tfile failed"
1120         unlinkmany $DIR/$tfile 20 || error "unlinkmany $DIR/$tfile failed"
1121
1122         return 0
1123 }
1124 run_test 47 "MDS->OSC failure during precreate cleanup (2824)"
1125
1126 test_48() {
1127         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1128         [ "$OSTCOUNT" -lt "2" ] &&
1129                 skip_env "$OSTCOUNT < 2 OSTs -- skipping" && return
1130
1131         replay_barrier $SINGLEMDS
1132         createmany -o $DIR/$tfile 20  ||
1133                 error "createmany -o $DIR/$tfile failed"
1134         # OBD_FAIL_OST_EROFS 0x216
1135         facet_failover $SINGLEMDS
1136         do_facet ost1 "lctl set_param fail_loc=0x80000216"
1137         client_up || error "client_up failed"
1138
1139         createmany -o $DIR/$tfile 20 20 ||
1140                 error "createmany recraete $DIR/$tfile failed"
1141         unlinkmany $DIR/$tfile 40 || error "unlinkmany $DIR/$tfile failed"
1142         return 0
1143 }
1144 run_test 48 "MDS->OSC failure during precreate cleanup (2824)"
1145
1146 test_50() {
1147         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS $ost1_svc)
1148         local oscdev=$(do_facet $SINGLEMDS "lctl get_param -n devices" |
1149                 grep $mdtosc | awk '{print $1}')
1150         [ "$oscdev" ] || error "could not find OSC device on MDS"
1151         do_facet $SINGLEMDS $LCTL --device $oscdev recover ||
1152                 error "OSC device $oscdev recovery failed"
1153         do_facet $SINGLEMDS $LCTL --device $oscdev recover ||
1154                 error "second OSC device $oscdev recovery failed"
1155         # give the mds_lov_sync threads a chance to run
1156         sleep 5
1157 }
1158 run_test 50 "Double OSC recovery, don't LASSERT (3812)"
1159
1160 # b3764 timed out lock replay
1161 test_52() {
1162         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.6.90) ] &&
1163                 skip "MDS prior to 2.6.90 handle LDLM_REPLY_NET incorrectly" &&
1164                 return 0
1165
1166         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
1167         cancel_lru_locks mdc
1168
1169         multiop_bg_pause $DIR/$tfile s_s || error "multiop $DIR/$tfile failed"
1170         mpid=$!
1171
1172         #define OBD_FAIL_MDS_LDLM_REPLY_NET     0x157
1173         lctl set_param -n ldlm.cancel_unused_locks_before_replay "0"
1174         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000157"
1175
1176         fail $SINGLEMDS || error "fail $SINGLEMDS failed"
1177         kill -USR1 $mpid
1178         wait $mpid || error "multiop_bg_pause pid failed"
1179
1180         do_facet $SINGLEMDS "lctl set_param fail_loc=0x0"
1181         lctl set_param fail_loc=0x0
1182         lctl set_param -n ldlm.cancel_unused_locks_before_replay "1"
1183         rm -f $DIR/$tfile
1184 }
1185 run_test 52 "time out lock replay (3764)"
1186
1187 # bug 3462 - simultaneous MDC requests
1188 test_53a() {
1189         cancel_lru_locks mdc    # cleanup locks from former test cases
1190         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1191         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1192         multiop $DIR/${tdir}-1/f O_c &
1193         close_pid=$!
1194         # give multiop a change to open
1195         sleep 1
1196
1197         #define OBD_FAIL_MDS_CLOSE_NET 0x115
1198         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
1199         kill -USR1 $close_pid
1200         cancel_lru_locks mdc    # force the close
1201         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1202
1203         mcreate $DIR/${tdir}-2/f || error "mcreate $DIR/${tdir}-2/f failed"
1204
1205         # close should still be here
1206         [ -d /proc/$close_pid ] || error "close_pid doesn't exist"
1207
1208         replay_barrier_nodf $SINGLEMDS
1209         fail $SINGLEMDS
1210         wait $close_pid || error "close_pid $close_pid failed"
1211
1212         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1213                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1214         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1215                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1216         rm -rf $DIR/${tdir}-*
1217 }
1218 run_test 53a "|X| close request while two MDC requests in flight"
1219
1220 test_53b() {
1221         cancel_lru_locks mdc    # cleanup locks from former test cases
1222
1223         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1224         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1225         multiop_bg_pause $DIR/${tdir}-1/f O_c ||
1226                 error "multiop_bg_pause $DIR/${tdir}-1/f failed"
1227         close_pid=$!
1228
1229         #define OBD_FAIL_MDS_REINT_NET 0x107
1230         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
1231         mcreate $DIR/${tdir}-2/f &
1232         open_pid=$!
1233         sleep 1
1234
1235         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1236         kill -USR1 $close_pid
1237         cancel_lru_locks mdc    # force the close
1238         wait $close_pid || error "close_pid $close_pid failed"
1239         # open should still be here
1240         [ -d /proc/$open_pid ] || error "open_pid doesn't exist"
1241
1242         replay_barrier_nodf $SINGLEMDS
1243         fail $SINGLEMDS
1244         wait $open_pid || error "open_pid failed"
1245
1246         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1247                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1248         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1249                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1250         rm -rf $DIR/${tdir}-*
1251 }
1252 run_test 53b "|X| open request while two MDC requests in flight"
1253
1254 test_53c() {
1255         cancel_lru_locks mdc    # cleanup locks from former test cases
1256
1257         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1258         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1259         multiop $DIR/${tdir}-1/f O_c &
1260         close_pid=$!
1261
1262         #define OBD_FAIL_MDS_REINT_NET 0x107
1263         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
1264         mcreate $DIR/${tdir}-2/f &
1265         open_pid=$!
1266         sleep 1
1267
1268         #define OBD_FAIL_MDS_CLOSE_NET 0x115
1269         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
1270         kill -USR1 $close_pid
1271         cancel_lru_locks mdc    # force the close
1272
1273         #bz20647: make sure all pids exist before failover
1274         [ -d /proc/$close_pid ] || error "close_pid doesn't exist"
1275         [ -d /proc/$open_pid ] || error "open_pid doesn't exists"
1276         replay_barrier_nodf $SINGLEMDS
1277         fail_nodf $SINGLEMDS
1278         wait $open_pid || error "open_pid failed"
1279         sleep 2
1280         # close should be gone
1281         [ -d /proc/$close_pid ] && error "close_pid should not exist"
1282         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1283
1284         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1285                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1286         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1287                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1288         rm -rf $DIR/${tdir}-*
1289 }
1290 run_test 53c "|X| open request and close request while two MDC requests in flight"
1291
1292 test_53d() {
1293         cancel_lru_locks mdc    # cleanup locks from former test cases
1294
1295         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1296         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1297         multiop $DIR/${tdir}-1/f O_c &
1298         close_pid=$!
1299         # give multiop a chance to open
1300         sleep 1
1301
1302         #define OBD_FAIL_MDS_CLOSE_NET_REP 0x13b
1303         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000013b"
1304         kill -USR1 $close_pid
1305         cancel_lru_locks mdc    # force the close
1306         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1307         mcreate $DIR/${tdir}-2/f || error "mcreate $DIR/${tdir}-2/f failed"
1308
1309         # close should still be here
1310         [ -d /proc/$close_pid ] || error "close_pid doesn't exist"
1311         fail $SINGLEMDS
1312         wait $close_pid || error "close_pid failed"
1313
1314         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1315                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1316         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1317                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1318         rm -rf $DIR/${tdir}-*
1319 }
1320 run_test 53d "close reply while two MDC requests in flight"
1321
1322 test_53e() {
1323         cancel_lru_locks mdc    # cleanup locks from former test cases
1324
1325         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1326         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1327         multiop $DIR/${tdir}-1/f O_c &
1328         close_pid=$!
1329
1330         #define OBD_FAIL_MDS_REINT_NET_REP 0x119
1331         do_facet $SINGLEMDS "lctl set_param fail_loc=0x119"
1332         mcreate $DIR/${tdir}-2/f &
1333         open_pid=$!
1334         sleep 1
1335
1336         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1337         kill -USR1 $close_pid
1338         cancel_lru_locks mdc    # force the close
1339         wait $close_pid || error "close_pid failed"
1340         # open should still be here
1341         [ -d /proc/$open_pid ] || error "open_pid doesn't exists"
1342
1343         replay_barrier_nodf $SINGLEMDS
1344         fail $SINGLEMDS
1345         wait $open_pid || error "open_pid failed"
1346
1347         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1348                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1349         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1350                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1351         rm -rf $DIR/${tdir}-*
1352 }
1353 run_test 53e "|X| open reply while two MDC requests in flight"
1354
1355 test_53f() {
1356         cancel_lru_locks mdc    # cleanup locks from former test cases
1357
1358         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1359         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1360         multiop $DIR/${tdir}-1/f O_c &
1361         close_pid=$!
1362
1363         #define OBD_FAIL_MDS_REINT_NET_REP 0x119
1364         do_facet $SINGLEMDS "lctl set_param fail_loc=0x119"
1365         mcreate $DIR/${tdir}-2/f &
1366         open_pid=$!
1367         sleep 1
1368
1369         #define OBD_FAIL_MDS_CLOSE_NET_REP 0x13b
1370         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000013b"
1371         kill -USR1 $close_pid
1372         cancel_lru_locks mdc    # force the close
1373
1374         #bz20647: make sure all pids are exists before failover
1375         [ -d /proc/$close_pid ] || error "close_pid doesn't exist"
1376         [ -d /proc/$open_pid ] || error "open_pid doesn't exists"
1377         replay_barrier_nodf $SINGLEMDS
1378         fail_nodf $SINGLEMDS
1379         wait $open_pid || error "open_pid failed"
1380         sleep 2
1381         # close should be gone
1382         [ -d /proc/$close_pid ] && error "close_pid should not exist"
1383         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1384
1385         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1386                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1387         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1388                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1389         rm -rf $DIR/${tdir}-*
1390 }
1391 run_test 53f "|X| open reply and close reply while two MDC requests in flight"
1392
1393 test_53g() {
1394         cancel_lru_locks mdc    # cleanup locks from former test cases
1395
1396         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1397         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1398         multiop $DIR/${tdir}-1/f O_c &
1399         close_pid=$!
1400
1401         #define OBD_FAIL_MDS_REINT_NET_REP 0x119
1402         do_facet $SINGLEMDS "lctl set_param fail_loc=0x119"
1403         mcreate $DIR/${tdir}-2/f &
1404         open_pid=$!
1405         sleep 1
1406
1407         #define OBD_FAIL_MDS_CLOSE_NET 0x115
1408         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
1409         kill -USR1 $close_pid
1410         cancel_lru_locks mdc    # force the close
1411         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1412
1413         #bz20647: make sure all pids are exists before failover
1414         [ -d /proc/$close_pid ] || error "close_pid doesn't exist"
1415         [ -d /proc/$open_pid ] || error "open_pid doesn't exists"
1416         replay_barrier_nodf $SINGLEMDS
1417         fail_nodf $SINGLEMDS
1418         wait $open_pid || error "open_pid failed"
1419         sleep 2
1420         # close should be gone
1421         [ -d /proc/$close_pid ] && error "close_pid should not exist"
1422
1423         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1424                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1425         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1426                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1427         rm -rf $DIR/${tdir}-*
1428 }
1429 run_test 53g "|X| drop open reply and close request while close and open are both in flight"
1430
1431 test_53h() {
1432         cancel_lru_locks mdc    # cleanup locks from former test cases
1433
1434         mkdir $DIR/${tdir}-1 || error "mkdir $DIR/${tdir}-1 failed"
1435         mkdir $DIR/${tdir}-2 || error "mkdir $DIR/${tdir}-2 failed"
1436         multiop $DIR/${tdir}-1/f O_c &
1437         close_pid=$!
1438
1439         #define OBD_FAIL_MDS_REINT_NET 0x107
1440         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
1441         mcreate $DIR/${tdir}-2/f &
1442         open_pid=$!
1443         sleep 1
1444
1445         #define OBD_FAIL_MDS_CLOSE_NET_REP 0x13b
1446         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000013b"
1447         kill -USR1 $close_pid
1448         cancel_lru_locks mdc    # force the close
1449         sleep 1
1450
1451         #bz20647: make sure all pids are exists before failover
1452         [ -d /proc/$close_pid ] || error "close_pid doesn't exist"
1453         [ -d /proc/$open_pid ] || error "open_pid doesn't exists"
1454         replay_barrier_nodf $SINGLEMDS
1455         fail_nodf $SINGLEMDS
1456         wait $open_pid || error "open_pid failed"
1457         sleep 2
1458         # close should be gone
1459         [ -d /proc/$close_pid ] && error "close_pid should not exist"
1460         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1461
1462         $CHECKSTAT -t file $DIR/${tdir}-1/f ||
1463                 error "$CHECKSTAT $DIR/${tdir}-1/f attribute check failed"
1464         $CHECKSTAT -t file $DIR/${tdir}-2/f ||
1465                 error "$CHECKSTAT $DIR/${tdir}-2/f attribute check failed"
1466         rm -rf $DIR/${tdir}-*
1467 }
1468 run_test 53h "open request and close reply while two MDC requests in flight"
1469
1470 #b3761 ASSERTION(hash != 0) failed
1471 test_55() {
1472 # OBD_FAIL_MDS_OPEN_CREATE | OBD_FAIL_ONCE
1473     do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000012b"
1474     touch $DIR/$tfile &
1475     # give touch a chance to run
1476     sleep 5
1477     do_facet $SINGLEMDS "lctl set_param fail_loc=0x0"
1478     rm $DIR/$tfile
1479     return 0
1480 }
1481 run_test 55 "let MDS_CHECK_RESENT return the original return code instead of 0"
1482
1483 #b3440 ASSERTION(rec->ur_fid2->id) failed
1484 test_56() {
1485     ln -s foo $DIR/$tfile
1486     replay_barrier $SINGLEMDS
1487     #drop_reply "cat $DIR/$tfile"
1488     fail $SINGLEMDS
1489     sleep 10
1490 }
1491 run_test 56 "don't replay a symlink open request (3440)"
1492
1493 #recovery one mds-ost setattr from llog
1494 test_57() {
1495         #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1496         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000012c"
1497         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
1498         replay_barrier $SINGLEMDS
1499         fail $SINGLEMDS
1500         sleep 1
1501         $CHECKSTAT -t file $DIR/$tfile ||
1502                 error "$CHECKSTAT $DIR/$tfile attribute check failed"
1503         do_facet $SINGLEMDS "lctl set_param fail_loc=0x0"
1504         rm $DIR/$tfile
1505 }
1506 run_test 57 "test recovery from llog for setattr op"
1507
1508 cleanup_58() {
1509         zconf_umount $(hostname) $MOUNT2
1510         trap - EXIT
1511 }
1512
1513 #recovery many mds-ost setattr from llog
1514 test_58a() {
1515         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1516         #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1517         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000012c"
1518         createmany -o $DIR/$tdir/$tfile-%d 2500
1519         replay_barrier $SINGLEMDS
1520         fail $SINGLEMDS
1521         sleep 2
1522         $CHECKSTAT -t file $DIR/$tdir/$tfile-* >/dev/null ||
1523                 error "$CHECKSTAT $DIR/$tfile-* attribute check failed"
1524         do_facet $SINGLEMDS "lctl set_param fail_loc=0x0"
1525         unlinkmany $DIR/$tdir/$tfile-%d 2500 ||
1526                 error "unlinkmany $DIR/$tfile failed"
1527         rmdir $DIR/$tdir
1528 }
1529 run_test 58a "test recovery from llog for setattr op (test llog_gen_rec)"
1530
1531 test_58b() {
1532         local orig
1533         local new
1534
1535         trap cleanup_58 EXIT
1536
1537         large_xattr_enabled &&
1538                 orig="$(generate_string $(max_xattr_size))" || orig="bar"
1539         # Original extended attribute can be long. Print a small version of
1540         # attribute if an error occurs
1541         local sm_msg=$(printf "%.9s" $orig)
1542
1543         mount_client $MOUNT2 || error "mount_client on $MOUNT2 failed"
1544         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1545         touch $DIR/$tdir/$tfile || error "touch $DIR/$tdir/$tfile failed"
1546         replay_barrier $SINGLEMDS
1547         setfattr -n trusted.foo -v $orig $DIR/$tdir/$tfile
1548         fail $SINGLEMDS
1549         new=$(get_xattr_value trusted.foo $MOUNT2/$tdir/$tfile)
1550         [[ "$new" = "$orig" ]] ||
1551                 error "xattr set ($sm_msg...) differs from xattr get ($new)"
1552         rm -f $DIR/$tdir/$tfile
1553         rmdir $DIR/$tdir
1554         cleanup_58
1555         wait_clients_import_state ${CLIENTS:-$HOSTNAME} "mgs" FULL
1556 }
1557 run_test 58b "test replay of setxattr op"
1558
1559 test_58c() { # bug 16570
1560         local orig
1561         local orig1
1562         local new
1563
1564         trap cleanup_58 EXIT
1565
1566         if large_xattr_enabled; then
1567                 local xattr_size=$(max_xattr_size)
1568                 orig="$(generate_string $((xattr_size / 2)))"
1569                 orig1="$(generate_string $xattr_size)"
1570         else
1571                 orig="bar"
1572                 orig1="bar1"
1573         fi
1574
1575         # PING_INTERVAL max(obd_timeout / 4, 1U)
1576         sleep $((TIMEOUT / 4))
1577
1578         # Original extended attribute can be long. Print a small version of
1579         # attribute if an error occurs
1580         local sm_msg=$(printf "%.9s" $orig)
1581         local sm_msg1=$(printf "%.9s" $orig1)
1582
1583         mount_client $MOUNT2 || error "mount_client on $MOUNT2 failed"
1584         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1585         touch $DIR/$tdir/$tfile || error "touch $DIR/$tdir/$tfile failed"
1586         drop_request "setfattr -n trusted.foo -v $orig $DIR/$tdir/$tfile" ||
1587                 error "drop_request for setfattr failed"
1588         new=$(get_xattr_value trusted.foo $MOUNT2/$tdir/$tfile)
1589         [[ "$new" = "$orig" ]] ||
1590                 error "xattr set ($sm_msg...) differs from xattr get ($new)"
1591         drop_reint_reply "setfattr -n trusted.foo1 \
1592                           -v $orig1 $DIR/$tdir/$tfile" ||
1593                 error "drop_reint_reply for setfattr failed"
1594         new=$(get_xattr_value trusted.foo1 $MOUNT2/$tdir/$tfile)
1595         [[ "$new" = "$orig1" ]] ||
1596                 error "second xattr set ($sm_msg1...) differs xattr get ($new)"
1597         rm -f $DIR/$tdir/$tfile
1598         rmdir $DIR/$tdir
1599         cleanup_58
1600 }
1601 run_test 58c "resend/reconstruct setxattr op"
1602
1603 # log_commit_thread vs filter_destroy race used to lead to import use after free
1604 # bug 11658
1605 test_59() {
1606         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1607
1608         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1609         createmany -o $DIR/$tdir/$tfile-%d 200 ||
1610                 error "createmany create files failed"
1611         sync
1612         unlinkmany $DIR/$tdir/$tfile-%d 200 ||
1613                 error "unlinkmany $DIR/$tdir/$tfile failed"
1614         #define OBD_FAIL_PTLRPC_DELAY_RECOV       0x507
1615         do_facet ost1 "lctl set_param fail_loc=0x507"
1616         fail ost1
1617         fail $SINGLEMDS
1618         do_facet ost1 "lctl set_param fail_loc=0x0"
1619         sleep 20
1620         rmdir $DIR/$tdir
1621 }
1622 run_test 59 "test log_commit_thread vs filter_destroy race"
1623
1624 # race between add unlink llog vs cat log init in post_recovery (only for b1_6)
1625 # bug 12086: should no oops and No ctxt error for this test
1626 test_60() {
1627         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1628         createmany -o $DIR/$tdir/$tfile-%d 200 ||
1629                 error "createmany create files failed"
1630         replay_barrier $SINGLEMDS
1631         unlinkmany $DIR/$tdir/$tfile-%d 0 100
1632         fail $SINGLEMDS
1633         unlinkmany $DIR/$tdir/$tfile-%d 100 100
1634         local no_ctxt=$(dmesg | grep "No ctxt")
1635         [ -z "$no_ctxt" ] || error "ctxt is not initialized in recovery"
1636 }
1637 run_test 60 "test llog post recovery init vs llog unlink"
1638
1639 #test race  llog recovery thread vs llog cleanup
1640 test_61a() {    # was test_61
1641         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1642
1643         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1644         createmany -o $DIR/$tdir/$tfile-%d 800 ||
1645                 error "createmany create files failed"
1646         replay_barrier ost1
1647         unlinkmany $DIR/$tdir/$tfile-%d 800
1648         #   OBD_FAIL_OST_LLOG_RECOVERY_TIMEOUT 0x221
1649         set_nodes_failloc "$(osts_nodes)" 0x80000221
1650         facet_failover ost1
1651         sleep 10
1652         fail ost1
1653         sleep 30
1654         set_nodes_failloc "$(osts_nodes)" 0x0
1655
1656         $CHECKSTAT -t file $DIR/$tdir/$tfile-* &&
1657                 error "$CHECKSTAT $DIR/$tdir/$tfile attribute check should fail"
1658         rmdir $DIR/$tdir
1659 }
1660 run_test 61a "test race llog recovery vs llog cleanup"
1661
1662 #test race  mds llog sync vs llog cleanup
1663 test_61b() {
1664         #   OBD_FAIL_MDS_LLOG_SYNC_TIMEOUT 0x13a
1665         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000013a"
1666         facet_failover $SINGLEMDS
1667         sleep 10
1668         fail $SINGLEMDS
1669         do_facet client dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 ||
1670                 error "dd failed"
1671 }
1672 run_test 61b "test race mds llog sync vs llog cleanup"
1673
1674 #test race  cancel cookie cb vs llog cleanup
1675 test_61c() {
1676         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1677
1678         #   OBD_FAIL_OST_CANCEL_COOKIE_TIMEOUT 0x222
1679         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
1680         set_nodes_failloc "$(osts_nodes)" 0x80000222
1681         rm $DIR/$tfile
1682         sleep 10
1683         fail ost1
1684         set_nodes_failloc "$(osts_nodes)" 0x0
1685 }
1686 run_test 61c "test race mds llog sync vs llog cleanup"
1687
1688 test_61d() { # bug 16002 # bug 17466 # bug 22137
1689 #   OBD_FAIL_OBD_LLOG_SETUP        0x605
1690     stop mgs
1691     do_facet mgs "lctl set_param fail_loc=0x80000605"
1692     start mgs $(mgsdevname) $MGS_MOUNT_OPTS &&
1693         error "mgs start should have failed"
1694     do_facet mgs "lctl set_param fail_loc=0"
1695     start mgs $(mgsdevname) $MGS_MOUNT_OPTS || error "cannot restart mgs"
1696 }
1697 run_test 61d "error in llog_setup should cleanup the llog context correctly"
1698
1699 test_62() { # Bug 15756 - don't mis-drop resent replay
1700         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1701         replay_barrier $SINGLEMDS
1702         createmany -o $DIR/$tdir/$tfile- 25 ||
1703                 error "createmany create files failed"
1704         #define OBD_FAIL_TGT_REPLAY_DROP         0x707
1705         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000707"
1706         fail $SINGLEMDS
1707         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1708         unlinkmany $DIR/$tdir/$tfile- 25 ||
1709                 error "unlinkmany $DIR/$tdir/$tfile failed"
1710         return 0
1711 }
1712 run_test 62 "don't mis-drop resent replay"
1713
1714 #Adaptive Timeouts (bug 3055)
1715 AT_MAX_SET=0
1716
1717 at_cleanup () {
1718     local var
1719     local facet
1720     local at_new
1721
1722     echo "Cleaning up AT ..."
1723     if [ -n "$ATOLDBASE" ]; then
1724         local at_history=$($LCTL get_param -n at_history)
1725         do_facet $SINGLEMDS "lctl set_param at_history=$at_history" || true
1726         do_facet ost1 "lctl set_param at_history=$at_history" || true
1727     fi
1728
1729         if [ $AT_MAX_SET -ne 0 ]; then
1730                 for facet in mds client ost; do
1731                         var=AT_MAX_SAVE_${facet}
1732                         echo restore AT on $facet to saved value ${!var}
1733                         at_max_set ${!var} $facet
1734                         at_new=$(at_max_get $facet)
1735                         echo Restored AT value on $facet $at_new
1736                         [ $at_new -eq ${!var} ] ||
1737                         error "AT value not restored SAVED ${!var} NEW $at_new"
1738                 done
1739         fi
1740 }
1741
1742 at_start()
1743 {
1744     local at_max_new=600
1745
1746     # Save at_max original values
1747     local facet
1748     if [ $AT_MAX_SET -eq 0 ]; then
1749         # Suppose that all osts have the same at_max
1750         for facet in mds client ost; do
1751             eval AT_MAX_SAVE_${facet}=$(at_max_get $facet)
1752         done
1753     fi
1754     local at_max
1755     for facet in mds client ost; do
1756         at_max=$(at_max_get $facet)
1757         if [ $at_max -ne $at_max_new ]; then
1758             echo "AT value on $facet is $at_max, set it by force temporarily to $at_max_new"
1759             at_max_set $at_max_new $facet
1760             AT_MAX_SET=1
1761         fi
1762     done
1763
1764     if [ -z "$ATOLDBASE" ]; then
1765         ATOLDBASE=$(do_facet $SINGLEMDS "lctl get_param -n at_history")
1766         # speed up the timebase so we can check decreasing AT
1767         do_facet $SINGLEMDS "lctl set_param at_history=8" || true
1768         do_facet ost1 "lctl set_param at_history=8" || true
1769
1770         # sleep for a while to cool down, should be > 8s and also allow
1771         # at least one ping to be sent. simply use TIMEOUT to be safe.
1772         sleep $TIMEOUT
1773     fi
1774 }
1775
1776 test_65a() #bug 3055
1777 {
1778     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1779
1780     at_start || return 0
1781     $LCTL dk > /dev/null
1782     debugsave
1783     $LCTL set_param debug="other"
1784     # Slow down a request to the current service time, this is critical
1785     # because previous tests may have caused this value to increase.
1786     REQ_DELAY=`lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts |
1787                awk '/portal 12/ {print $5}'`
1788     REQ_DELAY=$((${REQ_DELAY} + ${REQ_DELAY} / 4 + 5))
1789
1790     do_facet $SINGLEMDS lctl set_param fail_val=$((${REQ_DELAY} * 1000))
1791 #define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
1792     do_facet $SINGLEMDS $LCTL set_param fail_loc=0x8000050a
1793     createmany -o $DIR/$tfile 10 > /dev/null
1794     unlinkmany $DIR/$tfile 10 > /dev/null
1795     # check for log message
1796     $LCTL dk | grep "Early reply #" || error "No early reply"
1797     debugrestore
1798     # client should show REQ_DELAY estimates
1799     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep portal
1800     sleep 9
1801     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep portal
1802 }
1803 run_test 65a "AT: verify early replies"
1804
1805 test_65b() #bug 3055
1806 {
1807     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1808
1809     at_start || return 0
1810     # turn on D_ADAPTTO
1811     debugsave
1812     $LCTL set_param debug="other trace"
1813     $LCTL dk > /dev/null
1814     # Slow down a request to the current service time, this is critical
1815     # because previous tests may have caused this value to increase.
1816     $SETSTRIPE --stripe-index=0 --count=1 $DIR/$tfile
1817     multiop $DIR/$tfile Ow1yc
1818     REQ_DELAY=`lctl get_param -n osc.${FSNAME}-OST0000-osc-*.timeouts |
1819                awk '/portal 6/ {print $5}'`
1820     REQ_DELAY=$((${REQ_DELAY} + ${REQ_DELAY} / 4 + 5))
1821
1822     do_facet ost1 lctl set_param fail_val=${REQ_DELAY}
1823 #define OBD_FAIL_OST_BRW_PAUSE_PACK      0x224
1824     do_facet ost1 $LCTL set_param fail_loc=0x224
1825
1826     rm -f $DIR/$tfile
1827     $SETSTRIPE --stripe-index=0 --count=1 $DIR/$tfile
1828     # force some real bulk transfer
1829     multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
1830
1831     do_facet ost1 $LCTL set_param fail_loc=0
1832     # check for log message
1833     $LCTL dk | grep "Early reply #" || error "No early reply"
1834     debugrestore
1835     # client should show REQ_DELAY estimates
1836     lctl get_param -n osc.${FSNAME}-OST0000-osc-*.timeouts | grep portal
1837 }
1838 run_test 65b "AT: verify early replies on packed reply / bulk"
1839
1840 test_66a() #bug 3055
1841 {
1842     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1843
1844     at_start || return 0
1845     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1846     # adjust 5s at a time so no early reply is sent (within deadline)
1847     do_facet $SINGLEMDS "$LCTL set_param fail_val=5000"
1848 #define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
1849     do_facet $SINGLEMDS "$LCTL set_param fail_loc=0x8000050a"
1850     createmany -o $DIR/$tfile 20 > /dev/null
1851     unlinkmany $DIR/$tfile 20 > /dev/null
1852     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1853     do_facet $SINGLEMDS "$LCTL set_param fail_val=10000"
1854     do_facet $SINGLEMDS "$LCTL set_param fail_loc=0x8000050a"
1855     createmany -o $DIR/$tfile 20 > /dev/null
1856     unlinkmany $DIR/$tfile 20 > /dev/null
1857     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1858     do_facet $SINGLEMDS "$LCTL set_param fail_loc=0"
1859     sleep 9
1860     createmany -o $DIR/$tfile 20 > /dev/null
1861     unlinkmany $DIR/$tfile 20 > /dev/null
1862     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1863     CUR=$(lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | awk '/portal 12/ {print $5}')
1864     WORST=$(lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | awk '/portal 12/ {print $7}')
1865     echo "Current MDT timeout $CUR, worst $WORST"
1866     [ $CUR -lt $WORST ] || error "Current $CUR should be less than worst $WORST"
1867 }
1868 run_test 66a "AT: verify MDT service time adjusts with no early replies"
1869
1870 test_66b() #bug 3055
1871 {
1872         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1873
1874         at_start || return 0
1875         ORIG=$(lctl get_param -n mdc.${FSNAME}-MDT0000*.timeouts |
1876                 awk '/network/ {print $4}')
1877         $LCTL set_param fail_val=$(($ORIG + 5))
1878         #define OBD_FAIL_PTLRPC_PAUSE_REP      0x50c
1879         $LCTL set_param fail_loc=0x50c
1880         ls $DIR/$tfile > /dev/null 2>&1
1881         $LCTL set_param fail_loc=0
1882         CUR=$(lctl get_param -n mdc.${FSNAME}-MDT0000*.timeouts |
1883                 awk '/network/ {print $4}')
1884         WORST=$(lctl get_param -n mdc.${FSNAME}-MDT0000*.timeouts |
1885                 awk '/network/ {print $6}')
1886         echo "network timeout orig $ORIG, cur $CUR, worst $WORST"
1887         [ $WORST -gt $ORIG ] ||
1888                 error "Worst $WORST should be worse than orig $ORIG"
1889 }
1890 run_test 66b "AT: verify net latency adjusts"
1891
1892 test_67a() #bug 3055
1893 {
1894     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1895
1896     at_start || return 0
1897     CONN1=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1898     # sleeping threads may drive values above this
1899     do_facet ost1 "$LCTL set_param fail_val=400"
1900 #define OBD_FAIL_PTLRPC_PAUSE_REQ    0x50a
1901     do_facet ost1 "$LCTL set_param fail_loc=0x50a"
1902     createmany -o $DIR/$tfile 20 > /dev/null
1903     unlinkmany $DIR/$tfile 20 > /dev/null
1904     do_facet ost1 "$LCTL set_param fail_loc=0"
1905     CONN2=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1906     ATTEMPTS=$(($CONN2 - $CONN1))
1907     echo "$ATTEMPTS osc reconnect attempts on gradual slow"
1908         [ $ATTEMPTS -gt 0 ] &&
1909                 error_ignore bz13721 "AT should have prevented reconnect"
1910         return 0
1911 }
1912 run_test 67a "AT: verify slow request processing doesn't induce reconnects"
1913
1914 test_67b() #bug 3055
1915 {
1916     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1917
1918     at_start || return 0
1919     CONN1=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1920
1921     # exhaust precreations on ost1
1922     local OST=$(ostname_from_index 0)
1923     local mdtosc=$(get_mdtosc_proc_path mds $OST)
1924     local last_id=$(do_facet $SINGLEMDS lctl get_param -n \
1925         osc.$mdtosc.prealloc_last_id)
1926     local next_id=$(do_facet $SINGLEMDS lctl get_param -n \
1927         osc.$mdtosc.prealloc_next_id)
1928
1929         mkdir -p $DIR/$tdir/${OST} || error "mkdir $DIR/$tdir/${OST} failed"
1930         $SETSTRIPE -i 0 -c 1 $DIR/$tdir/${OST} || error "$SETSTRIPE failed"
1931         echo "Creating to objid $last_id on ost $OST..."
1932 #define OBD_FAIL_OST_PAUSE_CREATE        0x223
1933     do_facet ost1 "$LCTL set_param fail_val=20000"
1934     do_facet ost1 "$LCTL set_param fail_loc=0x80000223"
1935     createmany -o $DIR/$tdir/${OST}/f $next_id $((last_id - next_id + 2))
1936
1937     client_reconnect
1938     do_facet ost1 "lctl get_param -n ost.OSS.ost_create.timeouts"
1939     log "phase 2"
1940     CONN2=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1941     ATTEMPTS=$(($CONN2 - $CONN1))
1942     echo "$ATTEMPTS osc reconnect attempts on instant slow"
1943     # do it again; should not timeout
1944     do_facet ost1 "$LCTL set_param fail_loc=0x80000223"
1945     cp /etc/profile $DIR/$tfile || error "cp failed"
1946     do_facet ost1 "$LCTL set_param fail_loc=0"
1947     client_reconnect
1948     do_facet ost1 "lctl get_param -n ost.OSS.ost_create.timeouts"
1949     CONN3=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1950     ATTEMPTS=$(($CONN3 - $CONN2))
1951     echo "$ATTEMPTS osc reconnect attempts on 2nd slow"
1952     [ $ATTEMPTS -gt 0 ] && error "AT should have prevented reconnect"
1953     return 0
1954 }
1955 run_test 67b "AT: verify instant slowdown doesn't induce reconnects"
1956
1957 test_68 () #bug 13813
1958 {
1959     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1960
1961     at_start || return 0
1962     local ldlm_enqueue_min=$(find /sys -name ldlm_enqueue_min)
1963     [ -z "$ldlm_enqueue_min" ] && skip "missing /sys/.../ldlm_enqueue_min" && return 0
1964     local ldlm_enqueue_min_r=$(do_facet ost1 "find /sys -name ldlm_enqueue_min")
1965     [ -z "$ldlm_enqueue_min_r" ] && skip "missing /sys/.../ldlm_enqueue_min in the ost1" && return 0
1966     local ENQ_MIN=$(cat $ldlm_enqueue_min)
1967     local ENQ_MIN_R=$(do_facet ost1 "cat $ldlm_enqueue_min_r")
1968         echo $TIMEOUT >> $ldlm_enqueue_min
1969         do_facet ost1 "echo $TIMEOUT >> $ldlm_enqueue_min_r"
1970
1971         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
1972         $SETSTRIPE --stripe-index=0 --count=1 $DIR/$tdir
1973 #define OBD_FAIL_LDLM_PAUSE_CANCEL       0x312
1974     $LCTL set_param fail_val=$(($TIMEOUT - 1))
1975     $LCTL set_param fail_loc=0x80000312
1976     cp /etc/profile $DIR/$tdir/${tfile}_1 || error "1st cp failed $?"
1977     $LCTL set_param fail_val=$((TIMEOUT * 5 / 4))
1978     $LCTL set_param fail_loc=0x80000312
1979     cp /etc/profile $DIR/$tdir/${tfile}_2 || error "2nd cp failed $?"
1980     $LCTL set_param fail_loc=0
1981
1982     echo $ENQ_MIN >> $ldlm_enqueue_min
1983     do_facet ost1 "echo $ENQ_MIN_R >> $ldlm_enqueue_min_r"
1984     rm -rf $DIR/$tdir
1985     return 0
1986 }
1987 run_test 68 "AT: verify slowing locks"
1988
1989 at_cleanup
1990 # end of AT tests includes above lines
1991
1992 # start multi-client tests
1993 test_70a () {
1994         [ -z "$CLIENTS" ] &&
1995                 { skip "Need two or more clients." && return; }
1996         [ $CLIENTCOUNT -lt 2 ] &&
1997                 { skip "Need two or more clients, have $CLIENTCOUNT" && return; }
1998
1999         echo "mount clients $CLIENTS ..."
2000         zconf_mount_clients $CLIENTS $MOUNT
2001
2002         local clients=${CLIENTS//,/ }
2003         echo "Write/read files on $DIR ; clients $CLIENTS ... "
2004         for CLIENT in $clients; do
2005                 do_node $CLIENT dd bs=1M count=10 if=/dev/zero \
2006                         of=$DIR/${tfile}_${CLIENT} 2>/dev/null ||
2007                                 error "dd failed on $CLIENT"
2008         done
2009
2010         local prev_client=$(echo $clients | sed 's/^.* \(.\+\)$/\1/')
2011         for C in ${CLIENTS//,/ }; do
2012                 do_node $prev_client dd if=$DIR/${tfile}_${C} \
2013                         of=/dev/null 2>/dev/null ||
2014                         error "dd if=$DIR/${tfile}_${C} failed on $prev_client"
2015                 prev_client=$C
2016         done
2017
2018         ls $DIR
2019 }
2020 run_test 70a "check multi client t-f"
2021
2022 check_for_process () {
2023         local clients=$1
2024         shift
2025         local prog=$@
2026
2027         killall_process $clients "$prog" -0
2028 }
2029
2030 killall_process () {
2031         local clients=${1:-$(hostname)}
2032         local name=$2
2033         local signal=$3
2034         local rc=0
2035
2036         do_nodes $clients "killall $signal $name"
2037 }
2038
2039 test_70b () {
2040         local clients=${CLIENTS:-$HOSTNAME}
2041
2042         zconf_mount_clients $clients $MOUNT
2043
2044         local duration=300
2045         [ "$SLOW" = "no" ] && duration=120
2046         # set duration to 900 because it takes some time to boot node
2047         [ "$FAILURE_MODE" = HARD ] && duration=900
2048
2049         local elapsed
2050         local start_ts=$(date +%s)
2051         local cmd="rundbench 1 -t $duration"
2052         local pid=""
2053         if [ $MDSCOUNT -ge 2 ]; then
2054                 test_mkdir -p -c$MDSCOUNT $DIR/$tdir
2055                 $LFS setdirstripe -D -c$MDSCOUNT $DIR/$tdir
2056         fi
2057         do_nodesv $clients "set -x; MISSING_DBENCH_OK=$MISSING_DBENCH_OK \
2058                 PATH=\$PATH:$LUSTRE/utils:$LUSTRE/tests/:$DBENCH_LIB \
2059                 DBENCH_LIB=$DBENCH_LIB TESTSUITE=$TESTSUITE TESTNAME=$TESTNAME \
2060                 MOUNT=$MOUNT DIR=$DIR/$tdir/\\\$(hostname) LCTL=$LCTL $cmd" &
2061         pid=$!
2062
2063         #LU-1897 wait for all dbench copies to start
2064         while ! check_for_process $clients dbench; do
2065                 elapsed=$(($(date +%s) - start_ts))
2066                 if [ $elapsed -gt $duration ]; then
2067                         killall_process $clients dbench
2068                         error "dbench failed to start on $clients!"
2069                 fi
2070                 sleep 1
2071         done
2072
2073         log "Started rundbench load pid=$pid ..."
2074
2075         elapsed=$(($(date +%s) - start_ts))
2076         local num_failovers=0
2077         local fail_index=1
2078         while [ $elapsed -lt $duration ]; do
2079                 if ! check_for_process $clients dbench; then
2080                         error_noexit "dbench stopped on some of $clients!"
2081                         killall_process $clients dbench
2082                         break
2083                 fi
2084                 sleep 1
2085                 replay_barrier mds$fail_index
2086                 sleep 1 # give clients a time to do operations
2087                 # Increment the number of failovers
2088                 num_failovers=$((num_failovers+1))
2089                 log "$TESTNAME fail mds$fail_index $num_failovers times"
2090                 fail mds$fail_index
2091                 elapsed=$(($(date +%s) - start_ts))
2092                 if [ $fail_index -ge $MDSCOUNT ]; then
2093                         fail_index=1
2094                 else
2095                         fail_index=$((fail_index+1))
2096                 fi
2097         done
2098
2099         wait $pid || error "rundbench load on $clients failed!"
2100 }
2101 run_test 70b "dbench ${MDSCOUNT}mdts recovery; $CLIENTCOUNT clients"
2102 # end multi-client tests
2103
2104 test_73a() {
2105         multiop_bg_pause $DIR/$tfile O_tSc ||
2106                 error "multiop_bg_pause $DIR/$tfile failed"
2107         pid=$!
2108         rm -f $DIR/$tfile
2109
2110         replay_barrier $SINGLEMDS
2111         #define OBD_FAIL_LDLM_ENQUEUE_NET                       0x302
2112         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000302"
2113         fail $SINGLEMDS
2114         kill -USR1 $pid
2115         wait $pid || error "multiop pid failed"
2116         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
2117         return 0
2118 }
2119 run_test 73a "open(O_CREAT), unlink, replay, reconnect before open replay, close"
2120
2121 test_73b() {
2122         multiop_bg_pause $DIR/$tfile O_tSc ||
2123                 error "multiop_bg_pause $DIR/$tfile failed"
2124         pid=$!
2125         rm -f $DIR/$tfile
2126
2127         replay_barrier $SINGLEMDS
2128         #define OBD_FAIL_LDLM_REPLY       0x30c
2129         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000030c"
2130         fail $SINGLEMDS
2131         kill -USR1 $pid
2132         wait $pid || error "multiop pid failed"
2133         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
2134         return 0
2135 }
2136 run_test 73b "open(O_CREAT), unlink, replay, reconnect at open_replay reply, close"
2137
2138 # bug 18554
2139 test_74() {
2140         local clients=${CLIENTS:-$HOSTNAME}
2141
2142         zconf_umount_clients $clients $MOUNT
2143         stop ost1
2144         facet_failover $SINGLEMDS
2145         zconf_mount_clients $clients $MOUNT
2146         mount_facet ost1
2147         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
2148         rm $DIR/$tfile || error "rm $DIR/$tfile failed"
2149         clients_up || error "client evicted: $?"
2150         return 0
2151 }
2152 run_test 74 "Ensure applications don't fail waiting for OST recovery"
2153
2154 remote_dir_check_80() {
2155         local MDTIDX=1
2156         local diridx
2157         local fileidx
2158
2159         diridx=$($GETSTRIPE -M $remote_dir) ||
2160                 error "$GETSTRIPE -M $remote_dir failed"
2161         [ $diridx -eq $MDTIDX ] || error "$diridx != $MDTIDX"
2162
2163         createmany -o $remote_dir/f-%d 20 || error "creation failed"
2164         fileidx=$($GETSTRIPE -M $remote_dir/f-1) ||
2165                 error "$GETSTRIPE -M $remote_dir/f-1 failed"
2166         [ $fileidx -eq $MDTIDX ] || error "$fileidx != $MDTIDX"
2167
2168         return 0
2169 }
2170
2171 test_80a() {
2172         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2173         ([ $FAILURE_MODE == "HARD" ] &&
2174                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2175                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2176                 return 0
2177
2178         local MDTIDX=1
2179         local remote_dir=$DIR/$tdir/remote_dir
2180
2181         mkdir -p $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2182         #define OBD_FAIL_OUT_UPDATE_NET_REP     0x1701
2183         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2184         $LFS mkdir -i $MDTIDX $remote_dir &
2185         local CLIENT_PID=$!
2186
2187         replay_barrier mds1
2188         fail mds${MDTIDX}
2189
2190         wait $CLIENT_PID || error "remote creation failed"
2191
2192         remote_dir_check_80 || error "remote dir check failed"
2193         rm -rf $DIR/$tdir || error "rmdir failed"
2194
2195         return 0
2196 }
2197 run_test 80a "DNE: create remote dir, drop update rep from MDT0, fail MDT0"
2198
2199 test_80b() {
2200         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2201         ([ $FAILURE_MODE == "HARD" ] &&
2202                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2203                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2204                 return 0
2205
2206         local MDTIDX=1
2207         local remote_dir=$DIR/$tdir/remote_dir
2208
2209         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2210         #define OBD_FAIL_UPDATE_OBJ_NET_REP     0x1701
2211         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2212         $LFS mkdir -i $MDTIDX $remote_dir &
2213         local CLIENT_PID=$!
2214
2215         replay_barrier mds1
2216         replay_barrier mds2
2217         fail mds$((MDTIDX + 1))
2218
2219         wait $CLIENT_PID || error "remote creation failed"
2220
2221         remote_dir_check_80 || error "remote dir check failed"
2222         rm -rf $DIR/$tdir || error "rmdir failed"
2223
2224         return 0
2225 }
2226 run_test 80b "DNE: create remote dir, drop update rep from MDT0, fail MDT1"
2227
2228 test_80c() {
2229         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2230         ([ $FAILURE_MODE == "HARD" ] &&
2231                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2232                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2233                 return 0
2234
2235         local MDTIDX=1
2236         local remote_dir=$DIR/$tdir/remote_dir
2237
2238         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2239         #define OBD_FAIL_UPDATE_OBJ_NET_REP     0x1701
2240         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2241         $LFS mkdir -i $MDTIDX $remote_dir &
2242         local CLIENT_PID=$!
2243
2244         replay_barrier mds1
2245         replay_barrier mds2
2246         fail mds${MDTIDX}
2247         fail mds$((MDTIDX + 1))
2248
2249         wait $CLIENT_PID || error "remote creation failed"
2250
2251         remote_dir_check_80 || error "remote dir check failed"
2252         rm -rf $DIR/$tdir || error "rmdir failed"
2253
2254         return 0
2255 }
2256 run_test 80c "DNE: create remote dir, drop update rep from MDT1, fail MDT[0,1]"
2257
2258 test_80d() {
2259         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2260         local MDTIDX=1
2261         local remote_dir=$DIR/$tdir/remote_dir
2262
2263         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2264         #define OBD_FAIL_UPDATE_OBJ_NET_REP     0x1701
2265         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2266         $LFS mkdir -i $MDTIDX $remote_dir &
2267         local CLIENT_PID=$!
2268
2269         # sleep 3 seconds to make sure MDTs are failed after
2270         # lfs mkdir -i has finished on all of MDTs.
2271         sleep 3
2272
2273         replay_barrier mds1
2274         replay_barrier mds2
2275         fail mds${MDTIDX},mds$((MDTIDX + 1))
2276
2277         wait $CLIENT_PID || error "remote creation failed"
2278
2279         remote_dir_check_80 || error "remote dir check failed"
2280         rm -rf $DIR/$tdir || error "rmdir failed"
2281
2282         return 0
2283 }
2284 run_test 80d "DNE: create remote dir, drop update rep from MDT1, fail 2 MDTs"
2285
2286 test_80e() {
2287         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2288         ([ $FAILURE_MODE == "HARD" ] &&
2289                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2290                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2291                 return 0
2292
2293         local MDTIDX=1
2294         local remote_dir=$DIR/$tdir/remote_dir
2295
2296         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2297         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2298         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2299         $LFS mkdir -i $MDTIDX $remote_dir &
2300         local CLIENT_PID=$!
2301
2302         # sleep 3 seconds to make sure MDTs are failed after
2303         # lfs mkdir -i has finished on all of MDTs.
2304         sleep 3
2305
2306         replay_barrier mds1
2307         fail mds${MDTIDX}
2308
2309         wait $CLIENT_PID || error "remote creation failed"
2310
2311         remote_dir_check_80 || error "remote dir check failed"
2312         rm -rf $DIR/$tdir || error "rmdir failed"
2313
2314         return 0
2315 }
2316 run_test 80e "DNE: create remote dir, drop MDT1 rep, fail MDT0"
2317
2318 test_80f() {
2319         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2320         ([ $FAILURE_MODE == "HARD" ] &&
2321                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2322                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2323                 return 0
2324         local MDTIDX=1
2325         local remote_dir=$DIR/$tdir/remote_dir
2326
2327         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2328         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2329         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2330         $LFS mkdir -i $MDTIDX $remote_dir &
2331         local CLIENT_PID=$!
2332
2333         replay_barrier mds2
2334         fail mds$((MDTIDX + 1))
2335
2336         wait $CLIENT_PID || error "remote creation failed"
2337
2338         remote_dir_check_80 || error "remote dir check failed"
2339         rm -rf $DIR/$tdir || error "rmdir failed"
2340
2341         return 0
2342 }
2343 run_test 80f "DNE: create remote dir, drop MDT1 rep, fail MDT1"
2344
2345 test_80g() {
2346         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2347         ([ $FAILURE_MODE == "HARD" ] &&
2348                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2349                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2350                 return 0
2351
2352         local MDTIDX=1
2353         local remote_dir=$DIR/$tdir/remote_dir
2354
2355         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2356         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2357         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2358         $LFS mkdir -i $MDTIDX $remote_dir &
2359         local CLIENT_PID=$!
2360
2361         # sleep 3 seconds to make sure MDTs are failed after
2362         # lfs mkdir -i has finished on all of MDTs.
2363         sleep 3
2364
2365         replay_barrier mds1
2366         replay_barrier mds2
2367         fail mds${MDTIDX}
2368         fail mds$((MDTIDX + 1))
2369
2370         wait $CLIENT_PID || error "remote creation failed"
2371
2372         remote_dir_check_80 || error "remote dir check failed"
2373         rm -rf $DIR/$tdir || error "rmdir failed"
2374
2375         return 0
2376 }
2377 run_test 80g "DNE: create remote dir, drop MDT1 rep, fail MDT0, then MDT1"
2378
2379 test_80h() {
2380         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2381         local MDTIDX=1
2382         local remote_dir=$DIR/$tdir/remote_dir
2383
2384         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2385         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2386         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2387         $LFS mkdir -i $MDTIDX $remote_dir &
2388         local CLIENT_PID=$!
2389
2390         # sleep 3 seconds to make sure MDTs are failed after
2391         # lfs mkdir -i has finished on all of MDTs.
2392         sleep 3
2393
2394         replay_barrier mds1
2395         replay_barrier mds2
2396         fail mds${MDTIDX},mds$((MDTIDX + 1))
2397
2398         wait $CLIENT_PID || error "remote dir creation failed"
2399
2400         remote_dir_check_80 || error "remote dir check failed"
2401         rm -rf $DIR/$tdir || error "rmdir failed"
2402
2403         return 0
2404 }
2405 run_test 80h "DNE: create remote dir, drop MDT1 rep, fail 2 MDTs"
2406
2407 test_81a() {
2408         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2409         ([ $FAILURE_MODE == "HARD" ] &&
2410                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2411                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2412                 return 0
2413
2414         local MDTIDX=1
2415         local remote_dir=$DIR/$tdir/remote_dir
2416
2417         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2418         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2419
2420         touch $remote_dir || error "touch $remote_dir failed"
2421         # OBD_FAIL_OBJ_UPDATE_NET_REP       0x1701
2422         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2423         rmdir $remote_dir &
2424         local CLIENT_PID=$!
2425
2426         replay_barrier mds2
2427         fail mds$((MDTIDX + 1))
2428
2429         wait $CLIENT_PID || error "rm remote dir failed"
2430
2431         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2432
2433         rm -rf $DIR/$tdir || error "rmdir failed"
2434
2435         return 0
2436 }
2437 run_test 81a "DNE: unlink remote dir, drop MDT0 update rep,  fail MDT1"
2438
2439 test_81b() {
2440         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2441         ([ $FAILURE_MODE == "HARD" ] &&
2442                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2443                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2444                 return 0
2445         local MDTIDX=1
2446         local remote_dir=$DIR/$tdir/remote_dir
2447
2448         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2449         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2450
2451         # OBD_FAIL_OBJ_UPDATE_NET_REP       0x1701
2452         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2453         rmdir $remote_dir &
2454         local CLIENT_PID=$!
2455
2456         replay_barrier mds1
2457         fail mds${MDTIDX}
2458
2459         wait $CLIENT_PID || error "rm remote dir failed"
2460
2461         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2462
2463         rm -rf $DIR/$tdir || error "rmdir failed"
2464
2465         return 0
2466 }
2467 run_test 81b "DNE: unlink remote dir, drop MDT0 update reply,  fail MDT0"
2468
2469 test_81c() {
2470         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2471         ([ $FAILURE_MODE == "HARD" ] &&
2472                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2473                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2474                 return 0
2475
2476         local MDTIDX=1
2477         local remote_dir=$DIR/$tdir/remote_dir
2478
2479         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2480         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2481
2482         # OBD_FAIL_OBJ_UPDATE_NET_REP       0x1701
2483         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2484         rmdir $remote_dir &
2485         local CLIENT_PID=$!
2486
2487         replay_barrier mds1
2488         replay_barrier mds2
2489         fail mds${MDTIDX}
2490         fail mds$((MDTIDX + 1))
2491
2492         wait $CLIENT_PID || error "rm remote dir failed"
2493
2494         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2495
2496         rm -rf $DIR/$tdir || error "rmdir failed"
2497
2498         return 0
2499 }
2500 run_test 81c "DNE: unlink remote dir, drop MDT0 update reply, fail MDT0,MDT1"
2501
2502 test_81d() {
2503         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2504         local MDTIDX=1
2505         local remote_dir=$DIR/$tdir/remote_dir
2506
2507         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2508         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2509
2510         # OBD_FAIL_OBJ_UPDATE_NET_REP       0x1701
2511         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2512         rmdir $remote_dir &
2513         local CLIENT_PID=$!
2514
2515         replay_barrier mds1
2516         replay_barrier mds2
2517         fail mds${MDTIDX},mds$((MDTIDX + 1))
2518
2519         wait $CLIENT_PID || error "rm remote dir failed"
2520
2521         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2522
2523         rm -rf $DIR/$tdir || error "rmdir failed"
2524
2525         return 0
2526 }
2527 run_test 81d "DNE: unlink remote dir, drop MDT0 update reply,  fail 2 MDTs"
2528
2529 test_81e() {
2530         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2531         ([ $FAILURE_MODE == "HARD" ] &&
2532                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2533                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2534                 return 0
2535
2536         local MDTIDX=1
2537         local remote_dir=$DIR/$tdir/remote_dir
2538
2539         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2540         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2541
2542         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2543         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2544         rmdir $remote_dir &
2545         local CLIENT_PID=$!
2546         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0
2547
2548         replay_barrier mds1
2549         fail mds${MDTIDX}
2550
2551         wait $CLIENT_PID || error "rm remote dir failed"
2552
2553         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2554
2555         rm -rf $DIR/$tdir || error "rmdir failed"
2556
2557         return 0
2558 }
2559 run_test 81e "DNE: unlink remote dir, drop MDT1 req reply, fail MDT0"
2560
2561 test_81f() {
2562         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2563         ([ $FAILURE_MODE == "HARD" ] &&
2564                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2565                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2566                 return 0
2567
2568         local MDTIDX=1
2569         local remote_dir=$DIR/$tdir/remote_dir
2570
2571         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2572         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2573
2574         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2575         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2576         rmdir $remote_dir &
2577         local CLIENT_PID=$!
2578
2579         replay_barrier mds2
2580         fail mds$((MDTIDX + 1))
2581
2582         wait $CLIENT_PID || error "rm remote dir failed"
2583
2584         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2585
2586         rm -rf $DIR/$tdir || error "rmdir failed"
2587
2588         return 0
2589 }
2590 run_test 81f "DNE: unlink remote dir, drop MDT1 req reply, fail MDT1"
2591
2592 test_81g() {
2593         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2594         ([ $FAILURE_MODE == "HARD" ] &&
2595                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2596                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2597                 return 0
2598
2599         local MDTIDX=1
2600         local remote_dir=$DIR/$tdir/remote_dir
2601
2602         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2603         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2604
2605         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2606         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2607         rmdir $remote_dir &
2608         local CLIENT_PID=$!
2609
2610         replay_barrier mds1
2611         replay_barrier mds2
2612         fail mds${MDTIDX}
2613         fail mds$((MDTIDX + 1))
2614
2615         wait $CLIENT_PID || error "rm remote dir failed"
2616
2617         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2618
2619         rm -rf $DIR/$tdir || error "rmdir failed"
2620
2621         return 0
2622 }
2623 run_test 81g "DNE: unlink remote dir, drop req reply, fail M0, then M1"
2624
2625 test_81h() {
2626         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2627         local MDTIDX=1
2628         local remote_dir=$DIR/$tdir/remote_dir
2629
2630         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2631         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2632
2633         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2634         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2635         rmdir $remote_dir &
2636         local CLIENT_PID=$!
2637
2638         replay_barrier mds1
2639         replay_barrier mds2
2640         fail mds${MDTIDX},mds$((MDTIDX + 1))
2641
2642         wait $CLIENT_PID || error "rm remote dir failed"
2643
2644         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2645
2646         rm -rf $DIR/$tdir || error "rmdir failed"
2647
2648         return 0
2649 }
2650 run_test 81h "DNE: unlink remote dir, drop request reply, fail 2 MDTs"
2651
2652 test_84a() {
2653 #define OBD_FAIL_MDS_OPEN_WAIT_CREATE  0x144
2654     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000144"
2655     createmany -o $DIR/$tfile- 1 &
2656     PID=$!
2657     mds_evict_client
2658     wait $PID
2659     client_up || client_up || true    # reconnect
2660 }
2661 run_test 84a "stale open during export disconnect"
2662
2663 test_85a() { #bug 16774
2664         lctl set_param -n ldlm.cancel_unused_locks_before_replay "1"
2665
2666         for i in $(seq 100); do
2667                 echo "tag-$i" > $DIR/$tfile-$i
2668                 grep -q "tag-$i" $DIR/$tfile-$i || error "f2-$i"
2669         done
2670
2671         lov_id=$(lctl dl | grep "clilov")
2672         addr=$(echo $lov_id | awk '{print $4}' | awk -F '-' '{print $3}')
2673         count=$(lctl get_param -n \
2674                 ldlm.namespaces.*MDT0000*$addr.lock_unused_count)
2675         echo "before recovery: unused locks count = $count"
2676
2677         fail $SINGLEMDS
2678
2679         count2=$(lctl get_param -n \
2680                  ldlm.namespaces.*MDT0000*$addr.lock_unused_count)
2681         echo "after recovery: unused locks count = $count2"
2682
2683         if [ $count2 -ge $count ]; then
2684                 error "unused locks are not canceled"
2685         fi
2686 }
2687 run_test 85a "check the cancellation of unused locks during recovery(IBITS)"
2688
2689 test_85b() { #bug 16774
2690         lctl set_param -n ldlm.cancel_unused_locks_before_replay "1"
2691
2692         do_facet mgs $LCTL pool_new $FSNAME.$TESTNAME ||
2693                 error "unable to create pool $TESTNAME"
2694         do_facet mgs $LCTL pool_add $FSNAME.$TESTNAME $FSNAME-OST0000 ||
2695                 error "unable to add pool $TESTNAME"
2696
2697         $SETSTRIPE -c 1 -p $FSNAME.$TESTNAME $DIR
2698
2699         for i in $(seq 100); do
2700                 dd if=/dev/urandom of=$DIR/$tfile-$i bs=4096 \
2701                         count=32 >/dev/null 2>&1
2702         done
2703
2704         cancel_lru_locks osc
2705
2706         for i in $(seq 100); do
2707                 dd if=$DIR/$tfile-$i of=/dev/null bs=4096 \
2708                         count=32 >/dev/null 2>&1
2709         done
2710
2711         lov_id=$(lctl dl | grep "clilov")
2712         addr=$(echo $lov_id | awk '{print $4}' | awk -F '-' '{print $3}')
2713         count=$(lctl get_param \
2714                 -n ldlm.namespaces.*OST0000*$addr.lock_unused_count)
2715         echo "before recovery: unused locks count = $count"
2716         [ $count != 0 ] || error "unused locks ($count) should be zero"
2717
2718         fail ost1
2719
2720         count2=$(lctl get_param \
2721                  -n ldlm.namespaces.*OST0000*$addr.lock_unused_count)
2722         echo "after recovery: unused locks count = $count2"
2723
2724         do_facet mgs $LCTL pool_remove $FSNAME.$TESTNAME $FSNAME-OST0000 ||
2725                 error "unable to remove pool $TESTNAME"
2726         do_facet mgs $LCTL pool_destroy $FSNAME.$TESTNAME ||
2727                 error "unable to destroy the pool $TESTNAME"
2728
2729         if [ $count2 -ge $count ]; then
2730                 error "unused locks are not canceled"
2731         fi
2732 }
2733 run_test 85b "check the cancellation of unused locks during recovery(EXTENT)"
2734
2735 test_86() {
2736         local clients=${CLIENTS:-$HOSTNAME}
2737
2738         zconf_umount_clients $clients $MOUNT
2739         do_facet $SINGLEMDS lctl set_param mdt.${FSNAME}-MDT*.exports.clear=0
2740         remount_facet $SINGLEMDS
2741         zconf_mount_clients $clients $MOUNT
2742 }
2743 run_test 86 "umount server after clear nid_stats should not hit LBUG"
2744
2745 test_87() {
2746         do_facet ost1 "lctl set_param -n obdfilter.${ost1_svc}.sync_journal 0"
2747
2748         replay_barrier ost1
2749         $SETSTRIPE -i 0 -c 1 $DIR/$tfile
2750         dd if=/dev/urandom of=$DIR/$tfile bs=1024k count=8 ||
2751                 error "dd to $DIR/$tfile failed"
2752         cksum=$(md5sum $DIR/$tfile | awk '{print $1}')
2753         cancel_lru_locks osc
2754         fail ost1
2755         dd if=$DIR/$tfile of=/dev/null bs=1024k count=8 || error "Cannot read"
2756         cksum2=$(md5sum $DIR/$tfile | awk '{print $1}')
2757         if [ $cksum != $cksum2 ] ; then
2758                 error "New checksum $cksum2 does not match original $cksum"
2759         fi
2760 }
2761 run_test 87 "write replay"
2762
2763 test_87b() {
2764         do_facet ost1 "lctl set_param -n obdfilter.${ost1_svc}.sync_journal 0"
2765
2766         replay_barrier ost1
2767         $SETSTRIPE -i 0 -c 1 $DIR/$tfile
2768         dd if=/dev/urandom of=$DIR/$tfile bs=1024k count=8 ||
2769                 error "dd to $DIR/$tfile failed"
2770         sleep 1 # Give it a chance to flush dirty data
2771         echo TESTTEST | dd of=$DIR/$tfile bs=1 count=8 seek=64
2772         cksum=$(md5sum $DIR/$tfile | awk '{print $1}')
2773         cancel_lru_locks osc
2774         fail ost1
2775         dd if=$DIR/$tfile of=/dev/null bs=1024k count=8 || error "Cannot read"
2776         cksum2=$(md5sum $DIR/$tfile | awk '{print $1}')
2777         if [ $cksum != $cksum2 ] ; then
2778                 error "New checksum $cksum2 does not match original $cksum"
2779         fi
2780 }
2781 run_test 87b "write replay with changed data (checksum resend)"
2782
2783 test_88() { #bug 17485
2784         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2785         mkdir -p $TMP/$tdir || error "mkdir $TMP/$tdir failed"
2786
2787         $SETSTRIPE -i 0 -c 1 $DIR/$tdir || error "$SETSTRIPE"
2788
2789         replay_barrier ost1
2790         replay_barrier $SINGLEMDS
2791
2792     # exhaust precreations on ost1
2793     local OST=$(ostname_from_index 0)
2794     local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS $OST)
2795     local last_id=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_last_id)
2796     local next_id=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_next_id)
2797         echo "before test: last_id = $last_id, next_id = $next_id"
2798
2799         echo "Creating to objid $last_id on ost $OST..."
2800         createmany -o $DIR/$tdir/f-%d $next_id $((last_id - next_id + 2)) ||
2801                 error "createmany create files to last_id failed"
2802
2803         #create some files to use some uncommitted objids
2804         last_id=$(($last_id + 1))
2805         createmany -o $DIR/$tdir/f-%d $last_id 8 ||
2806                 error "createmany create files with uncommitted objids failed"
2807
2808     last_id2=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_last_id)
2809     next_id2=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_next_id)
2810     echo "before recovery: last_id = $last_id2, next_id = $next_id2"
2811
2812     # if test uses shutdown_facet && reboot_facet instead of facet_failover ()
2813     # it has to take care about the affected facets, bug20407
2814     local affected_mds1=$(affected_facets mds1)
2815     local affected_ost1=$(affected_facets ost1)
2816
2817     shutdown_facet $SINGLEMDS
2818     shutdown_facet ost1
2819
2820     reboot_facet $SINGLEMDS
2821     change_active $affected_mds1
2822     wait_for_facet $affected_mds1
2823     mount_facets $affected_mds1 || error "Restart of mds failed"
2824
2825     reboot_facet ost1
2826     change_active $affected_ost1
2827     wait_for_facet $affected_ost1
2828     mount_facets $affected_ost1 || error "Restart of ost1 failed"
2829
2830     clients_up
2831
2832     last_id2=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_last_id)
2833     next_id2=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_next_id)
2834         echo "after recovery: last_id = $last_id2, next_id = $next_id2"
2835
2836         # create new files, which should use new objids, and ensure the orphan
2837         # cleanup phase for ost1 is completed at the same time
2838         for i in $(seq 8); do
2839                 file_id=$(($last_id + 10 + $i))
2840                 dd if=/dev/urandom of=$DIR/$tdir/f-$file_id bs=4096 count=128
2841         done
2842
2843         # if the objids were not recreated, then "ls" will fail with -ENOENT
2844         ls -l $DIR/$tdir/* || error "can't get the status of precreated files"
2845
2846         local file_id
2847         # write into previously created files
2848         for i in $(seq 8); do
2849                 file_id=$(($last_id + $i))
2850                 dd if=/dev/urandom of=$DIR/$tdir/f-$file_id bs=4096 count=128
2851                 cp -f $DIR/$tdir/f-$file_id $TMP/$tdir/
2852         done
2853
2854         # compare the content
2855         for i in $(seq 8); do
2856                 file_id=$(($last_id + $i))
2857                 cmp $TMP/$tdir/f-$file_id $DIR/$tdir/f-$file_id ||
2858                         error "the content of file is modified!"
2859         done
2860
2861         rm -fr $TMP/$tdir
2862 }
2863 run_test 88 "MDS should not assign same objid to different files "
2864
2865 test_89() {
2866         cancel_lru_locks osc
2867         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2868         rm -f $DIR/$tdir/$tfile
2869         wait_mds_ost_sync
2870         wait_delete_completed
2871         BLOCKS1=$(df -P $MOUNT | tail -n 1 | awk '{ print $3 }')
2872         $SETSTRIPE -i 0 -c 1 $DIR/$tdir/$tfile
2873         dd if=/dev/zero bs=1M count=10 of=$DIR/$tdir/$tfile
2874         sync
2875         stop ost1
2876         facet_failover $SINGLEMDS
2877         rm $DIR/$tdir/$tfile
2878         umount $MOUNT
2879         mount_facet ost1
2880         zconf_mount $(hostname) $MOUNT || error "mount fails"
2881         client_up || error "client_up failed"
2882         wait_mds_ost_sync
2883         wait_delete_completed
2884         BLOCKS2=$(df -P $MOUNT | tail -n 1 | awk '{ print $3 }')
2885         [ $((BLOCKS2 - BLOCKS1)) -le 4  ] ||
2886                 error $((BLOCKS2 - BLOCKS1)) blocks leaked
2887 }
2888
2889 run_test 89 "no disk space leak on late ost connection"
2890
2891 cleanup_90 () {
2892     local facet=$1
2893     trap 0
2894     reboot_facet $facet
2895     change_active $facet
2896     wait_for_facet $facet
2897     mount_facet $facet || error "Restart of $facet failed"
2898     clients_up
2899 }
2900
2901 test_90() { # bug 19494
2902     local dir=$DIR/$tdir
2903     local ostfail=$(get_random_entry $(get_facets OST))
2904
2905     if [[ $FAILURE_MODE = HARD ]]; then
2906         local affected=$(affected_facets $ostfail);
2907         if [[ "$affected" != $ostfail ]]; then
2908             skip not functional with FAILURE_MODE=$FAILURE_MODE, affected: $affected
2909             return 0
2910         fi
2911     fi
2912
2913         mkdir $dir || error "mkdir $dir failed"
2914
2915         echo "Create the files"
2916
2917     # file "f${index}" striped over 1 OST
2918     # file "all" striped over all OSTs
2919
2920     $SETSTRIPE -c $OSTCOUNT $dir/all ||
2921         error "setstripe failed to create $dir/all"
2922
2923     for (( i=0; i<$OSTCOUNT; i++ )); do
2924         local f=$dir/f$i
2925         $SETSTRIPE -i $i -c 1 $f || error "$SETSTRIPE failed to create $f"
2926
2927         # confirm setstripe actually created the stripe on the requested OST
2928         local uuid=$(ostuuid_from_index $i)
2929         for file in f$i all; do
2930             if [[ $dir/$file != $($LFS find --obd $uuid --name $file $dir) ]]; then
2931                 $GETSTRIPE $dir/$file
2932                 error wrong stripe: $file, uuid: $uuid
2933             fi
2934         done
2935     done
2936
2937         # Before failing an OST, get its obd name and index
2938         local varsvc=${ostfail}_svc
2939         local obd=$(do_facet $ostfail lctl get_param \
2940                     -n obdfilter.${!varsvc}.uuid)
2941         local index=$(($(facet_number $ostfail) - 1))
2942
2943         echo "Fail $ostfail $obd, display the list of affected files"
2944         shutdown_facet $ostfail || error "shutdown_facet $ostfail failed"
2945
2946         trap "cleanup_90 $ostfail" EXIT INT
2947         echo "General Query: lfs find $dir"
2948         local list=$($LFS find $dir)
2949         echo "$list"
2950         for (( i=0; i<$OSTCOUNT; i++ )); do
2951                 list_member "$list" $dir/f$i ||
2952                         error_noexit "lfs find $dir: no file f$i"
2953         done
2954         list_member "$list" $dir/all ||
2955                 error_noexit "lfs find $dir: no file all"
2956
2957         # focus on the missing OST,
2958         # we expect to see only two files affected: "f$(index)" and "all"
2959
2960         echo "Querying files on shutdown $ostfail: lfs find --obd $obd"
2961     list=$($LFS find --obd $obd $dir)
2962     echo "$list"
2963     for file in all f$index; do
2964         list_member "$list" $dir/$file ||
2965             error_noexit "lfs find does not report the affected $obd for $file"
2966     done
2967
2968     [[ $(echo $list | wc -w) -eq 2 ]] ||
2969         error_noexit "lfs find reports the wrong list of affected files ${#list[@]}"
2970
2971     echo "Check getstripe: $GETSTRIPE -r --obd $obd"
2972     list=$($GETSTRIPE -r --obd $obd $dir)
2973     echo "$list"
2974     for file in all f$index; do
2975         echo "$list" | grep $dir/$file ||
2976             error_noexit "lfs getsripe does not report the affected $obd for $file"
2977     done
2978
2979     cleanup_90 $ostfail
2980 }
2981 run_test 90 "lfs find identifies the missing striped file segments"
2982
2983 test_93() {
2984         local server_version=$(lustre_version_code $SINGLEMDS)
2985                 [[ $server_version -ge $(version_code 2.6.90) ]] ||
2986                 [[ $server_version -ge $(version_code 2.5.4) &&
2987                    $server_version -lt $(version_code 2.5.50) ]] ||
2988                 { skip "Need MDS version 2.5.4+ or 2.6.90+"; return; }
2989
2990         cancel_lru_locks osc
2991
2992         $SETSTRIPE -i 0 -c 1 $DIR/$tfile ||
2993                 error "$SETSTRIPE  $DIR/$tfile failed"
2994         dd if=/dev/zero of=$DIR/$tfile bs=1024 count=1 ||
2995                 error "dd to $DIR/$tfile failed"
2996         #define OBD_FAIL_TGT_REPLAY_RECONNECT     0x715
2997         # We need to emulate a state that OST is waiting for other clients
2998         # not completing the recovery. Final ping is queued, but reply will be
2999         # sent on the recovery completion. It is done by sleep before
3000         # processing final pings
3001         do_facet ost1 "$LCTL set_param fail_val=40"
3002         do_facet ost1 "$LCTL set_param fail_loc=0x715"
3003         fail ost1
3004 }
3005 run_test 93 "replay + reconnect"
3006
3007 striped_dir_check_100() {
3008         local striped_dir=$DIR/$tdir/striped_dir
3009         local stripe_count=$($LFS getdirstripe -c $striped_dir)
3010
3011         $LFS getdirstripe $striped_dir
3012         [ $stripe_count -eq 2 ] || error "$stripe_count != 2"
3013
3014         createmany -o $striped_dir/f-%d 20 ||
3015                 error "creation failed under striped dir"
3016 }
3017
3018 test_100a() {
3019         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3020         ([ $FAILURE_MODE == "HARD" ] &&
3021                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3022                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3023                 return 0
3024
3025         local striped_dir=$DIR/$tdir/striped_dir
3026         local MDTIDX=1
3027
3028         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
3029
3030         #To make sure MDT1 and MDT0 are connected
3031         #otherwise it may create single stripe dir here
3032         $LFS setdirstripe -i1 $DIR/$tdir/remote_dir
3033
3034         #define OBD_FAIL_OUT_UPDATE_NET_REP     0x1701
3035         do_facet mds$((MDTIDX+1)) lctl set_param fail_loc=0x1701
3036         $LFS setdirstripe -i0 -c2 $striped_dir &
3037         local CLIENT_PID=$!
3038
3039         fail mds$((MDTIDX + 1))
3040
3041         wait $CLIENT_PID || error "striped dir creation failed"
3042
3043         striped_dir_check_100 || error "striped dir check failed"
3044         rm -rf $DIR/$tdir || error "rmdir failed"
3045 }
3046 run_test 100a "DNE: create striped dir, drop update rep from MDT1, fail MDT1"
3047
3048 test_100b() {
3049         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3050         ([ $FAILURE_MODE == "HARD" ] &&
3051                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3052                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3053                 return 0
3054
3055         local striped_dir=$DIR/$tdir/striped_dir
3056         local MDTIDX=1
3057
3058         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
3059
3060         #To make sure MDT1 and MDT0 are connected
3061         #otherwise it may create single stripe dir here
3062         $LFS setdirstripe -i1 $DIR/$tdir/remote_dir
3063
3064         # OBD_FAIL_MDS_REINT_NET_REP       0x119
3065         do_facet mds$MDTIDX lctl set_param fail_loc=0x119
3066         $LFS mkdir -i0 -c2 $striped_dir &
3067
3068         local CLIENT_PID=$!
3069         fail mds$MDTIDX
3070
3071         wait $CLIENT_PID || error "striped dir creation failed"
3072
3073         striped_dir_check_100 || error "striped dir check failed"
3074         rm -rf $DIR/$tdir || error "rmdir failed"
3075 }
3076 run_test 100b "DNE: create striped dir, fail MDT0"
3077
3078 test_101() { #LU-5648
3079         mkdir -p $DIR/$tdir/d1
3080         mkdir -p $DIR/$tdir/d2
3081         touch $DIR/$tdir/file0
3082         num=1000
3083
3084         replay_barrier $SINGLEMDS
3085         for i in $(seq $num) ; do
3086                 echo test$i > $DIR/$tdir/d1/file$i
3087         done
3088
3089         fail_abort $SINGLEMDS
3090         for i in $(seq $num) ; do
3091                 touch $DIR/$tdir/d2/file$i
3092                 test -s $DIR/$tdir/d2/file$i &&
3093                         ls -al $DIR/$tdir/d2/file$i && error "file$i's size > 0"
3094         done
3095
3096         rm -rf $DIR/$tdir
3097 }
3098 run_test 101 "Shouldn't reassign precreated objs to other files after recovery"
3099
3100 check_striped_dir_110()
3101 {
3102         $CHECKSTAT -t dir $DIR/$tdir/striped_dir ||
3103                         error "create striped dir failed"
3104         local stripe_count=$($LFS getdirstripe -c $DIR/$tdir/striped_dir)
3105         [ $stripe_count -eq $MDSCOUNT ] ||
3106                 error "$stripe_count != 2 after recovery"
3107 }
3108
3109 test_110a() {
3110         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3111         ([ $FAILURE_MODE == "HARD" ] &&
3112                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3113                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3114                 return 0
3115
3116         mkdir -p $DIR/$tdir
3117         replay_barrier mds1
3118         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3119         fail mds1
3120
3121         check_striped_dir_110 || error "check striped_dir failed"
3122         rm -rf $DIR/$tdir || error "rmdir failed"
3123
3124         return 0
3125 }
3126 run_test 110a "DNE: create striped dir, fail MDT1"
3127
3128 test_110b() {
3129         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3130         ([ $FAILURE_MODE == "HARD" ] &&
3131                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3132                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3133                 return 0
3134
3135         mkdir -p $DIR/$tdir
3136         replay_barrier mds1
3137         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3138         umount $MOUNT
3139         fail mds1
3140         zconf_mount $(hostname) $MOUNT
3141         client_up || return 1
3142
3143         check_striped_dir_110 || error "check striped_dir failed"
3144
3145         rm -rf $DIR/$tdir || error "rmdir failed"
3146
3147         return 0
3148 }
3149 run_test 110b "DNE: create striped dir, fail MDT1 and client"
3150
3151 test_110c() {
3152         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3153         ([ $FAILURE_MODE == "HARD" ] &&
3154                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3155                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3156                 return 0
3157
3158         mkdir -p $DIR/$tdir
3159         replay_barrier mds2
3160         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3161         fail mds2
3162
3163         check_striped_dir_110 || error "check striped_dir failed"
3164
3165         rm -rf $DIR/$tdir || error "rmdir failed"
3166
3167         return 0
3168 }
3169 run_test 110c "DNE: create striped dir, fail MDT2"
3170
3171 test_110d() {
3172         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3173         ([ $FAILURE_MODE == "HARD" ] &&
3174                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3175                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3176                 return 0
3177
3178         mkdir -p $DIR/$tdir
3179         replay_barrier mds2
3180         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3181         umount $MOUNT
3182         fail mds2
3183         zconf_mount $(hostname) $MOUNT
3184         client_up || return 1
3185
3186         check_striped_dir_110 || error "check striped_dir failed"
3187
3188         rm -rf $DIR/$tdir || error "rmdir failed"
3189
3190         return 0
3191 }
3192 run_test 110d "DNE: create striped dir, fail MDT2 and client"
3193
3194 test_110e() {
3195         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3196         ([ $FAILURE_MODE == "HARD" ] &&
3197                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3198                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3199                 return 0
3200
3201         mkdir -p $DIR/$tdir
3202         replay_barrier mds2
3203         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3204         umount $MOUNT
3205         replay_barrier mds1
3206         fail mds1,mds2
3207         zconf_mount $(hostname) $MOUNT
3208         client_up || return 1
3209
3210         check_striped_dir_110 || error "check striped_dir failed"
3211
3212         rm -rf $DIR/$tdir || error "rmdir failed"
3213
3214         return 0
3215 }
3216 run_test 110e "DNE: create striped dir, uncommit on MDT2, fail client/MDT1/MDT2"
3217
3218 test_110f() {
3219         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3220         ([ $FAILURE_MODE == "HARD" ] &&
3221                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3222                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3223                 return 0
3224
3225         mkdir -p $DIR/$tdir
3226         replay_barrier mds1
3227         replay_barrier mds2
3228         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3229         fail mds1,mds2
3230
3231         check_striped_dir_110 || error "check striped_dir failed"
3232
3233         rm -rf $DIR/$tdir || error "rmdir failed"
3234
3235         return 0
3236 }
3237 run_test 110f "DNE: create striped dir, fail MDT1/MDT2"
3238
3239 test_110g() {
3240         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3241         ([ $FAILURE_MODE == "HARD" ] &&
3242                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3243                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3244                 return 0
3245
3246         mkdir -p $DIR/$tdir
3247         replay_barrier mds1
3248         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3249         umount $MOUNT
3250         replay_barrier mds2
3251         fail mds1,mds2
3252         zconf_mount $(hostname) $MOUNT
3253         client_up || return 1
3254
3255         check_striped_dir_110 || error "check striped_dir failed"
3256
3257         rm -rf $DIR/$tdir || error "rmdir failed"
3258
3259         return 0
3260 }
3261 run_test 110g "DNE: create striped dir, uncommit on MDT1, fail client/MDT1/MDT2"
3262
3263 test_111a() {
3264         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3265         ([ $FAILURE_MODE == "HARD" ] &&
3266                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3267                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3268                 return 0
3269
3270         mkdir -p $DIR/$tdir
3271         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3272         replay_barrier mds1
3273         rm -rf $DIR/$tdir/striped_dir
3274         fail mds1
3275
3276         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3277                         error "striped dir still exists"
3278         return 0
3279 }
3280 run_test 111a "DNE: unlink striped dir, fail MDT1"
3281
3282 test_111b() {
3283         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3284         ([ $FAILURE_MODE == "HARD" ] &&
3285                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3286                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3287                 return 0
3288
3289         mkdir -p $DIR/$tdir
3290         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3291         replay_barrier mds2
3292         rm -rf $DIR/$tdir/striped_dir
3293         umount $MOUNT
3294         fail mds2
3295         zconf_mount $(hostname) $MOUNT
3296         client_up || return 1
3297
3298         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3299                         error "striped dir still exists"
3300         return 0
3301 }
3302 run_test 111b "DNE: unlink striped dir, fail MDT2"
3303
3304 test_111c() {
3305         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3306         ([ $FAILURE_MODE == "HARD" ] &&
3307                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3308                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3309                 return 0
3310
3311         mkdir -p $DIR/$tdir
3312         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3313         replay_barrier mds1
3314         rm -rf $DIR/$tdir/striped_dir
3315         umount $MOUNT
3316         replay_barrier mds2
3317         fail mds1,mds2
3318         zconf_mount $(hostname) $MOUNT
3319         client_up || return 1
3320         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3321                         error "striped dir still exists"
3322         return 0
3323 }
3324 run_test 111c "DNE: unlink striped dir, uncommit on MDT1, fail client/MDT1/MDT2"
3325
3326 test_111d() {
3327         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3328         ([ $FAILURE_MODE == "HARD" ] &&
3329                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3330                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3331                 return 0
3332
3333         mkdir -p $DIR/$tdir
3334         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3335         replay_barrier mds2
3336         rm -rf $DIR/$tdir/striped_dir
3337         umount $MOUNT
3338         replay_barrier mds1
3339         fail mds1,mds2
3340         zconf_mount $(hostname) $MOUNT
3341         client_up || return 1
3342         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3343                         error "striped dir still exists"
3344
3345         return 0
3346 }
3347 run_test 111d "DNE: unlink striped dir, uncommit on MDT2, fail client/MDT1/MDT2"
3348
3349 test_111e() {
3350         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3351         ([ $FAILURE_MODE == "HARD" ] &&
3352                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3353                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3354                 return 0
3355
3356         mkdir -p $DIR/$tdir
3357         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3358         replay_barrier mds2
3359         rm -rf $DIR/$tdir/striped_dir
3360         replay_barrier mds1
3361         fail mds1,mds2
3362         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3363                         error "striped dir still exists"
3364         return 0
3365 }
3366 run_test 111e "DNE: unlink striped dir, uncommit on MDT2, fail MDT1/MDT2"
3367
3368 test_111f() {
3369         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3370         ([ $FAILURE_MODE == "HARD" ] &&
3371                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3372                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3373                 return 0
3374
3375         mkdir -p $DIR/$tdir
3376         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3377         replay_barrier mds1
3378         rm -rf $DIR/$tdir/striped_dir
3379         replay_barrier mds2
3380         fail mds1,mds2
3381         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3382                         error "striped dir still exists"
3383         return 0
3384 }
3385 run_test 111f "DNE: unlink striped dir, uncommit on MDT1, fail MDT1/MDT2"
3386
3387 test_111g() {
3388         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3389         ([ $FAILURE_MODE == "HARD" ] &&
3390                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3391                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3392                 return 0
3393
3394         mkdir -p $DIR/$tdir
3395         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3396         replay_barrier mds1
3397         replay_barrier mds2
3398         rm -rf $DIR/$tdir/striped_dir
3399         fail mds1,mds2
3400         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3401                         error "striped dir still exists"
3402         return 0
3403 }
3404 run_test 111g "DNE: unlink striped dir, fail MDT1/MDT2"
3405
3406 test_112_rename_prepare() {
3407         mkdir -p $DIR/$tdir/src_dir
3408         $LFS mkdir -i 1 $DIR/$tdir/src_dir/src_child ||
3409                 error "create remote source failed"
3410
3411         touch $DIR/$tdir/src_dir/src_child/a
3412
3413         $LFS mkdir -i 2 $DIR/$tdir/tgt_dir ||
3414                 error "create remote target dir failed"
3415
3416         $LFS mkdir -i 3 $DIR/$tdir/tgt_dir/tgt_child ||
3417                 error "create remote target child failed"
3418 }
3419
3420 test_112_check() {
3421         find $DIR/$tdir/
3422         $CHECKSTAT -t dir $DIR/$tdir/src_dir/src_child &&
3423                 error "src_child still exists after rename"
3424
3425         $CHECKSTAT -t file $DIR/$tdir/tgt_dir/tgt_child/a ||
3426                 error "missing file(a) after rename"
3427 }
3428
3429 test_112a() {
3430         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3431         ([ $FAILURE_MODE == "HARD" ] &&
3432                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3433                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3434                 return 0
3435
3436         test_112_rename_prepare
3437         replay_barrier mds1
3438
3439         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3440                 error "rename dir cross MDT failed!"
3441         fail mds1
3442
3443         test_112_check
3444         rm -rf $DIR/$tdir || error "rmdir failed"
3445 }
3446 run_test 112a "DNE: cross MDT rename, fail MDT1"
3447
3448 test_112b() {
3449         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3450         ([ $FAILURE_MODE == "HARD" ] &&
3451                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3452                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3453                 return 0
3454
3455         test_112_rename_prepare
3456         replay_barrier mds2
3457
3458         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3459                 error "rename dir cross MDT failed!"
3460
3461         fail mds2
3462
3463         test_112_check
3464         rm -rf $DIR/$tdir || error "rmdir failed"
3465 }
3466 run_test 112b "DNE: cross MDT rename, fail MDT2"
3467
3468 test_112c() {
3469         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3470         ([ $FAILURE_MODE == "HARD" ] &&
3471                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3472                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3473                 return 0
3474
3475         test_112_rename_prepare
3476         replay_barrier mds3
3477
3478         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3479                 error "rename dir cross MDT failed!"
3480
3481         fail mds3
3482
3483         test_112_check
3484         rm -rf $DIR/$tdir || error "rmdir failed"
3485 }
3486 run_test 112c "DNE: cross MDT rename, fail MDT3"
3487
3488 test_112d() {
3489         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3490         ([ $FAILURE_MODE == "HARD" ] &&
3491                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3492                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3493                 return 0
3494
3495         test_112_rename_prepare
3496         replay_barrier mds4
3497
3498         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3499                 error "rename dir cross MDT failed!"
3500
3501         fail mds4
3502
3503         test_112_check
3504         rm -rf $DIR/$tdir || error "rmdir failed"
3505 }
3506 run_test 112d "DNE: cross MDT rename, fail MDT4"
3507
3508 test_112e() {
3509         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3510         ([ $FAILURE_MODE == "HARD" ] &&
3511                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3512                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3513                 return 0
3514
3515         test_112_rename_prepare
3516         replay_barrier mds1
3517         replay_barrier mds2
3518
3519         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3520                 error "rename dir cross MDT failed!"
3521
3522         fail mds1,mds2
3523
3524         test_112_check
3525         rm -rf $DIR/$tdir || error "rmdir failed"
3526 }
3527 run_test 112e "DNE: cross MDT rename, fail MDT1 and MDT2"
3528
3529 test_112f() {
3530         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3531         ([ $FAILURE_MODE == "HARD" ] &&
3532                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3533                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3534                 return 0
3535
3536         test_112_rename_prepare
3537         replay_barrier mds1
3538         replay_barrier mds3
3539
3540         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3541                 error "rename dir cross MDT failed!"
3542
3543         fail mds1,mds3
3544
3545         test_112_check
3546         rm -rf $DIR/$tdir || error "rmdir failed"
3547 }
3548 run_test 112f "DNE: cross MDT rename, fail MDT1 and MDT3"
3549
3550 test_112g() {
3551         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3552         ([ $FAILURE_MODE == "HARD" ] &&
3553                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3554                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3555                 return 0
3556
3557         test_112_rename_prepare
3558         replay_barrier mds1
3559         replay_barrier mds4
3560
3561         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3562                 error "rename dir cross MDT failed!"
3563
3564         fail mds1,mds4
3565
3566         test_112_check
3567         rm -rf $DIR/$tdir || error "rmdir failed"
3568 }
3569 run_test 112g "DNE: cross MDT rename, fail MDT1 and MDT4"
3570
3571 test_112h() {
3572         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3573         ([ $FAILURE_MODE == "HARD" ] &&
3574                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3575                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3576                 return 0
3577
3578         test_112_rename_prepare
3579         replay_barrier mds2
3580         replay_barrier mds3
3581
3582         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3583                 error "rename dir cross MDT failed!"
3584
3585         fail mds2,mds3
3586
3587         test_112_check
3588         rm -rf $DIR/$tdir || error "rmdir failed"
3589 }
3590 run_test 112h "DNE: cross MDT rename, fail MDT2 and MDT3"
3591
3592 test_112i() {
3593         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3594         ([ $FAILURE_MODE == "HARD" ] &&
3595                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3596                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3597                 return 0
3598
3599         test_112_rename_prepare
3600         replay_barrier mds2
3601         replay_barrier mds4
3602
3603         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3604                 error "rename dir cross MDT failed!"
3605
3606         fail mds2,mds4
3607
3608         test_112_check
3609         rm -rf $DIR/$tdir || error "rmdir failed"
3610 }
3611 run_test 112i "DNE: cross MDT rename, fail MDT2 and MDT4"
3612
3613 test_112j() {
3614         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3615         ([ $FAILURE_MODE == "HARD" ] &&
3616                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3617                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3618                 return 0
3619
3620         test_112_rename_prepare
3621         replay_barrier mds3
3622         replay_barrier mds4
3623
3624         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3625                 error "rename dir cross MDT failed!"
3626
3627         fail mds3,mds4
3628
3629         test_112_check
3630         rm -rf $DIR/$tdir || error "rmdir failed"
3631 }
3632 run_test 112j "DNE: cross MDT rename, fail MDT3 and MDT4"
3633
3634 test_112k() {
3635         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3636         ([ $FAILURE_MODE == "HARD" ] &&
3637                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3638                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3639                 return 0
3640
3641         test_112_rename_prepare
3642         replay_barrier mds1
3643         replay_barrier mds2
3644         replay_barrier mds3
3645
3646         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3647                 error "rename dir cross MDT failed!"
3648
3649         fail mds1,mds2,mds3
3650
3651         test_112_check
3652         rm -rf $DIR/$tdir || error "rmdir failed"
3653 }
3654 run_test 112k "DNE: cross MDT rename, fail MDT1,MDT2,MDT3"
3655
3656 test_112l() {
3657         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3658         ([ $FAILURE_MODE == "HARD" ] &&
3659                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3660                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3661                 return 0
3662
3663         test_112_rename_prepare
3664         replay_barrier mds1
3665         replay_barrier mds2
3666         replay_barrier mds4
3667
3668         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3669                 error "rename dir cross MDT failed!"
3670
3671         fail mds1,mds2,mds4
3672
3673         test_112_check
3674         rm -rf $DIR/$tdir || error "rmdir failed"
3675 }
3676 run_test 112l "DNE: cross MDT rename, fail MDT1,MDT2,MDT4"
3677
3678 test_112m() {
3679         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3680         ([ $FAILURE_MODE == "HARD" ] &&
3681                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3682                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3683                 return 0
3684
3685         test_112_rename_prepare
3686         replay_barrier mds1
3687         replay_barrier mds3
3688         replay_barrier mds4
3689
3690         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3691                 error "rename dir cross MDT failed!"
3692
3693         fail mds1,mds3,mds4
3694
3695         test_112_check
3696         rm -rf $DIR/$tdir || error "rmdir failed"
3697 }
3698 run_test 112m "DNE: cross MDT rename, fail MDT1,MDT3,MDT4"
3699
3700 test_112n() {
3701         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3702         ([ $FAILURE_MODE == "HARD" ] &&
3703                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3704                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3705                 return 0
3706
3707         test_112_rename_prepare
3708         replay_barrier mds2
3709         replay_barrier mds3
3710         replay_barrier mds4
3711
3712         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3713                 error "rename dir cross MDT failed!"
3714
3715         fail mds2,mds3,mds4
3716
3717         test_112_check
3718         rm -rf $DIR/$tdir || error "rmdir failed"
3719 }
3720 run_test 112n "DNE: cross MDT rename, fail MDT2,MDT3,MDT4"
3721
3722 test_115() {
3723         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3724         ([ $FAILURE_MODE == "HARD" ] &&
3725                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3726                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3727                 return 0
3728         local fail_index=0
3729         local index
3730         local i
3731         local j
3732
3733         mkdir -p $DIR/$tdir
3734         for ((j=0;j<$((MDSCOUNT));j++)); do
3735                 fail_index=$((fail_index+1))
3736                 index=$((fail_index % MDSCOUNT))
3737                 replay_barrier mds$((index + 1))
3738                 for ((i=0;i<5;i++)); do
3739                         test_mkdir -i$index -c$MDSCOUNT $DIR/$tdir/test_$i ||
3740                                 error "create striped dir $DIR/$tdir/test_$i"
3741                 done
3742
3743                 fail mds$((index + 1))
3744                 for ((i=0;i<5;i++)); do
3745                         checkstat -t dir $DIR/$tdir/test_$i ||
3746                                 error "$DIR/$tdir/test_$i does not exist!"
3747                 done
3748                 rm -rf $DIR/$tdir/test_* ||
3749                                 error "rmdir fails"
3750         done
3751 }
3752 run_test 115 "failover for create/unlink striped directory"
3753
3754 complete $SECONDS
3755 check_and_cleanup_lustre
3756 exit_status