lustre/tests/replay-dual.sh

   1 #!/bin/bash
   2
   3 set -e
   4
   5 # bug number:  LU-2012 10124
   6 ALWAYS_EXCEPT="14b     15c   $REPLAY_DUAL_EXCEPT"
   7
   8 SAVE_PWD=$PWD
   9 PTLDEBUG=${PTLDEBUG:--1}
  10 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
  11 SETUP=${SETUP:-""}
  12 CLEANUP=${CLEANUP:-""}
  13 MOUNT_2=${MOUNT_2:-"yes"}
  14 export MULTIOP=${MULTIOP:-multiop}
  15 . $LUSTRE/tests/test-framework.sh
  16
  17 init_test_env $@
  18 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
  19 init_logging
  20
  21 remote_mds_nodsh && skip "remote MDS with nodsh" && exit 0
  22
  23 [ "$SLOW" = "no" ] && EXCEPT_SLOW="21b"
  24
  25 [[ $(facet_fstype $SINGLEMDS) == zfs ]] &&
  26 # bug number for skipped test:        LU-2230
  27         ALWAYS_EXCEPT="$ALWAYS_EXCEPT 21b"
  28
  29 build_test_filter
  30
  31 check_and_setup_lustre
  32 MOUNTED=$(mounted_lustre_filesystems)
  33 if ! $(echo $MOUNTED' ' | grep -w -q $MOUNT2' '); then
  34     zconf_mount $HOSTNAME $MOUNT2
  35     MOUNTED2=yes
  36 fi
  37
  38 assert_DIR
  39 rm -rf $DIR/[df][0-9]*
  40
  41 [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
  42
  43 # if there is no CLIENT1 defined, some tests can be ran on localhost
  44 CLIENT1=${CLIENT1:-$HOSTNAME}
  45 # if CLIENT2 doesn't exist then use CLIENT1 instead
  46 # All tests should use CLIENT2 with MOUNT2 only therefore it will work if
  47 # $CLIENT2 == CLIENT1
  48 # Exception is the test which need two separate nodes
  49 CLIENT2=${CLIENT2:-$CLIENT1}
  50
  51 # LU-482 Avert LVM and VM inability to flush caches in pre .33 kernels
  52 if [ $LINUX_VERSION_CODE -lt $(version_code 2.6.33) ]; then
  53         sync
  54         do_facet $SINGLEMDS "sync; sleep 10; sync; sleep 10; sync"
  55 fi
  56
  57 LU482_FAILED=$(mktemp -u $TMP/$TESTSUITE.lu482.XXXXXX)
  58 test_0a() {
  59         echo "Check file is LU482_FAILED=$LU482_FAILED"
  60         touch $MOUNT2/$tfile-A # force sync FLD/SEQ update before barrier
  61         replay_barrier $SINGLEMDS
  62 #define OBD_FAIL_PTLRPC_FINISH_REPLAY | OBD_FAIL_ONCE
  63         touch $MOUNT2/$tfile
  64         createmany -o $MOUNT1/$tfile- 50
  65         $LCTL set_param fail_loc=0x80000514
  66         facet_failover $SINGLEMDS
  67         [ -f "$LU482_FAILED" ] && skip "LU-482 failure" && return 0
  68         client_up || return 1
  69         umount -f $MOUNT2
  70         client_up || return 1
  71         zconf_mount `hostname` $MOUNT2 || error "mount2 fais"
  72         unlinkmany $MOUNT1/$tfile- 50 || return 2
  73         rm $MOUNT2/$tfile || return 3
  74         rm $MOUNT2/$tfile-A || return 4
  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 $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 $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     munlink $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         $SETSTRIPE -i 0 $MOUNT1/$tdir
 333         replay_barrier $SINGLEMDS
 334         createmany -o $MOUNT1/$tdir/$tfile- 5
 335
 336         $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 -gt $((BEFOREUSED + 128)) ] &&
 358                 error "after $AFTERUSED > before $BEFOREUSED" || true
 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" || error "create ${tfile}-$i failed"
 382     done
 383     umount $MOUNT2
 384
 385     fail $SINGLEMDS
 386
 387     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 388     return 0
 389 }
 390 run_test 15c "remove multiple OST orphans"
 391
 392 test_16() {
 393     replay_barrier $SINGLEMDS
 394     createmany -o $MOUNT1/$tfile- 25
 395     createmany -o $MOUNT2/$tfile-2- 1
 396     umount $MOUNT2
 397
 398     facet_failover $SINGLEMDS
 399     sleep $TIMEOUT
 400     fail $SINGLEMDS
 401
 402     unlinkmany $MOUNT1/$tfile- 25 || return 2
 403
 404     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 405     return 0
 406
 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 -p $MOUNT1/$tdir || error "mkdir $MOUNT1/$tdir failed"
 440         touch $MOUNT1/$tdir/$tfile
 441         #define OBD_FAIL_LDLM_ENQUEUE_BLOCKED    0x30b
 442         statmany -s $MOUNT1/$tdir/f 1 500 &
 443         OPENPID=$!
 444         NOW=$(date +%s)
 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         usleep 500 # 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_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 2.25x original timeout
 495         ((tier2 < tier1 * 9 / 4)) ||
 496                 error "recovery time $tier2 >= 2.25x 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         [ -z "$CLIENTS" ] && skip "Need two or more clients" && return
 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         # COS disabled (should fail)
 581         COS=0
 582         do_facet $facet lctl set_param mdt.*.commit_on_sharing=$COS
 583
 584         # there is still a window when transactions may be written to disk
 585         # before the mds device is set R/O. To avoid such a rare test failure,
 586         # the check is repeated several times.
 587         local n_attempts=1
 588         while true; do
 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 mkdir -p $MOUNT1/${tdir}
 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
 635         fail mds$((MDTIDX + 1))
 636         wait $CLIENT_PID || error "lfs mkdir failed"
 637
 638         replay_barrier mds$MDTIDX
 639         create_remote_dir_files_22 || error "Remote creation failed $?"
 640         fail mds$MDTIDX
 641
 642         checkstat_22 || error "check stat failed $?"
 643
 644         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 645         return 0
 646 }
 647 run_test 22a "c1 lfs mkdir -i 1 dir1, M1 drop reply & fail, c2 mkdir dir1/dir"
 648
 649 test_22b () {
 650         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 651         local MDTIDX=1
 652         local remote_dir=$tdir/remote_dir
 653
 654         # OBD_FAIL_MDS_REINT_NET_REP       0x119
 655         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 656
 657         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
 658         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
 659         CLIENT_PID=$!
 660
 661         fail mds${MDTIDX},mds$((MDTIDX + 1))
 662         wait $CLIENT_PID || error "lfs mkdir failed"
 663
 664         replay_barrier mds$MDTIDX
 665         create_remote_dir_files_22 || error "Remote creation failed $?"
 666         fail mds${MDTIDX}
 667
 668         checkstat_22 || error "check stat failed $?"
 669
 670         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 671         return 0
 672 }
 673 run_test 22b "c1 lfs mkdir -i 1 d1, M1 drop reply & fail M0/M1, c2 mkdir d1/dir"
 674
 675 test_22c () {
 676         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 677         ([ $FAILURE_MODE == "HARD" ] &&
 678                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
 679                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
 680                 return 0
 681         local MDTIDX=1
 682         local remote_dir=${tdir}/remote_dir
 683
 684         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 685
 686         # OBD_FAIL_UPDATE_OBJ_NET_REP    0x1701
 687         do_facet mds$MDTIDX lctl set_param fail_loc=0x1701
 688         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
 689         CLIENT_PID=$!
 690         do_facet mds$MDTIDX lctl set_param fail_loc=0
 691
 692         fail mds$MDTIDX
 693         wait $CLIENT_PID || error "lfs mkdir failed"
 694
 695         replay_barrier mds$MDTIDX
 696         create_remote_dir_files_22 || error "Remote creation failed $?"
 697         fail mds$MDTIDX
 698
 699         checkstat_22 || error "check stat failed $?"
 700
 701         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 702         return 0
 703 }
 704 run_test 22c "c1 lfs mkdir -i 1 d1, M1 drop update & fail M1, c2 mkdir d1/dir"
 705
 706 test_22d () {
 707         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 708         local MDTIDX=1
 709         local remote_dir=${tdir}/remote_dir
 710
 711         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 712
 713         # OBD_FAIL_UPDATE_OBJ_NET_REP    0x1701
 714         do_facet mds$MDTIDX lctl set_param fail_loc=0x1701
 715         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
 716         CLIENT_PID=$!
 717         do_facet mds$MDTIDX lctl set_param fail_loc=0
 718
 719         fail mds${MDTIDX},mds$((MDTIDX + 1))
 720         wait $CLIENT_PID || error "lfs mkdir failed"
 721
 722         replay_barrier mds$MDTIDX
 723         create_remote_dir_files_22 || error "Remote creation failed $?"
 724         fail mds$MDTIDX
 725
 726         checkstat_22 || error "check stat failed $?"
 727
 728         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 729         return 0
 730 }
 731 run_test 22d "c1 lfs mkdir -i 1 d1, M1 drop update & fail M0/M1,c2 mkdir d1/dir"
 732
 733 checkstat_23() {
 734         checkstat $MOUNT1/$remote_dir || return 1
 735         checkstat $MOUNT1/$remote_dir/$tfile-1 || return 2
 736         return 0
 737 }
 738
 739 create_remote_dir_files_23() {
 740         do_node $CLIENT2 mkdir ${MOUNT2}/$remote_dir || return 1
 741         do_node $CLIENT2 createmany -o $MOUNT2/$remote_dir/$tfile- 2 || return 2
 742         return 0
 743 }
 744
 745 test_23a () {
 746         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 747         ([ $FAILURE_MODE == "HARD" ] &&
 748                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
 749                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
 750                 return 0
 751         local MDTIDX=1
 752         local remote_dir=$tdir/remote_dir
 753
 754         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 755         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
 756                         error "lfs mkdir failed"
 757         # OBD_FAIL_MDS_REINT_NET_REP       0x119
 758         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
 759         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
 760         local CLIENT_PID=$!
 761         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0
 762
 763         fail mds$((MDTIDX + 1))
 764         wait $CLIENT_PID || error "rmdir remote dir failed"
 765
 766         replay_barrier mds${MDTIDX}
 767         create_remote_dir_files_23 || error "Remote creation failed $?"
 768         fail mds${MDTIDX}
 769
 770         checkstat_23 || error "check stat failed $?"
 771
 772         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 773         return 0
 774 }
 775 run_test 23a "c1 rmdir d1, M1 drop reply and fail, client2 mkdir d1"
 776
 777 test_23b () {
 778         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 779         local MDTIDX=1
 780         local remote_dir=$tdir/remote_dir
 781
 782         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 783         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
 784                         error "lfs mkdir failed"
 785
 786         # OBD_FAIL_MDS_REINT_NET_REP       0x119
 787         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
 788         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
 789         local CLIENT_PID=$!
 790         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0
 791
 792         fail mds${MDTIDX},mds$((MDTIDX + 1))
 793         wait $CLIENT_PID || error "rmdir remote dir failed"
 794
 795         replay_barrier mds${MDTIDX}
 796         create_remote_dir_files_23 || error "Remote creation failed $?"
 797         fail mds${MDTIDX}
 798
 799         checkstat_23 || error "check stat failed $?"
 800
 801         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 802         return 0
 803 }
 804 run_test 23b "c1 rmdir d1, M1 drop reply and fail M0/M1, c2 mkdir d1"
 805
 806 test_23c () {
 807         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 808
 809         ([ $FAILURE_MODE == "HARD" ] &&
 810                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
 811                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
 812                 return 0
 813         local MDTIDX=1
 814         local remote_dir=$tdir/remote_dir
 815
 816         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 817         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
 818                         error "lfs mkdir failed"
 819
 820         # OBD_FAIL_UPDATE_OBJ_NET_REP    0x1701
 821         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
 822         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
 823         CLIENT_PID=$!
 824         do_facet mds${MDTIDX} lctl set_param fail_loc=0
 825
 826         fail mds${MDTIDX}
 827         wait $CLIENT_PID || error "rmdir remote dir failed"
 828
 829         replay_barrier mds${MDTIDX}
 830         create_remote_dir_files_23 || error "Remote creation failed $?"
 831         fail mds${MDTIDX}
 832
 833         checkstat_23 || error "check stat failed $?"
 834
 835         rm -rf $MOUNT1/$tdir || return 6
 836         return 0
 837 }
 838 run_test 23c "c1 rmdir d1, M0 drop update reply and fail M0, c2 mkdir d1"
 839
 840 test_23d () {
 841         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 842         local MDTIDX=1
 843         local remote_dir=$tdir/remote_dir
 844
 845         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 846         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
 847                         error "lfs mkdir failed"
 848
 849         # OBD_FAIL_UPDATE_OBJ_NET    0x1701
 850         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
 851         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
 852         CLIENT_PID=$!
 853         do_facet mds${MDTIDX} lctl set_param fail_loc=0
 854
 855         fail mds${MDTIDX},mds$((MDTIDX + 1))
 856         wait $CLIENT_PID || error "rmdir remote dir failed"
 857
 858         replay_barrier mds${MDTIDX}
 859         create_remote_dir_files_23 || error "Remote creation failed $?"
 860         fail mds${MDTIDX}
 861
 862         checkstat_23 || error "check stat failed $?"
 863
 864         rm -rf $MOUNT1/$tdir || return 6
 865         return 0
 866 }
 867 run_test 23d "c1 rmdir d1, M0 drop update reply and fail M0/M1, c2 mkdir d1"
 868
 869 test_24 () {
 870         [[ $(lustre_version_code $SINGLEMDS) -gt $(version_code 2.5.2) ]] ||
 871                 { skip "Need MDS version newer than 2.5.2"; return 0; }
 872
 873         touch $MOUNT/$tfile
 874         stat $MOUNT/$tfile >&/dev/null
 875 # OBD_FAIL_MDS_REINT_NET_REP
 876         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x119
 877         $TRUNCATE $MOUNT/$tfile 100 &
 878         PID=$!
 879         sleep 1
 880         do_facet $SINGLEMDS lctl set_param fail_loc=0
 881         # sync to release rep-ack lock quickly
 882         do_nodes $(comma_list $(mdts_nodes)) \
 883             "lctl set_param -n osd*.*MDT*.force_sync 1"
 884         rm $MOUNT2/$tfile
 885         wait
 886 }
 887 run_test 24 "reconstruct on non-existing object"
 888
 889 # end commit on sharing tests
 890
 891 test_25() {
 892         cancel_lru_locks osc
 893
 894         $SETSTRIPE -i 0 -c 1 $DIR/$tfile
 895
 896         # get lock for the 1st client
 897         dd if=/dev/zero of=$DIR/$tfile count=1 >/dev/null ||
 898                 error "failed to write data"
 899
 900         # get waiting locks for the 2nd client
 901         drop_ldlm_cancel "multiop $DIR2/$tfile Ow512" &
 902         sleep 1
 903
 904 #define OBD_FAIL_OST_LDLM_REPLY_NET      0x213
 905         # failover, replay and resend replayed waiting locks
 906         do_facet ost1 lctl set_param fail_loc=0x80000213
 907         fail ost1
 908
 909         # multiop does not finish because CP AST is skipped;
 910         # it is ok to kill it in the test, because CP AST is already re-sent
 911         # and it does not hung forever in real life
 912         killall multiop
 913         wait
 914 }
 915 run_test 25 "replay|resend"
 916
 917 complete $SECONDS
 918 SLEEP=$((`date +%s` - $NOW))
 919 [ $SLEEP -lt $TIMEOUT ] && sleep $SLEEP
 920 [ "$MOUNTED2" = yes ] && zconf_umount $HOSTNAME $MOUNT2 || true
 921 check_and_cleanup_lustre
 922 exit_status