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