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 test_70b () {
2031         local clients=${CLIENTS:-$HOSTNAME}
2032
2033         zconf_mount_clients $clients $MOUNT
2034
2035         local duration=300
2036         [ "$SLOW" = "no" ] && duration=120
2037         # set duration to 900 because it takes some time to boot node
2038         [ "$FAILURE_MODE" = HARD ] && duration=900
2039
2040         local elapsed
2041         local start_ts=$(date +%s)
2042         local cmd="rundbench 1 -t $duration"
2043         local pid=""
2044         if [ $MDSCOUNT -ge 2 ]; then
2045                 test_mkdir -p -c$MDSCOUNT $DIR/$tdir
2046                 $LFS setdirstripe -D -c$MDSCOUNT $DIR/$tdir
2047         fi
2048         do_nodesv $clients "set -x; MISSING_DBENCH_OK=$MISSING_DBENCH_OK \
2049                 PATH=\$PATH:$LUSTRE/utils:$LUSTRE/tests/:$DBENCH_LIB \
2050                 DBENCH_LIB=$DBENCH_LIB TESTSUITE=$TESTSUITE TESTNAME=$TESTNAME \
2051                 MOUNT=$MOUNT DIR=$DIR/$tdir/\\\$(hostname) LCTL=$LCTL $cmd" &
2052         pid=$!
2053
2054         #LU-1897 wait for all dbench copies to start
2055         while ! check_for_process $clients dbench; do
2056                 elapsed=$(($(date +%s) - start_ts))
2057                 if [ $elapsed -gt $duration ]; then
2058                         killall_process $clients dbench
2059                         error "dbench failed to start on $clients!"
2060                 fi
2061                 sleep 1
2062         done
2063
2064         log "Started rundbench load pid=$pid ..."
2065
2066         elapsed=$(($(date +%s) - start_ts))
2067         local num_failovers=0
2068         local fail_index=1
2069         while [ $elapsed -lt $duration ]; do
2070                 if ! check_for_process $clients dbench; then
2071                         error_noexit "dbench stopped on some of $clients!"
2072                         killall_process $clients dbench
2073                         break
2074                 fi
2075                 sleep 1
2076                 replay_barrier mds$fail_index
2077                 sleep 1 # give clients a time to do operations
2078                 # Increment the number of failovers
2079                 num_failovers=$((num_failovers+1))
2080                 log "$TESTNAME fail mds$fail_index $num_failovers times"
2081                 fail mds$fail_index
2082                 elapsed=$(($(date +%s) - start_ts))
2083                 if [ $fail_index -ge $MDSCOUNT ]; then
2084                         fail_index=1
2085                 else
2086                         fail_index=$((fail_index+1))
2087                 fi
2088         done
2089
2090         wait $pid || error "rundbench load on $clients failed!"
2091 }
2092 run_test 70b "dbench ${MDSCOUNT}mdts recovery; $CLIENTCOUNT clients"
2093 # end multi-client tests
2094
2095 test_73a() {
2096         multiop_bg_pause $DIR/$tfile O_tSc ||
2097                 error "multiop_bg_pause $DIR/$tfile failed"
2098         pid=$!
2099         rm -f $DIR/$tfile
2100
2101         replay_barrier $SINGLEMDS
2102         #define OBD_FAIL_LDLM_ENQUEUE_NET                       0x302
2103         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000302"
2104         fail $SINGLEMDS
2105         kill -USR1 $pid
2106         wait $pid || error "multiop pid failed"
2107         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
2108         return 0
2109 }
2110 run_test 73a "open(O_CREAT), unlink, replay, reconnect before open replay, close"
2111
2112 test_73b() {
2113         multiop_bg_pause $DIR/$tfile O_tSc ||
2114                 error "multiop_bg_pause $DIR/$tfile failed"
2115         pid=$!
2116         rm -f $DIR/$tfile
2117
2118         replay_barrier $SINGLEMDS
2119         #define OBD_FAIL_LDLM_REPLY       0x30c
2120         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000030c"
2121         fail $SINGLEMDS
2122         kill -USR1 $pid
2123         wait $pid || error "multiop pid failed"
2124         [ -e $DIR/$tfile ] && error "file $DIR/$tfile should not exist"
2125         return 0
2126 }
2127 run_test 73b "open(O_CREAT), unlink, replay, reconnect at open_replay reply, close"
2128
2129 # bug 18554
2130 test_74() {
2131         local clients=${CLIENTS:-$HOSTNAME}
2132
2133         zconf_umount_clients $clients $MOUNT
2134         stop ost1
2135         facet_failover $SINGLEMDS
2136         zconf_mount_clients $clients $MOUNT
2137         mount_facet ost1
2138         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
2139         rm $DIR/$tfile || error "rm $DIR/$tfile failed"
2140         clients_up || error "client evicted: $?"
2141         return 0
2142 }
2143 run_test 74 "Ensure applications don't fail waiting for OST recovery"
2144
2145 remote_dir_check_80() {
2146         local MDTIDX=1
2147         local diridx
2148         local fileidx
2149
2150         diridx=$($GETSTRIPE -M $remote_dir) ||
2151                 error "$GETSTRIPE -M $remote_dir failed"
2152         [ $diridx -eq $MDTIDX ] || error "$diridx != $MDTIDX"
2153
2154         createmany -o $remote_dir/f-%d 20 || error "creation failed"
2155         fileidx=$($GETSTRIPE -M $remote_dir/f-1) ||
2156                 error "$GETSTRIPE -M $remote_dir/f-1 failed"
2157         [ $fileidx -eq $MDTIDX ] || error "$fileidx != $MDTIDX"
2158
2159         return 0
2160 }
2161
2162 test_80a() {
2163         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2164         ([ $FAILURE_MODE == "HARD" ] &&
2165                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2166                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2167                 return 0
2168
2169         local MDTIDX=1
2170         local remote_dir=$DIR/$tdir/remote_dir
2171
2172         mkdir -p $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2173         #define OBD_FAIL_OUT_UPDATE_NET_REP     0x1701
2174         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2175         $LFS mkdir -i $MDTIDX $remote_dir &
2176         local CLIENT_PID=$!
2177
2178         replay_barrier mds1
2179         fail mds${MDTIDX}
2180
2181         wait $CLIENT_PID || error "remote creation failed"
2182
2183         remote_dir_check_80 || error "remote dir check failed"
2184         rm -rf $DIR/$tdir || error "rmdir failed"
2185
2186         return 0
2187 }
2188 run_test 80a "DNE: create remote dir, drop update rep from MDT0, fail MDT0"
2189
2190 test_80b() {
2191         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2192         ([ $FAILURE_MODE == "HARD" ] &&
2193                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2194                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2195                 return 0
2196
2197         local MDTIDX=1
2198         local remote_dir=$DIR/$tdir/remote_dir
2199
2200         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2201         #define OBD_FAIL_UPDATE_OBJ_NET_REP     0x1701
2202         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2203         $LFS mkdir -i $MDTIDX $remote_dir &
2204         local CLIENT_PID=$!
2205
2206         replay_barrier mds1
2207         replay_barrier mds2
2208         fail mds$((MDTIDX + 1))
2209
2210         wait $CLIENT_PID || error "remote creation failed"
2211
2212         remote_dir_check_80 || error "remote dir check failed"
2213         rm -rf $DIR/$tdir || error "rmdir failed"
2214
2215         return 0
2216 }
2217 run_test 80b "DNE: create remote dir, drop update rep from MDT0, fail MDT1"
2218
2219 test_80c() {
2220         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2221         ([ $FAILURE_MODE == "HARD" ] &&
2222                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2223                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2224                 return 0
2225
2226         local MDTIDX=1
2227         local remote_dir=$DIR/$tdir/remote_dir
2228
2229         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2230         #define OBD_FAIL_UPDATE_OBJ_NET_REP     0x1701
2231         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2232         $LFS mkdir -i $MDTIDX $remote_dir &
2233         local CLIENT_PID=$!
2234
2235         replay_barrier mds1
2236         replay_barrier mds2
2237         fail mds${MDTIDX}
2238         fail mds$((MDTIDX + 1))
2239
2240         wait $CLIENT_PID || error "remote creation failed"
2241
2242         remote_dir_check_80 || error "remote dir check failed"
2243         rm -rf $DIR/$tdir || error "rmdir failed"
2244
2245         return 0
2246 }
2247 run_test 80c "DNE: create remote dir, drop update rep from MDT1, fail MDT[0,1]"
2248
2249 test_80d() {
2250         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2251         local MDTIDX=1
2252         local remote_dir=$DIR/$tdir/remote_dir
2253
2254         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2255         #define OBD_FAIL_UPDATE_OBJ_NET_REP     0x1701
2256         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2257         $LFS mkdir -i $MDTIDX $remote_dir &
2258         local CLIENT_PID=$!
2259
2260         # sleep 3 seconds to make sure MDTs are failed after
2261         # lfs mkdir -i has finished on all of MDTs.
2262         sleep 3
2263
2264         replay_barrier mds1
2265         replay_barrier mds2
2266         fail mds${MDTIDX},mds$((MDTIDX + 1))
2267
2268         wait $CLIENT_PID || error "remote creation failed"
2269
2270         remote_dir_check_80 || error "remote dir check failed"
2271         rm -rf $DIR/$tdir || error "rmdir failed"
2272
2273         return 0
2274 }
2275 run_test 80d "DNE: create remote dir, drop update rep from MDT1, fail 2 MDTs"
2276
2277 test_80e() {
2278         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2279         ([ $FAILURE_MODE == "HARD" ] &&
2280                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2281                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2282                 return 0
2283
2284         local MDTIDX=1
2285         local remote_dir=$DIR/$tdir/remote_dir
2286
2287         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2288         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2289         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2290         $LFS mkdir -i $MDTIDX $remote_dir &
2291         local CLIENT_PID=$!
2292
2293         # sleep 3 seconds to make sure MDTs are failed after
2294         # lfs mkdir -i has finished on all of MDTs.
2295         sleep 3
2296
2297         replay_barrier mds1
2298         fail mds${MDTIDX}
2299
2300         wait $CLIENT_PID || error "remote creation failed"
2301
2302         remote_dir_check_80 || error "remote dir check failed"
2303         rm -rf $DIR/$tdir || error "rmdir failed"
2304
2305         return 0
2306 }
2307 run_test 80e "DNE: create remote dir, drop MDT1 rep, fail MDT0"
2308
2309 test_80f() {
2310         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2311         ([ $FAILURE_MODE == "HARD" ] &&
2312                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2313                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2314                 return 0
2315         local MDTIDX=1
2316         local remote_dir=$DIR/$tdir/remote_dir
2317
2318         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2319         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2320         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2321         $LFS mkdir -i $MDTIDX $remote_dir &
2322         local CLIENT_PID=$!
2323
2324         replay_barrier mds2
2325         fail mds$((MDTIDX + 1))
2326
2327         wait $CLIENT_PID || error "remote creation failed"
2328
2329         remote_dir_check_80 || error "remote dir check failed"
2330         rm -rf $DIR/$tdir || error "rmdir failed"
2331
2332         return 0
2333 }
2334 run_test 80f "DNE: create remote dir, drop MDT1 rep, fail MDT1"
2335
2336 test_80g() {
2337         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2338         ([ $FAILURE_MODE == "HARD" ] &&
2339                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2340                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2341                 return 0
2342
2343         local MDTIDX=1
2344         local remote_dir=$DIR/$tdir/remote_dir
2345
2346         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2347         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2348         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2349         $LFS mkdir -i $MDTIDX $remote_dir &
2350         local CLIENT_PID=$!
2351
2352         # sleep 3 seconds to make sure MDTs are failed after
2353         # lfs mkdir -i has finished on all of MDTs.
2354         sleep 3
2355
2356         replay_barrier mds1
2357         replay_barrier mds2
2358         fail mds${MDTIDX}
2359         fail mds$((MDTIDX + 1))
2360
2361         wait $CLIENT_PID || error "remote creation failed"
2362
2363         remote_dir_check_80 || error "remote dir check failed"
2364         rm -rf $DIR/$tdir || error "rmdir failed"
2365
2366         return 0
2367 }
2368 run_test 80g "DNE: create remote dir, drop MDT1 rep, fail MDT0, then MDT1"
2369
2370 test_80h() {
2371         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2372         local MDTIDX=1
2373         local remote_dir=$DIR/$tdir/remote_dir
2374
2375         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2376         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2377         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2378         $LFS mkdir -i $MDTIDX $remote_dir &
2379         local CLIENT_PID=$!
2380
2381         # sleep 3 seconds to make sure MDTs are failed after
2382         # lfs mkdir -i has finished on all of MDTs.
2383         sleep 3
2384
2385         replay_barrier mds1
2386         replay_barrier mds2
2387         fail mds${MDTIDX},mds$((MDTIDX + 1))
2388
2389         wait $CLIENT_PID || error "remote dir creation failed"
2390
2391         remote_dir_check_80 || error "remote dir check failed"
2392         rm -rf $DIR/$tdir || error "rmdir failed"
2393
2394         return 0
2395 }
2396 run_test 80h "DNE: create remote dir, drop MDT1 rep, fail 2 MDTs"
2397
2398 test_81a() {
2399         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2400         ([ $FAILURE_MODE == "HARD" ] &&
2401                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2402                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2403                 return 0
2404
2405         local MDTIDX=1
2406         local remote_dir=$DIR/$tdir/remote_dir
2407
2408         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2409         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2410
2411         touch $remote_dir || error "touch $remote_dir failed"
2412         # OBD_FAIL_OBJ_UPDATE_NET_REP       0x1701
2413         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2414         rmdir $remote_dir &
2415         local CLIENT_PID=$!
2416
2417         replay_barrier mds2
2418         fail mds$((MDTIDX + 1))
2419
2420         wait $CLIENT_PID || error "rm remote dir failed"
2421
2422         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2423
2424         rm -rf $DIR/$tdir || error "rmdir failed"
2425
2426         return 0
2427 }
2428 run_test 81a "DNE: unlink remote dir, drop MDT0 update rep,  fail MDT1"
2429
2430 test_81b() {
2431         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2432         ([ $FAILURE_MODE == "HARD" ] &&
2433                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2434                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2435                 return 0
2436         local MDTIDX=1
2437         local remote_dir=$DIR/$tdir/remote_dir
2438
2439         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2440         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2441
2442         # OBD_FAIL_OBJ_UPDATE_NET_REP       0x1701
2443         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2444         rmdir $remote_dir &
2445         local CLIENT_PID=$!
2446
2447         replay_barrier mds1
2448         fail mds${MDTIDX}
2449
2450         wait $CLIENT_PID || error "rm remote dir failed"
2451
2452         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2453
2454         rm -rf $DIR/$tdir || error "rmdir failed"
2455
2456         return 0
2457 }
2458 run_test 81b "DNE: unlink remote dir, drop MDT0 update reply,  fail MDT0"
2459
2460 test_81c() {
2461         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2462         ([ $FAILURE_MODE == "HARD" ] &&
2463                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2464                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2465                 return 0
2466
2467         local MDTIDX=1
2468         local remote_dir=$DIR/$tdir/remote_dir
2469
2470         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2471         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2472
2473         # OBD_FAIL_OBJ_UPDATE_NET_REP       0x1701
2474         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2475         rmdir $remote_dir &
2476         local CLIENT_PID=$!
2477
2478         replay_barrier mds1
2479         replay_barrier mds2
2480         fail mds${MDTIDX}
2481         fail mds$((MDTIDX + 1))
2482
2483         wait $CLIENT_PID || error "rm remote dir failed"
2484
2485         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2486
2487         rm -rf $DIR/$tdir || error "rmdir failed"
2488
2489         return 0
2490 }
2491 run_test 81c "DNE: unlink remote dir, drop MDT0 update reply, fail MDT0,MDT1"
2492
2493 test_81d() {
2494         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2495         local MDTIDX=1
2496         local remote_dir=$DIR/$tdir/remote_dir
2497
2498         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2499         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2500
2501         # OBD_FAIL_OBJ_UPDATE_NET_REP       0x1701
2502         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
2503         rmdir $remote_dir &
2504         local CLIENT_PID=$!
2505
2506         replay_barrier mds1
2507         replay_barrier mds2
2508         fail mds${MDTIDX},mds$((MDTIDX + 1))
2509
2510         wait $CLIENT_PID || error "rm remote dir failed"
2511
2512         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2513
2514         rm -rf $DIR/$tdir || error "rmdir failed"
2515
2516         return 0
2517 }
2518 run_test 81d "DNE: unlink remote dir, drop MDT0 update reply,  fail 2 MDTs"
2519
2520 test_81e() {
2521         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2522         ([ $FAILURE_MODE == "HARD" ] &&
2523                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2524                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2525                 return 0
2526
2527         local MDTIDX=1
2528         local remote_dir=$DIR/$tdir/remote_dir
2529
2530         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2531         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2532
2533         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2534         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2535         rmdir $remote_dir &
2536         local CLIENT_PID=$!
2537         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0
2538
2539         replay_barrier mds1
2540         fail mds${MDTIDX}
2541
2542         wait $CLIENT_PID || error "rm remote dir failed"
2543
2544         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2545
2546         rm -rf $DIR/$tdir || error "rmdir failed"
2547
2548         return 0
2549 }
2550 run_test 81e "DNE: unlink remote dir, drop MDT1 req reply, fail MDT0"
2551
2552 test_81f() {
2553         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2554         ([ $FAILURE_MODE == "HARD" ] &&
2555                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2556                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2557                 return 0
2558
2559         local MDTIDX=1
2560         local remote_dir=$DIR/$tdir/remote_dir
2561
2562         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2563         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2564
2565         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2566         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2567         rmdir $remote_dir &
2568         local CLIENT_PID=$!
2569
2570         replay_barrier mds2
2571         fail mds$((MDTIDX + 1))
2572
2573         wait $CLIENT_PID || error "rm remote dir failed"
2574
2575         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2576
2577         rm -rf $DIR/$tdir || error "rmdir failed"
2578
2579         return 0
2580 }
2581 run_test 81f "DNE: unlink remote dir, drop MDT1 req reply, fail MDT1"
2582
2583 test_81g() {
2584         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2585         ([ $FAILURE_MODE == "HARD" ] &&
2586                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
2587                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
2588                 return 0
2589
2590         local MDTIDX=1
2591         local remote_dir=$DIR/$tdir/remote_dir
2592
2593         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2594         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2595
2596         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2597         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2598         rmdir $remote_dir &
2599         local CLIENT_PID=$!
2600
2601         replay_barrier mds1
2602         replay_barrier mds2
2603         fail mds${MDTIDX}
2604         fail mds$((MDTIDX + 1))
2605
2606         wait $CLIENT_PID || error "rm remote dir failed"
2607
2608         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2609
2610         rm -rf $DIR/$tdir || error "rmdir failed"
2611
2612         return 0
2613 }
2614 run_test 81g "DNE: unlink remote dir, drop req reply, fail M0, then M1"
2615
2616 test_81h() {
2617         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
2618         local MDTIDX=1
2619         local remote_dir=$DIR/$tdir/remote_dir
2620
2621         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2622         $LFS mkdir -i $MDTIDX $remote_dir || error "lfs mkdir failed"
2623
2624         # OBD_FAIL_MDS_REINT_NET_REP       0x119
2625         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
2626         rmdir $remote_dir &
2627         local CLIENT_PID=$!
2628
2629         replay_barrier mds1
2630         replay_barrier mds2
2631         fail mds${MDTIDX},mds$((MDTIDX + 1))
2632
2633         wait $CLIENT_PID || error "rm remote dir failed"
2634
2635         stat $remote_dir 2&>/dev/null && error "$remote_dir still exist!"
2636
2637         rm -rf $DIR/$tdir || error "rmdir failed"
2638
2639         return 0
2640 }
2641 run_test 81h "DNE: unlink remote dir, drop request reply, fail 2 MDTs"
2642
2643 test_84a() {
2644 #define OBD_FAIL_MDS_OPEN_WAIT_CREATE  0x144
2645     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000144"
2646     createmany -o $DIR/$tfile- 1 &
2647     PID=$!
2648     mds_evict_client
2649     wait $PID
2650     client_up || client_up || true    # reconnect
2651 }
2652 run_test 84a "stale open during export disconnect"
2653
2654 test_85a() { #bug 16774
2655         lctl set_param -n ldlm.cancel_unused_locks_before_replay "1"
2656
2657         for i in $(seq 100); do
2658                 echo "tag-$i" > $DIR/$tfile-$i
2659                 grep -q "tag-$i" $DIR/$tfile-$i || error "f2-$i"
2660         done
2661
2662         lov_id=$(lctl dl | grep "clilov")
2663         addr=$(echo $lov_id | awk '{print $4}' | awk -F '-' '{print $3}')
2664         count=$(lctl get_param -n \
2665                 ldlm.namespaces.*MDT0000*$addr.lock_unused_count)
2666         echo "before recovery: unused locks count = $count"
2667
2668         fail $SINGLEMDS
2669
2670         count2=$(lctl get_param -n \
2671                  ldlm.namespaces.*MDT0000*$addr.lock_unused_count)
2672         echo "after recovery: unused locks count = $count2"
2673
2674         if [ $count2 -ge $count ]; then
2675                 error "unused locks are not canceled"
2676         fi
2677 }
2678 run_test 85a "check the cancellation of unused locks during recovery(IBITS)"
2679
2680 test_85b() { #bug 16774
2681         lctl set_param -n ldlm.cancel_unused_locks_before_replay "1"
2682
2683         do_facet mgs $LCTL pool_new $FSNAME.$TESTNAME ||
2684                 error "unable to create pool $TESTNAME"
2685         do_facet mgs $LCTL pool_add $FSNAME.$TESTNAME $FSNAME-OST0000 ||
2686                 error "unable to add pool $TESTNAME"
2687
2688         $SETSTRIPE -c 1 -p $FSNAME.$TESTNAME $DIR
2689
2690         for i in $(seq 100); do
2691                 dd if=/dev/urandom of=$DIR/$tfile-$i bs=4096 \
2692                         count=32 >/dev/null 2>&1
2693         done
2694
2695         cancel_lru_locks osc
2696
2697         for i in $(seq 100); do
2698                 dd if=$DIR/$tfile-$i of=/dev/null bs=4096 \
2699                         count=32 >/dev/null 2>&1
2700         done
2701
2702         lov_id=$(lctl dl | grep "clilov")
2703         addr=$(echo $lov_id | awk '{print $4}' | awk -F '-' '{print $3}')
2704         count=$(lctl get_param \
2705                 -n ldlm.namespaces.*OST0000*$addr.lock_unused_count)
2706         echo "before recovery: unused locks count = $count"
2707         [ $count != 0 ] || error "unused locks ($count) should be zero"
2708
2709         fail ost1
2710
2711         count2=$(lctl get_param \
2712                  -n ldlm.namespaces.*OST0000*$addr.lock_unused_count)
2713         echo "after recovery: unused locks count = $count2"
2714
2715         do_facet mgs $LCTL pool_remove $FSNAME.$TESTNAME $FSNAME-OST0000 ||
2716                 error "unable to remove pool $TESTNAME"
2717         do_facet mgs $LCTL pool_destroy $FSNAME.$TESTNAME ||
2718                 error "unable to destroy the pool $TESTNAME"
2719
2720         if [ $count2 -ge $count ]; then
2721                 error "unused locks are not canceled"
2722         fi
2723 }
2724 run_test 85b "check the cancellation of unused locks during recovery(EXTENT)"
2725
2726 test_86() {
2727         local clients=${CLIENTS:-$HOSTNAME}
2728
2729         zconf_umount_clients $clients $MOUNT
2730         do_facet $SINGLEMDS lctl set_param mdt.${FSNAME}-MDT*.exports.clear=0
2731         remount_facet $SINGLEMDS
2732         zconf_mount_clients $clients $MOUNT
2733 }
2734 run_test 86 "umount server after clear nid_stats should not hit LBUG"
2735
2736 test_87() {
2737         do_facet ost1 "lctl set_param -n obdfilter.${ost1_svc}.sync_journal 0"
2738
2739         replay_barrier ost1
2740         $SETSTRIPE -i 0 -c 1 $DIR/$tfile
2741         dd if=/dev/urandom of=$DIR/$tfile bs=1024k count=8 ||
2742                 error "dd to $DIR/$tfile failed"
2743         cksum=$(md5sum $DIR/$tfile | awk '{print $1}')
2744         cancel_lru_locks osc
2745         fail ost1
2746         dd if=$DIR/$tfile of=/dev/null bs=1024k count=8 || error "Cannot read"
2747         cksum2=$(md5sum $DIR/$tfile | awk '{print $1}')
2748         if [ $cksum != $cksum2 ] ; then
2749                 error "New checksum $cksum2 does not match original $cksum"
2750         fi
2751 }
2752 run_test 87 "write replay"
2753
2754 test_87b() {
2755         do_facet ost1 "lctl set_param -n obdfilter.${ost1_svc}.sync_journal 0"
2756
2757         replay_barrier ost1
2758         $SETSTRIPE -i 0 -c 1 $DIR/$tfile
2759         dd if=/dev/urandom of=$DIR/$tfile bs=1024k count=8 ||
2760                 error "dd to $DIR/$tfile failed"
2761         sleep 1 # Give it a chance to flush dirty data
2762         echo TESTTEST | dd of=$DIR/$tfile bs=1 count=8 seek=64
2763         cksum=$(md5sum $DIR/$tfile | awk '{print $1}')
2764         cancel_lru_locks osc
2765         fail ost1
2766         dd if=$DIR/$tfile of=/dev/null bs=1024k count=8 || error "Cannot read"
2767         cksum2=$(md5sum $DIR/$tfile | awk '{print $1}')
2768         if [ $cksum != $cksum2 ] ; then
2769                 error "New checksum $cksum2 does not match original $cksum"
2770         fi
2771 }
2772 run_test 87b "write replay with changed data (checksum resend)"
2773
2774 test_88() { #bug 17485
2775         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2776         mkdir -p $TMP/$tdir || error "mkdir $TMP/$tdir failed"
2777
2778         $SETSTRIPE -i 0 -c 1 $DIR/$tdir || error "$SETSTRIPE"
2779
2780         replay_barrier ost1
2781         replay_barrier $SINGLEMDS
2782
2783     # exhaust precreations on ost1
2784     local OST=$(ostname_from_index 0)
2785     local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS $OST)
2786     local last_id=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_last_id)
2787     local next_id=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_next_id)
2788         echo "before test: last_id = $last_id, next_id = $next_id"
2789
2790         echo "Creating to objid $last_id on ost $OST..."
2791         createmany -o $DIR/$tdir/f-%d $next_id $((last_id - next_id + 2)) ||
2792                 error "createmany create files to last_id failed"
2793
2794         #create some files to use some uncommitted objids
2795         last_id=$(($last_id + 1))
2796         createmany -o $DIR/$tdir/f-%d $last_id 8 ||
2797                 error "createmany create files with uncommitted objids failed"
2798
2799     last_id2=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_last_id)
2800     next_id2=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_next_id)
2801     echo "before recovery: last_id = $last_id2, next_id = $next_id2"
2802
2803     # if test uses shutdown_facet && reboot_facet instead of facet_failover ()
2804     # it has to take care about the affected facets, bug20407
2805     local affected_mds1=$(affected_facets mds1)
2806     local affected_ost1=$(affected_facets ost1)
2807
2808     shutdown_facet $SINGLEMDS
2809     shutdown_facet ost1
2810
2811     reboot_facet $SINGLEMDS
2812     change_active $affected_mds1
2813     wait_for_facet $affected_mds1
2814     mount_facets $affected_mds1 || error "Restart of mds failed"
2815
2816     reboot_facet ost1
2817     change_active $affected_ost1
2818     wait_for_facet $affected_ost1
2819     mount_facets $affected_ost1 || error "Restart of ost1 failed"
2820
2821     clients_up
2822
2823     last_id2=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_last_id)
2824     next_id2=$(do_facet $SINGLEMDS lctl get_param -n osc.$mdtosc.prealloc_next_id)
2825         echo "after recovery: last_id = $last_id2, next_id = $next_id2"
2826
2827         # create new files, which should use new objids, and ensure the orphan
2828         # cleanup phase for ost1 is completed at the same time
2829         for i in $(seq 8); do
2830                 file_id=$(($last_id + 10 + $i))
2831                 dd if=/dev/urandom of=$DIR/$tdir/f-$file_id bs=4096 count=128
2832         done
2833
2834         # if the objids were not recreated, then "ls" will fail with -ENOENT
2835         ls -l $DIR/$tdir/* || error "can't get the status of precreated files"
2836
2837         local file_id
2838         # write into previously created files
2839         for i in $(seq 8); do
2840                 file_id=$(($last_id + $i))
2841                 dd if=/dev/urandom of=$DIR/$tdir/f-$file_id bs=4096 count=128
2842                 cp -f $DIR/$tdir/f-$file_id $TMP/$tdir/
2843         done
2844
2845         # compare the content
2846         for i in $(seq 8); do
2847                 file_id=$(($last_id + $i))
2848                 cmp $TMP/$tdir/f-$file_id $DIR/$tdir/f-$file_id ||
2849                         error "the content of file is modified!"
2850         done
2851
2852         rm -fr $TMP/$tdir
2853 }
2854 run_test 88 "MDS should not assign same objid to different files "
2855
2856 test_89() {
2857         cancel_lru_locks osc
2858         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
2859         rm -f $DIR/$tdir/$tfile
2860         wait_mds_ost_sync
2861         wait_delete_completed
2862         BLOCKS1=$(df -P $MOUNT | tail -n 1 | awk '{ print $3 }')
2863         $SETSTRIPE -i 0 -c 1 $DIR/$tdir/$tfile
2864         dd if=/dev/zero bs=1M count=10 of=$DIR/$tdir/$tfile
2865         sync
2866         stop ost1
2867         facet_failover $SINGLEMDS
2868         rm $DIR/$tdir/$tfile
2869         umount $MOUNT
2870         mount_facet ost1
2871         zconf_mount $(hostname) $MOUNT || error "mount fails"
2872         client_up || error "client_up failed"
2873         wait_mds_ost_sync
2874         wait_delete_completed
2875         BLOCKS2=$(df -P $MOUNT | tail -n 1 | awk '{ print $3 }')
2876         [ $((BLOCKS2 - BLOCKS1)) -le 4  ] ||
2877                 error $((BLOCKS2 - BLOCKS1)) blocks leaked
2878 }
2879
2880 run_test 89 "no disk space leak on late ost connection"
2881
2882 cleanup_90 () {
2883     local facet=$1
2884     trap 0
2885     reboot_facet $facet
2886     change_active $facet
2887     wait_for_facet $facet
2888     mount_facet $facet || error "Restart of $facet failed"
2889     clients_up
2890 }
2891
2892 test_90() { # bug 19494
2893     local dir=$DIR/$tdir
2894     local ostfail=$(get_random_entry $(get_facets OST))
2895
2896     if [[ $FAILURE_MODE = HARD ]]; then
2897         local affected=$(affected_facets $ostfail);
2898         if [[ "$affected" != $ostfail ]]; then
2899             skip not functional with FAILURE_MODE=$FAILURE_MODE, affected: $affected
2900             return 0
2901         fi
2902     fi
2903
2904         mkdir $dir || error "mkdir $dir failed"
2905
2906         echo "Create the files"
2907
2908     # file "f${index}" striped over 1 OST
2909     # file "all" striped over all OSTs
2910
2911     $SETSTRIPE -c $OSTCOUNT $dir/all ||
2912         error "setstripe failed to create $dir/all"
2913
2914     for (( i=0; i<$OSTCOUNT; i++ )); do
2915         local f=$dir/f$i
2916         $SETSTRIPE -i $i -c 1 $f || error "$SETSTRIPE failed to create $f"
2917
2918         # confirm setstripe actually created the stripe on the requested OST
2919         local uuid=$(ostuuid_from_index $i)
2920         for file in f$i all; do
2921             if [[ $dir/$file != $($LFS find --obd $uuid --name $file $dir) ]]; then
2922                 $GETSTRIPE $dir/$file
2923                 error wrong stripe: $file, uuid: $uuid
2924             fi
2925         done
2926     done
2927
2928         # Before failing an OST, get its obd name and index
2929         local varsvc=${ostfail}_svc
2930         local obd=$(do_facet $ostfail lctl get_param \
2931                     -n obdfilter.${!varsvc}.uuid)
2932         local index=$(($(facet_number $ostfail) - 1))
2933
2934         echo "Fail $ostfail $obd, display the list of affected files"
2935         shutdown_facet $ostfail || error "shutdown_facet $ostfail failed"
2936
2937         trap "cleanup_90 $ostfail" EXIT INT
2938         echo "General Query: lfs find $dir"
2939         local list=$($LFS find $dir)
2940         echo "$list"
2941         for (( i=0; i<$OSTCOUNT; i++ )); do
2942                 list_member "$list" $dir/f$i ||
2943                         error_noexit "lfs find $dir: no file f$i"
2944         done
2945         list_member "$list" $dir/all ||
2946                 error_noexit "lfs find $dir: no file all"
2947
2948         # focus on the missing OST,
2949         # we expect to see only two files affected: "f$(index)" and "all"
2950
2951         echo "Querying files on shutdown $ostfail: lfs find --obd $obd"
2952     list=$($LFS find --obd $obd $dir)
2953     echo "$list"
2954     for file in all f$index; do
2955         list_member "$list" $dir/$file ||
2956             error_noexit "lfs find does not report the affected $obd for $file"
2957     done
2958
2959     [[ $(echo $list | wc -w) -eq 2 ]] ||
2960         error_noexit "lfs find reports the wrong list of affected files ${#list[@]}"
2961
2962     echo "Check getstripe: $GETSTRIPE -r --obd $obd"
2963     list=$($GETSTRIPE -r --obd $obd $dir)
2964     echo "$list"
2965     for file in all f$index; do
2966         echo "$list" | grep $dir/$file ||
2967             error_noexit "lfs getsripe does not report the affected $obd for $file"
2968     done
2969
2970     cleanup_90 $ostfail
2971 }
2972 run_test 90 "lfs find identifies the missing striped file segments"
2973
2974 test_93() {
2975         local server_version=$(lustre_version_code $SINGLEMDS)
2976                 [[ $server_version -ge $(version_code 2.6.90) ]] ||
2977                 [[ $server_version -ge $(version_code 2.5.4) &&
2978                    $server_version -lt $(version_code 2.5.50) ]] ||
2979                 { skip "Need MDS version 2.5.4+ or 2.6.90+"; return; }
2980
2981         cancel_lru_locks osc
2982
2983         $SETSTRIPE -i 0 -c 1 $DIR/$tfile ||
2984                 error "$SETSTRIPE  $DIR/$tfile failed"
2985         dd if=/dev/zero of=$DIR/$tfile bs=1024 count=1 ||
2986                 error "dd to $DIR/$tfile failed"
2987         #define OBD_FAIL_TGT_REPLAY_RECONNECT     0x715
2988         # We need to emulate a state that OST is waiting for other clients
2989         # not completing the recovery. Final ping is queued, but reply will be
2990         # sent on the recovery completion. It is done by sleep before
2991         # processing final pings
2992         do_facet ost1 "$LCTL set_param fail_val=40"
2993         do_facet ost1 "$LCTL set_param fail_loc=0x715"
2994         fail ost1
2995 }
2996 run_test 93 "replay + reconnect"
2997
2998 striped_dir_check_100() {
2999         local striped_dir=$DIR/$tdir/striped_dir
3000         local stripe_count=$($LFS getdirstripe -c $striped_dir)
3001
3002         $LFS getdirstripe $striped_dir
3003         [ $stripe_count -eq 2 ] || error "$stripe_count != 2"
3004
3005         createmany -o $striped_dir/f-%d 20 ||
3006                 error "creation failed under striped dir"
3007 }
3008
3009 test_100a() {
3010         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3011         ([ $FAILURE_MODE == "HARD" ] &&
3012                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3013                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3014                 return 0
3015
3016         local striped_dir=$DIR/$tdir/striped_dir
3017         local MDTIDX=1
3018
3019         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
3020
3021         #To make sure MDT1 and MDT0 are connected
3022         #otherwise it may create single stripe dir here
3023         $LFS setdirstripe -i1 $DIR/$tdir/remote_dir
3024
3025         #define OBD_FAIL_OUT_UPDATE_NET_REP     0x1701
3026         do_facet mds$((MDTIDX+1)) lctl set_param fail_loc=0x1701
3027         $LFS setdirstripe -i0 -c2 $striped_dir &
3028         local CLIENT_PID=$!
3029
3030         fail mds$((MDTIDX + 1))
3031
3032         wait $CLIENT_PID || error "striped dir creation failed"
3033
3034         striped_dir_check_100 || error "striped dir check failed"
3035         rm -rf $DIR/$tdir || error "rmdir failed"
3036 }
3037 run_test 100a "DNE: create striped dir, drop update rep from MDT1, fail MDT1"
3038
3039 test_100b() {
3040         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3041         ([ $FAILURE_MODE == "HARD" ] &&
3042                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3043                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3044                 return 0
3045
3046         local striped_dir=$DIR/$tdir/striped_dir
3047         local MDTIDX=1
3048
3049         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
3050
3051         #To make sure MDT1 and MDT0 are connected
3052         #otherwise it may create single stripe dir here
3053         $LFS setdirstripe -i1 $DIR/$tdir/remote_dir
3054
3055         # OBD_FAIL_MDS_REINT_NET_REP       0x119
3056         do_facet mds$MDTIDX lctl set_param fail_loc=0x119
3057         $LFS mkdir -i0 -c2 $striped_dir &
3058
3059         local CLIENT_PID=$!
3060         fail mds$MDTIDX
3061
3062         wait $CLIENT_PID || error "striped dir creation failed"
3063
3064         striped_dir_check_100 || error "striped dir check failed"
3065         rm -rf $DIR/$tdir || error "rmdir failed"
3066 }
3067 run_test 100b "DNE: create striped dir, fail MDT0"
3068
3069 test_101() { #LU-5648
3070         mkdir -p $DIR/$tdir/d1
3071         mkdir -p $DIR/$tdir/d2
3072         touch $DIR/$tdir/file0
3073         num=1000
3074
3075         replay_barrier $SINGLEMDS
3076         for i in $(seq $num) ; do
3077                 echo test$i > $DIR/$tdir/d1/file$i
3078         done
3079
3080         fail_abort $SINGLEMDS
3081         for i in $(seq $num) ; do
3082                 touch $DIR/$tdir/d2/file$i
3083                 test -s $DIR/$tdir/d2/file$i &&
3084                         ls -al $DIR/$tdir/d2/file$i && error "file$i's size > 0"
3085         done
3086
3087         rm -rf $DIR/$tdir
3088 }
3089 run_test 101 "Shouldn't reassign precreated objs to other files after recovery"
3090
3091 check_striped_dir_110()
3092 {
3093         $CHECKSTAT -t dir $DIR/$tdir/striped_dir ||
3094                         error "create striped dir failed"
3095         local stripe_count=$($LFS getdirstripe -c $DIR/$tdir/striped_dir)
3096         [ $stripe_count -eq $MDSCOUNT ] ||
3097                 error "$stripe_count != 2 after recovery"
3098 }
3099
3100 test_110a() {
3101         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3102         ([ $FAILURE_MODE == "HARD" ] &&
3103                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3104                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3105                 return 0
3106
3107         mkdir -p $DIR/$tdir
3108         replay_barrier mds1
3109         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3110         fail mds1
3111
3112         check_striped_dir_110 || error "check striped_dir failed"
3113         rm -rf $DIR/$tdir || error "rmdir failed"
3114
3115         return 0
3116 }
3117 run_test 110a "DNE: create striped dir, fail MDT1"
3118
3119 test_110b() {
3120         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3121         ([ $FAILURE_MODE == "HARD" ] &&
3122                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3123                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3124                 return 0
3125
3126         mkdir -p $DIR/$tdir
3127         replay_barrier mds1
3128         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3129         umount $MOUNT
3130         fail mds1
3131         zconf_mount $(hostname) $MOUNT
3132         client_up || return 1
3133
3134         check_striped_dir_110 || error "check striped_dir failed"
3135
3136         rm -rf $DIR/$tdir || error "rmdir failed"
3137
3138         return 0
3139 }
3140 run_test 110b "DNE: create striped dir, fail MDT1 and client"
3141
3142 test_110c() {
3143         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3144         ([ $FAILURE_MODE == "HARD" ] &&
3145                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3146                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3147                 return 0
3148
3149         mkdir -p $DIR/$tdir
3150         replay_barrier mds2
3151         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3152         fail mds2
3153
3154         check_striped_dir_110 || error "check striped_dir failed"
3155
3156         rm -rf $DIR/$tdir || error "rmdir failed"
3157
3158         return 0
3159 }
3160 run_test 110c "DNE: create striped dir, fail MDT2"
3161
3162 test_110d() {
3163         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3164         ([ $FAILURE_MODE == "HARD" ] &&
3165                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3166                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3167                 return 0
3168
3169         mkdir -p $DIR/$tdir
3170         replay_barrier mds2
3171         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3172         umount $MOUNT
3173         fail mds2
3174         zconf_mount $(hostname) $MOUNT
3175         client_up || return 1
3176
3177         check_striped_dir_110 || error "check striped_dir failed"
3178
3179         rm -rf $DIR/$tdir || error "rmdir failed"
3180
3181         return 0
3182 }
3183 run_test 110d "DNE: create striped dir, fail MDT2 and client"
3184
3185 test_110e() {
3186         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3187         ([ $FAILURE_MODE == "HARD" ] &&
3188                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3189                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3190                 return 0
3191
3192         mkdir -p $DIR/$tdir
3193         replay_barrier mds2
3194         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3195         umount $MOUNT
3196         replay_barrier mds1
3197         fail mds1,mds2
3198         zconf_mount $(hostname) $MOUNT
3199         client_up || return 1
3200
3201         check_striped_dir_110 || error "check striped_dir failed"
3202
3203         rm -rf $DIR/$tdir || error "rmdir failed"
3204
3205         return 0
3206 }
3207 run_test 110e "DNE: create striped dir, uncommit on MDT2, fail client/MDT1/MDT2"
3208
3209 test_110f() {
3210         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3211         ([ $FAILURE_MODE == "HARD" ] &&
3212                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3213                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3214                 return 0
3215
3216         mkdir -p $DIR/$tdir
3217         replay_barrier mds1
3218         replay_barrier mds2
3219         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3220         fail mds1,mds2
3221
3222         check_striped_dir_110 || error "check striped_dir failed"
3223
3224         rm -rf $DIR/$tdir || error "rmdir failed"
3225
3226         return 0
3227 }
3228 run_test 110f "DNE: create striped dir, fail MDT1/MDT2"
3229
3230 test_110g() {
3231         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3232         ([ $FAILURE_MODE == "HARD" ] &&
3233                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3234                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3235                 return 0
3236
3237         mkdir -p $DIR/$tdir
3238         replay_barrier mds1
3239         $LFS mkdir -i1 -c$MDSCOUNT $DIR/$tdir/striped_dir
3240         umount $MOUNT
3241         replay_barrier mds2
3242         fail mds1,mds2
3243         zconf_mount $(hostname) $MOUNT
3244         client_up || return 1
3245
3246         check_striped_dir_110 || error "check striped_dir failed"
3247
3248         rm -rf $DIR/$tdir || error "rmdir failed"
3249
3250         return 0
3251 }
3252 run_test 110g "DNE: create striped dir, uncommit on MDT1, fail client/MDT1/MDT2"
3253
3254 test_111a() {
3255         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3256         ([ $FAILURE_MODE == "HARD" ] &&
3257                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3258                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3259                 return 0
3260
3261         mkdir -p $DIR/$tdir
3262         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3263         replay_barrier mds1
3264         rm -rf $DIR/$tdir/striped_dir
3265         fail mds1
3266
3267         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3268                         error "striped dir still exists"
3269         return 0
3270 }
3271 run_test 111a "DNE: unlink striped dir, fail MDT1"
3272
3273 test_111b() {
3274         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3275         ([ $FAILURE_MODE == "HARD" ] &&
3276                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3277                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3278                 return 0
3279
3280         mkdir -p $DIR/$tdir
3281         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3282         replay_barrier mds2
3283         rm -rf $DIR/$tdir/striped_dir
3284         umount $MOUNT
3285         fail mds2
3286         zconf_mount $(hostname) $MOUNT
3287         client_up || return 1
3288
3289         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3290                         error "striped dir still exists"
3291         return 0
3292 }
3293 run_test 111b "DNE: unlink striped dir, fail MDT2"
3294
3295 test_111c() {
3296         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3297         ([ $FAILURE_MODE == "HARD" ] &&
3298                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3299                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3300                 return 0
3301
3302         mkdir -p $DIR/$tdir
3303         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3304         replay_barrier mds1
3305         rm -rf $DIR/$tdir/striped_dir
3306         umount $MOUNT
3307         replay_barrier mds2
3308         fail mds1,mds2
3309         zconf_mount $(hostname) $MOUNT
3310         client_up || return 1
3311         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3312                         error "striped dir still exists"
3313         return 0
3314 }
3315 run_test 111c "DNE: unlink striped dir, uncommit on MDT1, fail client/MDT1/MDT2"
3316
3317 test_111d() {
3318         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3319         ([ $FAILURE_MODE == "HARD" ] &&
3320                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3321                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3322                 return 0
3323
3324         mkdir -p $DIR/$tdir
3325         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3326         replay_barrier mds2
3327         rm -rf $DIR/$tdir/striped_dir
3328         umount $MOUNT
3329         replay_barrier mds1
3330         fail mds1,mds2
3331         zconf_mount $(hostname) $MOUNT
3332         client_up || return 1
3333         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3334                         error "striped dir still exists"
3335
3336         return 0
3337 }
3338 run_test 111d "DNE: unlink striped dir, uncommit on MDT2, fail client/MDT1/MDT2"
3339
3340 test_111e() {
3341         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3342         ([ $FAILURE_MODE == "HARD" ] &&
3343                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3344                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3345                 return 0
3346
3347         mkdir -p $DIR/$tdir
3348         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3349         replay_barrier mds2
3350         rm -rf $DIR/$tdir/striped_dir
3351         replay_barrier mds1
3352         fail mds1,mds2
3353         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3354                         error "striped dir still exists"
3355         return 0
3356 }
3357 run_test 111e "DNE: unlink striped dir, uncommit on MDT2, fail MDT1/MDT2"
3358
3359 test_111f() {
3360         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3361         ([ $FAILURE_MODE == "HARD" ] &&
3362                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3363                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3364                 return 0
3365
3366         mkdir -p $DIR/$tdir
3367         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3368         replay_barrier mds1
3369         rm -rf $DIR/$tdir/striped_dir
3370         replay_barrier mds2
3371         fail mds1,mds2
3372         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3373                         error "striped dir still exists"
3374         return 0
3375 }
3376 run_test 111f "DNE: unlink striped dir, uncommit on MDT1, fail MDT1/MDT2"
3377
3378 test_111g() {
3379         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3380         ([ $FAILURE_MODE == "HARD" ] &&
3381                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3382                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3383                 return 0
3384
3385         mkdir -p $DIR/$tdir
3386         $LFS mkdir -i1 -c2 $DIR/$tdir/striped_dir
3387         replay_barrier mds1
3388         replay_barrier mds2
3389         rm -rf $DIR/$tdir/striped_dir
3390         fail mds1,mds2
3391         $CHECKSTAT -t dir $DIR/$tdir/striped_dir &&
3392                         error "striped dir still exists"
3393         return 0
3394 }
3395 run_test 111g "DNE: unlink striped dir, fail MDT1/MDT2"
3396
3397 test_112_rename_prepare() {
3398         mkdir -p $DIR/$tdir/src_dir
3399         $LFS mkdir -i 1 $DIR/$tdir/src_dir/src_child ||
3400                 error "create remote source failed"
3401
3402         touch $DIR/$tdir/src_dir/src_child/a
3403
3404         $LFS mkdir -i 2 $DIR/$tdir/tgt_dir ||
3405                 error "create remote target dir failed"
3406
3407         $LFS mkdir -i 3 $DIR/$tdir/tgt_dir/tgt_child ||
3408                 error "create remote target child failed"
3409 }
3410
3411 test_112_check() {
3412         find $DIR/$tdir/
3413         $CHECKSTAT -t dir $DIR/$tdir/src_dir/src_child &&
3414                 error "src_child still exists after rename"
3415
3416         $CHECKSTAT -t file $DIR/$tdir/tgt_dir/tgt_child/a ||
3417                 error "missing file(a) after rename"
3418 }
3419
3420 test_112a() {
3421         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3422         ([ $FAILURE_MODE == "HARD" ] &&
3423                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3424                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3425                 return 0
3426
3427         test_112_rename_prepare
3428         replay_barrier mds1
3429
3430         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3431                 error "rename dir cross MDT failed!"
3432         fail mds1
3433
3434         test_112_check
3435         rm -rf $DIR/$tdir || error "rmdir failed"
3436 }
3437 run_test 112a "DNE: cross MDT rename, fail MDT1"
3438
3439 test_112b() {
3440         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3441         ([ $FAILURE_MODE == "HARD" ] &&
3442                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3443                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3444                 return 0
3445
3446         test_112_rename_prepare
3447         replay_barrier mds2
3448
3449         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3450                 error "rename dir cross MDT failed!"
3451
3452         fail mds2
3453
3454         test_112_check
3455         rm -rf $DIR/$tdir || error "rmdir failed"
3456 }
3457 run_test 112b "DNE: cross MDT rename, fail MDT2"
3458
3459 test_112c() {
3460         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3461         ([ $FAILURE_MODE == "HARD" ] &&
3462                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3463                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3464                 return 0
3465
3466         test_112_rename_prepare
3467         replay_barrier mds3
3468
3469         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3470                 error "rename dir cross MDT failed!"
3471
3472         fail mds3
3473
3474         test_112_check
3475         rm -rf $DIR/$tdir || error "rmdir failed"
3476 }
3477 run_test 112c "DNE: cross MDT rename, fail MDT3"
3478
3479 test_112d() {
3480         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3481         ([ $FAILURE_MODE == "HARD" ] &&
3482                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3483                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3484                 return 0
3485
3486         test_112_rename_prepare
3487         replay_barrier mds4
3488
3489         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3490                 error "rename dir cross MDT failed!"
3491
3492         fail mds4
3493
3494         test_112_check
3495         rm -rf $DIR/$tdir || error "rmdir failed"
3496 }
3497 run_test 112d "DNE: cross MDT rename, fail MDT4"
3498
3499 test_112e() {
3500         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3501         ([ $FAILURE_MODE == "HARD" ] &&
3502                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3503                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3504                 return 0
3505
3506         test_112_rename_prepare
3507         replay_barrier mds1
3508         replay_barrier mds2
3509
3510         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3511                 error "rename dir cross MDT failed!"
3512
3513         fail mds1,mds2
3514
3515         test_112_check
3516         rm -rf $DIR/$tdir || error "rmdir failed"
3517 }
3518 run_test 112e "DNE: cross MDT rename, fail MDT1 and MDT2"
3519
3520 test_112f() {
3521         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3522         ([ $FAILURE_MODE == "HARD" ] &&
3523                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3524                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3525                 return 0
3526
3527         test_112_rename_prepare
3528         replay_barrier mds1
3529         replay_barrier mds3
3530
3531         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3532                 error "rename dir cross MDT failed!"
3533
3534         fail mds1,mds3
3535
3536         test_112_check
3537         rm -rf $DIR/$tdir || error "rmdir failed"
3538 }
3539 run_test 112f "DNE: cross MDT rename, fail MDT1 and MDT3"
3540
3541 test_112g() {
3542         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3543         ([ $FAILURE_MODE == "HARD" ] &&
3544                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3545                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3546                 return 0
3547
3548         test_112_rename_prepare
3549         replay_barrier mds1
3550         replay_barrier mds4
3551
3552         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3553                 error "rename dir cross MDT failed!"
3554
3555         fail mds1,mds4
3556
3557         test_112_check
3558         rm -rf $DIR/$tdir || error "rmdir failed"
3559 }
3560 run_test 112g "DNE: cross MDT rename, fail MDT1 and MDT4"
3561
3562 test_112h() {
3563         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3564         ([ $FAILURE_MODE == "HARD" ] &&
3565                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3566                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3567                 return 0
3568
3569         test_112_rename_prepare
3570         replay_barrier mds2
3571         replay_barrier mds3
3572
3573         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3574                 error "rename dir cross MDT failed!"
3575
3576         fail mds2,mds3
3577
3578         test_112_check
3579         rm -rf $DIR/$tdir || error "rmdir failed"
3580 }
3581 run_test 112h "DNE: cross MDT rename, fail MDT2 and MDT3"
3582
3583 test_112i() {
3584         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3585         ([ $FAILURE_MODE == "HARD" ] &&
3586                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3587                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3588                 return 0
3589
3590         test_112_rename_prepare
3591         replay_barrier mds2
3592         replay_barrier mds4
3593
3594         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3595                 error "rename dir cross MDT failed!"
3596
3597         fail mds2,mds4
3598
3599         test_112_check
3600         rm -rf $DIR/$tdir || error "rmdir failed"
3601 }
3602 run_test 112i "DNE: cross MDT rename, fail MDT2 and MDT4"
3603
3604 test_112j() {
3605         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3606         ([ $FAILURE_MODE == "HARD" ] &&
3607                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3608                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3609                 return 0
3610
3611         test_112_rename_prepare
3612         replay_barrier mds3
3613         replay_barrier mds4
3614
3615         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3616                 error "rename dir cross MDT failed!"
3617
3618         fail mds3,mds4
3619
3620         test_112_check
3621         rm -rf $DIR/$tdir || error "rmdir failed"
3622 }
3623 run_test 112j "DNE: cross MDT rename, fail MDT3 and MDT4"
3624
3625 test_112k() {
3626         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3627         ([ $FAILURE_MODE == "HARD" ] &&
3628                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3629                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3630                 return 0
3631
3632         test_112_rename_prepare
3633         replay_barrier mds1
3634         replay_barrier mds2
3635         replay_barrier mds3
3636
3637         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3638                 error "rename dir cross MDT failed!"
3639
3640         fail mds1,mds2,mds3
3641
3642         test_112_check
3643         rm -rf $DIR/$tdir || error "rmdir failed"
3644 }
3645 run_test 112k "DNE: cross MDT rename, fail MDT1,MDT2,MDT3"
3646
3647 test_112l() {
3648         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3649         ([ $FAILURE_MODE == "HARD" ] &&
3650                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3651                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3652                 return 0
3653
3654         test_112_rename_prepare
3655         replay_barrier mds1
3656         replay_barrier mds2
3657         replay_barrier mds4
3658
3659         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3660                 error "rename dir cross MDT failed!"
3661
3662         fail mds1,mds2,mds4
3663
3664         test_112_check
3665         rm -rf $DIR/$tdir || error "rmdir failed"
3666 }
3667 run_test 112l "DNE: cross MDT rename, fail MDT1,MDT2,MDT4"
3668
3669 test_112m() {
3670         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3671         ([ $FAILURE_MODE == "HARD" ] &&
3672                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3673                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3674                 return 0
3675
3676         test_112_rename_prepare
3677         replay_barrier mds1
3678         replay_barrier mds3
3679         replay_barrier mds4
3680
3681         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3682                 error "rename dir cross MDT failed!"
3683
3684         fail mds1,mds3,mds4
3685
3686         test_112_check
3687         rm -rf $DIR/$tdir || error "rmdir failed"
3688 }
3689 run_test 112m "DNE: cross MDT rename, fail MDT1,MDT3,MDT4"
3690
3691 test_112n() {
3692         [ $MDSCOUNT -lt 4 ] && skip "needs >= 4 MDTs" && return 0
3693         ([ $FAILURE_MODE == "HARD" ] &&
3694                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3695                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3696                 return 0
3697
3698         test_112_rename_prepare
3699         replay_barrier mds2
3700         replay_barrier mds3
3701         replay_barrier mds4
3702
3703         mrename $DIR/$tdir/src_dir/src_child $DIR/$tdir/tgt_dir/tgt_child ||
3704                 error "rename dir cross MDT failed!"
3705
3706         fail mds2,mds3,mds4
3707
3708         test_112_check
3709         rm -rf $DIR/$tdir || error "rmdir failed"
3710 }
3711 run_test 112n "DNE: cross MDT rename, fail MDT2,MDT3,MDT4"
3712
3713 test_115() {
3714         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3715         ([ $FAILURE_MODE == "HARD" ] &&
3716                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3717                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3718                 return 0
3719         local fail_index=0
3720         local index
3721         local i
3722         local j
3723
3724         mkdir -p $DIR/$tdir
3725         for ((j=0;j<$((MDSCOUNT));j++)); do
3726                 fail_index=$((fail_index+1))
3727                 index=$((fail_index % MDSCOUNT))
3728                 replay_barrier mds$((index + 1))
3729                 for ((i=0;i<5;i++)); do
3730                         test_mkdir -i$index -c$MDSCOUNT $DIR/$tdir/test_$i ||
3731                                 error "create striped dir $DIR/$tdir/test_$i"
3732                 done
3733
3734                 fail mds$((index + 1))
3735                 for ((i=0;i<5;i++)); do
3736                         checkstat -t dir $DIR/$tdir/test_$i ||
3737                                 error "$DIR/$tdir/test_$i does not exist!"
3738                 done
3739                 rm -rf $DIR/$tdir/test_* ||
3740                                 error "rmdir fails"
3741         done
3742 }
3743 run_test 115 "failover for create/unlink striped directory"
3744
3745 test_116a() {
3746         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3747         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.7.55) ] &&
3748                 skip "Do not support large update log before 2.7.55" &&
3749                 return 0
3750         ([ $FAILURE_MODE == "HARD" ] &&
3751                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3752                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3753                 return 0
3754         local fail_index=0
3755
3756         mkdir -p $DIR/$tdir
3757         replay_barrier mds1
3758
3759         # OBD_FAIL_SPLIT_UPDATE_REC       0x1702
3760         do_facet mds1 "lctl set_param fail_loc=0x80001702"
3761         $LFS setdirstripe -c$MDSCOUNT $DIR/$tdir/striped_dir
3762
3763         fail mds1
3764         $CHECKSTAT -t dir $DIR/$tdir/striped_dir ||
3765                 error "stried_dir does not exists"
3766 }
3767 run_test 116a "large update log master MDT recovery"
3768
3769 test_116b() {
3770         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
3771         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.7.55) ] &&
3772                 skip "Do not support large update log before 2.7.55" &&
3773                 return 0
3774
3775         ([ $FAILURE_MODE == "HARD" ] &&
3776                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
3777                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
3778                 return 0
3779         local fail_index=0
3780
3781         mkdir -p $DIR/$tdir
3782         replay_barrier mds2
3783
3784         # OBD_FAIL_SPLIT_UPDATE_REC       0x1702
3785         do_facet mds2 "lctl set_param fail_loc=0x80001702"
3786         $LFS setdirstripe -c$MDSCOUNT $DIR/$tdir/striped_dir
3787
3788         fail mds2
3789         $CHECKSTAT -t dir $DIR/$tdir/striped_dir ||
3790                 error "stried_dir does not exists"
3791 }
3792 run_test 116b "large update log slave MDT recovery"
3793
3794
3795 complete $SECONDS
3796 check_and_cleanup_lustre
3797 exit_status