lustre/tests/replay-dual.sh

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