lustre/tests/replay-dual.sh

   1 #!/bin/bash
   2
   3 set -e
   4
   5 PTLDEBUG=${PTLDEBUG:--1}
   6 MOUNT_2=${MOUNT_2:-"yes"}
   7 LR_READER=${LR_READER:-"$LUSTRE/utils/lr_reader"}
   8
   9 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
  10 . $LUSTRE/tests/test-framework.sh
  11 init_test_env "$@"
  12 init_logging
  13
  14 remote_mds_nodsh && skip "remote MDS with nodsh" && exit 0
  15
  16 ALWAYS_EXCEPT="$REPLAY_DUAL_EXCEPT "
  17 # bug number for skipped test:  LU-2012 LU-8333
  18 ALWAYS_EXCEPT+="                14b     21b"
  19 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  20
  21 [[ "$mds1_FSTYPE" == zfs ]] &&
  22 # bug number for skipped test:        LU-2230
  23         ALWAYS_EXCEPT="$ALWAYS_EXCEPT 21b"
  24
  25 #                                   7  (min)"
  26 [ "$SLOW" = "no" ] && EXCEPT_SLOW="21b "
  27
  28 build_test_filter
  29 check_and_setup_lustre
  30
  31 MOUNTED=$(mounted_lustre_filesystems)
  32 if ! $(echo $MOUNTED' ' | grep -w -q $MOUNT2' '); then
  33         zconf_mount $HOSTNAME $MOUNT2
  34         MOUNTED2=yes
  35 fi
  36
  37 assert_DIR
  38 rm -rf $DIR/[df][0-9]*
  39
  40 [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
  41
  42 # if there is no CLIENT1 defined, some tests can be ran on localhost
  43 CLIENT1=${CLIENT1:-$HOSTNAME}
  44 # if CLIENT2 doesn't exist then use CLIENT1 instead
  45 # All tests should use CLIENT2 with MOUNT2 only therefore it will work if
  46 # $CLIENT2 == CLIENT1
  47 # Exception is the test which need two separate nodes
  48 CLIENT2=${CLIENT2:-$CLIENT1}
  49
  50 # new sequence needed for MDS < v2_15_61-226-gf00d2467fc
  51 if (( $MDS1_VERSION < $(version_code 2.15.61.226) )); then
  52         force_new_seq_all
  53 fi
  54
  55 LU482_FAILED=$(mktemp -u $TMP/$TESTSUITE.lu482.XXXXXX)
  56 test_0a() {
  57         echo "Check file is LU482_FAILED=$LU482_FAILED"
  58         touch $MOUNT2/$tfile-A # force sync FLD/SEQ update before barrier
  59         replay_barrier $SINGLEMDS
  60 #define OBD_FAIL_PTLRPC_FINISH_REPLAY | CFS_FAIL_ONCE
  61         touch $MOUNT2/$tfile
  62         createmany -o $MOUNT1/$tfile- 50
  63         $LCTL set_param fail_loc=0x80000514
  64         facet_failover $SINGLEMDS
  65         [ -f "$LU482_FAILED" ] && skip "LU-482 failure" && return 0
  66         client_up || (sleep 10; client_up) || (sleep 10; client_up) ||
  67                 error "reconnect failed"
  68         umount -f $MOUNT2
  69         client_up || (sleep 10; client_up) || (sleep 10; client_up) ||
  70                 error "reconnect failed"
  71         zconf_mount `hostname` $MOUNT2 || error "mount2 failed"
  72         unlinkmany $MOUNT1/$tfile- 50 || errot "unlinkmany failed"
  73         rm $MOUNT2/$tfile || error "rm $MOUNT2/$tfile failed"
  74         rm $MOUNT2/$tfile-A || error "rm $MOUNT2/$tfile-A failed"
  75 }
  76 run_test 0a "expired recovery with lost client"
  77
  78 if [ -f "$LU482_FAILED" ]; then
  79         log "Found check file $LU482_FAILED, aborting test script"
  80         rm -vf "$LU482_FAILED"
  81         complete_test $SECONDS
  82         do_nodes $CLIENTS umount -f $MOUNT2 || true
  83         do_nodes $CLIENTS umount -f $MOUNT || true
  84         # copied from stopall, but avoid the MDS recovery
  85         for num in `seq $OSTCOUNT`; do
  86                 stop ost$num -f
  87                 rm -f $TMP/ost${num}active
  88         done
  89         if ! combined_mgs_mds ; then
  90                 stop mgs
  91         fi
  92
  93         exit_status
  94 fi
  95
  96 test_0b() {
  97         replay_barrier $SINGLEMDS
  98         touch $MOUNT2/$tfile
  99         touch $MOUNT1/$tfile-2
 100         umount $MOUNT2
 101         facet_failover $SINGLEMDS
 102         umount -f $MOUNT1
 103         zconf_mount `hostname` $MOUNT1 || error "mount1 fais"
 104         zconf_mount `hostname` $MOUNT2 || error "mount2 fais"
 105         # it is uncertain if file-2 exists or not, remove it if it does
 106         checkstat $MOUNT1/$tfile-2 && rm $MOUNT1/$tfile-2
 107         checkstat $MOUNT2/$tfile && return 2
 108         return 0
 109 }
 110 run_test 0b "lost client during waiting for next transno"
 111
 112 test_1() {
 113         touch $MOUNT1/a
 114         replay_barrier $SINGLEMDS
 115         touch $MOUNT2/b
 116
 117         fail $SINGLEMDS
 118         checkstat $MOUNT2/a || return 1
 119         checkstat $MOUNT1/b || return 2
 120         rm $MOUNT2/a $MOUNT1/b
 121         checkstat $MOUNT1/a && return 3
 122         checkstat $MOUNT2/b && return 4
 123         return 0
 124 }
 125
 126 run_test 1 "|X| simple create"
 127
 128
 129 test_2() {
 130         replay_barrier $SINGLEMDS
 131         mkdir $MOUNT1/adir
 132
 133         fail $SINGLEMDS
 134         checkstat $MOUNT2/adir || return 1
 135         rmdir $MOUNT2/adir
 136         checkstat $MOUNT2/adir && return 2
 137         return 0
 138 }
 139 run_test 2 "|X| mkdir adir"
 140
 141 test_3() {
 142         replay_barrier $SINGLEMDS
 143         mkdir $MOUNT1/adir
 144         mkdir $MOUNT2/adir/bdir
 145
 146         fail $SINGLEMDS
 147         checkstat $MOUNT2/adir      || return 1
 148         checkstat $MOUNT1/adir/bdir || return 2
 149         rmdir $MOUNT2/adir/bdir $MOUNT1/adir
 150         checkstat $MOUNT1/adir      && return 3
 151         checkstat $MOUNT2/adir/bdir && return 4
 152         return 0
 153 }
 154 run_test 3 "|X| mkdir adir, mkdir adir/bdir "
 155
 156 test_4() {
 157         mkdir_on_mdt0 $MOUNT1/adir
 158         replay_barrier $SINGLEMDS
 159         mkdir $MOUNT1/adir  && return 1
 160         mkdir $MOUNT2/adir/bdir
 161
 162         fail $SINGLEMDS
 163         checkstat $MOUNT2/adir      || return 2
 164         checkstat $MOUNT1/adir/bdir || return 3
 165
 166         rmdir $MOUNT2/adir/bdir $MOUNT1/adir
 167         checkstat $MOUNT1/adir      && return 4
 168         checkstat $MOUNT2/adir/bdir && return 5
 169         return 0
 170 }
 171 run_test 4 "|X| mkdir adir (-EEXIST), mkdir adir/bdir "
 172
 173
 174 test_5() {
 175         # multiclient version of replay_single.sh/test_8
 176         mcreate $MOUNT1/a
 177         multiop_bg_pause $MOUNT2/a o_tSc || return  1
 178         pid=$!
 179         rm -f $MOUNT1/a
 180         replay_barrier $SINGLEMDS
 181         kill -USR1 $pid
 182         wait $pid || return 1
 183
 184         fail $SINGLEMDS
 185         [ -e $MOUNT2/a ] && return 2
 186         return 0
 187 }
 188 run_test 5 "open, unlink |X| close"
 189
 190
 191 test_6() {
 192         mcreate $MOUNT1/a
 193         multiop_bg_pause $MOUNT2/a o_c || return 1
 194         pid1=$!
 195         multiop_bg_pause $MOUNT1/a o_c || return 1
 196         pid2=$!
 197         rm -f $MOUNT1/a
 198         replay_barrier $SINGLEMDS
 199         kill -USR1 $pid1
 200         wait $pid1 || return 1
 201
 202         fail $SINGLEMDS
 203         kill -USR1 $pid2
 204         wait $pid2 || return 1
 205         [ -e $MOUNT2/a ] && return 2
 206         return 0
 207 }
 208 run_test 6 "open1, open2, unlink |X| close1 [fail $SINGLEMDS] close2"
 209
 210 test_8() {
 211         replay_barrier $SINGLEMDS
 212         drop_reint_reply "mcreate $MOUNT1/$tfile"    || return 1
 213         fail $SINGLEMDS
 214         checkstat $MOUNT2/$tfile || return 2
 215         rm $MOUNT1/$tfile || return 3
 216
 217         return 0
 218 }
 219 run_test 8 "replay of resent request"
 220
 221 test_9() {
 222         replay_barrier $SINGLEMDS
 223         mcreate $MOUNT1/$tfile-1
 224         mcreate $MOUNT2/$tfile-2
 225         # drop first reint reply
 226         do_facet $SINGLEMDS lctl set_param fail_loc=0x80000119
 227         fail $SINGLEMDS
 228         do_facet $SINGLEMDS lctl set_param fail_loc=0
 229
 230         rm $MOUNT1/$tfile-[1,2] || return 1
 231
 232         return 0
 233 }
 234 run_test 9 "resending a replayed create"
 235
 236 test_10() {
 237         mcreate $MOUNT1/$tfile-1
 238         replay_barrier $SINGLEMDS
 239         unlink $MOUNT1/$tfile-1
 240         mcreate $MOUNT2/$tfile-2
 241         # drop first reint reply
 242         do_facet $SINGLEMDS lctl set_param fail_loc=0x80000119
 243         fail $SINGLEMDS
 244         do_facet $SINGLEMDS lctl set_param fail_loc=0
 245
 246         checkstat $MOUNT1/$tfile-1 && return 1
 247         checkstat $MOUNT1/$tfile-2 || return 2
 248         rm $MOUNT1/$tfile-2
 249
 250         return 0
 251 }
 252 run_test 10 "resending a replayed unlink"
 253
 254 test_11() {
 255         replay_barrier $SINGLEMDS
 256         mcreate $DIR1/$tfile-1
 257         mcreate $DIR2/$tfile-2
 258         mcreate $DIR1/$tfile-3
 259         mcreate $DIR2/$tfile-4
 260         mcreate $DIR1/$tfile-5
 261         # drop all reint replies for a while
 262         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x0119
 263         # note that with this fail_loc set, facet_failover df will fail
 264         facet_failover $SINGLEMDS
 265
 266         local clients=${CLIENTS:-$HOSTNAME}
 267         wait_clients_import_state "$clients" $SINGLEMDS FULL
 268
 269         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
 270
 271         rm $DIR1/$tfile-[1-5] || return 1
 272
 273         return 0
 274 }
 275 run_test 11 "both clients timeout during replay"
 276
 277 test_12() {
 278         replay_barrier $SINGLEMDS
 279
 280         multiop_bg_pause $DIR/$tfile mo_c || return 1
 281         MULTIPID=$!
 282
 283 #define OBD_FAIL_LDLM_ENQUEUE_NET                       0x302
 284         do_facet $SINGLEMDS lctl set_param fail_loc=0x80000302
 285         facet_failover $SINGLEMDS
 286         do_facet $SINGLEMDS lctl set_param fail_loc=0
 287         clients_up || return 1
 288
 289         ls $DIR/$tfile
 290         kill -USR1 $MULTIPID || return 3
 291         wait $MULTIPID || return 4
 292         $CHECKSTAT -t file $DIR/$tfile || return 2
 293         rm $DIR/$tfile
 294
 295         return 0
 296 }
 297 run_test 12 "open resend timeout"
 298
 299 test_13() {
 300         multiop_bg_pause $DIR/$tfile mo_c || return 1
 301         MULTIPID=$!
 302
 303         replay_barrier $SINGLEMDS
 304
 305         kill -USR1 $MULTIPID || return 3
 306         wait $MULTIPID || return 4
 307
 308         # drop close
 309         do_facet $SINGLEMDS lctl set_param fail_loc=0x80000115
 310         facet_failover $SINGLEMDS
 311         do_facet $SINGLEMDS lctl set_param fail_loc=0
 312         clients_up || return 1
 313
 314         ls $DIR/$tfile
 315         $CHECKSTAT -t file $DIR/$tfile || return 2
 316         rm $DIR/$tfile
 317
 318         return 0
 319 }
 320 run_test 13 "close resend timeout"
 321
 322 # test 14a removed after 18143 because it shouldn't fail anymore and do the same
 323 # as test_15a
 324
 325 test_14b() {
 326         wait_mds_ost_sync
 327         wait_delete_completed
 328
 329         local beforeused=$(df -P $DIR | tail -1 | awk '{ print $3 }')
 330
 331         mkdir -p $MOUNT1/$tdir
 332         $LFS setstripe -i 0 $MOUNT1/$tdir
 333         replay_barrier $SINGLEMDS
 334         createmany -o $MOUNT1/$tdir/$tfile- 5
 335
 336         $LFS setstripe -i 0 $MOUNT2/$tfile-2
 337         dd if=/dev/zero of=$MOUNT2/$tfile-2 bs=1M count=5
 338         createmany -o $MOUNT1/$tdir/$tfile-3- 5
 339         umount $MOUNT2
 340
 341         fail $SINGLEMDS
 342         wait_recovery_complete $SINGLEMDS || error "MDS recovery not done"
 343
 344         # first set of files should have been replayed
 345         unlinkmany $MOUNT1/$tdir/$tfile- 5 || error "first unlinks failed"
 346         unlinkmany $MOUNT1/$tdir/$tfile-3- 5 || error "second unlinks failed"
 347
 348         zconf_mount $HOSTNAME $MOUNT2 || error "mount $MOUNT2 failed"
 349         [ -f $MOUNT2/$tfile-2 ] && error "$MOUNT2/$tfile-2 exists!"
 350
 351         wait_mds_ost_sync || error "wait_mds_ost_sync failed"
 352         wait_delete_completed || error "wait_delete_complete failed"
 353
 354         local afterused=$(df -P $DIR | tail -1 | awk '{ print $3 }')
 355         log "before $beforeused, after $afterused"
 356         # leave some margin for some files/dirs to be modified (OI, llog, etc)
 357         [ $afterused -le $((beforeused + $(fs_log_size))) ] ||
 358                 error "after $afterused > before $beforeused"
 359 }
 360 run_test 14b "delete ost orphans if gap occured in objids due to VBR"
 361
 362 test_15a() { # was test_15
 363         replay_barrier $SINGLEMDS
 364         createmany -o $MOUNT1/$tfile- 25
 365         createmany -o $MOUNT2/$tfile-2- 1
 366         umount $MOUNT2
 367
 368         fail $SINGLEMDS
 369
 370         unlinkmany $MOUNT1/$tfile- 25 || return 2
 371         [ -e $MOUNT1/$tfile-2-0 ] && error "$tfile-2-0 exists"
 372
 373         zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 374         return 0
 375 }
 376 run_test 15a "timeout waiting for lost client during replay, 1 client completes"
 377
 378 test_15c() {
 379         replay_barrier $SINGLEMDS
 380         for ((i = 0; i < 2000; i++)); do
 381                 echo "data" > "$MOUNT2/${tfile}-$i" ||
 382                         error "create ${tfile}-$i failed"
 383         done
 384         umount $MOUNT2
 385
 386         fail $SINGLEMDS
 387
 388         zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 389         return 0
 390 }
 391 run_test 15c "remove multiple OST orphans"
 392
 393 test_16() {
 394         replay_barrier $SINGLEMDS
 395         createmany -o $MOUNT1/$tfile- 25
 396         createmany -o $MOUNT2/$tfile-2- 1
 397         umount $MOUNT2
 398
 399         facet_failover $SINGLEMDS
 400         sleep $TIMEOUT
 401         fail $SINGLEMDS
 402
 403         unlinkmany $MOUNT1/$tfile- 25 || return 2
 404
 405         zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 406         return 0
 407 }
 408 run_test 16 "fail MDS during recovery (3571)"
 409
 410 test_17() {
 411         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 412
 413         createmany -o $MOUNT1/$tfile- 25
 414         createmany -o $MOUNT2/$tfile-2- 1
 415
 416         # Make sure the disconnect is lost
 417         replay_barrier ost1
 418         umount $MOUNT2
 419
 420         facet_failover ost1
 421         sleep $TIMEOUT
 422         fail ost1
 423
 424         unlinkmany $MOUNT1/$tfile- 25 || return 2
 425
 426         zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 427         return 0
 428
 429 }
 430 run_test 17 "fail OST during recovery (3571)"
 431
 432 # cleanup with blocked enqueue fails until timer elapses (MDS busy), wait for it
 433 export NOW=0
 434
 435 test_18() { # bug 3822 - evicting client with enqueued lock
 436         #set -vx
 437         local DLMTRACE=$(do_facet $SINGLEMDS lctl get_param debug)
 438         do_facet $SINGLEMDS lctl set_param debug=+dlmtrace
 439         mkdir_on_mdt0 $MOUNT1/$tdir || error "mkdir $MOUNT1/$tdir failed"
 440         touch $MOUNT1/$tdir/${tfile}0 || error "touch file failed"
 441         statmany -s $MOUNT1/$tdir/$tfile 1 500 &
 442         OPENPID=$!
 443         NOW=$SECONDS
 444         #define OBD_FAIL_LDLM_ENQUEUE_BLOCKED    0x30b
 445         do_facet $SINGLEMDS lctl set_param fail_loc=0x8000030b  # hold enqueue
 446         sleep 1
 447         #define OBD_FAIL_LDLM_BL_CALLBACK_NET                   0x305
 448         do_facet client lctl set_param ldlm.namespaces.*.early_lock_cancel=0
 449         do_facet client lctl set_param fail_loc=0x80000305  # drop cb, evict
 450         cancel_lru_locks mdc
 451         sleep 0.1 # wait to ensure first client is one that will be evicted
 452         openfile -f O_RDONLY $MOUNT2/$tdir/$tfile
 453         wait $OPENPID
 454         do_facet client lctl set_param ldlm.namespaces.*.early_lock_cancel=1
 455         do_facet $SINGLEMDS lctl debug_kernel |
 456                 grep "not entering recovery" && error "client not evicted"
 457         do_facet client "lctl set_param fail_loc=0"
 458         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 459 }
 460 run_test 18 "ldlm_handle_enqueue succeeds on evicted export (3822)"
 461
 462 test_19() { # Bug 10991 - resend of open request does not fail assertion.
 463         replay_barrier $SINGLEMDS
 464         drop_mdt_ldlm_reply "createmany -o $DIR/$tfile 1" || return 1
 465         fail $SINGLEMDS
 466         checkstat $DIR2/${tfile}0 || return 2
 467         rm $DIR/${tfile}0 || return 3
 468
 469         return 0
 470 }
 471 run_test 19 "resend of open request"
 472
 473 test_20() { #16389
 474         local before=$SECONDS
 475         replay_barrier $SINGLEMDS
 476         touch $DIR1/$tfile.a
 477         touch $DIR2/$tfile.b
 478         umount $DIR2
 479         fail $SINGLEMDS
 480         rm $DIR1/$tfile.a
 481         zconf_mount $HOSTNAME $DIR2 || error "mount $DIR2 fail"
 482         local tier1=$((SECONDS - before))
 483
 484         before=$SECONDS
 485         replay_barrier $SINGLEMDS
 486         touch $DIR1/$tfile.a
 487         touch $DIR2/$tfile.b
 488         umount $DIR2
 489         fail $SINGLEMDS
 490         rm $DIR1/$tfile.a
 491         zconf_mount $HOSTNAME $DIR2 || error "mount $DIR2 fail"
 492         local tier2=$((SECONDS - before))
 493
 494         # timeout is more than 1.5x original timeout
 495         ((tier2 < tier1 * 6 / 4)) ||
 496                 error "recovery time $tier2 >= 1.5x original time $tier1"
 497 }
 498 run_test 20 "recovery time is not increasing"
 499
 500 # commit on sharing tests
 501 test_21a() {
 502         local param_file=$TMP/$tfile-params
 503
 504         save_lustre_params $SINGLEMDS "mdt.*.commit_on_sharing" > $param_file
 505         do_facet $SINGLEMDS lctl set_param mdt.*.commit_on_sharing=1
 506         touch  $MOUNT1/$tfile-1
 507         mv  $MOUNT2/$tfile-1 $MOUNT2/$tfile-2
 508         mv  $MOUNT1/$tfile-2 $MOUNT1/$tfile-3
 509         replay_barrier_nosync $SINGLEMDS
 510         umount $MOUNT2
 511
 512         facet_failover $SINGLEMDS
 513
 514         # all renames are replayed
 515         unlink  $MOUNT1/$tfile-3 || return 2
 516
 517         zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 518
 519         do_facet $SINGLEMDS lctl set_param mdt.*.commit_on_sharing=0
 520         rm -rf $MOUNT1/$tfile-*
 521         restore_lustre_params < $param_file
 522         rm -f $param_file
 523         return 0
 524 }
 525 run_test 21a "commit on sharing"
 526
 527 test_21b_sub () {
 528         local mds=$1
 529         do_node $CLIENT1 rm -f $MOUNT1/$tfile-*
 530
 531         do_facet $mds sync
 532         do_node $CLIENT1 touch $MOUNT1/$tfile-1
 533         do_node $CLIENT2 mv $MOUNT1/$tfile-1 $MOUNT1/$tfile-2
 534         do_node $CLIENT1 mv $MOUNT1/$tfile-2 $MOUNT1/$tfile-3
 535
 536         replay_barrier_nosync $mds
 537         shutdown_client $CLIENT2 $MOUNT1
 538
 539         facet_failover $mds
 540
 541         # were renames replayed?
 542         local rc=0
 543         echo UNLINK $MOUNT1/$tfile-3
 544         do_node $CLIENT1 unlink  $MOUNT1/$tfile-3 ||
 545                 { echo "unlink $tfile-3 fail!" && rc=1; }
 546
 547         boot_node $CLIENT2
 548         zconf_mount_clients $CLIENT2 $MOUNT1 ||
 549                 error "mount $CLIENT2 $MOUNT1 fail"
 550
 551         return $rc
 552 }
 553
 554 test_21b() {
 555         [ $CLIENTCOUNT -lt 2 ] &&
 556                 { skip "Need 2+ clients, have $CLIENTCOUNT" && return; }
 557
 558         if [ "$FAILURE_MODE" = "HARD" ] && mixed_mdt_devs; then
 559                 skip "Several MDTs on one MDS with FAILURE_MODE=$FAILURE_MODE"
 560                 return 0
 561         fi
 562
 563         zconf_umount_clients $CLIENTS $MOUNT2
 564         zconf_mount_clients $CLIENTS $MOUNT1
 565
 566         local param_file=$TMP/$tfile-params
 567
 568         local mdtidx=$($LFS getstripe -m $MOUNT1)
 569         local facet=mds$((mdtidx + 1))
 570
 571         save_lustre_params $facet "mdt.*.commit_on_sharing" > $param_file
 572
 573         # COS enabled
 574         local COS=1
 575         do_facet $facet lctl set_param mdt.*.commit_on_sharing=$COS
 576
 577         test_21b_sub $facet || error "Not all renames are replayed. COS=$COS"
 578
 579         # there is still a window when transactions may be written to disk
 580         # before the mds device is set R/O. To avoid such a rare test failure,
 581         # the check is repeated several times.
 582         COS=0
 583         local n_attempts=1
 584         while true; do
 585                 # COS disabled (should fail)
 586                 do_facet $facet lctl set_param mdt.*.commit_on_sharing=$COS
 587
 588                 test_21b_sub $facet || break
 589                 n_attempts=$((n_attempts + 1))
 590                 [ $n_attempts -gt 3 ] &&
 591                         error "can't check if COS works: rename replied w/o COS"
 592         done
 593         zconf_mount_clients $CLIENTS $MOUNT2
 594         restore_lustre_params < $param_file
 595         rm -f $param_file
 596         return 0
 597 }
 598 run_test 21b "commit on sharing, two clients"
 599
 600 checkstat_22() {
 601         checkstat $MOUNT1/$remote_dir || return 1
 602         checkstat $MOUNT1/$remote_dir/dir || return 2
 603         checkstat $MOUNT1/$remote_dir/$tfile-1 || return 3
 604         checkstat $MOUNT1/$remote_dir/dir/$tfile-1 || return 4
 605         return 0
 606 }
 607
 608 create_remote_dir_files_22() {
 609         do_node $CLIENT2 mkdir ${MOUNT2}/$remote_dir/dir || return 1
 610         do_node $CLIENT1 createmany -o $MOUNT1/$remote_dir/dir/$tfile- 2 ||
 611                                                             return 2
 612         do_node $CLIENT2 createmany -o $MOUNT2/$remote_dir/$tfile- 2 ||
 613                                                             return 3
 614         return 0
 615 }
 616
 617 test_22a () {
 618         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 619         ([ $FAILURE_MODE == "HARD" ] &&
 620                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
 621                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
 622                 return 0
 623
 624         local MDTIDX=1
 625         local remote_dir=$tdir/remote_dir
 626
 627         do_node $CLIENT1 $LFS mkdir -i 0 $MOUNT1/$tdir ||
 628                 error "lfs mkdir -i 0 $MOUNT1/$tdir failed"
 629
 630         # OBD_FAIL_MDS_REINT_NET_REP       0x119
 631         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
 632         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
 633         CLIENT_PID=$!
 634         sleep 1
 635
 636         fail mds$((MDTIDX + 1))
 637         wait $CLIENT_PID || error "lfs mkdir -i $MDTIDX failed"
 638
 639         replay_barrier mds$MDTIDX
 640         create_remote_dir_files_22 || error "Remote creation failed $?"
 641         fail mds$MDTIDX
 642
 643         checkstat_22 || error "check stat failed $?"
 644
 645         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 646         return 0
 647 }
 648 run_test 22a "c1 lfs mkdir -i 1 dir1, M1 drop reply & fail, c2 mkdir dir1/dir"
 649
 650 test_22b () {
 651         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 652         local MDTIDX=1
 653         local remote_dir=$tdir/remote_dir
 654
 655         do_node $CLIENT1 $LFS mkdir -i 0 $MOUNT1/$tdir ||
 656                 error "lfs mkdir -i 0 $MOUNT1/$tdir failed"
 657
 658         # OBD_FAIL_MDS_REINT_NET_REP       0x119
 659         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
 660         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
 661         CLIENT_PID=$!
 662         sleep 1
 663
 664         fail mds${MDTIDX},mds$((MDTIDX + 1))
 665         wait $CLIENT_PID || error "lfs mkdir -i $MDTIDX failed"
 666
 667         replay_barrier mds$MDTIDX
 668         create_remote_dir_files_22 || error "Remote creation failed $?"
 669         fail mds${MDTIDX}
 670
 671         checkstat_22 || error "check stat failed $?"
 672
 673         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 674         return 0
 675 }
 676 run_test 22b "c1 lfs mkdir -i 1 d1, M1 drop reply & fail M0/M1, c2 mkdir d1/dir"
 677
 678 test_22c () {
 679         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 680         ([ $FAILURE_MODE == "HARD" ] &&
 681                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
 682                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
 683                 return 0
 684         local MDTIDX=1
 685         local remote_dir=$tdir/remote_dir
 686
 687         do_node $CLIENT1 $LFS mkdir -i 0 $MOUNT1/$tdir ||
 688                 error "lfs mkdir -i 0 $MOUNT1/$tdir failed"
 689
 690         # OBD_FAIL_OUT_UPDATE_NET_REP    0x1701
 691         do_facet mds$MDTIDX lctl set_param fail_loc=0x1701
 692         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
 693         CLIENT_PID=$!
 694         sleep 1
 695         do_facet mds$MDTIDX lctl set_param fail_loc=0
 696
 697         fail mds$MDTIDX
 698         wait $CLIENT_PID || error "lfs mkdir -i $MDTIDX failed"
 699
 700         replay_barrier mds$MDTIDX
 701         create_remote_dir_files_22 || error "Remote creation failed $?"
 702         fail mds$MDTIDX
 703
 704         checkstat_22 || error "check stat failed $?"
 705
 706         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 707         return 0
 708 }
 709 run_test 22c "c1 lfs mkdir -i 1 d1, M1 drop update & fail M1, c2 mkdir d1/dir"
 710
 711 test_22d () {
 712         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 713         local MDTIDX=1
 714         local remote_dir=$tdir/remote_dir
 715
 716         do_node $CLIENT1 $LFS mkdir -i 0 $MOUNT1/$tdir ||
 717                 error "lfs mkdir -i 0 $MOUNT1/$tdir failed"
 718
 719         # let previous transactions to complete
 720         # (distributed llog cancels, etc)
 721         do_nodes $(comma_list $(mdts_nodes)) \
 722                 "$LCTL set_param -n osd*.*MDT*.force_sync=1"
 723         sleep 2
 724
 725         # OBD_FAIL_OUT_UPDATE_NET_REP    0x1701
 726         do_facet mds$MDTIDX lctl set_param fail_loc=0x1701
 727         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
 728         CLIENT_PID=$!
 729         sleep 1
 730         do_facet mds$MDTIDX lctl set_param fail_loc=0
 731
 732         fail mds${MDTIDX},mds$((MDTIDX + 1))
 733         wait $CLIENT_PID || error "lfs mkdir -i $MDTIDX failed"
 734
 735         replay_barrier mds$MDTIDX
 736         create_remote_dir_files_22 || error "Remote creation failed $?"
 737         fail mds$MDTIDX
 738
 739         checkstat_22 || error "check stat failed $?"
 740
 741         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 742         return 0
 743 }
 744 run_test 22d "c1 lfs mkdir -i 1 d1, M1 drop update & fail M0/M1,c2 mkdir d1/dir"
 745
 746 checkstat_23() {
 747         checkstat $MOUNT1/$remote_dir || return 1
 748         checkstat $MOUNT1/$remote_dir/$tfile-1 || return 2
 749         return 0
 750 }
 751
 752 create_remote_dir_files_23() {
 753         do_node $CLIENT2 mkdir ${MOUNT2}/$remote_dir || return 1
 754         do_node $CLIENT2 createmany -o $MOUNT2/$remote_dir/$tfile- 2 || return 2
 755         return 0
 756 }
 757
 758 test_23a () {
 759         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 760         ([ $FAILURE_MODE == "HARD" ] &&
 761                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
 762                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
 763                 return 0
 764         local MDTIDX=1
 765         local remote_dir=$tdir/remote_dir
 766
 767         do_node $CLIENT1 $LFS mkdir -i 0 $MOUNT1/$tdir ||
 768                 error "lfs mkdir -i 0 $MOUNT1/$tdir failed"
 769         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
 770                 error "lfs mkdir -i $MDTIDX failed"
 771         # OBD_FAIL_MDS_REINT_NET_REP       0x119
 772         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
 773         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
 774         local CLIENT_PID=$!
 775         sleep 1
 776         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0
 777
 778         fail mds$((MDTIDX + 1))
 779         wait $CLIENT_PID || error "rmdir remote dir failed"
 780
 781         replay_barrier mds${MDTIDX}
 782         create_remote_dir_files_23 || error "Remote creation failed $?"
 783         fail mds${MDTIDX}
 784
 785         checkstat_23 || error "check stat failed $?"
 786
 787         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 788         return 0
 789 }
 790 run_test 23a "c1 rmdir d1, M1 drop reply and fail, client2 mkdir d1"
 791
 792 test_23b () {
 793         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 794         local MDTIDX=1
 795         local remote_dir=$tdir/remote_dir
 796
 797         do_node $CLIENT1 $LFS mkdir -i 0 $MOUNT1/$tdir ||
 798                 error "lfs mkdir -i 0 $MOUNT/$tdir failed"
 799         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
 800                 error "lfs mkdir -i $MDTIDX failed"
 801
 802         # OBD_FAIL_MDS_REINT_NET_REP       0x119
 803         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
 804         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
 805         local CLIENT_PID=$!
 806         sleep 1
 807         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0
 808
 809         fail mds${MDTIDX},mds$((MDTIDX + 1))
 810         wait $CLIENT_PID || error "rmdir remote dir failed"
 811
 812         replay_barrier mds${MDTIDX}
 813         create_remote_dir_files_23 || error "Remote creation failed $?"
 814         fail mds${MDTIDX}
 815
 816         checkstat_23 || error "check stat failed $?"
 817
 818         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 819         return 0
 820 }
 821 run_test 23b "c1 rmdir d1, M1 drop reply and fail M0/M1, c2 mkdir d1"
 822
 823 test_23c () {
 824         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 825
 826         ([ $FAILURE_MODE == "HARD" ] &&
 827                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
 828                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
 829                 return 0
 830         local MDTIDX=1
 831         local remote_dir=$tdir/remote_dir
 832
 833         do_node $CLIENT1 $LFS mkdir -i 0 $MOUNT1/$tdir ||
 834                 error "lfs mkdir -i 0 $MOUNT1/$tdir failed"
 835         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
 836                 error "lfs mkdir -i $MDTIDX failed"
 837
 838         # OBD_FAIL_OUT_UPDATE_NET_REP    0x1701
 839         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
 840         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
 841         CLIENT_PID=$!
 842         sleep 1
 843         do_facet mds${MDTIDX} lctl set_param fail_loc=0
 844
 845         fail mds${MDTIDX}
 846         wait $CLIENT_PID || error "rmdir remote dir failed"
 847
 848         replay_barrier mds${MDTIDX}
 849         create_remote_dir_files_23 || error "Remote creation failed $?"
 850         fail mds${MDTIDX}
 851
 852         checkstat_23 || error "check stat failed $?"
 853
 854         rm -rf $MOUNT1/$tdir || return 6
 855         return 0
 856 }
 857 run_test 23c "c1 rmdir d1, M0 drop update reply and fail M0, c2 mkdir d1"
 858
 859 test_23d () {
 860         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 861         local MDTIDX=1
 862         local remote_dir=$tdir/remote_dir
 863
 864         do_node $CLIENT1 $LFS mkdir -i 0 $MOUNT1/$tdir ||
 865                 error "lfs mkdir -i 0 $MOUNT1/$tdir failed"
 866         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
 867                 error "lfs mkdir -i $MDTIDX failed"
 868
 869         # let previous transactions to complete
 870         # (distributed llog cancels, etc)
 871         do_nodes $(mdts_nodes) "$LCTL set_param -n osd*.*MDT*.force_sync=1"
 872         sleep 2
 873
 874         # OBD_FAIL_UPDATE_OBJ_NET    0x1701
 875         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
 876         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
 877         CLIENT_PID=$!
 878         sleep 1
 879         do_facet mds${MDTIDX} lctl set_param fail_loc=0
 880
 881         fail mds${MDTIDX},mds$((MDTIDX + 1))
 882         wait $CLIENT_PID || error "rmdir remote dir failed"
 883
 884         replay_barrier mds${MDTIDX}
 885         create_remote_dir_files_23 || error "Remote creation failed $?"
 886         fail mds${MDTIDX}
 887
 888         checkstat_23 || error "check stat failed $?"
 889
 890         rm -rf $MOUNT1/$tdir || return 6
 891         return 0
 892 }
 893 run_test 23d "c1 rmdir d1, M0 drop update reply and fail M0/M1, c2 mkdir d1"
 894
 895 test_24 () {
 896         [[ "$MDS1_VERSION" -gt $(version_code 2.5.2) ]] ||
 897                 skip "Need MDS version newer than 2.5.2"
 898
 899         touch $MOUNT/$tfile
 900         stat $MOUNT/$tfile >&/dev/null
 901 # OBD_FAIL_MDS_REINT_NET_REP
 902         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x119
 903         $TRUNCATE $MOUNT/$tfile 100 &
 904         PID=$!
 905         sleep 1
 906         do_facet $SINGLEMDS lctl set_param fail_loc=0
 907         # sync to release rep-ack lock quickly
 908         do_nodes $(mdts_nodes) "lctl set_param -n osd*.*MDT*.force_sync 1"
 909         rm $MOUNT2/$tfile
 910         wait
 911 }
 912 run_test 24 "reconstruct on non-existing object"
 913
 914 # end commit on sharing tests
 915
 916 test_25() {
 917         cancel_lru_locks osc
 918
 919         $LFS setstripe -i 0 -c 1 $DIR/$tfile
 920
 921         # get lock for the 1st client
 922         dd if=/dev/zero of=$DIR/$tfile count=1 >/dev/null ||
 923                 error "failed to write data"
 924
 925         # get waiting locks for the 2nd client
 926         drop_ldlm_cancel "multiop $DIR2/$tfile Ow512" &
 927         sleep 1
 928
 929         # failover, replay and resend replayed waiting locks
 930         if [ "$OST1_VERSION" -ge $(version_code 2.6.90) ]; then
 931                 #define OBD_FAIL_LDLM_SRV_CP_AST      0x325
 932                 do_facet ost1 lctl set_param fail_loc=0x80000325
 933         else
 934                 #define OBD_FAIL_OST_LDLM_REPLY_NET     0x213
 935                 do_facet ost1 lctl set_param fail_loc=0x80000213
 936         fi
 937
 938         fail ost1
 939
 940         # multiop does not finish because CP AST is skipped;
 941         # it is ok to kill it in the test, because CP AST is already re-sent
 942         # and it does not hung forever in real life
 943         killall -r "(multiop)$"
 944         wait
 945 }
 946 run_test 25 "replay|resend"
 947
 948 pids_26=()
 949 dirs_26=()
 950
 951 cleanup_26() {
 952         trap 0
 953
 954         for pid_26 in "${pids_26[@]}"; do
 955                 if [[ -n "$pid_26" ]]; then
 956                         kill -0 "$pid_26" && kill "$pid_26" && \
 957                                 wait "$pid_26" || true
 958                 fi
 959         done
 960
 961         for dir_26 in "${dirs_26[@]}"; do
 962                 if [[ -n "$dir_26" && -d "$dir_26" ]]; then
 963                         rm -rf "$dir_26"
 964                 fi
 965         done
 966 }
 967
 968 test_26() {
 969         local clients=${CLIENTS:-$HOSTNAME}
 970
 971         zconf_mount_clients $clients $MOUNT
 972
 973         local duration=600
 974         [[ "$SLOW" == "no" ]] && duration=200
 975         # set duration to 900 because it takes some time to boot node
 976         [[ "$FAILURE_MODE" == HARD ]] && duration=900
 977
 978         local start_ts=$SECONDS
 979         local rc=0
 980
 981         stack_trap cleanup_26
 982
 983         local tar_dir=$DIR/$tdir/run_tar
 984
 985         dirs_26+=($tar_dir)
 986         (
 987                 stack_trap 'set +e; jobs -p | xargs -r kill; wait; exit' \
 988                         SIGTERM
 989
 990                 while true; do
 991                         test_mkdir -p -c$MDSCOUNT $tar_dir || break
 992
 993                         if (( MDSCOUNT >= 2 )); then
 994                                 $LFS setdirstripe -D -c$MDSCOUNT $tar_dir ||
 995                                         error "set default dirstripe failed"
 996                         fi
 997
 998                         cd $tar_dir || break
 999                         tar -C / -cf - etc | tar -xf - &
1000
1001                         local tar_pid=$!
1002                         local tar_rc=0
1003
1004                         wait $tar_pid || tar_rc=$?
1005
1006                         if (( tar_rc > 0 && tar_rc <= 128 )); then
1007                                 error "tar failed with rc $tar_rc"
1008                         fi
1009
1010                         cd $DIR/$tdir || break
1011                         rm -rf $tar_dir || break
1012                 done
1013         ) &
1014
1015         local tar_26_pid=$!
1016
1017         echo "Started tar loop with pid $tar_26_pid"
1018         pids_26+=($tar_26_pid)
1019
1020         local dbench_dir=$DIR2/$tdir/run_dbench
1021
1022         dirs_26+=($dbench_dir)
1023         (
1024                 stack_trap 'set +e; jobs -p | xargs -r kill; wait; exit' \
1025                         SIGTERM
1026
1027                 while true; do
1028                         test_mkdir -p -c$MDSCOUNT $dbench_dir || break
1029
1030                         if (( MDSCOUNT >= 2 )); then
1031                                 $LFS setdirstripe -D -c$MDSCOUNT $dbench_dir ||
1032                                         error "set default dirstripe failed"
1033                         fi
1034
1035                         cd $dbench_dir || break
1036                         bash rundbench 1 -D $dbench_dir -t 100 &
1037
1038                         local dbench_pid=$!
1039                         local dbench_rc=0
1040
1041                         wait $dbench_pid || dbench_rc=$?
1042
1043                         if (( dbench_rc > 0 && dbench_rc <= 128 )); then
1044                                 error "dbench failed with rc $dbench_rc"
1045                         fi
1046
1047                         cd $DIR/$tdir || break
1048                         rm -rf $dbench_dir || break
1049                 done
1050         ) &
1051
1052         local dbench_26_pid=$!
1053
1054         echo "Started dbench loop with $dbench_26_pid"
1055         pids_26+=($dbench_26_pid)
1056
1057         local num_failovers=0
1058         local fail_index=1
1059
1060         while (( (SECONDS - start_ts) < duration )); do
1061                 kill -0 $tar_26_pid || error "tar $tar_26_pid missing"
1062                 kill -0 $dbench_26_pid || error "dbench $dbench_26_pid missing"
1063                 sleep 2
1064                 replay_barrier mds$fail_index
1065                 sleep 2 # give clients a time to do operations
1066                 # Increment the number of failovers
1067                 num_failovers=$((num_failovers + 1))
1068                 log "$TESTNAME fail mds$fail_index $num_failovers times"
1069                 fail mds$fail_index
1070                 if (( fail_index < MDSCOUNT )); then
1071                         fail_index=$((fail_index + 1))
1072                 else
1073                         fail_index=1
1074                 fi
1075         done
1076
1077         # stop the client loads
1078         kill -0 $tar_26_pid || error "tar $tar_26_pid stopped"
1079         kill -0 $dbench_26_pid || error "dbench $dbench_26_pid stopped"
1080
1081         cleanup_26 || true
1082 }
1083 run_test 26 "dbench and tar with mds failover"
1084
1085 test_28() {
1086         wait_delete_completed
1087
1088         $LFS setstripe -i 0 -c 1 $DIR2/$tfile
1089         dd if=/dev/zero of=$DIR2/$tfile bs=4096 count=1
1090
1091         #define OBD_FAIL_LDLM_SRV_BL_AST         0x324
1092         do_facet ost1 $LCTL set_param fail_loc=0x80000324
1093
1094         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 &
1095         local pid=$!
1096         sleep 2
1097
1098         #define OBD_FAIL_LDLM_GRANT_CHECK        0x32a
1099         do_facet ost1 $LCTL set_param fail_loc=0x32a
1100
1101         fail ost1
1102
1103         sleep 2
1104         cancel_lru_locks OST0000-osc
1105         wait $pid || error "dd failed"
1106 }
1107 run_test 28 "lock replay should be ordered: waiting after granted"
1108
1109 test_29() {
1110         local dir0=$DIR/$tdir/d0
1111         local dir1=$DIR/$tdir/d1
1112
1113         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1114         [ $CLIENTCOUNT -lt 2 ] && skip "needs >= 2 clients" && return 0
1115         [ "$CLIENT1" == "$CLIENT2" ] &&
1116                 skip "clients must be on different nodes" && return 0
1117
1118         mkdir -p $DIR/$tdir
1119         $LFS mkdir -i0 $dir0
1120         $LFS mkdir -i1 $dir1
1121         sync
1122
1123         replay_barrier mds2
1124         # create a remote dir, drop reply
1125         #define OBD_FAIL_PTLRPC_ROUND_XID 0x530
1126         $LCTL set_param fail_loc=0x530 fail_val=36
1127         #define OBD_FAIL_MDS_REINT_MULTI_NET_REP 0x15a
1128         do_facet mds2 $LCTL set_param fail_loc=0x8000015a
1129         echo make remote dir d0 for $dir0
1130         $LFS mkdir -i1 -c1 $dir0/d3 &
1131         sleep 1
1132
1133         echo make local dir d1 for $dir1
1134         do_node $CLIENT2 $LCTL set_param fail_loc=0x530 fail_val=36
1135         do_node $CLIENT2 mkdir $dir1/d4
1136
1137         fail mds2
1138 }
1139 run_test 29 "replay vs update with the same xid"
1140
1141 test_30() {
1142         $LFS setstripe -E 1m -L mdt -E -1 $DIR/$tfile
1143         #first write to have no problems with grants
1144         dd if=/dev/zero of=$DIR/$tfile bs=4k count=10 ||
1145                 error "dd on client failed"
1146         dd if=/dev/zero of=$DIR/$tfile bs=4k count=10 seek=10 ||
1147                 error "dd on client failed"
1148
1149         #define OBD_FAIL_LDLM_REPLAY_PAUSE       0x32e
1150         lctl set_param fail_loc=0x32e fail_val=4
1151         dd of=/dev/null if=$DIR2/$tfile &
1152         local pid=$!
1153         sleep 1
1154
1155         fail $SINGLEMDS
1156
1157         wait $pid || error "dd on client failed"
1158 }
1159 run_test 30 "layout lock replay is not blocked on IO"
1160
1161 test_31() {
1162         mkdir_on_mdt0 $DIR1/$tdir
1163         $LFS setstripe -c 1 -i 0 $DIR1/$tdir
1164         for (( i=0; i < 10; i++ )) ; do
1165                 mkdir -p $DIR1/$tdir/d.${i}
1166         done
1167         mkdir $DIR1/$tdir/mdtdir
1168         $LFS setstripe -E 1M -L mdt $DIR1/$tdir/mdtdir
1169
1170         # failover has to take longer than blocking timeout involved
1171         # by second multiop below which is set to obd_timeout/2 by
1172         # disabling AT
1173         local timeout=$(do_facet mds1 $LCTL get_param -n timeout)
1174
1175         timeout=$((timeout / 2 + 5))
1176         fail ost1 $timeout &
1177         local failpid=$!
1178
1179         sleep 1
1180
1181         # consume preallocated objects, precreate thread will be awakened
1182         consume_precreations $DIR1/$tdir mds1 0 1
1183
1184         # disable AT so that blocking timeout gets set to obd_timeout/2
1185         local amm=$(at_max_get mds1)
1186
1187         at_max_set 0 mds1
1188         stack_trap "at_max_set $amm mds1"
1189
1190         declare -a multiops
1191
1192         #define OBD_FAIL_LLITE_XATTR_PAUSE                 0x1420
1193         $LCTL set_param fail_loc=0x80001420
1194         $MULTIOP $DIR1/$tdir/mdtdir/$tfile Osw4096c &
1195         multiops+=($!)
1196
1197         for (( i=0; i<10; i++ )); do
1198                 if [ -w $DIR2/$tdir/mdtdir/$tfile ]; then
1199                         echo "file $DIR2/$tdir/mdtdir/$tfile is ready"
1200                         break
1201                 else
1202                         echo "file $DIR2/$tdir/mdtdir/$tfile is not ready, wait 0.5 second..."
1203                         sleep 0.5
1204                 fi
1205         done
1206
1207         $MULTIOP $DIR2/$tdir/mdtdir/$tfile oO_WRONLY:w4096c &
1208         multiops+=($!)
1209
1210         sleep 0.5
1211         local mmrif=$($LCTL get_param -n \
1212                 mdc.$FSNAME-MDT0000-mdc-*.max_mod_rpcs_in_flight | tail -1)
1213         # these are blocked by precreation until ost failover is in progress
1214         for (( i=0; i < $mmrif; i++ )) ; do
1215                 $MULTIOP $DIR1/$tdir/d.${i}/parallel Oc &
1216                 multiops+=($!)
1217         done
1218         wait $failpid
1219         local failed=0
1220
1221         echo "pids: ${multiops[@]}"
1222         for pid in "${multiops[@]}"; do
1223                 local rc=0
1224
1225                 wait $pid || rc=$?
1226                 if (( $rc != 0 )); then
1227                         echo "wait $pid failed, rc = $rc"
1228                         ((failed++))
1229                 fi
1230         done
1231
1232         $LFS df $MOUNT
1233         $LFS df -i $MOUNT
1234
1235         if (( failed != 0 )); then
1236                 local bigly=($(du -sk $MOUNT/* | sort -nr | head -10))
1237
1238                 for ((i = 0; i < ${#bigly[*]}; i += 2)); do
1239                         echo -e "${bigly[i]}\t${bigly[$((i+1))]}"
1240                 done
1241
1242                 local biggest=${bigly[1]}
1243
1244                 [[ -f $biggest ]] || du -sk $biggest/* | sort -nr | head -10
1245                 error "$failed multiops failed due to '$biggest'"
1246         fi
1247 }
1248 run_test 31 "deadlock on file_remove_privs and occupied mod rpc slots"
1249
1250 test_32() {
1251         (( $MDSCOUNT < 2 )) && skip_env "needs >= 2 MDTs"
1252
1253         # inject a gap with 10th transaction
1254 #define OBD_FAIL_LLOG_ADD_GAP                      0x131d
1255         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x0000131d fail_val=10
1256         for ((i=0; i < 20; i++)); do
1257                 $LFS setdirstripe -i1 $DIR/$tdir-$i ||
1258                         error "can't mkdir $DIR/$tdir-$i"
1259         done
1260
1261         # prevent update llog cancellation, so next boot MDS has
1262         # process the update llog with gap injected
1263 #define OBD_FAIL_TGT_TXN_NO_CANCEL      0x726
1264         $LCTL set_param fail_loc=0x726
1265
1266         stop mds2
1267         stop mds1
1268
1269         $LCTL set_param fail_loc=0
1270
1271         mount_facet mds1
1272         mount_facet mds2
1273
1274         $LFS df $DIR
1275
1276         client_evicted $CLIENT1 &&
1277                 error "client got evicted due to aborted recovery"
1278         return 0
1279 }
1280 run_test 32 "gap in update llog shouldn't break recovery"
1281
1282 last_rcvd_check_incompat_flag() {
1283         local facet="$1"
1284         local flag2check="$2"
1285         local dev=$(facet_device $facet)
1286         local incompat
1287
1288         incompat=$(do_facet $facet $LR_READER $dev |
1289                         awk '/feature_incompat:/ {print $2}')
1290         echo "last_rcvd in $dev: incompat = $incompat"
1291
1292         return $(( (incompat & flag2check) != flag2check ))
1293 }
1294
1295
1296 test_33() { # LU-15935
1297         (( $MDS1_VERSION >= $(version_code 2.15.52.86) )) ||
1298         (( $MDS1_VERSION >= $(version_code 2.15.2) &&
1299            $MDS1_VERSION < $(version_code 2.15.50) )) ||
1300                 skip "Need MDS version at least 2.15.52.86 or 2.15.2"
1301
1302         [[ "$mds1_FSTYPE" == "ldiskfs" ]] || skip "ldiskfs only test"
1303         (( MDSCOUNT > 1 )) || skip "needs >= 2 MDTs"
1304
1305         local at_min_old
1306         at_min_old=$(at_min_get ost1)
1307         at_min_set 60 ost
1308         stack_trap "at_min_set $at_min_old ost || true"
1309
1310         # Clean old locks
1311         cancel_lru_locks mdc
1312
1313         clients_up
1314         stop mds2
1315
1316         # check for OBD_INCOMPAT_MULTI_RPCS (0x400) in last_rcvd
1317         last_rcvd_check_incompat_flag mds2 0x400 ||
1318                 error "1st failover: OBD_INCOMPAT_MULTI_RPCS is not set on MDT0000 last_rcvd"
1319
1320         # lose 1 client while the MDT failover
1321         umount -f $MOUNT2
1322
1323         mount_facet mds2
1324         wait_clients_import_state "$HOSTNAME" mds2 "REPLAY_WAIT"
1325
1326         do_facet mds2 $LCTL --device $(convert_facet2label mds2) abort_recovery
1327         wait_clients_import_state "$HOSTNAME" mds2 "FULL"
1328         wait_recovery_complete mds2
1329         sleep 5
1330         stop mds2
1331
1332         last_rcvd_check_incompat_flag mds2 0x400 ||
1333                 error "2sd failover: OBD_INCOMPAT_MULTI_RPCS is not set on MDT0000 last_rcvd"
1334
1335         mount_facet mds2
1336
1337         zconf_mount $HOSTNAME $MOUNT2 || error "Fail to mount $MOUNT2"
1338         wait_clients_import_state "$HOSTNAME" mds2 "FULL"
1339         wait_recovery_complete mds2
1340 }
1341 run_test 33 "Check for OBD_INCOMPAT_MULTI_RPCS in last_rcvd after abort_recovery"
1342
1343 complete_test $SECONDS
1344 SLEEP=$((SECONDS - $NOW))
1345 [ $SLEEP -lt $TIMEOUT ] && sleep $SLEEP
1346 [ "$MOUNTED2" = yes ] && zconf_umount $HOSTNAME $MOUNT2 || true
1347 check_and_cleanup_lustre
1348 exit_status